BASELINE: Update Chromium to 85.0.4183.14085-based

Change-Id: Iaa42f4680837c57725b1344f108c0196741f6057
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

32 files changed, 1482 insertions, 478 deletions

diff --git a/chromium/components/page_load_metrics/browser/BUILD.gn b/chromium/components/page_load_metrics/browser/BUILD.gn
index 8383f36b9af..c27d2e44573 100644
--- a/chromium/components/page_load_metrics/browser/BUILD.gn
+++ b/chromium/components/page_load_metrics/browser/BUILD.gn
@@ -10,6 +10,8 @@ source_set("browser") {
     "metrics_navigation_throttle.h",
     "metrics_web_contents_observer.cc",
     "metrics_web_contents_observer.h",
+    "observers/back_forward_cache_page_load_metrics_observer.cc",
+    "observers/back_forward_cache_page_load_metrics_observer.h",
     "observers/click_input_tracker.cc",
     "observers/click_input_tracker.h",
     "observers/core_page_load_metrics_observer.cc",
@@ -26,6 +28,7 @@ source_set("browser") {
     "page_load_metrics_embedder_interface.h",
     "page_load_metrics_observer.cc",
     "page_load_metrics_observer.h",
+    "page_load_metrics_observer_delegate.cc",
     "page_load_metrics_observer_delegate.h",
     "page_load_metrics_update_dispatcher.cc",
     "page_load_metrics_update_dispatcher.h",
diff --git a/chromium/components/page_load_metrics/browser/metrics_web_contents_observer.cc b/chromium/components/page_load_metrics/browser/metrics_web_contents_observer.cc
index c718da71648..2bade0dc409 100644
--- a/chromium/components/page_load_metrics/browser/metrics_web_contents_observer.cc
+++ b/chromium/components/page_load_metrics/browser/metrics_web_contents_observer.cc
@@ -76,23 +76,6 @@ void MetricsWebContentsObserver::RecordFeatureUsage(
     observer->OnBrowserFeatureUsage(render_frame_host, new_features);
 }
 
-MetricsWebContentsObserver::MetricsWebContentsObserver(
-    content::WebContents* web_contents,
-    std::unique_ptr<PageLoadMetricsEmbedderInterface> embedder_interface)
-    : content::WebContentsObserver(web_contents),
-      in_foreground_(web_contents->GetVisibility() !=
-                     content::Visibility::HIDDEN),
-      embedder_interface_(std::move(embedder_interface)),
-      has_navigated_(false),
-      page_load_metrics_receiver_(web_contents, this) {
-  // Prerenders erroneously report that they are initially visible, so we
-  // manually override visibility state for prerender.
-  if (embedder_interface_->IsPrerender(web_contents))
-    in_foreground_ = false;
-
-  RegisterInputEventObserver(web_contents->GetRenderViewHost());
-}
-
 // static
 MetricsWebContentsObserver* MetricsWebContentsObserver::CreateForWebContents(
     content::WebContents* web_contents,
@@ -188,6 +171,23 @@ void MetricsWebContentsObserver::WillStartNavigationRequest(
   has_navigated_ = true;
 }
 
+MetricsWebContentsObserver::MetricsWebContentsObserver(
+    content::WebContents* web_contents,
+    std::unique_ptr<PageLoadMetricsEmbedderInterface> embedder_interface)
+    : content::WebContentsObserver(web_contents),
+      in_foreground_(web_contents->GetVisibility() !=
+                     content::Visibility::HIDDEN),
+      embedder_interface_(std::move(embedder_interface)),
+      has_navigated_(false),
+      page_load_metrics_receiver_(web_contents, this) {
+  // Prerenders erroneously report that they are initially visible, so we
+  // manually override visibility state for prerender.
+  if (embedder_interface_->IsPrerender(web_contents))
+    in_foreground_ = false;
+
+  RegisterInputEventObserver(web_contents->GetRenderViewHost());
+}
+
 void MetricsWebContentsObserver::WillStartNavigationRequestImpl(
     content::NavigationHandle* navigation_handle) {
   UserInitiatedInfo user_initiated_info(
@@ -397,6 +397,22 @@ void MetricsWebContentsObserver::OnCookiesAccessedImpl(
   }
 }
 
+void MetricsWebContentsObserver::DidActivatePortal(
+    content::WebContents* predecessor_web_contents,
+    base::TimeTicks activation_time) {
+  // The |predecessor_web_contents| is the WebContents that instantiated the
+  // portal.
+  MetricsWebContentsObserver* predecessor_observer =
+      MetricsWebContentsObserver::FromWebContents(predecessor_web_contents);
+  // We only track the portal activation if the predecessor is also being
+  // tracked.
+  if (!committed_load_ || !predecessor_observer ||
+      !predecessor_observer->committed_load_) {
+    return;
+  }
+  committed_load_->DidActivatePortal(activation_time);
+}
+
 void MetricsWebContentsObserver::OnStorageAccessed(const GURL& url,
                                                    const GURL& first_party_url,
                                                    bool blocked_by_policy,
@@ -574,7 +590,11 @@ bool MetricsWebContentsObserver::MaybeRestorePageLoadTrackerForBackForwardCache(
 
   committed_load_ = std::move(it->second);
   back_forward_cached_pages_.erase(it);
-  committed_load_->OnRestoreFromBackForwardCache();
+  committed_load_->OnRestoreFromBackForwardCache(navigation_handle);
+
+  for (auto& observer : testing_observers_)
+    observer.OnRestoredFromBackForwardCache(committed_load_.get());
+
   return true;
 }
 
@@ -783,24 +803,7 @@ void MetricsWebContentsObserver::OnTimingUpdated(
 
   const bool is_main_frame = (render_frame_host->GetParent() == nullptr);
   if (is_main_frame) {
-    // While timings arriving for the wrong frame are expected, we do not expect
-    // any of the errors below for main frames. Thus, we track occurrences of
-    // all errors below, rather than returning early after encountering an
-    // error.
-    // TODO(crbug/1061090): Update page load metrics IPC validation to ues
-    // mojo::ReportBadMessage.
-    bool error = false;
-    if (!committed_load_) {
-      RecordInternalError(ERR_IPC_WITH_NO_RELEVANT_LOAD);
-      error = true;
-    }
-
-    if (!web_contents()->GetLastCommittedURL().SchemeIsHTTPOrHTTPS()) {
-      RecordInternalError(ERR_IPC_FROM_BAD_URL_SCHEME);
-      error = true;
-    }
-
-    if (error)
+    if (DoesTimingUpdateHaveError())
       return;
   } else if (!committed_load_) {
     RecordInternalError(ERR_SUBFRAME_IPC_WITH_NO_RELEVANT_LOAD);
@@ -815,6 +818,26 @@ void MetricsWebContentsObserver::OnTimingUpdated(
   }
 }
 
+bool MetricsWebContentsObserver::DoesTimingUpdateHaveError() {
+  // While timings arriving for the wrong frame are expected, we do not expect
+  // any of the errors below for main frames. Thus, we track occurrences of
+  // all errors below, rather than returning early after encountering an
+  // error.
+  // TODO(crbug/1061090): Update page load metrics IPC validation to ues
+  // mojo::ReportBadMessage.
+  bool error = false;
+  if (!committed_load_) {
+    RecordInternalError(ERR_IPC_WITH_NO_RELEVANT_LOAD);
+    error = true;
+  }
+
+  if (!web_contents()->GetLastCommittedURL().SchemeIsHTTPOrHTTPS()) {
+    RecordInternalError(ERR_IPC_FROM_BAD_URL_SCHEME);
+    error = true;
+  }
+  return error;
+}
+
 void MetricsWebContentsObserver::UpdateTiming(
     mojom::PageLoadTimingPtr timing,
     mojom::FrameMetadataPtr metadata,
@@ -832,17 +855,22 @@ void MetricsWebContentsObserver::UpdateTiming(
                   std::move(input_timing_delta));
 }
 
+void MetricsWebContentsObserver::SubmitThroughputData(
+    mojom::ThroughputUkmDataPtr throughput_data) {
+  if (DoesTimingUpdateHaveError())
+    return;
+
+  content::RenderFrameHost* render_frame_host =
+      page_load_metrics_receiver_.GetCurrentTargetFrame();
+  committed_load_->metrics_update_dispatcher()->UpdateThroughput(
+      render_frame_host, std::move(throughput_data));
+}
+
 bool MetricsWebContentsObserver::ShouldTrackMainFrameNavigation(
     content::NavigationHandle* navigation_handle) const {
   DCHECK(navigation_handle->IsInMainFrame());
   DCHECK(!navigation_handle->HasCommitted() ||
          !navigation_handle->IsSameDocument());
-  // If there is an outer WebContents, then this WebContents is embedded into
-  // another one (it is either a portal or a Chrome App <webview>). Ignore these
-  // navigations for now.
-  if (web_contents()->GetOuterWebContents())
-    return false;
-
   // Ignore non-HTTP schemes (e.g. chrome://).
   if (!navigation_handle->GetURL().SchemeIsHTTPOrHTTPS())
     return false;
diff --git a/chromium/components/page_load_metrics/browser/metrics_web_contents_observer.h b/chromium/components/page_load_metrics/browser/metrics_web_contents_observer.h
index e511b3f562f..3fedb707723 100644
--- a/chromium/components/page_load_metrics/browser/metrics_web_contents_observer.h
+++ b/chromium/components/page_load_metrics/browser/metrics_web_contents_observer.h
@@ -65,6 +65,8 @@ class MetricsWebContentsObserver
     // fine.
     virtual void OnCommit(PageLoadTracker* tracker) {}
 
+    virtual void OnRestoredFromBackForwardCache(PageLoadTracker* tracker) {}
+
     // Returns the observer delegate for the committed load associated with
     // the MetricsWebContentsObserver.
     const PageLoadMetricsObserverDelegate& GetDelegateForCommittedLoad();
@@ -85,9 +87,6 @@ class MetricsWebContentsObserver
   static MetricsWebContentsObserver* CreateForWebContents(
       content::WebContents* web_contents,
       std::unique_ptr<PageLoadMetricsEmbedderInterface> embedder_interface);
-  MetricsWebContentsObserver(
-      content::WebContents* web_contents,
-      std::unique_ptr<PageLoadMetricsEmbedderInterface> embedder_interface);
   ~MetricsWebContentsObserver() override;
 
   // Any visibility changes that occur after this method should be ignored since
@@ -131,6 +130,8 @@ class MetricsWebContentsObserver
                          const GURL& first_party_url,
                          bool blocked_by_policy,
                          StorageType storage_type);
+  void DidActivatePortal(content::WebContents* predecessor_web_contents,
+                         base::TimeTicks activation_time) override;
 
   // These methods are forwarded from the MetricsNavigationThrottle.
   void WillStartNavigationRequest(content::NavigationHandle* navigation_handle);
@@ -171,6 +172,10 @@ class MetricsWebContentsObserver
  private:
   friend class content::WebContentsUserData<MetricsWebContentsObserver>;
 
+  MetricsWebContentsObserver(
+      content::WebContents* web_contents,
+      std::unique_ptr<PageLoadMetricsEmbedderInterface> embedder_interface);
+
   void WillStartNavigationRequestImpl(
       content::NavigationHandle* navigation_handle);
 
@@ -184,6 +189,14 @@ class MetricsWebContentsObserver
                     mojom::DeferredResourceCountsPtr new_deferred_resource_data,
                     mojom::InputTimingPtr input_timing) override;
 
+  // Update the throughput samples on the browser side, and report it to UKM at
+  // page shuts down / nagivates away, report it to UKM.
+  void SubmitThroughputData(
+      mojom::ThroughputUkmDataPtr throughput_data) override;
+
+  // Common part for UpdateThroughput and OnTimingUpdated.
+  bool DoesTimingUpdateHaveError();
+
   void HandleFailedNavigationForTrackedLoad(
       content::NavigationHandle* navigation_handle,
       std::unique_ptr<PageLoadTracker> tracker);
diff --git a/chromium/components/page_load_metrics/browser/observers/back_forward_cache_page_load_metrics_observer.cc b/chromium/components/page_load_metrics/browser/observers/back_forward_cache_page_load_metrics_observer.cc
new file mode 100644
index 00000000000..f055e06017a
--- /dev/null
+++ b/chromium/components/page_load_metrics/browser/observers/back_forward_cache_page_load_metrics_observer.cc
@@ -0,0 +1,60 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/page_load_metrics/browser/observers/back_forward_cache_page_load_metrics_observer.h"
+
+#include "components/page_load_metrics/browser/page_load_metrics_util.h"
+
+namespace internal {
+
+const char kHistogramFirstPaintAfterBackForwardCacheRestore[] =
+    "PageLoad.PaintTiming.NavigationToFirstPaint.AfterBackForwardCacheRestore";
+const char kHistogramFirstInputDelayAfterBackForwardCacheRestore[] =
+    "PageLoad.InteractiveTiming.FirstInputDelay.AfterBackForwardCacheRestore";
+
+}  // namespace internal
+
+BackForwardCachePageLoadMetricsObserver::
+    BackForwardCachePageLoadMetricsObserver() = default;
+
+BackForwardCachePageLoadMetricsObserver::
+    ~BackForwardCachePageLoadMetricsObserver() = default;
+
+page_load_metrics::PageLoadMetricsObserver::ObservePolicy
+BackForwardCachePageLoadMetricsObserver::OnEnterBackForwardCache(
+    const page_load_metrics::mojom::PageLoadTiming& timing) {
+  return CONTINUE_OBSERVING;
+}
+
+void BackForwardCachePageLoadMetricsObserver::
+    OnFirstPaintAfterBackForwardCacheRestoreInPage(
+        const page_load_metrics::mojom::BackForwardCacheTiming& timing,
+        size_t index) {
+  auto first_paint = timing.first_paint_after_back_forward_cache_restore;
+  DCHECK(!first_paint.is_zero());
+  if (page_load_metrics::
+          WasStartedInForegroundOptionalEventInForegroundAfterBackForwardCacheRestore(
+              first_paint, GetDelegate(), index)) {
+    PAGE_LOAD_HISTOGRAM(
+        internal::kHistogramFirstPaintAfterBackForwardCacheRestore,
+        first_paint);
+  }
+}
+
+void BackForwardCachePageLoadMetricsObserver::
+    OnFirstInputAfterBackForwardCacheRestoreInPage(
+        const page_load_metrics::mojom::BackForwardCacheTiming& timing,
+        size_t index) {
+  auto first_input_delay =
+      timing.first_input_delay_after_back_forward_cache_restore;
+  DCHECK(first_input_delay.has_value());
+  if (page_load_metrics::
+          WasStartedInForegroundOptionalEventInForegroundAfterBackForwardCacheRestore(
+              first_input_delay, GetDelegate(), index)) {
+    UMA_HISTOGRAM_CUSTOM_TIMES(
+        internal::kHistogramFirstInputDelayAfterBackForwardCacheRestore,
+        *first_input_delay, base::TimeDelta::FromMilliseconds(1),
+        base::TimeDelta::FromSeconds(60), 50);
+  }
+}
diff --git a/chromium/components/page_load_metrics/browser/observers/back_forward_cache_page_load_metrics_observer.h b/chromium/components/page_load_metrics/browser/observers/back_forward_cache_page_load_metrics_observer.h
new file mode 100644
index 00000000000..ddcb5ede44f
--- /dev/null
+++ b/chromium/components/page_load_metrics/browser/observers/back_forward_cache_page_load_metrics_observer.h
@@ -0,0 +1,38 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_PAGE_LOAD_METRICS_BROWSER_OBSERVERS_BACK_FORWARD_CACHE_PAGE_LOAD_METRICS_OBSERVER_H_
+#define COMPONENTS_PAGE_LOAD_METRICS_BROWSER_OBSERVERS_BACK_FORWARD_CACHE_PAGE_LOAD_METRICS_OBSERVER_H_
+
+#include "components/page_load_metrics/browser/page_load_metrics_observer.h"
+
+namespace internal {
+
+extern const char kHistogramFirstPaintAfterBackForwardCacheRestore[];
+extern const char kHistogramFirstInputDelayAfterBackForwardCacheRestore[];
+
+}  // namespace internal
+
+class BackForwardCachePageLoadMetricsObserver
+    : public page_load_metrics::PageLoadMetricsObserver {
+ public:
+  BackForwardCachePageLoadMetricsObserver();
+  ~BackForwardCachePageLoadMetricsObserver() override;
+
+  // page_load_metrics::PageLoadMetricsObserver:
+  page_load_metrics::PageLoadMetricsObserver::ObservePolicy
+  OnEnterBackForwardCache(
+      const page_load_metrics::mojom::PageLoadTiming& timing) override;
+  void OnFirstPaintAfterBackForwardCacheRestoreInPage(
+      const page_load_metrics::mojom::BackForwardCacheTiming& timing,
+      size_t index) override;
+  void OnFirstInputAfterBackForwardCacheRestoreInPage(
+      const page_load_metrics::mojom::BackForwardCacheTiming& timing,
+      size_t index) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(BackForwardCachePageLoadMetricsObserver);
+};
+
+#endif  // COMPONENTS_PAGE_LOAD_METRICS_BROWSER_OBSERVERS_BACK_FORWARD_CACHE_PAGE_LOAD_METRICS_OBSERVER_H_
diff --git a/chromium/components/page_load_metrics/browser/observers/core_page_load_metrics_observer.cc b/chromium/components/page_load_metrics/browser/observers/core_page_load_metrics_observer.cc
index a885037b114..a6f18f2ca29 100644
--- a/chromium/components/page_load_metrics/browser/observers/core_page_load_metrics_observer.cc
+++ b/chromium/components/page_load_metrics/browser/observers/core_page_load_metrics_observer.cc
@@ -12,6 +12,7 @@
 #include "base/feature_list.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/power_monitor/power_monitor.h"
+#include "components/page_load_metrics/browser/observers/largest_contentful_paint_handler.h"
 #include "components/page_load_metrics/browser/page_load_metrics_util.h"
 #include "content/public/common/process_type.h"
 #include "net/http/http_response_headers.h"
@@ -112,6 +113,18 @@ const char kHistogramLargestContentfulPaintMainFrame[] =
 const char kHistogramLargestContentfulPaintMainFrameContentType[] =
     "PageLoad.Internal.PaintTiming.LargestContentfulPaint.MainFrame."
     "ContentType";
+const char kHistogramExperimentalLargestContentfulPaint[] =
+    "PageLoad.PaintTiming.NavigationToExperimentalLargestContentfulPaint";
+const char kHistogramExperimentalLargestContentfulPaintContentType[] =
+    "PageLoad.Internal.PaintTiming.ExperimentalLargestContentfulPaint."
+    "ContentType";
+const char kHistogramExperimentalLargestContentfulPaintMainFrame[] =
+    "PageLoad.PaintTiming.NavigationToExperimentalLargestContentfulPaint."
+    "MainFrame";
+const char kHistogramExperimentalLargestContentfulPaintMainFrameContentType[] =
+    "PageLoad.Internal.PaintTiming.ExperimentalLargestContentfulPaint."
+    "MainFrame."
+    "ContentType";
 const char kHistogramFirstInputDelay[] =
     "PageLoad.InteractiveTiming.FirstInputDelay4";
 const char kHistogramFirstInputTimestamp[] =
@@ -291,6 +304,12 @@ const char kHistogramFontPreloadFirstContentfulPaint[] =
 const char kHistogramFontPreloadLargestContentfulPaint[] =
     "PageLoad.Clients.FontPreload.PaintTiming."
     "NavigationToLargestContentfulPaint";
+const char kHistogramFontPreloadLargestImagePaint[] =
+    "PageLoad.Clients.FontPreload.PaintTiming."
+    "NavigationToLargestImagePaint";
+const char kHistogramFontPreloadLargestTextPaint[] =
+    "PageLoad.Clients.FontPreload.PaintTiming."
+    "NavigationToLargestTextPaint";
 
 // Navigation metrics from the navigation start.
 const char kHistogramNavigationTimingNavigationStartToFirstRequestStart[] =
@@ -298,11 +317,46 @@ const char kHistogramNavigationTimingNavigationStartToFirstRequestStart[] =
 const char kHistogramNavigationTimingNavigationStartToFirstResponseStart[] =
     "PageLoad.Experimental.NavigationTiming."
     "NavigationStartToFirstResponseStart";
+const char kHistogramNavigationTimingNavigationStartToFirstLoaderCallback[] =
+    "PageLoad.Experimental.NavigationTiming."
+    "NavigationStartToFirstLoaderCallback";
+const char kHistogramNavigationTimingNavigationStartToFinalRequestStart[] =
+    "PageLoad.Experimental.NavigationTiming.NavigationStartToFinalRequestStart";
+const char kHistogramNavigationTimingNavigationStartToFinalResponseStart[] =
+    "PageLoad.Experimental.NavigationTiming."
+    "NavigationStartToFinalResponseStart";
+const char kHistogramNavigationTimingNavigationStartToFinalLoaderCallback[] =
+    "PageLoad.Experimental.NavigationTiming."
+    "NavigationStartToFinalLoaderCallback";
+const char kHistogramNavigationTimingNavigationStartToNavigationCommitSent[] =
+    "PageLoad.Experimental.NavigationTiming."
+    "NavigationStartToNavigationCommitSent";
 
 // Navigation metrics between milestones.
 const char kHistogramNavigationTimingFirstRequestStartToFirstResponseStart[] =
     "PageLoad.Experimental.NavigationTiming."
     "FirstRequestStartToFirstResponseStart";
+const char kHistogramNavigationTimingFirstResponseStartToFirstLoaderCallback[] =
+    "PageLoad.Experimental.NavigationTiming."
+    "FirstResponseStartToFirstLoaderCallback";
+const char kHistogramNavigationTimingFinalRequestStartToFinalResponseStart[] =
+    "PageLoad.Experimental.NavigationTiming."
+    "FinalRequestStartToFinalResponseStart";
+const char kHistogramNavigationTimingFinalResponseStartToFinalLoaderCallback[] =
+    "PageLoad.Experimental.NavigationTiming."
+    "FinalResponseStartToFinalLoaderCallback";
+const char
+    kHistogramNavigationTimingFinalLoaderCallbackToNavigationCommitSent[] =
+        "PageLoad.Experimental.NavigationTiming."
+        "FinalLoaderCallbackToNavigationCommitSent";
+
+// 103 Early Hints metrics for experiment (https://crbug.com/1093693).
+const char kHistogramEarlyHintsFirstRequestStartToEarlyHints[] =
+    "PageLoad.Experimental.EarlyHints.FirstRequestStartToEarlyHints";
+const char kHistogramEarlyHintsFinalRequestStartToEarlyHints[] =
+    "PageLoad.Experimental.EarlyHints.FinalRequestStartToEarlyHints";
+const char kHistogramEarlyHintsEarlyHintsToFinalResponseStart[] =
+    "PageLoad.Experimental.EarlyHints.EarlyHintsToFinalResponseStart";
 
 }  // namespace internal
 
@@ -314,8 +368,7 @@ CorePageLoadMetricsObserver::CorePageLoadMetricsObserver()
       cache_bytes_(0),
       network_bytes_(0),
       network_bytes_including_headers_(0),
-      redirect_chain_size_(0),
-      largest_contentful_paint_handler_() {}
+      redirect_chain_size_(0) {}
 
 CorePageLoadMetricsObserver::~CorePageLoadMetricsObserver() {}
 
@@ -339,7 +392,7 @@ CorePageLoadMetricsObserver::OnCommit(
   }
   UMA_HISTOGRAM_COUNTS_100("PageLoad.Navigation.RedirectChainLength",
                            redirect_chain_size_);
-  RecordNavigationTimingHistograms(navigation_handle);
+  navigation_handle_timing_ = navigation_handle->GetNavigationHandleTiming();
   return CONTINUE_OBSERVING;
 }
 
@@ -678,6 +731,7 @@ void CorePageLoadMetricsObserver::OnParseStop(
 
 void CorePageLoadMetricsObserver::OnComplete(
     const page_load_metrics::mojom::PageLoadTiming& timing) {
+  RecordNavigationTimingHistograms();
   RecordTimingHistograms(timing);
   RecordByteAndResourceHistograms(timing);
   RecordCpuUsageHistograms();
@@ -692,6 +746,7 @@ CorePageLoadMetricsObserver::FlushMetricsOnAppEnterBackground(
   // flow. After this method is invoked, Chrome may be killed without further
   // notification, so we record final metrics collected up to this point.
   if (GetDelegate().DidCommit()) {
+    RecordNavigationTimingHistograms();
     RecordTimingHistograms(timing);
     RecordByteAndResourceHistograms(timing);
     RecordCpuUsageHistograms();
@@ -770,42 +825,113 @@ void CorePageLoadMetricsObserver::OnResourceDataUseObserved(
   }
 }
 
-void CorePageLoadMetricsObserver::RecordNavigationTimingHistograms(
-    content::NavigationHandle* navigation_handle) {
-  // Record only main frame navigation.
-  DCHECK(navigation_handle->IsInMainFrame());
+void CorePageLoadMetricsObserver::RecordNavigationTimingHistograms() {
+  const base::TimeTicks navigation_start_time =
+      GetDelegate().GetNavigationStart();
+  const content::NavigationHandleTiming& timing = navigation_handle_timing_;
 
   // Record metrics for navigation only when all relevant milestones are
   // recorded and in the expected order. It is allowed that they have the same
   // value for some cases (e.g., internal redirection for HSTS).
-  if (navigation_handle->NavigationStart().is_null() ||
-      navigation_handle->FirstRequestStart().is_null() ||
-      navigation_handle->FirstResponseStart().is_null())
+  if (navigation_start_time.is_null() ||
+      timing.first_request_start_time.is_null() ||
+      timing.first_response_start_time.is_null() ||
+      timing.first_loader_callback_time.is_null() ||
+      timing.final_request_start_time.is_null() ||
+      timing.final_response_start_time.is_null() ||
+      timing.final_loader_callback_time.is_null() ||
+      timing.navigation_commit_sent_time.is_null()) {
     return;
+  }
   // TODO(https://crbug.com/1076710): Change these early-returns to DCHECKs
   // after the issue 1076710 is fixed.
-  if (navigation_handle->NavigationStart() >
-          navigation_handle->FirstRequestStart() ||
-      navigation_handle->FirstRequestStart() >
-          navigation_handle->FirstResponseStart()) {
+  if (navigation_start_time > timing.first_request_start_time ||
+      timing.first_request_start_time > timing.first_response_start_time ||
+      timing.first_response_start_time > timing.first_loader_callback_time ||
+      timing.first_loader_callback_time > timing.navigation_commit_sent_time) {
+    return;
+  }
+  if (navigation_start_time > timing.final_request_start_time ||
+      timing.final_request_start_time > timing.final_response_start_time ||
+      timing.final_response_start_time > timing.final_loader_callback_time ||
+      timing.final_loader_callback_time > timing.navigation_commit_sent_time) {
     return;
   }
+  DCHECK_LE(timing.first_request_start_time, timing.final_request_start_time);
+  DCHECK_LE(timing.first_response_start_time, timing.final_response_start_time);
+  DCHECK_LE(timing.first_loader_callback_time,
+            timing.final_loader_callback_time);
 
   // Record the elapsed time from the navigation start milestone.
   PAGE_LOAD_HISTOGRAM(
       internal::kHistogramNavigationTimingNavigationStartToFirstRequestStart,
-      navigation_handle->FirstRequestStart() -
-          navigation_handle->NavigationStart());
+      timing.first_request_start_time - navigation_start_time);
   PAGE_LOAD_HISTOGRAM(
       internal::kHistogramNavigationTimingNavigationStartToFirstResponseStart,
-      navigation_handle->FirstResponseStart() -
-          navigation_handle->NavigationStart());
+      timing.first_response_start_time - navigation_start_time);
+  PAGE_LOAD_HISTOGRAM(
+      internal::kHistogramNavigationTimingNavigationStartToFirstLoaderCallback,
+      timing.first_loader_callback_time - navigation_start_time);
+
+  PAGE_LOAD_HISTOGRAM(
+      internal::kHistogramNavigationTimingNavigationStartToFinalRequestStart,
+      timing.final_request_start_time - navigation_start_time);
+  PAGE_LOAD_HISTOGRAM(
+      internal::kHistogramNavigationTimingNavigationStartToFinalResponseStart,
+      timing.final_response_start_time - navigation_start_time);
+  PAGE_LOAD_HISTOGRAM(
+      internal::kHistogramNavigationTimingNavigationStartToFinalLoaderCallback,
+      timing.final_loader_callback_time - navigation_start_time);
+
+  PAGE_LOAD_HISTOGRAM(
+      internal::kHistogramNavigationTimingNavigationStartToNavigationCommitSent,
+      timing.navigation_commit_sent_time - navigation_start_time);
 
   // Record the intervals between milestones.
   PAGE_LOAD_HISTOGRAM(
       internal::kHistogramNavigationTimingFirstRequestStartToFirstResponseStart,
-      navigation_handle->FirstResponseStart() -
-          navigation_handle->FirstRequestStart());
+      timing.first_response_start_time - timing.first_request_start_time);
+  PAGE_LOAD_HISTOGRAM(
+      internal::
+          kHistogramNavigationTimingFirstResponseStartToFirstLoaderCallback,
+      timing.first_loader_callback_time - timing.first_response_start_time);
+
+  PAGE_LOAD_HISTOGRAM(
+      internal::kHistogramNavigationTimingFinalRequestStartToFinalResponseStart,
+      timing.final_response_start_time - timing.final_request_start_time);
+  PAGE_LOAD_HISTOGRAM(
+      internal::
+          kHistogramNavigationTimingFinalResponseStartToFinalLoaderCallback,
+      timing.final_loader_callback_time - timing.final_response_start_time);
+
+  PAGE_LOAD_HISTOGRAM(
+      internal::
+          kHistogramNavigationTimingFinalLoaderCallbackToNavigationCommitSent,
+      timing.navigation_commit_sent_time - timing.final_loader_callback_time);
+
+  // Record the following intervals for the 103 Early Hints experiment
+  // (https://crbug.com/1093693).
+  // - The first request start to the 103 response,
+  // - The final request start to the 103 response, and the 103 response to the
+  //   final response,
+  // Note that multiple 103 responses can be served per request. These metrics
+  // use the first 103 response as the timing.
+  if (!timing.early_hints_for_first_request_time.is_null()) {
+    PAGE_LOAD_HISTOGRAM(
+        internal::kHistogramEarlyHintsFirstRequestStartToEarlyHints,
+        timing.first_request_start_time -
+            timing.early_hints_for_first_request_time);
+  }
+  if (!timing.early_hints_for_final_request_time.is_null()) {
+    PAGE_LOAD_HISTOGRAM(
+        internal::kHistogramEarlyHintsFinalRequestStartToEarlyHints,
+        timing.final_request_start_time -
+            timing.early_hints_for_final_request_time);
+    PAGE_LOAD_HISTOGRAM(
+        internal::kHistogramEarlyHintsEarlyHintsToFinalResponseStart,
+        timing.early_hints_for_final_request_time -
+            timing.final_response_start_time);
+  }
 }
 
 // This method records values for metrics that were not recorded during any
@@ -823,8 +949,34 @@ void CorePageLoadMetricsObserver::RecordTimingHistograms(
   }
 
   const page_load_metrics::ContentfulPaintTimingInfo&
+      main_frame_largest_image_paint = GetDelegate()
+                                           .GetLargestContentfulPaintHandler()
+                                           .MainFrameLargestImagePaint();
+  if (main_frame_largest_image_paint.ContainsValidTime() &&
+      WasStartedInForegroundOptionalEventInForeground(
+          main_frame_largest_image_paint.Time(), GetDelegate()) &&
+      font_preload_started_before_rendering_observed_) {
+    PAGE_LOAD_HISTOGRAM(internal::kHistogramFontPreloadLargestImagePaint,
+                        main_frame_largest_image_paint.Time().value());
+  }
+
+  const page_load_metrics::ContentfulPaintTimingInfo&
+      main_frame_largest_text_paint = GetDelegate()
+                                          .GetLargestContentfulPaintHandler()
+                                          .MainFrameLargestTextPaint();
+  if (main_frame_largest_text_paint.ContainsValidTime() &&
+      WasStartedInForegroundOptionalEventInForeground(
+          main_frame_largest_text_paint.Time(), GetDelegate()) &&
+      font_preload_started_before_rendering_observed_) {
+    PAGE_LOAD_HISTOGRAM(internal::kHistogramFontPreloadLargestTextPaint,
+                        main_frame_largest_text_paint.Time().value());
+  }
+
+  const page_load_metrics::ContentfulPaintTimingInfo&
       main_frame_largest_contentful_paint =
-          largest_contentful_paint_handler_.MainFrameLargestContentfulPaint();
+          GetDelegate()
+              .GetLargestContentfulPaintHandler()
+              .MainFrameLargestContentfulPaint();
   if (main_frame_largest_contentful_paint.ContainsValidTime() &&
       WasStartedInForegroundOptionalEventInForeground(
           main_frame_largest_contentful_paint.Time(), GetDelegate())) {
@@ -837,7 +989,9 @@ void CorePageLoadMetricsObserver::RecordTimingHistograms(
 
   const page_load_metrics::ContentfulPaintTimingInfo&
       all_frames_largest_contentful_paint =
-          largest_contentful_paint_handler_.MergeMainFrameAndSubframes();
+          GetDelegate()
+              .GetLargestContentfulPaintHandler()
+              .MergeMainFrameAndSubframes();
   if (all_frames_largest_contentful_paint.ContainsValidTime() &&
       WasStartedInForegroundOptionalEventInForeground(
           all_frames_largest_contentful_paint.Time(), GetDelegate())) {
@@ -860,6 +1014,48 @@ void CorePageLoadMetricsObserver::RecordTimingHistograms(
     }
   }
 
+  const page_load_metrics::ContentfulPaintTimingInfo&
+      main_frame_experimental_largest_contentful_paint =
+          GetDelegate()
+              .GetExperimentalLargestContentfulPaintHandler()
+              .MainFrameLargestContentfulPaint();
+  if (main_frame_experimental_largest_contentful_paint.ContainsValidTime() &&
+      WasStartedInForegroundOptionalEventInForeground(
+          main_frame_experimental_largest_contentful_paint.Time(),
+          GetDelegate())) {
+    PAGE_LOAD_HISTOGRAM(
+        internal::kHistogramExperimentalLargestContentfulPaintMainFrame,
+        main_frame_experimental_largest_contentful_paint.Time().value());
+    UMA_HISTOGRAM_ENUMERATION(
+        internal::
+            kHistogramExperimentalLargestContentfulPaintMainFrameContentType,
+        main_frame_experimental_largest_contentful_paint.Type());
+  }
+
+  const page_load_metrics::ContentfulPaintTimingInfo&
+      all_frames_experimental_largest_contentful_paint =
+          GetDelegate()
+              .GetExperimentalLargestContentfulPaintHandler()
+              .MergeMainFrameAndSubframes();
+  if (all_frames_experimental_largest_contentful_paint.ContainsValidTime() &&
+      WasStartedInForegroundOptionalEventInForeground(
+          all_frames_experimental_largest_contentful_paint.Time(),
+          GetDelegate())) {
+    PAGE_LOAD_HISTOGRAM(
+        internal::kHistogramExperimentalLargestContentfulPaint,
+        all_frames_experimental_largest_contentful_paint.Time().value());
+    UMA_HISTOGRAM_ENUMERATION(
+        internal::kHistogramExperimentalLargestContentfulPaintContentType,
+        all_frames_experimental_largest_contentful_paint.Type());
+    TRACE_EVENT_MARK_WITH_TIMESTAMP1(
+        "loading",
+        "NavStartToExperimentalLargestContentfulPaint::AllFrames::UMA",
+        GetDelegate().GetNavigationStart() +
+            all_frames_experimental_largest_contentful_paint.Time().value(),
+        "data",
+        all_frames_experimental_largest_contentful_paint.DataAsTraceValue());
+  }
+
   if (main_frame_timing.paint_timing->first_paint &&
       !main_frame_timing.paint_timing->first_meaningful_paint) {
     RecordFirstMeaningfulPaintStatus(
@@ -1001,19 +1197,6 @@ void CorePageLoadMetricsObserver::RecordCpuUsageHistograms() {
                       foreground_cpu_usage_);
 }
 
-void CorePageLoadMetricsObserver::OnTimingUpdate(
-    content::RenderFrameHost* subframe_rfh,
-    const page_load_metrics::mojom::PageLoadTiming& timing) {
-  largest_contentful_paint_handler_.RecordTiming(timing.paint_timing,
-                                                 subframe_rfh);
-}
-
-void CorePageLoadMetricsObserver::OnDidFinishSubFrameNavigation(
-    content::NavigationHandle* navigation_handle) {
-  largest_contentful_paint_handler_.OnDidFinishSubFrameNavigation(
-      navigation_handle, GetDelegate());
-}
-
 page_load_metrics::PageLoadMetricsObserver::ObservePolicy
 CorePageLoadMetricsObserver::OnEnterBackForwardCache(
     const page_load_metrics::mojom::PageLoadTiming& timing) {
diff --git a/chromium/components/page_load_metrics/browser/observers/core_page_load_metrics_observer.h b/chromium/components/page_load_metrics/browser/observers/core_page_load_metrics_observer.h
index 0ffaa0c8704..3fb6e3c42ec 100644
--- a/chromium/components/page_load_metrics/browser/observers/core_page_load_metrics_observer.h
+++ b/chromium/components/page_load_metrics/browser/observers/core_page_load_metrics_observer.h
@@ -6,7 +6,6 @@
 #define COMPONENTS_PAGE_LOAD_METRICS_BROWSER_OBSERVERS_CORE_PAGE_LOAD_METRICS_OBSERVER_H_
 
 #include "components/page_load_metrics/browser/observers/click_input_tracker.h"
-#include "components/page_load_metrics/browser/observers/largest_contentful_paint_handler.h"
 #include "components/page_load_metrics/browser/page_load_metrics_observer.h"
 #include "services/metrics/public/cpp/ukm_source.h"
 
@@ -32,6 +31,11 @@ extern const char kHistogramLargestContentfulPaint[];
 extern const char kHistogramLargestContentfulPaintContentType[];
 extern const char kHistogramLargestContentfulPaintMainFrame[];
 extern const char kHistogramLargestContentfulPaintMainFrameContentType[];
+extern const char kHistogramExperimentalLargestContentfulPaint[];
+extern const char kHistogramExperimentalLargestContentfulPaintContentType[];
+extern const char kHistogramExperimentalLargestContentfulPaintMainFrame[];
+extern const char
+    kHistogramExperimentalLargestContentfulPaintMainFrameContentType[];
 extern const char kHistogramParseDuration[];
 extern const char kHistogramParseBlockedOnScriptLoad[];
 extern const char kHistogramParseBlockedOnScriptExecution[];
@@ -105,16 +109,41 @@ extern const char kHistogramBackForwardCacheEvent[];
 extern const char kHistogramFontPreloadFirstPaint[];
 extern const char kHistogramFontPreloadFirstContentfulPaint[];
 extern const char kHistogramFontPreloadLargestContentfulPaint[];
+extern const char kHistogramFontPreloadLargestImagePaint[];
+extern const char kHistogramFontPreloadLargestTextPaint[];
 
 // Navigation metrics from the navigation start.
 extern const char
     kHistogramNavigationTimingNavigationStartToFirstRequestStart[];
 extern const char
     kHistogramNavigationTimingNavigationStartToFirstResponseStart[];
+extern const char
+    kHistogramNavigationTimingNavigationStartToFirstLoaderCallback[];
+extern const char
+    kHistogramNavigationTimingNavigationStartToFinalRequestStart[];
+extern const char
+    kHistogramNavigationTimingNavigationStartToFinalResponseStart[];
+extern const char
+    kHistogramNavigationTimingNavigationStartToFinalLoaderCallback[];
+extern const char
+    kHistogramNavigationTimingNavigationStartToNavigationCommitSent[];
 
 // Navigation metrics between milestones.
 extern const char
     kHistogramNavigationTimingFirstRequestStartToFirstResponseStart[];
+extern const char
+    kHistogramNavigationTimingFirstResponseStartToFirstLoaderCallback[];
+extern const char
+    kHistogramNavigationTimingFinalRequestStartToFinalResponseStart[];
+extern const char
+    kHistogramNavigationTimingFinalResponseStartToFinalLoaderCallback[];
+extern const char
+    kHistogramNavigationTimingFinalLoaderCallbackToNavigationCommitSent[];
+
+// 103 Early Hints metrics for experiment (https://crbug.com/1093693).
+extern const char kHistogramEarlyHintsFirstRequestStartToEarlyHints[];
+extern const char kHistogramEarlyHintsFinalRequestStartToEarlyHints[];
+extern const char kHistogramEarlyHintsEarlyHintsToFinalResponseStart[];
 
 enum FirstMeaningfulPaintStatus {
   FIRST_MEANINGFUL_PAINT_RECORDED,
@@ -181,14 +210,9 @@ class CorePageLoadMetricsObserver
       content::RenderFrameHost* rfh,
       const std::vector<page_load_metrics::mojom::ResourceDataUpdatePtr>&
           resources) override;
-  void OnTimingUpdate(
-      content::RenderFrameHost* subframe_rfh,
-      const page_load_metrics::mojom::PageLoadTiming& timing) override;
   void OnCpuTimingUpdate(
       content::RenderFrameHost* subframe_rfh,
       const page_load_metrics::mojom::CpuTiming& timing) override;
-  void OnDidFinishSubFrameNavigation(
-      content::NavigationHandle* navigation_handle) override;
   ObservePolicy OnEnterBackForwardCache(
       const page_load_metrics::mojom::PageLoadTiming& timing) override;
   void OnRestoreFromBackForwardCache(
@@ -197,8 +221,7 @@ class CorePageLoadMetricsObserver
                                  int behavior_flags) override;
 
  private:
-  void RecordNavigationTimingHistograms(
-      content::NavigationHandle* navigation_handle);
+  void RecordNavigationTimingHistograms();
   void RecordTimingHistograms(
       const page_load_metrics::mojom::PageLoadTiming& main_frame_timing);
   void RecordByteAndResourceHistograms(
@@ -208,6 +231,8 @@ class CorePageLoadMetricsObserver
       const page_load_metrics::mojom::PageLoadTiming& timing,
       base::TimeTicks app_background_time);
 
+  content::NavigationHandleTiming navigation_handle_timing_;
+
   ui::PageTransition transition_;
   bool was_no_store_main_resource_;
 
@@ -244,9 +269,6 @@ class CorePageLoadMetricsObserver
 
   base::TimeTicks first_paint_;
 
-  page_load_metrics::LargestContentfulPaintHandler
-      largest_contentful_paint_handler_;
-
   // Tracks user input clicks for possible click burst.
   page_load_metrics::ClickInputTracker click_tracker_;
 
diff --git a/chromium/components/page_load_metrics/browser/observers/core_page_load_metrics_observer_unittest.cc b/chromium/components/page_load_metrics/browser/observers/core_page_load_metrics_observer_unittest.cc
index f9e7623e6b0..123f97f986e 100644
--- a/chromium/components/page_load_metrics/browser/observers/core_page_load_metrics_observer_unittest.cc
+++ b/chromium/components/page_load_metrics/browser/observers/core_page_load_metrics_observer_unittest.cc
@@ -8,6 +8,7 @@
 
 #include "base/test/power_monitor_test_base.h"
 #include "components/page_load_metrics/browser/metrics_web_contents_observer.h"
+#include "components/page_load_metrics/browser/observers/largest_contentful_paint_handler.h"
 #include "components/page_load_metrics/browser/observers/page_load_metrics_observer_content_test_harness.h"
 #include "components/page_load_metrics/browser/page_load_metrics_util.h"
 #include "components/page_load_metrics/browser/page_load_tracker.h"
@@ -22,7 +23,7 @@ using content::NavigationSimulator;
 using content::RenderFrameHost;
 using content::RenderFrameHostTester;
 using LargestContentType =
-    page_load_metrics::PageLoadMetricsObserver::LargestContentType;
+    page_load_metrics::ContentfulPaintTimingInfo::LargestContentType;
 
 namespace {
 
@@ -57,6 +58,101 @@ class CorePageLoadMetricsObserverTest
     page_load_metrics::mojom::CpuTiming cpu_timing(cpu_time_spent);
     tester()->SimulateCpuTimingUpdate(cpu_timing, render_frame_host);
   }
+
+  void TestNoLCP() {
+    tester()->histogram_tester().ExpectTotalCount(
+        internal::kHistogramLargestContentfulPaint, 0);
+    tester()->histogram_tester().ExpectTotalCount(
+        internal::kHistogramLargestContentfulPaintContentType, 0);
+    tester()->histogram_tester().ExpectTotalCount(
+        internal::kHistogramLargestContentfulPaintMainFrame, 0);
+    tester()->histogram_tester().ExpectTotalCount(
+        internal::kHistogramLargestContentfulPaintMainFrameContentType, 0);
+
+    // Experimental values
+    tester()->histogram_tester().ExpectTotalCount(
+        internal::kHistogramExperimentalLargestContentfulPaint, 0);
+    tester()->histogram_tester().ExpectTotalCount(
+        internal::kHistogramExperimentalLargestContentfulPaintContentType, 0);
+    tester()->histogram_tester().ExpectTotalCount(
+        internal::kHistogramExperimentalLargestContentfulPaintMainFrame, 0);
+    tester()->histogram_tester().ExpectTotalCount(
+        internal::
+            kHistogramExperimentalLargestContentfulPaintMainFrameContentType,
+        0);
+  }
+
+  void TestAllFramesLCP(int value, LargestContentType type) {
+    EXPECT_THAT(tester()->histogram_tester().GetAllSamples(
+                    internal::kHistogramLargestContentfulPaint),
+                testing::ElementsAre(base::Bucket(value, 1)));
+    EXPECT_THAT(tester()->histogram_tester().GetAllSamples(
+                    internal::kHistogramLargestContentfulPaintContentType),
+                testing::ElementsAre(base::Bucket(
+                    static_cast<base::HistogramBase::Sample>(type), 1)));
+
+    // Experimental values
+    EXPECT_THAT(tester()->histogram_tester().GetAllSamples(
+                    internal::kHistogramExperimentalLargestContentfulPaint),
+                testing::ElementsAre(base::Bucket(value, 1)));
+    EXPECT_THAT(
+        tester()->histogram_tester().GetAllSamples(
+            internal::kHistogramExperimentalLargestContentfulPaintContentType),
+        testing::ElementsAre(
+            base::Bucket(static_cast<base::HistogramBase::Sample>(type), 1)));
+  }
+
+  void TestMainFrameLCP(int value, LargestContentType type) {
+    EXPECT_THAT(tester()->histogram_tester().GetAllSamples(
+                    internal::kHistogramLargestContentfulPaintMainFrame),
+                testing::ElementsAre(base::Bucket(value, 1)));
+    EXPECT_THAT(
+        tester()->histogram_tester().GetAllSamples(
+            internal::kHistogramLargestContentfulPaintMainFrameContentType),
+        testing::ElementsAre(
+            base::Bucket(static_cast<base::HistogramBase::Sample>(type), 1)));
+
+    // Experimental values
+    EXPECT_THAT(
+        tester()->histogram_tester().GetAllSamples(
+            internal::kHistogramExperimentalLargestContentfulPaintMainFrame),
+        testing::ElementsAre(base::Bucket(value, 1)));
+    EXPECT_THAT(
+        tester()->histogram_tester().GetAllSamples(
+            internal::
+                kHistogramExperimentalLargestContentfulPaintMainFrameContentType),
+        testing::ElementsAre(
+            base::Bucket(static_cast<base::HistogramBase::Sample>(type), 1)));
+  }
+
+  void TestEmptyMainFrameLCP() {
+    EXPECT_TRUE(
+        tester()
+            ->histogram_tester()
+            .GetAllSamples(internal::kHistogramLargestContentfulPaintMainFrame)
+            .empty());
+    EXPECT_TRUE(
+        tester()
+            ->histogram_tester()
+            .GetAllSamples(
+                internal::kHistogramLargestContentfulPaintMainFrameContentType)
+            .empty());
+
+    // Experimental LCP histograms
+    EXPECT_TRUE(
+        tester()
+            ->histogram_tester()
+            .GetAllSamples(
+                internal::kHistogramExperimentalLargestContentfulPaintMainFrame)
+            .empty());
+    EXPECT_TRUE(
+        tester()
+            ->histogram_tester()
+            .GetAllSamples(
+                internal::
+                    kHistogramExperimentalLargestContentfulPaintMainFrameContentType)
+            .empty());
+  }
 };
 
 TEST_F(CorePageLoadMetricsObserverTest, NoMetrics) {
@@ -508,18 +604,31 @@ TEST_F(CorePageLoadMetricsObserverTest, ForwardBack) {
 TEST_F(CorePageLoadMetricsObserverTest, NavigationTiming) {
   GURL url(kDefaultTestUrl);
   tester()->NavigateWithPageTransitionAndCommit(url, ui::PAGE_TRANSITION_LINK);
+  tester()->NavigateToUntrackedUrl();
 
   // Verify if the elapsed times from the navigation start are recorded.
   std::vector<const char*> metrics_from_navigation_start = {
       internal::kHistogramNavigationTimingNavigationStartToFirstRequestStart,
-      internal::kHistogramNavigationTimingNavigationStartToFirstResponseStart};
+      internal::kHistogramNavigationTimingNavigationStartToFirstResponseStart,
+      internal::kHistogramNavigationTimingNavigationStartToFirstLoaderCallback,
+      internal::kHistogramNavigationTimingNavigationStartToFinalRequestStart,
+      internal::kHistogramNavigationTimingNavigationStartToFinalResponseStart,
+      internal::kHistogramNavigationTimingNavigationStartToFinalLoaderCallback,
+      internal::
+          kHistogramNavigationTimingNavigationStartToNavigationCommitSent};
   for (const char* metric : metrics_from_navigation_start)
     tester()->histogram_tester().ExpectTotalCount(metric, 1);
 
   // Verify if the intervals between adjacent milestones are recorded.
   std::vector<const char*> metrics_between_milestones = {
+      internal::kHistogramNavigationTimingFirstRequestStartToFirstResponseStart,
+      internal::
+          kHistogramNavigationTimingFirstResponseStartToFirstLoaderCallback,
+      internal::kHistogramNavigationTimingFinalRequestStartToFinalResponseStart,
       internal::
-          kHistogramNavigationTimingFirstRequestStartToFirstResponseStart};
+          kHistogramNavigationTimingFinalResponseStartToFinalLoaderCallback,
+      internal::
+          kHistogramNavigationTimingFinalLoaderCallbackToNavigationCommitSent};
   for (const char* metric : metrics_between_milestones)
     tester()->histogram_tester().ExpectTotalCount(metric, 1);
 }
@@ -659,13 +768,16 @@ TEST_F(CorePageLoadMetricsObserverTest, LargestImageLoading) {
   page_load_metrics::InitPageLoadTimingForTest(&timing);
   timing.navigation_start = base::Time::FromDoubleT(1);
   // Largest image is loading so its timestamp is TimeDelta().
-  timing.paint_timing->largest_image_paint = base::TimeDelta();
-  timing.paint_timing->largest_image_paint_size = 100u;
+  timing.paint_timing->largest_contentful_paint->largest_image_paint =
+      base::TimeDelta();
+  timing.paint_timing->largest_contentful_paint->largest_image_paint_size =
+      100u;
   // There is a text paint but it's smaller than image. Pick a value that lines
   // up with a histogram bucket.
-  timing.paint_timing->largest_text_paint =
+  timing.paint_timing->largest_contentful_paint->largest_text_paint =
       base::TimeDelta::FromMilliseconds(4780);
-  timing.paint_timing->largest_text_paint_size = 70u;
+  timing.paint_timing->largest_contentful_paint->largest_text_paint_size = 70u;
+  PopulateExperimentalLCP(timing.paint_timing);
   PopulateRequiredTimingFields(&timing);
 
   NavigateAndCommit(GURL(kDefaultTestUrl));
@@ -674,8 +786,7 @@ TEST_F(CorePageLoadMetricsObserverTest, LargestImageLoading) {
   NavigateAndCommit(GURL(kDefaultTestUrl2));
 
   // The image was larger so LCP should NOT be reported.
-  tester()->histogram_tester().ExpectTotalCount(
-      internal::kHistogramLargestContentfulPaint, 0);
+  TestNoLCP();
 }
 
 TEST_F(CorePageLoadMetricsObserverTest, LargestImageLoadingSmallerThanText) {
@@ -683,13 +794,16 @@ TEST_F(CorePageLoadMetricsObserverTest, LargestImageLoadingSmallerThanText) {
   page_load_metrics::InitPageLoadTimingForTest(&timing);
   timing.navigation_start = base::Time::FromDoubleT(1);
   // Largest image is loading so its timestamp is TimeDelta().
-  timing.paint_timing->largest_image_paint = base::TimeDelta();
-  timing.paint_timing->largest_image_paint_size = 100u;
+  timing.paint_timing->largest_contentful_paint->largest_image_paint =
+      base::TimeDelta();
+  timing.paint_timing->largest_contentful_paint->largest_image_paint_size =
+      100u;
   // There is a text paint but it's smaller than image. Pick a value that lines
   // up with a histogram bucket.
-  timing.paint_timing->largest_text_paint =
+  timing.paint_timing->largest_contentful_paint->largest_text_paint =
       base::TimeDelta::FromMilliseconds(4780);
-  timing.paint_timing->largest_text_paint_size = 120u;
+  timing.paint_timing->largest_contentful_paint->largest_text_paint_size = 120u;
+  PopulateExperimentalLCP(timing.paint_timing);
   PopulateRequiredTimingFields(&timing);
 
   NavigateAndCommit(GURL(kDefaultTestUrl));
@@ -697,9 +811,7 @@ TEST_F(CorePageLoadMetricsObserverTest, LargestImageLoadingSmallerThanText) {
   // Navigate again to force histogram recording.
   NavigateAndCommit(GURL(kDefaultTestUrl2));
 
-  EXPECT_THAT(tester()->histogram_tester().GetAllSamples(
-                  internal::kHistogramLargestContentfulPaint),
-              testing::ElementsAre(base::Bucket(4780, 1)));
+  TestAllFramesLCP(4780, LargestContentType::kText);
 }
 
 TEST_F(CorePageLoadMetricsObserverTest,
@@ -716,9 +828,11 @@ TEST_F(CorePageLoadMetricsObserverTest,
   page_load_metrics::mojom::PageLoadTiming subframe_timing;
   page_load_metrics::InitPageLoadTimingForTest(&subframe_timing);
   subframe_timing.navigation_start = base::Time::FromDoubleT(200);
-  subframe_timing.paint_timing->largest_image_paint =
+  subframe_timing.paint_timing->largest_contentful_paint->largest_image_paint =
       base::TimeDelta::FromMilliseconds(4780);
-  subframe_timing.paint_timing->largest_image_paint_size = 100u;
+  subframe_timing.paint_timing->largest_contentful_paint
+      ->largest_image_paint_size = 100u;
+  PopulateExperimentalLCP(subframe_timing.paint_timing);
   PopulateRequiredTimingFields(&subframe_timing);
 
   // Commit the main frame and a subframe.
@@ -736,26 +850,8 @@ TEST_F(CorePageLoadMetricsObserverTest,
   // Navigate again to force histogram recording in the main frame.
   NavigateAndCommit(GURL(kDefaultTestUrl2));
 
-  EXPECT_THAT(tester()->histogram_tester().GetAllSamples(
-                  internal::kHistogramLargestContentfulPaint),
-              testing::ElementsAre(base::Bucket(4780, 1)));
-  EXPECT_THAT(
-      tester()->histogram_tester().GetAllSamples(
-          internal::kHistogramLargestContentfulPaintContentType),
-      testing::ElementsAre(base::Bucket(
-          static_cast<base::HistogramBase::Sample>(LargestContentType::kImage),
-          1)));
-  EXPECT_TRUE(
-      tester()
-          ->histogram_tester()
-          .GetAllSamples(internal::kHistogramLargestContentfulPaintMainFrame)
-          .empty());
-  EXPECT_TRUE(
-      tester()
-          ->histogram_tester()
-          .GetAllSamples(
-              internal::kHistogramLargestContentfulPaintMainFrameContentType)
-          .empty());
+  TestAllFramesLCP(4780, LargestContentType::kImage);
+  TestEmptyMainFrameLCP();
 }
 
 TEST_F(CorePageLoadMetricsObserverTest,
@@ -772,11 +868,15 @@ TEST_F(CorePageLoadMetricsObserverTest,
   page_load_metrics::mojom::PageLoadTiming subframe_timing;
   page_load_metrics::InitPageLoadTimingForTest(&subframe_timing);
   subframe_timing.navigation_start = base::Time::FromDoubleT(200);
-  subframe_timing.paint_timing->largest_image_paint = base::TimeDelta();
-  subframe_timing.paint_timing->largest_image_paint_size = 100u;
-  subframe_timing.paint_timing->largest_text_paint =
+  subframe_timing.paint_timing->largest_contentful_paint->largest_image_paint =
+      base::TimeDelta();
+  subframe_timing.paint_timing->largest_contentful_paint
+      ->largest_image_paint_size = 100u;
+  subframe_timing.paint_timing->largest_contentful_paint->largest_text_paint =
       base::TimeDelta::FromMilliseconds(500);
-  subframe_timing.paint_timing->largest_text_paint_size = 80u;
+  subframe_timing.paint_timing->largest_contentful_paint
+      ->largest_text_paint_size = 80u;
+  PopulateExperimentalLCP(subframe_timing.paint_timing);
   PopulateRequiredTimingFields(&subframe_timing);
 
   // Commit the main frame and a subframe.
@@ -794,14 +894,7 @@ TEST_F(CorePageLoadMetricsObserverTest,
   // Navigate again to force histogram recording in the main frame.
   NavigateAndCommit(GURL(kDefaultTestUrl2));
 
-  tester()->histogram_tester().ExpectTotalCount(
-      internal::kHistogramLargestContentfulPaint, 0);
-  tester()->histogram_tester().ExpectTotalCount(
-      internal::kHistogramLargestContentfulPaintContentType, 0);
-  tester()->histogram_tester().ExpectTotalCount(
-      internal::kHistogramLargestContentfulPaintMainFrame, 0);
-  tester()->histogram_tester().ExpectTotalCount(
-      internal::kHistogramLargestContentfulPaintMainFrameContentType, 0);
+  TestNoLCP();
 }
 
 TEST_F(CorePageLoadMetricsObserverTest,
@@ -812,9 +905,10 @@ TEST_F(CorePageLoadMetricsObserverTest,
   page_load_metrics::InitPageLoadTimingForTest(&timing);
   timing.navigation_start = base::Time::FromDoubleT(1);
   // Pick a value that lines up with a histogram bucket.
-  timing.paint_timing->largest_image_paint =
+  timing.paint_timing->largest_contentful_paint->largest_image_paint =
       base::TimeDelta::FromMilliseconds(4780);
-  timing.paint_timing->largest_image_paint_size = 50u;
+  timing.paint_timing->largest_contentful_paint->largest_image_paint_size = 50u;
+  PopulateExperimentalLCP(timing.paint_timing);
   PopulateRequiredTimingFields(&timing);
 
   page_load_metrics::mojom::PageLoadTiming subframe_timing;
@@ -838,24 +932,8 @@ TEST_F(CorePageLoadMetricsObserverTest,
   // Navigate again to force histogram recording in the main frame.
   NavigateAndCommit(GURL(kDefaultTestUrl2));
 
-  EXPECT_THAT(tester()->histogram_tester().GetAllSamples(
-                  internal::kHistogramLargestContentfulPaint),
-              testing::ElementsAre(base::Bucket(4780, 1)));
-  EXPECT_THAT(
-      tester()->histogram_tester().GetAllSamples(
-          internal::kHistogramLargestContentfulPaintContentType),
-      testing::ElementsAre(base::Bucket(
-          static_cast<base::HistogramBase::Sample>(LargestContentType::kImage),
-          1)));
-  EXPECT_THAT(tester()->histogram_tester().GetAllSamples(
-                  internal::kHistogramLargestContentfulPaintMainFrame),
-              testing::ElementsAre(base::Bucket(4780, 1)));
-  EXPECT_THAT(
-      tester()->histogram_tester().GetAllSamples(
-          internal::kHistogramLargestContentfulPaintMainFrameContentType),
-      testing::ElementsAre(base::Bucket(
-          static_cast<base::HistogramBase::Sample>(LargestContentType::kImage),
-          1)));
+  TestAllFramesLCP(4780, LargestContentType::kImage);
+  TestMainFrameLCP(4780, LargestContentType::kImage);
 }
 
 // This is to test whether LargestContentfulPaintAllFrames could merge
@@ -870,18 +948,21 @@ TEST_F(CorePageLoadMetricsObserverTest,
   page_load_metrics::InitPageLoadTimingForTest(&timing);
   timing.navigation_start = base::Time::FromDoubleT(1);
   // Pick a value that lines up with a histogram bucket.
-  timing.paint_timing->largest_image_paint =
+  timing.paint_timing->largest_contentful_paint->largest_image_paint =
       base::TimeDelta::FromMilliseconds(9382);
-  timing.paint_timing->largest_image_paint_size = 50u;
+  timing.paint_timing->largest_contentful_paint->largest_image_paint_size = 50u;
+  PopulateExperimentalLCP(timing.paint_timing);
   PopulateRequiredTimingFields(&timing);
 
   // Create a candidate in subframe with a larger size.
   page_load_metrics::mojom::PageLoadTiming subframe_timing;
   page_load_metrics::InitPageLoadTimingForTest(&subframe_timing);
   subframe_timing.navigation_start = base::Time::FromDoubleT(2);
-  subframe_timing.paint_timing->largest_image_paint =
+  subframe_timing.paint_timing->largest_contentful_paint->largest_image_paint =
       base::TimeDelta::FromMilliseconds(4780);
-  subframe_timing.paint_timing->largest_image_paint_size = 100u;
+  subframe_timing.paint_timing->largest_contentful_paint
+      ->largest_image_paint_size = 100u;
+  PopulateExperimentalLCP(subframe_timing.paint_timing);
   PopulateRequiredTimingFields(&subframe_timing);
 
   // Commit the main frame and a subframe.
@@ -899,25 +980,8 @@ TEST_F(CorePageLoadMetricsObserverTest,
   // Navigate again to force histogram recording in the main frame.
   NavigateAndCommit(GURL(kDefaultTestUrl2));
 
-  EXPECT_THAT(tester()->histogram_tester().GetAllSamples(
-                  internal::kHistogramLargestContentfulPaint),
-              testing::ElementsAre(base::Bucket(4780, 1)));
-  EXPECT_THAT(
-      tester()->histogram_tester().GetAllSamples(
-          internal::kHistogramLargestContentfulPaintContentType),
-      testing::ElementsAre(base::Bucket(
-          static_cast<base::HistogramBase::Sample>(LargestContentType::kImage),
-          1)));
-
-  EXPECT_THAT(tester()->histogram_tester().GetAllSamples(
-                  internal::kHistogramLargestContentfulPaintMainFrame),
-              testing::ElementsAre(base::Bucket(9382, 1)));
-  EXPECT_THAT(
-      tester()->histogram_tester().GetAllSamples(
-          internal::kHistogramLargestContentfulPaintMainFrameContentType),
-      testing::ElementsAre(base::Bucket(
-          static_cast<base::HistogramBase::Sample>(LargestContentType::kImage),
-          1)));
+  TestAllFramesLCP(4780, LargestContentType::kImage);
+  TestMainFrameLCP(9382, LargestContentType::kImage);
 }
 
 // This is to test whether LargestContentfulPaintAllFrames could merge
@@ -931,18 +995,21 @@ TEST_F(CorePageLoadMetricsObserverTest,
   page_load_metrics::InitPageLoadTimingForTest(&timing);
   timing.navigation_start = base::Time::FromDoubleT(1);
   // Pick a value that lines up with a histogram bucket.
-  timing.paint_timing->largest_text_paint =
+  timing.paint_timing->largest_contentful_paint->largest_text_paint =
       base::TimeDelta::FromMilliseconds(4780);
-  timing.paint_timing->largest_text_paint_size = 100u;
+  timing.paint_timing->largest_contentful_paint->largest_text_paint_size = 100u;
+  PopulateExperimentalLCP(timing.paint_timing);
   PopulateRequiredTimingFields(&timing);
 
   // Create a candidate in subframe with a smaller size.
   page_load_metrics::mojom::PageLoadTiming subframe_timing;
   page_load_metrics::InitPageLoadTimingForTest(&subframe_timing);
   subframe_timing.navigation_start = base::Time::FromDoubleT(2);
-  subframe_timing.paint_timing->largest_text_paint =
+  subframe_timing.paint_timing->largest_contentful_paint->largest_text_paint =
       base::TimeDelta::FromMilliseconds(300);
-  subframe_timing.paint_timing->largest_text_paint_size = 50u;
+  subframe_timing.paint_timing->largest_contentful_paint
+      ->largest_text_paint_size = 50u;
+  PopulateExperimentalLCP(subframe_timing.paint_timing);
   PopulateRequiredTimingFields(&subframe_timing);
 
   // Commit the main frame and a subframe.
@@ -960,25 +1027,8 @@ TEST_F(CorePageLoadMetricsObserverTest,
   // Navigate again to force histogram recording in the main frame.
   NavigateAndCommit(GURL(kDefaultTestUrl2));
 
-  EXPECT_THAT(tester()->histogram_tester().GetAllSamples(
-                  internal::kHistogramLargestContentfulPaint),
-              testing::ElementsAre(base::Bucket(4780, 1)));
-  EXPECT_THAT(
-      tester()->histogram_tester().GetAllSamples(
-          internal::kHistogramLargestContentfulPaintContentType),
-      testing::ElementsAre(base::Bucket(
-          static_cast<base::HistogramBase::Sample>(LargestContentType::kText),
-          1)));
-
-  EXPECT_THAT(tester()->histogram_tester().GetAllSamples(
-                  internal::kHistogramLargestContentfulPaintMainFrame),
-              testing::ElementsAre(base::Bucket(4780, 1)));
-  EXPECT_THAT(
-      tester()->histogram_tester().GetAllSamples(
-          internal::kHistogramLargestContentfulPaintMainFrameContentType),
-      testing::ElementsAre(base::Bucket(
-          static_cast<base::HistogramBase::Sample>(LargestContentType::kText),
-          1)));
+  TestAllFramesLCP(4780, LargestContentType::kText);
+  TestMainFrameLCP(4780, LargestContentType::kText);
 }
 
 // This tests a trade-off we have made - aggregating all subframe candidates,
@@ -997,9 +1047,11 @@ TEST_F(CorePageLoadMetricsObserverTest,
   page_load_metrics::mojom::PageLoadTiming subframe_timing;
   page_load_metrics::InitPageLoadTimingForTest(&subframe_timing);
   subframe_timing.navigation_start = base::Time::FromDoubleT(2);
-  subframe_timing.paint_timing->largest_image_paint =
+  subframe_timing.paint_timing->largest_contentful_paint->largest_image_paint =
       base::TimeDelta::FromMilliseconds(4780);
-  subframe_timing.paint_timing->largest_image_paint_size = 50u;
+  subframe_timing.paint_timing->largest_contentful_paint
+      ->largest_image_paint_size = 50u;
+  PopulateExperimentalLCP(subframe_timing.paint_timing);
   PopulateRequiredTimingFields(&subframe_timing);
 
   // Commit the main frame and a subframe.
@@ -1014,24 +1066,18 @@ TEST_F(CorePageLoadMetricsObserverTest,
   tester()->SimulateTimingUpdate(timing);
   tester()->SimulateTimingUpdate(subframe_timing, subframe);
 
-  subframe_timing.paint_timing->largest_image_paint =
+  subframe_timing.paint_timing->largest_contentful_paint->largest_image_paint =
       base::TimeDelta::FromMilliseconds(300);
-  subframe_timing.paint_timing->largest_image_paint_size = 10u;
+  subframe_timing.paint_timing->largest_contentful_paint
+      ->largest_image_paint_size = 10u;
+  PopulateExperimentalLCP(subframe_timing.paint_timing);
   tester()->SimulateTimingUpdate(subframe_timing, subframe);
 
   // Navigate again to force histogram recording in the main frame.
   NavigateAndCommit(GURL(kDefaultTestUrl2));
 
   // Ensure that the largest_image_paint timing for the main frame is recorded.
-  EXPECT_THAT(tester()->histogram_tester().GetAllSamples(
-                  internal::kHistogramLargestContentfulPaint),
-              testing::ElementsAre(base::Bucket(4780, 1)));
-  EXPECT_THAT(
-      tester()->histogram_tester().GetAllSamples(
-          internal::kHistogramLargestContentfulPaintContentType),
-      testing::ElementsAre(base::Bucket(
-          static_cast<base::HistogramBase::Sample>(LargestContentType::kImage),
-          1)));
+  TestAllFramesLCP(4780, LargestContentType::kImage);
 }
 
 // This tests a trade-off we have made - aggregating all subframe candidates,
@@ -1051,9 +1097,11 @@ TEST_F(
   page_load_metrics::mojom::PageLoadTiming subframe_timing;
   page_load_metrics::InitPageLoadTimingForTest(&subframe_timing);
   subframe_timing.navigation_start = base::Time::FromDoubleT(2);
-  subframe_timing.paint_timing->largest_image_paint =
+  subframe_timing.paint_timing->largest_contentful_paint->largest_image_paint =
       base::TimeDelta::FromMilliseconds(4780);
-  subframe_timing.paint_timing->largest_image_paint_size = 10u;
+  subframe_timing.paint_timing->largest_contentful_paint
+      ->largest_image_paint_size = 10u;
+  PopulateExperimentalLCP(subframe_timing.paint_timing);
   PopulateRequiredTimingFields(&subframe_timing);
 
   // Commit the main frame and a subframe.
@@ -1068,24 +1116,18 @@ TEST_F(
   tester()->SimulateTimingUpdate(timing);
   tester()->SimulateTimingUpdate(subframe_timing, subframe);
 
-  subframe_timing.paint_timing->largest_image_paint =
+  subframe_timing.paint_timing->largest_contentful_paint->largest_image_paint =
       base::TimeDelta::FromMilliseconds(990);
-  subframe_timing.paint_timing->largest_image_paint_size = 50u;
+  subframe_timing.paint_timing->largest_contentful_paint
+      ->largest_image_paint_size = 50u;
+  PopulateExperimentalLCP(subframe_timing.paint_timing);
   tester()->SimulateTimingUpdate(subframe_timing, subframe);
 
   // Navigate again to force histogram recording in the main frame.
   NavigateAndCommit(GURL(kDefaultTestUrl2));
 
   // Ensure that the largest_image_paint timing for the main frame is recorded.
-  EXPECT_THAT(tester()->histogram_tester().GetAllSamples(
-                  internal::kHistogramLargestContentfulPaint),
-              testing::ElementsAre(base::Bucket(990, 1)));
-  EXPECT_THAT(
-      tester()->histogram_tester().GetAllSamples(
-          internal::kHistogramLargestContentfulPaintContentType),
-      testing::ElementsAre(base::Bucket(
-          static_cast<base::HistogramBase::Sample>(LargestContentType::kImage),
-          1)));
+  TestAllFramesLCP(990, LargestContentType::kImage);
 }
 
 TEST_F(CorePageLoadMetricsObserverTest, LargestContentfulPaint_NoTextOrImage) {
@@ -1094,7 +1136,8 @@ TEST_F(CorePageLoadMetricsObserverTest, LargestContentfulPaint_NoTextOrImage) {
   timing.navigation_start = base::Time::FromDoubleT(1);
   // When the size is 0, the timing is regarded as not set and should be
   // excluded from recording to UMA.
-  timing.paint_timing->largest_text_paint_size = 0u;
+  timing.paint_timing->largest_contentful_paint->largest_text_paint_size = 0u;
+  PopulateExperimentalLCP(timing.paint_timing);
   PopulateRequiredTimingFields(&timing);
 
   NavigateAndCommit(GURL(kDefaultTestUrl));
@@ -1102,14 +1145,7 @@ TEST_F(CorePageLoadMetricsObserverTest, LargestContentfulPaint_NoTextOrImage) {
   // Navigate again to force histogram recording.
   NavigateAndCommit(GURL(kDefaultTestUrl2));
 
-  tester()->histogram_tester().ExpectTotalCount(
-      internal::kHistogramLargestContentfulPaint, 0);
-  tester()->histogram_tester().ExpectTotalCount(
-      internal::kHistogramLargestContentfulPaintContentType, 0);
-  tester()->histogram_tester().ExpectTotalCount(
-      internal::kHistogramLargestContentfulPaintMainFrame, 0);
-  tester()->histogram_tester().ExpectTotalCount(
-      internal::kHistogramLargestContentfulPaintMainFrameContentType, 0);
+  TestNoLCP();
 }
 
 TEST_F(CorePageLoadMetricsObserverTest, LargestContentfulPaint_OnlyText) {
@@ -1117,9 +1153,10 @@ TEST_F(CorePageLoadMetricsObserverTest, LargestContentfulPaint_OnlyText) {
   page_load_metrics::InitPageLoadTimingForTest(&timing);
   timing.navigation_start = base::Time::FromDoubleT(1);
   // Pick a value that lines up with a histogram bucket.
-  timing.paint_timing->largest_text_paint =
+  timing.paint_timing->largest_contentful_paint->largest_text_paint =
       base::TimeDelta::FromMilliseconds(4780);
-  timing.paint_timing->largest_text_paint_size = 100;
+  timing.paint_timing->largest_contentful_paint->largest_text_paint_size = 100;
+  PopulateExperimentalLCP(timing.paint_timing);
   PopulateRequiredTimingFields(&timing);
 
   NavigateAndCommit(GURL(kDefaultTestUrl));
@@ -1127,15 +1164,7 @@ TEST_F(CorePageLoadMetricsObserverTest, LargestContentfulPaint_OnlyText) {
   // Navigate again to force histogram recording.
   NavigateAndCommit(GURL(kDefaultTestUrl2));
 
-  EXPECT_THAT(tester()->histogram_tester().GetAllSamples(
-                  internal::kHistogramLargestContentfulPaint),
-              testing::ElementsAre(base::Bucket(4780, 1)));
-  EXPECT_THAT(
-      tester()->histogram_tester().GetAllSamples(
-          internal::kHistogramLargestContentfulPaintContentType),
-      testing::ElementsAre(base::Bucket(
-          static_cast<base::HistogramBase::Sample>(LargestContentType::kText),
-          1)));
+  TestAllFramesLCP(4780, LargestContentType::kText);
 }
 
 TEST_F(CorePageLoadMetricsObserverTest, LargestContentfulPaint_OnlyImage) {
@@ -1143,9 +1172,10 @@ TEST_F(CorePageLoadMetricsObserverTest, LargestContentfulPaint_OnlyImage) {
   page_load_metrics::InitPageLoadTimingForTest(&timing);
   timing.navigation_start = base::Time::FromDoubleT(1);
   // Pick a value that lines up with a histogram bucket.
-  timing.paint_timing->largest_image_paint =
+  timing.paint_timing->largest_contentful_paint->largest_image_paint =
       base::TimeDelta::FromMilliseconds(4780);
-  timing.paint_timing->largest_image_paint_size = 100;
+  timing.paint_timing->largest_contentful_paint->largest_image_paint_size = 100;
+  PopulateExperimentalLCP(timing.paint_timing);
   PopulateRequiredTimingFields(&timing);
 
   NavigateAndCommit(GURL(kDefaultTestUrl));
@@ -1153,15 +1183,7 @@ TEST_F(CorePageLoadMetricsObserverTest, LargestContentfulPaint_OnlyImage) {
   // Navigate again to force histogram recording.
   NavigateAndCommit(GURL(kDefaultTestUrl2));
 
-  EXPECT_THAT(tester()->histogram_tester().GetAllSamples(
-                  internal::kHistogramLargestContentfulPaint),
-              testing::ElementsAre(base::Bucket(4780, 1)));
-  EXPECT_THAT(
-      tester()->histogram_tester().GetAllSamples(
-          internal::kHistogramLargestContentfulPaintContentType),
-      testing::ElementsAre(base::Bucket(
-          static_cast<base::HistogramBase::Sample>(LargestContentType::kImage),
-          1)));
+  TestAllFramesLCP(4780, LargestContentType::kImage);
 }
 
 TEST_F(CorePageLoadMetricsObserverTest,
@@ -1170,12 +1192,13 @@ TEST_F(CorePageLoadMetricsObserverTest,
   page_load_metrics::InitPageLoadTimingForTest(&timing);
   timing.navigation_start = base::Time::FromDoubleT(1);
   // Pick a value that lines up with a histogram bucket.
-  timing.paint_timing->largest_image_paint =
+  timing.paint_timing->largest_contentful_paint->largest_image_paint =
       base::TimeDelta::FromMilliseconds(4780);
-  timing.paint_timing->largest_image_paint_size = 100;
-  timing.paint_timing->largest_text_paint =
+  timing.paint_timing->largest_contentful_paint->largest_image_paint_size = 100;
+  timing.paint_timing->largest_contentful_paint->largest_text_paint =
       base::TimeDelta::FromMilliseconds(1000);
-  timing.paint_timing->largest_text_paint_size = 10;
+  timing.paint_timing->largest_contentful_paint->largest_text_paint_size = 10;
+  PopulateExperimentalLCP(timing.paint_timing);
   PopulateRequiredTimingFields(&timing);
 
   NavigateAndCommit(GURL(kDefaultTestUrl));
@@ -1183,15 +1206,7 @@ TEST_F(CorePageLoadMetricsObserverTest,
   // Navigate again to force histogram recording.
   NavigateAndCommit(GURL(kDefaultTestUrl2));
 
-  EXPECT_THAT(tester()->histogram_tester().GetAllSamples(
-                  internal::kHistogramLargestContentfulPaint),
-              testing::ElementsAre(base::Bucket(4780, 1)));
-  EXPECT_THAT(
-      tester()->histogram_tester().GetAllSamples(
-          internal::kHistogramLargestContentfulPaintContentType),
-      testing::ElementsAre(base::Bucket(
-          static_cast<base::HistogramBase::Sample>(LargestContentType::kImage),
-          1)));
+  TestAllFramesLCP(4780, LargestContentType::kImage);
 }
 
 TEST_F(CorePageLoadMetricsObserverTest,
@@ -1199,13 +1214,14 @@ TEST_F(CorePageLoadMetricsObserverTest,
   page_load_metrics::mojom::PageLoadTiming timing;
   page_load_metrics::InitPageLoadTimingForTest(&timing);
   timing.navigation_start = base::Time::FromDoubleT(1);
-  timing.paint_timing->largest_image_paint =
+  timing.paint_timing->largest_contentful_paint->largest_image_paint =
       base::TimeDelta::FromMilliseconds(4780);
-  timing.paint_timing->largest_image_paint_size = 10;
+  timing.paint_timing->largest_contentful_paint->largest_image_paint_size = 10;
   // Pick a value that lines up with a histogram bucket.
-  timing.paint_timing->largest_text_paint =
+  timing.paint_timing->largest_contentful_paint->largest_text_paint =
       base::TimeDelta::FromMilliseconds(990);
-  timing.paint_timing->largest_text_paint_size = 100;
+  timing.paint_timing->largest_contentful_paint->largest_text_paint_size = 100;
+  PopulateExperimentalLCP(timing.paint_timing);
   PopulateRequiredTimingFields(&timing);
 
   NavigateAndCommit(GURL(kDefaultTestUrl));
@@ -1213,15 +1229,7 @@ TEST_F(CorePageLoadMetricsObserverTest,
   // Navigate again to force histogram recording.
   NavigateAndCommit(GURL(kDefaultTestUrl2));
 
-  EXPECT_THAT(tester()->histogram_tester().GetAllSamples(
-                  internal::kHistogramLargestContentfulPaint),
-              testing::ElementsAre(base::Bucket(990, 1)));
-  EXPECT_THAT(
-      tester()->histogram_tester().GetAllSamples(
-          internal::kHistogramLargestContentfulPaintContentType),
-      testing::ElementsAre(base::Bucket(
-          static_cast<base::HistogramBase::Sample>(LargestContentType::kText),
-          1)));
+  TestAllFramesLCP(990, LargestContentType::kText);
 }
 
 TEST_F(CorePageLoadMetricsObserverTest, ForegroundToFirstMeaningfulPaint) {
@@ -1423,12 +1431,13 @@ TEST_F(CorePageLoadMetricsObserverTest, FontPreloadHistogramsNotObserved) {
   timing.paint_timing->first_paint = base::TimeDelta::FromMilliseconds(150);
   timing.paint_timing->first_contentful_paint =
       base::TimeDelta::FromMilliseconds(200);
-  timing.paint_timing->largest_text_paint =
+  timing.paint_timing->largest_contentful_paint->largest_text_paint =
       base::TimeDelta::FromMilliseconds(250);
-  timing.paint_timing->largest_text_paint_size = 100u;
-  timing.paint_timing->largest_image_paint =
+  timing.paint_timing->largest_contentful_paint->largest_text_paint_size = 100u;
+  timing.paint_timing->largest_contentful_paint->largest_image_paint =
       base::TimeDelta::FromMilliseconds(250);
-  timing.paint_timing->largest_image_paint_size = 100u;
+  timing.paint_timing->largest_contentful_paint->largest_image_paint_size =
+      100u;
   PopulateRequiredTimingFields(&timing);
 
   NavigateAndCommit(GURL("https://www.google.com/"));
@@ -1443,6 +1452,10 @@ TEST_F(CorePageLoadMetricsObserverTest, FontPreloadHistogramsNotObserved) {
       internal::kHistogramFontPreloadFirstContentfulPaint, 0);
   tester()->histogram_tester().ExpectTotalCount(
       internal::kHistogramFontPreloadLargestContentfulPaint, 0);
+  tester()->histogram_tester().ExpectTotalCount(
+      internal::kHistogramFontPreloadLargestImagePaint, 0);
+  tester()->histogram_tester().ExpectTotalCount(
+      internal::kHistogramFontPreloadLargestTextPaint, 0);
 }
 
 // PageLoad.Clients.FontPreload.* should be recorded when the behavior is
@@ -1456,12 +1469,13 @@ TEST_F(CorePageLoadMetricsObserverTest, FontPreloadHistogramsObserved) {
   timing.paint_timing->first_paint = base::TimeDelta::FromMilliseconds(150);
   timing.paint_timing->first_contentful_paint =
       base::TimeDelta::FromMilliseconds(200);
-  timing.paint_timing->largest_text_paint =
+  timing.paint_timing->largest_contentful_paint->largest_text_paint =
       base::TimeDelta::FromMilliseconds(250);
-  timing.paint_timing->largest_text_paint_size = 100u;
-  timing.paint_timing->largest_image_paint =
+  timing.paint_timing->largest_contentful_paint->largest_text_paint_size = 100u;
+  timing.paint_timing->largest_contentful_paint->largest_image_paint =
       base::TimeDelta::FromMilliseconds(250);
-  timing.paint_timing->largest_image_paint_size = 100u;
+  timing.paint_timing->largest_contentful_paint->largest_image_paint_size =
+      100u;
   PopulateRequiredTimingFields(&timing);
 
   // Note: PageLoadMetrics internally processes loading behavior before timing
@@ -1481,6 +1495,10 @@ TEST_F(CorePageLoadMetricsObserverTest, FontPreloadHistogramsObserved) {
       internal::kHistogramFontPreloadFirstContentfulPaint, 1);
   tester()->histogram_tester().ExpectTotalCount(
       internal::kHistogramFontPreloadLargestContentfulPaint, 1);
+  tester()->histogram_tester().ExpectTotalCount(
+      internal::kHistogramFontPreloadLargestImagePaint, 1);
+  tester()->histogram_tester().ExpectTotalCount(
+      internal::kHistogramFontPreloadLargestTextPaint, 1);
 }
 
 // PageLoad.Clients.FontPreload.* depends on the order that, we need to first
@@ -1497,12 +1515,13 @@ TEST_F(CorePageLoadMetricsObserverTest,
   timing.paint_timing->first_paint = base::TimeDelta::FromMilliseconds(150);
   timing.paint_timing->first_contentful_paint =
       base::TimeDelta::FromMilliseconds(200);
-  timing.paint_timing->largest_text_paint =
+  timing.paint_timing->largest_contentful_paint->largest_text_paint =
       base::TimeDelta::FromMilliseconds(250);
-  timing.paint_timing->largest_text_paint_size = 100u;
-  timing.paint_timing->largest_image_paint =
+  timing.paint_timing->largest_contentful_paint->largest_text_paint_size = 100u;
+  timing.paint_timing->largest_contentful_paint->largest_image_paint =
       base::TimeDelta::FromMilliseconds(250);
-  timing.paint_timing->largest_image_paint_size = 100u;
+  timing.paint_timing->largest_contentful_paint->largest_image_paint_size =
+      100u;
   PopulateRequiredTimingFields(&timing);
 
   // Note: PageLoadMetrics internally processes loading behavior before timing
@@ -1523,7 +1542,12 @@ TEST_F(CorePageLoadMetricsObserverTest,
   tester()->histogram_tester().ExpectTotalCount(
       internal::kHistogramFontPreloadFirstContentfulPaint, 0);
 
-  // LCP is recorded on page complete/closing, so it can still be observed.
+  // Largest*Paint is recorded on page complete/closing, so they can still be
+  // observed.
   tester()->histogram_tester().ExpectTotalCount(
       internal::kHistogramFontPreloadLargestContentfulPaint, 1);
+  tester()->histogram_tester().ExpectTotalCount(
+      internal::kHistogramFontPreloadLargestImagePaint, 1);
+  tester()->histogram_tester().ExpectTotalCount(
+      internal::kHistogramFontPreloadLargestTextPaint, 1);
 }
diff --git a/chromium/components/page_load_metrics/browser/observers/largest_contentful_paint_handler.cc b/chromium/components/page_load_metrics/browser/observers/largest_contentful_paint_handler.cc
index c338e901f66..ea407015ecb 100644
--- a/chromium/components/page_load_metrics/browser/observers/largest_contentful_paint_handler.cc
+++ b/chromium/components/page_load_metrics/browser/observers/largest_contentful_paint_handler.cc
@@ -6,6 +6,7 @@
 
 #include "components/page_load_metrics/browser/page_load_metrics_observer_delegate.h"
 #include "components/page_load_metrics/common/page_load_metrics.mojom.h"
+#include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_frame_host.h"
 
 namespace page_load_metrics {
@@ -63,9 +64,8 @@ void Reset(ContentfulPaintTimingInfo& timing) {
 
 }  // namespace
 
-ContentfulPaintTimingInfo::ContentfulPaintTimingInfo(
-    PageLoadMetricsObserver::LargestContentType type,
-    bool in_main_frame)
+ContentfulPaintTimingInfo::ContentfulPaintTimingInfo(LargestContentType type,
+                                                     bool in_main_frame)
     : time_(base::Optional<base::TimeDelta>()),
       size_(0),
       type_(type),
@@ -73,7 +73,7 @@ ContentfulPaintTimingInfo::ContentfulPaintTimingInfo(
 ContentfulPaintTimingInfo::ContentfulPaintTimingInfo(
     const base::Optional<base::TimeDelta>& time,
     const uint64_t& size,
-    const page_load_metrics::PageLoadMetricsObserver::LargestContentType type,
+    const LargestContentType type,
     bool in_main_frame)
     : time_(time), size_(size), type_(type), in_main_frame_(in_main_frame) {}
 
@@ -93,9 +93,9 @@ ContentfulPaintTimingInfo::DataAsTraceValue() const {
 
 std::string ContentfulPaintTimingInfo::TypeInString() const {
   switch (Type()) {
-    case page_load_metrics::PageLoadMetricsObserver::LargestContentType::kText:
+    case LargestContentType::kText:
       return "text";
-    case page_load_metrics::PageLoadMetricsObserver::LargestContentType::kImage:
+    case LargestContentType::kImage:
       return "image";
     default:
       NOTREACHED();
@@ -114,16 +114,50 @@ void ContentfulPaintTimingInfo::Reset(
   size_ = size;
   time_ = time;
 }
-
 ContentfulPaint::ContentfulPaint(bool in_main_frame)
-    : text_(PageLoadMetricsObserver::LargestContentType::kText, in_main_frame),
-      image_(PageLoadMetricsObserver::LargestContentType::kImage,
+    : text_(ContentfulPaintTimingInfo::LargestContentType::kText,
+            in_main_frame),
+      image_(ContentfulPaintTimingInfo::LargestContentType::kImage,
              in_main_frame) {}
 
-const ContentfulPaintTimingInfo& ContentfulPaint::MergeTextAndImageTiming() {
+const ContentfulPaintTimingInfo& ContentfulPaint::MergeTextAndImageTiming()
+    const {
   return MergeTimingsBySizeAndTime(text_, image_);
 }
 
+// static
+bool LargestContentfulPaintHandler::AssignTimeAndSizeForLargestContentfulPaint(
+    const page_load_metrics::mojom::LargestContentfulPaintTiming&
+        largest_contentful_paint,
+    base::Optional<base::TimeDelta>* largest_content_paint_time,
+    uint64_t* largest_content_paint_size,
+    ContentfulPaintTimingInfo::LargestContentType* largest_content_type) {
+  // Size being 0 means the paint time is not recorded.
+  if (!largest_contentful_paint.largest_text_paint_size &&
+      !largest_contentful_paint.largest_image_paint_size)
+    return false;
+
+  if ((largest_contentful_paint.largest_text_paint_size >
+       largest_contentful_paint.largest_image_paint_size) ||
+      (largest_contentful_paint.largest_text_paint_size ==
+           largest_contentful_paint.largest_image_paint_size &&
+       largest_contentful_paint.largest_text_paint <
+           largest_contentful_paint.largest_image_paint)) {
+    *largest_content_paint_time = largest_contentful_paint.largest_text_paint;
+    *largest_content_paint_size =
+        largest_contentful_paint.largest_text_paint_size;
+    *largest_content_type =
+        ContentfulPaintTimingInfo::LargestContentType::kText;
+  } else {
+    *largest_content_paint_time = largest_contentful_paint.largest_image_paint;
+    *largest_content_paint_size =
+        largest_contentful_paint.largest_image_paint_size;
+    *largest_content_type =
+        ContentfulPaintTimingInfo::LargestContentType::kImage;
+  }
+  return true;
+}
+
 LargestContentfulPaintHandler::LargestContentfulPaintHandler()
     : main_frame_contentful_paint_(true /*in_main_frame*/),
       subframe_contentful_paint_(false /*in_main_frame*/) {}
@@ -131,10 +165,14 @@ LargestContentfulPaintHandler::LargestContentfulPaintHandler()
 LargestContentfulPaintHandler::~LargestContentfulPaintHandler() = default;
 
 void LargestContentfulPaintHandler::RecordTiming(
-    const mojom::PaintTimingPtr& timing,
+    const page_load_metrics::mojom::LargestContentfulPaintTiming&
+        largest_contentful_paint,
+    const base::Optional<base::TimeDelta>&
+        first_input_or_scroll_notified_timestamp,
     content::RenderFrameHost* subframe_rfh) {
   if (!IsSubframe(subframe_rfh)) {
-    RecordMainFrameTiming(timing);
+    RecordMainFrameTiming(largest_contentful_paint,
+                          first_input_or_scroll_notified_timestamp);
     return;
   }
   // For subframes
@@ -144,11 +182,12 @@ void LargestContentfulPaintHandler::RecordTiming(
     // We received timing information for an untracked load. Ignore it.
     return;
   }
-  RecordSubframeTiming(timing, it->second);
+  RecordSubframeTiming(largest_contentful_paint,
+                       first_input_or_scroll_notified_timestamp, it->second);
 }
 
 const ContentfulPaintTimingInfo&
-LargestContentfulPaintHandler::MergeMainFrameAndSubframes() {
+LargestContentfulPaintHandler::MergeMainFrameAndSubframes() const {
   const ContentfulPaintTimingInfo& main_frame_timing =
       main_frame_contentful_paint_.MergeTextAndImageTiming();
   const ContentfulPaintTimingInfo& subframe_timing =
@@ -165,31 +204,40 @@ LargestContentfulPaintHandler::MergeMainFrameAndSubframes() {
 // trade-off we make to keep a simple algorithm, otherwise we will have to
 // track one candidate per subframe.
 void LargestContentfulPaintHandler::RecordSubframeTiming(
-    const mojom::PaintTimingPtr& timing,
+    const page_load_metrics::mojom::LargestContentfulPaintTiming&
+        largest_contentful_paint,
+    const base::Optional<base::TimeDelta>&
+        first_input_or_scroll_notified_timestamp,
     const base::TimeDelta& navigation_start_offset) {
-  UpdateFirstInputOrScrollNotified(
-      timing->first_input_or_scroll_notified_timestamp,
-      navigation_start_offset);
+  UpdateFirstInputOrScrollNotified(first_input_or_scroll_notified_timestamp,
+                                   navigation_start_offset);
   MergeForSubframes(&subframe_contentful_paint_.Text(),
-                    timing->largest_text_paint, timing->largest_text_paint_size,
+                    largest_contentful_paint.largest_text_paint,
+                    largest_contentful_paint.largest_text_paint_size,
                     navigation_start_offset);
   MergeForSubframes(&subframe_contentful_paint_.Image(),
-                    timing->largest_image_paint,
-                    timing->largest_image_paint_size, navigation_start_offset);
+                    largest_contentful_paint.largest_image_paint,
+                    largest_contentful_paint.largest_image_paint_size,
+                    navigation_start_offset);
 }
 
 void LargestContentfulPaintHandler::RecordMainFrameTiming(
-    const mojom::PaintTimingPtr& timing) {
+    const page_load_metrics::mojom::LargestContentfulPaintTiming&
+        largest_contentful_paint,
+    const base::Optional<base::TimeDelta>&
+        first_input_or_scroll_notified_timestamp) {
   UpdateFirstInputOrScrollNotified(
-      timing->first_input_or_scroll_notified_timestamp,
+      first_input_or_scroll_notified_timestamp,
       /* navigation_start_offset */ base::TimeDelta());
-  if (IsValid(timing->largest_text_paint)) {
-    main_frame_contentful_paint_.Text().Reset(timing->largest_text_paint,
-                                              timing->largest_text_paint_size);
+  if (IsValid(largest_contentful_paint.largest_text_paint)) {
+    main_frame_contentful_paint_.Text().Reset(
+        largest_contentful_paint.largest_text_paint,
+        largest_contentful_paint.largest_text_paint_size);
   }
-  if (IsValid(timing->largest_image_paint)) {
+  if (IsValid(largest_contentful_paint.largest_image_paint)) {
     main_frame_contentful_paint_.Image().Reset(
-        timing->largest_image_paint, timing->largest_image_paint_size);
+        largest_contentful_paint.largest_image_paint,
+        largest_contentful_paint.largest_image_paint_size);
   }
 }
 
@@ -220,7 +268,7 @@ void LargestContentfulPaintHandler::UpdateFirstInputOrScrollNotified(
 
 void LargestContentfulPaintHandler::OnDidFinishSubFrameNavigation(
     content::NavigationHandle* navigation_handle,
-    const PageLoadMetricsObserverDelegate& delegate) {
+    base::TimeTicks navigation_start) {
   if (!navigation_handle->HasCommitted())
     return;
 
@@ -229,7 +277,7 @@ void LargestContentfulPaintHandler::OnDidFinishSubFrameNavigation(
   subframe_navigation_start_offset_.erase(
       navigation_handle->GetFrameTreeNodeId());
 
-  if (delegate.GetNavigationStart() > navigation_handle->NavigationStart())
+  if (navigation_start > navigation_handle->NavigationStart())
     return;
   base::TimeDelta navigation_delta;
   // If navigation start offset tracking has been disabled for tests, then
@@ -238,13 +286,18 @@ void LargestContentfulPaintHandler::OnDidFinishSubFrameNavigation(
   // See crbug/616901 for more details on why navigation start offset tracking
   // is disabled in tests.
   if (!g_disable_subframe_navigation_start_offset) {
-    navigation_delta =
-        navigation_handle->NavigationStart() - delegate.GetNavigationStart();
+    navigation_delta = navigation_handle->NavigationStart() - navigation_start;
   }
   subframe_navigation_start_offset_.insert(std::make_pair(
       navigation_handle->GetFrameTreeNodeId(), navigation_delta));
 }
 
+void LargestContentfulPaintHandler::OnFrameDeleted(
+    content::RenderFrameHost* render_frame_host) {
+  subframe_navigation_start_offset_.erase(
+      render_frame_host->GetFrameTreeNodeId());
+}
+
 void LargestContentfulPaintHandler::MergeForSubframes(
     ContentfulPaintTimingInfo* inout_timing,
     const base::Optional<base::TimeDelta>& candidate_new_time,
diff --git a/chromium/components/page_load_metrics/browser/observers/largest_contentful_paint_handler.h b/chromium/components/page_load_metrics/browser/observers/largest_contentful_paint_handler.h
index b0f87192f12..0ac2bcbd5eb 100644
--- a/chromium/components/page_load_metrics/browser/observers/largest_contentful_paint_handler.h
+++ b/chromium/components/page_load_metrics/browser/observers/largest_contentful_paint_handler.h
@@ -6,31 +6,43 @@
 
 #include <map>
 
+#include "base/time/time.h"
 #include "base/trace_event/traced_value.h"
-#include "components/page_load_metrics/browser/page_load_metrics_observer.h"
 #include "components/page_load_metrics/common/page_load_metrics.mojom.h"
 #include "components/page_load_metrics/common/page_load_timing.h"
 
+namespace content {
+
+class NavigationHandle;
+class RenderFrameHost;
+
+}  // namespace content
+
 namespace page_load_metrics {
 
 class ContentfulPaintTimingInfo {
  public:
-  explicit ContentfulPaintTimingInfo(
-      page_load_metrics::PageLoadMetricsObserver::LargestContentType,
-      bool in_main_frame);
+  // These values are persisted to logs. Entries should not be renumbered and
+  // numeric values should never be reused.
+  enum class LargestContentType {
+    kImage = 0,
+    kText = 1,
+    kMaxValue = kText,
+  };
+
+  explicit ContentfulPaintTimingInfo(LargestContentType largest_content_type,
+                                     bool in_main_frame);
   explicit ContentfulPaintTimingInfo(
       const base::Optional<base::TimeDelta>&,
       const uint64_t& size,
-      const page_load_metrics::PageLoadMetricsObserver::LargestContentType,
+      const LargestContentType largest_content_type,
       bool in_main_frame);
   explicit ContentfulPaintTimingInfo(const ContentfulPaintTimingInfo& other);
   void Reset(const base::Optional<base::TimeDelta>&, const uint64_t& size);
   base::Optional<base::TimeDelta> Time() const { return time_; }
   bool InMainFrame() const { return in_main_frame_; }
   uint64_t Size() const { return size_; }
-  page_load_metrics::PageLoadMetricsObserver::LargestContentType Type() const {
-    return type_;
-  }
+  LargestContentType Type() const { return type_; }
 
   // Returns true iff this object does not represent any paint.
   bool Empty() const {
@@ -52,7 +64,7 @@ class ContentfulPaintTimingInfo {
   std::string TypeInString() const;
   base::Optional<base::TimeDelta> time_;
   uint64_t size_;
-  page_load_metrics::PageLoadMetricsObserver::LargestContentType type_;
+  LargestContentType type_;
   bool in_main_frame_;
 };
 
@@ -60,8 +72,10 @@ class ContentfulPaint {
  public:
   explicit ContentfulPaint(bool in_main_frame);
   ContentfulPaintTimingInfo& Text() { return text_; }
+  const ContentfulPaintTimingInfo& Text() const { return text_; }
   ContentfulPaintTimingInfo& Image() { return image_; }
-  const ContentfulPaintTimingInfo& MergeTextAndImageTiming();
+  const ContentfulPaintTimingInfo& Image() const { return image_; }
+  const ContentfulPaintTimingInfo& MergeTextAndImageTiming() const;
 
  private:
   ContentfulPaintTimingInfo text_;
@@ -70,13 +84,25 @@ class ContentfulPaint {
 
 class LargestContentfulPaintHandler {
  public:
-  using FrameTreeNodeId =
-      page_load_metrics::PageLoadMetricsObserver::FrameTreeNodeId;
+  using FrameTreeNodeId = int;
   static void SetTestMode(bool enabled);
   LargestContentfulPaintHandler();
   ~LargestContentfulPaintHandler();
-  void RecordTiming(const page_load_metrics::mojom::PaintTimingPtr&,
-                    content::RenderFrameHost* subframe_rfh);
+
+  // Returns true if the out parameters are assigned values.
+  static bool AssignTimeAndSizeForLargestContentfulPaint(
+      const page_load_metrics::mojom::LargestContentfulPaintTiming&
+          largest_contentful_paint,
+      base::Optional<base::TimeDelta>* largest_content_paint_time,
+      uint64_t* largest_content_paint_size,
+      ContentfulPaintTimingInfo::LargestContentType* largest_content_type);
+
+  void RecordTiming(
+      const page_load_metrics::mojom::LargestContentfulPaintTiming&
+          largest_contentful_paint,
+      const base::Optional<base::TimeDelta>&
+          first_input_or_scroll_notified_timestamp,
+      content::RenderFrameHost* subframe_rfh);
   inline void RecordMainFrameTreeNodeId(int main_frame_tree_node_id) {
     main_frame_tree_node_id_.emplace(main_frame_tree_node_id);
   }
@@ -87,24 +113,39 @@ class LargestContentfulPaintHandler {
 
   // We merge the candidates from text side and image side to get the largest
   // candidate across both types of content.
-  const ContentfulPaintTimingInfo& MainFrameLargestContentfulPaint() {
+  const ContentfulPaintTimingInfo& MainFrameLargestContentfulPaint() const {
     return main_frame_contentful_paint_.MergeTextAndImageTiming();
   }
-  const ContentfulPaintTimingInfo& SubframesLargestContentfulPaint() {
+  const ContentfulPaintTimingInfo& SubframesLargestContentfulPaint() const {
     return subframe_contentful_paint_.MergeTextAndImageTiming();
   }
+  const ContentfulPaintTimingInfo& MainFrameLargestImagePaint() const {
+    return main_frame_contentful_paint_.Image();
+  }
+  const ContentfulPaintTimingInfo& MainFrameLargestTextPaint() const {
+    return main_frame_contentful_paint_.Text();
+  }
 
   // We merge the candidates from main frame and subframe to get the largest
   // candidate across all frames.
-  const ContentfulPaintTimingInfo& MergeMainFrameAndSubframes();
+  const ContentfulPaintTimingInfo& MergeMainFrameAndSubframes() const;
   void OnDidFinishSubFrameNavigation(
       content::NavigationHandle* navigation_handle,
-      const PageLoadMetricsObserverDelegate& delegate);
+      base::TimeTicks navigation_start);
+  void OnFrameDeleted(content::RenderFrameHost* render_frame_host);
 
  private:
-  void RecordSubframeTiming(const mojom::PaintTimingPtr& timing,
-                            const base::TimeDelta& navigation_start_offset);
-  void RecordMainFrameTiming(const page_load_metrics::mojom::PaintTimingPtr&);
+  void RecordSubframeTiming(
+      const page_load_metrics::mojom::LargestContentfulPaintTiming&
+          largest_contentful_paint,
+      const base::Optional<base::TimeDelta>&
+          first_input_or_scroll_notified_timestamp,
+      const base::TimeDelta& navigation_start_offset);
+  void RecordMainFrameTiming(
+      const page_load_metrics::mojom::LargestContentfulPaintTiming&
+          largest_contentful_paint,
+      const base::Optional<base::TimeDelta>&
+          first_input_or_scroll_notified_timestamp);
   void UpdateFirstInputOrScrollNotified(
       const base::Optional<base::TimeDelta>& candidate_new_time,
       const base::TimeDelta& navigation_start_offset);
diff --git a/chromium/components/page_load_metrics/browser/observers/use_counter/ukm_features.cc b/chromium/components/page_load_metrics/browser/observers/use_counter/ukm_features.cc
index 2d822f9eacf..8c4045c51a5 100644
--- a/chromium/components/page_load_metrics/browser/observers/use_counter/ukm_features.cc
+++ b/chromium/components/page_load_metrics/browser/observers/use_counter/ukm_features.cc
@@ -160,6 +160,7 @@ UseCounterPageLoadMetricsObserver::GetAllowedUkmFeatures() {
           WebFeature::kThirdPartyCacheStorage,
           WebFeature::kThirdPartyLocalStorage,
           WebFeature::kThirdPartySessionStorage,
+          WebFeature::kOverlayPopup,
           WebFeature::kOverlayPopupAd,
           WebFeature::kTrustTokenXhr,
           WebFeature::kTrustTokenFetch,
@@ -169,6 +170,9 @@ UseCounterPageLoadMetricsObserver::GetAllowedUkmFeatures() {
           WebFeature::kV8HTMLVideoElement_CancelVideoFrameCallback_Method,
           WebFeature::kSchemefulSameSiteContextDowngrade,
           WebFeature::kIdleDetectionStart,
+          WebFeature::kPerformanceObserverEntryTypesAndBuffered,
+          WebFeature::kStorageAccessAPI_HasStorageAccess_Method,
+          WebFeature::kStorageAccessAPI_requestStorageAccess_Method,
       }));
   return *opt_in_features;
 }
diff --git a/chromium/components/page_load_metrics/browser/observers/use_counter_page_load_metrics_observer.h b/chromium/components/page_load_metrics/browser/observers/use_counter_page_load_metrics_observer.h
index 542c1dcec8e..d0aca784cea 100644
--- a/chromium/components/page_load_metrics/browser/observers/use_counter_page_load_metrics_observer.h
+++ b/chromium/components/page_load_metrics/browser/observers/use_counter_page_load_metrics_observer.h
@@ -7,7 +7,6 @@
 
 #include <bitset>
 #include "base/containers/flat_set.h"
-#include "base/logging.h"
 #include "base/macros.h"
 #include "components/page_load_metrics/browser/page_load_metrics_observer.h"
 #include "third_party/blink/public/mojom/use_counter/css_property_id.mojom.h"
diff --git a/chromium/components/page_load_metrics/browser/page_load_metrics_embedder_base.cc b/chromium/components/page_load_metrics/browser/page_load_metrics_embedder_base.cc
index 2a31766142e..84b6e992068 100644
--- a/chromium/components/page_load_metrics/browser/page_load_metrics_embedder_base.cc
+++ b/chromium/components/page_load_metrics/browser/page_load_metrics_embedder_base.cc
@@ -6,6 +6,7 @@
 
 #include "base/timer/timer.h"
 
+#include "components/page_load_metrics/browser/observers/back_forward_cache_page_load_metrics_observer.h"
 #include "components/page_load_metrics/browser/observers/core_page_load_metrics_observer.h"
 #include "components/page_load_metrics/browser/observers/layout_page_load_metrics_observer.h"
 #include "components/page_load_metrics/browser/observers/use_counter_page_load_metrics_observer.h"
@@ -22,6 +23,8 @@ PageLoadMetricsEmbedderBase::~PageLoadMetricsEmbedderBase() = default;
 void PageLoadMetricsEmbedderBase::RegisterObservers(PageLoadTracker* tracker) {
   // Register observers used by all embedders
   if (!IsPrerendering()) {
+    tracker->AddObserver(
+        std::make_unique<BackForwardCachePageLoadMetricsObserver>());
     tracker->AddObserver(std::make_unique<CorePageLoadMetricsObserver>());
     tracker->AddObserver(std::make_unique<LayoutPageLoadMetricsObserver>());
     tracker->AddObserver(std::make_unique<UseCounterPageLoadMetricsObserver>());
diff --git a/chromium/components/page_load_metrics/browser/page_load_metrics_observer.cc b/chromium/components/page_load_metrics/browser/page_load_metrics_observer.cc
index 758bae3025e..148a3b4b151 100644
--- a/chromium/components/page_load_metrics/browser/page_load_metrics_observer.cc
+++ b/chromium/components/page_load_metrics/browser/page_load_metrics_observer.cc
@@ -112,35 +112,6 @@ bool PageLoadMetricsObserver::IsStandardWebPageMimeType(
   return mime_type == "text/html" || mime_type == "application/xhtml+xml";
 }
 
-// static
-bool PageLoadMetricsObserver::AssignTimeAndSizeForLargestContentfulPaint(
-    const page_load_metrics::mojom::PaintTimingPtr& paint_timing,
-    base::Optional<base::TimeDelta>* largest_content_paint_time,
-    uint64_t* largest_content_paint_size,
-    LargestContentType* largest_content_type) {
-  base::Optional<base::TimeDelta>& text_time = paint_timing->largest_text_paint;
-  base::Optional<base::TimeDelta>& image_time =
-      paint_timing->largest_image_paint;
-  uint64_t text_size = paint_timing->largest_text_paint_size;
-  uint64_t image_size = paint_timing->largest_image_paint_size;
-
-  // Size being 0 means the paint time is not recorded.
-  if (!text_size && !image_size)
-    return false;
-
-  if ((text_size > image_size) ||
-      (text_size == image_size && text_time < image_time)) {
-    *largest_content_paint_time = text_time;
-    *largest_content_paint_size = text_size;
-    *largest_content_type = LargestContentType::kText;
-  } else {
-    *largest_content_paint_time = image_time;
-    *largest_content_paint_size = image_size;
-    *largest_content_type = LargestContentType::kImage;
-  }
-  return true;
-}
-
 const PageLoadMetricsObserverDelegate& PageLoadMetricsObserver::GetDelegate()
     const {
   // The delegate must exist and outlive the page load metrics observer.
diff --git a/chromium/components/page_load_metrics/browser/page_load_metrics_observer.h b/chromium/components/page_load_metrics/browser/page_load_metrics_observer.h
index baecda6e2e8..7aab9839073 100644
--- a/chromium/components/page_load_metrics/browser/page_load_metrics_observer.h
+++ b/chromium/components/page_load_metrics/browser/page_load_metrics_observer.h
@@ -195,10 +195,12 @@ class PageLoadMetricsObserver {
 
   // These values are persisted to logs. Entries should not be renumbered and
   // numeric values should never be reused.
-  enum class LargestContentType {
-    kImage = 0,
-    kText = 1,
-    kMaxValue = kText,
+  enum class LargestContentState {
+    kReported = 0,
+    kLargestImageLoading = 1,
+    kNotFound = 2,
+    kFoundButNotReported = 3,
+    kMaxValue = kFoundButNotReported,
   };
 
   using FrameTreeNodeId = int;
@@ -207,13 +209,6 @@ class PageLoadMetricsObserver {
 
   static bool IsStandardWebPageMimeType(const std::string& mime_type);
 
-  // Returns true if the out parameters are assigned values.
-  static bool AssignTimeAndSizeForLargestContentfulPaint(
-      const page_load_metrics::mojom::PaintTimingPtr& paint_timing,
-      base::Optional<base::TimeDelta>* largest_content_paint_time,
-      uint64_t* largest_content_paint_size,
-      LargestContentType* largest_content_type);
-
   // Gets/Sets the delegate. The delegate must outlive the observer and is
   // normally set when the observer is first registered for the page load. The
   // delegate can only be set once.
@@ -369,6 +364,15 @@ class PageLoadMetricsObserver {
   virtual void OnFirstContentfulPaintInPage(
       const mojom::PageLoadTiming& timing) {}
 
+  // These are called once every time when the page is restored from the
+  // back-forward cache. |index| indicates |index|-th restore.
+  virtual void OnFirstPaintAfterBackForwardCacheRestoreInPage(
+      const mojom::BackForwardCacheTiming& timing,
+      size_t index) {}
+  virtual void OnFirstInputAfterBackForwardCacheRestoreInPage(
+      const mojom::BackForwardCacheTiming& timing,
+      size_t index) {}
+
   // Unlike other paint callbacks, OnFirstMeaningfulPaintInMainFrameDocument is
   // tracked per document, and is reported for the main frame document only.
   virtual void OnFirstMeaningfulPaintInMainFrameDocument(
@@ -386,6 +390,9 @@ class PageLoadMetricsObserver {
       content::RenderFrameHost* rfh,
       const mojom::PageLoadFeatures& features) {}
 
+  virtual void OnThroughputUpdate(
+      const mojom::ThroughputUkmDataPtr& throughput_data) {}
+
   // Invoked when there is data use for loading a resource on the page
   // for a given render frame host. This only contains resources that have had
   // new data use since the last callback. Resources loaded from the cache only
@@ -495,6 +502,10 @@ class PageLoadMetricsObserver {
   // load.
   virtual void OnEventOccurred(const void* const event_key) {}
 
+  // Called when the page tracked was just activated after being loaded inside a
+  // portal.
+  virtual void DidActivatePortal(base::TimeTicks activation_time) {}
+
  private:
   PageLoadMetricsObserverDelegate* delegate_ = nullptr;
 };
diff --git a/chromium/components/page_load_metrics/browser/page_load_metrics_observer_delegate.cc b/chromium/components/page_load_metrics/browser/page_load_metrics_observer_delegate.cc
new file mode 100644
index 00000000000..6084579a962
--- /dev/null
+++ b/chromium/components/page_load_metrics/browser/page_load_metrics_observer_delegate.cc
@@ -0,0 +1,16 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/page_load_metrics/browser/page_load_metrics_observer_delegate.h"
+
+namespace page_load_metrics {
+
+PageLoadMetricsObserverDelegate::BackForwardCacheRestore::
+    BackForwardCacheRestore(bool was_in_foreground)
+    : was_in_foreground(was_in_foreground) {}
+
+PageLoadMetricsObserverDelegate::BackForwardCacheRestore::
+    BackForwardCacheRestore(const BackForwardCacheRestore&) = default;
+
+}  // namespace page_load_metrics
diff --git a/chromium/components/page_load_metrics/browser/page_load_metrics_observer_delegate.h b/chromium/components/page_load_metrics/browser/page_load_metrics_observer_delegate.h
index 00199f5f775..cec06c91ed6 100644
--- a/chromium/components/page_load_metrics/browser/page_load_metrics_observer_delegate.h
+++ b/chromium/components/page_load_metrics/browser/page_load_metrics_observer_delegate.h
@@ -7,6 +7,7 @@
 
 #include "base/optional.h"
 #include "base/time/time.h"
+#include "components/page_load_metrics/browser/observers/largest_contentful_paint_handler.h"
 #include "components/page_load_metrics/browser/resource_tracker.h"
 #include "components/page_load_metrics/common/page_end_reason.h"
 #include "services/metrics/public/cpp/ukm_source_id.h"
@@ -29,6 +30,20 @@ struct PageRenderData;
 // from any PageLoadMetricsObserver.
 class PageLoadMetricsObserverDelegate {
  public:
+  // States when the page is restored from the back-forward cache.
+  struct BackForwardCacheRestore {
+    explicit BackForwardCacheRestore(bool was_in_foreground);
+    BackForwardCacheRestore(const BackForwardCacheRestore&);
+
+    // The first time when the page becomes backgrounded after the page is
+    // restored. The time is relative to the navigation start of bfcache restore
+    // avigation.
+    base::Optional<base::TimeDelta> first_background_time;
+
+    // True if the page was in foreground when the page is restored.
+    bool was_in_foreground = false;
+  };
+
   virtual content::WebContents* GetWebContents() const = 0;
 
   // The time the navigation was initiated.
@@ -42,6 +57,10 @@ class PageLoadMetricsObserverDelegate {
   virtual const base::Optional<base::TimeDelta>& GetFirstForegroundTime()
       const = 0;
 
+  // The state of index-th restore from the back-forward cache.
+  virtual const BackForwardCacheRestore& GetBackForwardCacheRestore(
+      size_t index) const = 0;
+
   // True if the page load started in the foreground.
   virtual bool StartedInForeground() const = 0;
 
@@ -104,6 +123,14 @@ class PageLoadMetricsObserverDelegate {
   virtual const ui::ScopedVisibilityTracker& GetVisibilityTracker() const = 0;
   virtual const ResourceTracker& GetResourceTracker() const = 0;
 
+  // Returns a shared LargestContentfulPaintHandler for page load metrics.
+  virtual const LargestContentfulPaintHandler&
+  GetLargestContentfulPaintHandler() const = 0;
+  // Returns a LargestContentfulPaintHandler for the experimental version of
+  // LCP.
+  virtual const LargestContentfulPaintHandler&
+  GetExperimentalLargestContentfulPaintHandler() const = 0;
+
   // UKM SourceId for the current page load.
   virtual ukm::SourceId GetSourceId() const = 0;
 
diff --git a/chromium/components/page_load_metrics/browser/page_load_metrics_test_waiter.cc b/chromium/components/page_load_metrics/browser/page_load_metrics_test_waiter.cc
index 6b858e895fb..c509c63db4d 100644
--- a/chromium/components/page_load_metrics/browser/page_load_metrics_test_waiter.cc
+++ b/chromium/components/page_load_metrics/browser/page_load_metrics_test_waiter.cc
@@ -238,36 +238,58 @@ PageLoadMetricsTestWaiter::GetMatchedBits(
       blink::LoadingBehaviorFlag::kLoadingBehaviorDocumentWriteBlockReload) {
     matched_bits.Set(TimingField::kDocumentWriteBlockReload);
   }
-  if (timing.paint_timing->largest_image_paint ||
-      timing.paint_timing->largest_text_paint) {
+  if (timing.paint_timing->largest_contentful_paint->largest_image_paint ||
+      timing.paint_timing->largest_contentful_paint->largest_text_paint) {
     matched_bits.Set(TimingField::kLargestContentfulPaint);
   }
   if (timing.paint_timing->first_input_or_scroll_notified_timestamp)
     matched_bits.Set(TimingField::kFirstInputOrScroll);
   if (timing.interactive_timing->first_input_delay)
     matched_bits.Set(TimingField::kFirstInputDelay);
+  if (!timing.back_forward_cache_timings.empty()) {
+    if (!timing.back_forward_cache_timings.back()
+             ->first_paint_after_back_forward_cache_restore.is_zero()) {
+      matched_bits.Set(TimingField::kFirstPaintAfterBackForwardCacheRestore);
+    }
+    if (timing.back_forward_cache_timings.back()
+            ->first_input_delay_after_back_forward_cache_restore.has_value()) {
+      matched_bits.Set(
+          TimingField::kFirstInputDelayAfterBackForwardCacheRestore);
+    }
+  }
 
   return matched_bits;
 }
 
 void PageLoadMetricsTestWaiter::OnTrackerCreated(
     page_load_metrics::PageLoadTracker* tracker) {
-  if (!attach_on_tracker_creation_)
-    return;
   // A PageLoadMetricsWaiter should only wait for events from a single page
   // load.
-  ASSERT_FALSE(did_add_observer_);
-  tracker->AddObserver(
-      std::make_unique<WaiterMetricsObserver>(weak_factory_.GetWeakPtr()));
-  did_add_observer_ = true;
+  if (!attach_on_tracker_creation_)
+    return;
+  AddObserver(tracker);
 }
 
 void PageLoadMetricsTestWaiter::OnCommit(
     page_load_metrics::PageLoadTracker* tracker) {
+  // A PageLoadMetricsWaiter should only wait for events from a single page
+  // load.
   if (attach_on_tracker_creation_)
     return;
+  AddObserver(tracker);
+}
+
+void PageLoadMetricsTestWaiter::OnRestoredFromBackForwardCache(
+    page_load_metrics::PageLoadTracker* tracker) {
   // A PageLoadMetricsWaiter should only wait for events from a single page
   // load.
+  if (attach_on_tracker_creation_)
+    return;
+  AddObserver(tracker);
+}
+
+void PageLoadMetricsTestWaiter::AddObserver(
+    page_load_metrics::PageLoadTracker* tracker) {
   ASSERT_FALSE(did_add_observer_);
   tracker->AddObserver(
       std::make_unique<WaiterMetricsObserver>(weak_factory_.GetWeakPtr()));
diff --git a/chromium/components/page_load_metrics/browser/page_load_metrics_test_waiter.h b/chromium/components/page_load_metrics/browser/page_load_metrics_test_waiter.h
index 6456c2643b9..cfff1e12a14 100644
--- a/chromium/components/page_load_metrics/browser/page_load_metrics_test_waiter.h
+++ b/chromium/components/page_load_metrics/browser/page_load_metrics_test_waiter.h
@@ -31,6 +31,8 @@ class PageLoadMetricsTestWaiter
     kLargestContentfulPaint = 1 << 6,
     kFirstInputOrScroll = 1 << 7,
     kFirstInputDelay = 1 << 8,
+    kFirstPaintAfterBackForwardCacheRestore = 1 << 9,
+    kFirstInputDelayAfterBackForwardCacheRestore = 1 << 10,
   };
   using FrameTreeNodeId =
       page_load_metrics::PageLoadMetricsObserver::FrameTreeNodeId;
@@ -228,6 +230,9 @@ class PageLoadMetricsTestWaiter
 
   void OnCommit(page_load_metrics::PageLoadTracker* tracker) override;
 
+  void OnRestoredFromBackForwardCache(
+      page_load_metrics::PageLoadTracker* tracker) override;
+
   bool CpuTimeExpectationsSatisfied() const;
 
   bool ResourceUseExpectationsSatisfied() const;
@@ -238,6 +243,8 @@ class PageLoadMetricsTestWaiter
 
   bool SubframeDataExpectationsSatisfied() const;
 
+  void AddObserver(page_load_metrics::PageLoadTracker* tracker);
+
   std::unique_ptr<base::RunLoop> run_loop_;
 
   TimingFieldBitSet page_expected_fields_;
diff --git a/chromium/components/page_load_metrics/browser/page_load_metrics_update_dispatcher.cc b/chromium/components/page_load_metrics/browser/page_load_metrics_update_dispatcher.cc
index d9f76dd0953..eb2dfaeaf1b 100644
--- a/chromium/components/page_load_metrics/browser/page_load_metrics_update_dispatcher.cc
+++ b/chromium/components/page_load_metrics/browser/page_load_metrics_update_dispatcher.cc
@@ -194,6 +194,16 @@ internal::PageLoadTimingStatus IsValidPageLoadTiming(
     return internal::INVALID_NULL_FIRST_INPUT_DELAY;
   }
 
+  if (timing.interactive_timing->first_scroll_delay.has_value() &&
+      !timing.interactive_timing->first_scroll_timestamp.has_value()) {
+    return internal::INVALID_NULL_FIRST_SCROLL_TIMESTAMP;
+  }
+
+  if (!timing.interactive_timing->first_scroll_delay.has_value() &&
+      timing.interactive_timing->first_scroll_timestamp.has_value()) {
+    return internal::INVALID_NULL_FIRST_SCROLL_DELAY;
+  }
+
   if (timing.interactive_timing->longest_input_delay.has_value() &&
       !timing.interactive_timing->longest_input_timestamp.has_value()) {
     return internal::INVALID_NULL_LONGEST_INPUT_TIMESTAMP;
@@ -252,6 +262,9 @@ class PageLoadTimingMerger {
     MergeInteractiveTiming(navigation_start_offset,
                            *new_page_load_timing.interactive_timing,
                            is_main_frame);
+    MergeBackForwardCacheTiming(navigation_start_offset,
+                                new_page_load_timing.back_forward_cache_timings,
+                                is_main_frame);
   }
 
   // Whether we merged a new value.
@@ -327,16 +340,14 @@ class PageLoadTimingMerger {
       target_paint_timing->first_meaningful_paint =
           new_paint_timing.first_meaningful_paint;
 
-      target_paint_timing->largest_image_paint =
-          new_paint_timing.largest_image_paint;
-      target_paint_timing->largest_image_paint_size =
-          new_paint_timing.largest_image_paint_size;
-      target_paint_timing->largest_text_paint =
-          new_paint_timing.largest_text_paint;
-      target_paint_timing->largest_text_paint_size =
-          new_paint_timing.largest_text_paint_size;
+      target_paint_timing->largest_contentful_paint =
+          new_paint_timing.largest_contentful_paint->Clone();
+      target_paint_timing->experimental_largest_contentful_paint =
+          new_paint_timing.experimental_largest_contentful_paint.Clone();
       target_paint_timing->first_input_or_scroll_notified_timestamp =
           new_paint_timing.first_input_or_scroll_notified_timestamp;
+      target_paint_timing->portal_activated_paint =
+          new_paint_timing.portal_activated_paint;
     }
   }
 
@@ -354,6 +365,10 @@ class PageLoadTimingMerger {
       // associated first input delay.
       target_interactive_timing->first_input_delay =
           new_interactive_timing.first_input_delay;
+      if (new_interactive_timing.first_input_processing_time.has_value()) {
+        target_interactive_timing->first_input_processing_time =
+            new_interactive_timing.first_input_processing_time;
+      }
     }
 
     if (new_interactive_timing.longest_input_delay.has_value()) {
@@ -369,6 +384,28 @@ class PageLoadTimingMerger {
             new_longest_input_timestamp;
       }
     }
+
+    // Update First Scroll Delay.
+    if (MaybeUpdateTimeDelta(&target_interactive_timing->first_scroll_timestamp,
+                             navigation_start_offset,
+                             new_interactive_timing.first_scroll_timestamp)) {
+      target_interactive_timing->first_scroll_delay =
+          new_interactive_timing.first_scroll_delay;
+    }
+  }
+
+  void MergeBackForwardCacheTiming(
+      base::TimeDelta navigation_start_offset,
+      const std::vector<mojo::StructPtr<mojom::BackForwardCacheTiming>>&
+          new_back_forward_cache_timings,
+      bool is_main_frame) {
+    if (is_main_frame) {
+      target_->back_forward_cache_timings.clear();
+      target_->back_forward_cache_timings.reserve(
+          new_back_forward_cache_timings.size());
+      for (const auto& timing : new_back_forward_cache_timings)
+        target_->back_forward_cache_timings.push_back(timing.Clone());
+    }
   }
 
   // The target PageLoadTiming we are merging values into.
@@ -470,6 +507,18 @@ void PageLoadMetricsUpdateDispatcher::UpdateFeatures(
   client_->UpdateFeaturesUsage(render_frame_host, new_features);
 }
 
+void PageLoadMetricsUpdateDispatcher::UpdateThroughput(
+    content::RenderFrameHost* render_frame_host,
+    mojom::ThroughputUkmDataPtr throughput_data) {
+  if (embedder_interface_->IsExtensionUrl(
+          render_frame_host->GetLastCommittedURL())) {
+    // Extensions can inject child frames into a page. We don't want to track
+    // these as they could skew metrics. See http://crbug.com/761037
+    return;
+  }
+  client_->UpdateThroughput(std::move(throughput_data));
+}
+
 void PageLoadMetricsUpdateDispatcher::DidFinishSubFrameNavigation(
     content::NavigationHandle* navigation_handle) {
   if (!navigation_handle->HasCommitted())
@@ -490,6 +539,12 @@ void PageLoadMetricsUpdateDispatcher::DidFinishSubFrameNavigation(
       navigation_handle->GetFrameTreeNodeId(), navigation_delta));
 }
 
+void PageLoadMetricsUpdateDispatcher::OnFrameDeleted(
+    content::RenderFrameHost* render_frame_host) {
+  subframe_navigation_start_offset_.erase(
+      render_frame_host->GetFrameTreeNodeId());
+}
+
 void PageLoadMetricsUpdateDispatcher::UpdateSubFrameTiming(
     content::RenderFrameHost* render_frame_host,
     mojom::PageLoadTimingPtr new_timing) {
diff --git a/chromium/components/page_load_metrics/browser/page_load_metrics_update_dispatcher.h b/chromium/components/page_load_metrics/browser/page_load_metrics_update_dispatcher.h
index 0fbc534a82c..912c1bc27ab 100644
--- a/chromium/components/page_load_metrics/browser/page_load_metrics_update_dispatcher.h
+++ b/chromium/components/page_load_metrics/browser/page_load_metrics_update_dispatcher.h
@@ -75,6 +75,11 @@ enum PageLoadTimingStatus {
   // We received a longest input timestamp without a longest input delay.
   INVALID_NULL_LONGEST_INPUT_DELAY,
 
+  // We received a first scroll delay without a first scroll timestamp.
+  INVALID_NULL_FIRST_SCROLL_TIMESTAMP,
+  // We received a first scroll timestamp without a first scroll delay.
+  INVALID_NULL_FIRST_SCROLL_DELAY,
+
   // Longest input delay cannot happen before first input delay.
   INVALID_LONGEST_INPUT_TIMESTAMP_LESS_THAN_FIRST_INPUT_TIMESTAMP,
 
@@ -127,6 +132,8 @@ class PageLoadMetricsUpdateDispatcher {
         const mojom::FrameIntersectionUpdate& frame_intersection_update) = 0;
     virtual void OnNewDeferredResourceCounts(
         const mojom::DeferredResourceCounts& new_deferred_resource_data) = 0;
+    virtual void UpdateThroughput(
+        mojom::ThroughputUkmDataPtr throughput_data) = 0;
   };
 
   // The |client| instance must outlive this object.
@@ -147,6 +154,9 @@ class PageLoadMetricsUpdateDispatcher {
       mojom::DeferredResourceCountsPtr new_deferred_resource_data,
       mojom::InputTimingPtr input_timing_delta);
 
+  void UpdateThroughput(content::RenderFrameHost* render_frame_host,
+                        mojom::ThroughputUkmDataPtr throughput_data);
+
   // This method is only intended to be called for PageLoadFeatures being
   // recorded directly from the browser process. Features coming from the
   // renderer process should use the main flow into |UpdateMetrics|.
@@ -156,6 +166,8 @@ class PageLoadMetricsUpdateDispatcher {
   void DidFinishSubFrameNavigation(
       content::NavigationHandle* navigation_handle);
 
+  void OnFrameDeleted(content::RenderFrameHost* render_frame_host);
+
   void ShutDown();
 
   const mojom::PageLoadTiming& timing() const {
diff --git a/chromium/components/page_load_metrics/browser/page_load_metrics_util.cc b/chromium/components/page_load_metrics/browser/page_load_metrics_util.cc
index 9e33a8c8f13..5bcb45f80b3 100644
--- a/chromium/components/page_load_metrics/browser/page_load_metrics_util.cc
+++ b/chromium/components/page_load_metrics/browser/page_load_metrics_util.cc
@@ -109,6 +109,19 @@ bool WasStartedInForegroundOptionalEventInForeground(
           event.value() <= delegate.GetFirstBackgroundTime().value());
 }
 
+bool WasStartedInForegroundOptionalEventInForegroundAfterBackForwardCacheRestore(
+    const base::Optional<base::TimeDelta>& event,
+    const PageLoadMetricsObserverDelegate& delegate,
+    size_t index) {
+  const auto& back_forward_cache_restore =
+      delegate.GetBackForwardCacheRestore(index);
+  base::Optional<base::TimeDelta> first_background_time =
+      back_forward_cache_restore.first_background_time;
+  return back_forward_cache_restore.was_in_foreground && event &&
+         (!first_background_time ||
+          event.value() <= first_background_time.value());
+}
+
 bool WasStartedInBackgroundOptionalEventInForeground(
     const base::Optional<base::TimeDelta>& event,
     const PageLoadMetricsObserverDelegate& delegate) {
diff --git a/chromium/components/page_load_metrics/browser/page_load_metrics_util.h b/chromium/components/page_load_metrics/browser/page_load_metrics_util.h
index bee6462ef5c..51cb8de9a77 100644
--- a/chromium/components/page_load_metrics/browser/page_load_metrics_util.h
+++ b/chromium/components/page_load_metrics/browser/page_load_metrics_util.h
@@ -103,6 +103,11 @@ bool WasStartedInForegroundOptionalEventInForeground(
     const base::Optional<base::TimeDelta>& event,
     const PageLoadMetricsObserverDelegate& delegate);
 
+bool WasStartedInForegroundOptionalEventInForegroundAfterBackForwardCacheRestore(
+    const base::Optional<base::TimeDelta>& event,
+    const PageLoadMetricsObserverDelegate& delegate,
+    size_t index);
+
 // Returns true if:
 // - We have timing information for the event.
 // - The page load started in the background.
diff --git a/chromium/components/page_load_metrics/browser/page_load_tracker.cc b/chromium/components/page_load_metrics/browser/page_load_tracker.cc
index b9cd0830760..40a6f4844a2 100644
--- a/chromium/components/page_load_metrics/browser/page_load_tracker.cc
+++ b/chromium/components/page_load_metrics/browser/page_load_tracker.cc
@@ -122,38 +122,82 @@ void RecordAppBackgroundPageLoadCompleted(bool completed_after_background) {
                         completed_after_background);
 }
 
+void DispatchEventsAfterBackForwardCacheRestore(
+    PageLoadMetricsObserver* observer,
+    const std::vector<mojo::StructPtr<mojom::BackForwardCacheTiming>>&
+        last_timings,
+    const std::vector<mojo::StructPtr<mojom::BackForwardCacheTiming>>&
+        new_timings) {
+  DCHECK_GE(new_timings.size(), last_timings.size());
+
+  for (size_t i = 0; i < new_timings.size(); i++) {
+    auto first_paint =
+        new_timings[i]->first_paint_after_back_forward_cache_restore;
+    if (!first_paint.is_zero() &&
+        (i >= last_timings.size() ||
+         last_timings[i]
+             ->first_paint_after_back_forward_cache_restore.is_zero())) {
+      observer->OnFirstPaintAfterBackForwardCacheRestoreInPage(*new_timings[i],
+                                                               i);
+    }
+
+    auto first_input_delay =
+        new_timings[i]->first_input_delay_after_back_forward_cache_restore;
+    if (first_input_delay.has_value() &&
+        (i >= last_timings.size() ||
+         !last_timings[i]
+              ->first_input_delay_after_back_forward_cache_restore
+              .has_value())) {
+      observer->OnFirstInputAfterBackForwardCacheRestoreInPage(*new_timings[i],
+                                                               i);
+    }
+  }
+}
+
 void DispatchObserverTimingCallbacks(PageLoadMetricsObserver* observer,
                                      const mojom::PageLoadTiming& last_timing,
                                      const mojom::PageLoadTiming& new_timing) {
   if (!last_timing.Equals(new_timing))
     observer->OnTimingUpdate(nullptr, new_timing);
   if (new_timing.document_timing->dom_content_loaded_event_start &&
-      !last_timing.document_timing->dom_content_loaded_event_start)
+      !last_timing.document_timing->dom_content_loaded_event_start) {
     observer->OnDomContentLoadedEventStart(new_timing);
+  }
   if (new_timing.document_timing->load_event_start &&
-      !last_timing.document_timing->load_event_start)
+      !last_timing.document_timing->load_event_start) {
     observer->OnLoadEventStart(new_timing);
+  }
   if (new_timing.interactive_timing->first_input_delay &&
-      !last_timing.interactive_timing->first_input_delay)
+      !last_timing.interactive_timing->first_input_delay) {
     observer->OnFirstInputInPage(new_timing);
+  }
   if (new_timing.paint_timing->first_paint &&
-      !last_timing.paint_timing->first_paint)
+      !last_timing.paint_timing->first_paint) {
     observer->OnFirstPaintInPage(new_timing);
+  }
+  DispatchEventsAfterBackForwardCacheRestore(
+      observer, last_timing.back_forward_cache_timings,
+      new_timing.back_forward_cache_timings);
   if (new_timing.paint_timing->first_image_paint &&
-      !last_timing.paint_timing->first_image_paint)
+      !last_timing.paint_timing->first_image_paint) {
     observer->OnFirstImagePaintInPage(new_timing);
+  }
   if (new_timing.paint_timing->first_contentful_paint &&
-      !last_timing.paint_timing->first_contentful_paint)
+      !last_timing.paint_timing->first_contentful_paint) {
     observer->OnFirstContentfulPaintInPage(new_timing);
+  }
   if (new_timing.paint_timing->first_meaningful_paint &&
-      !last_timing.paint_timing->first_meaningful_paint)
+      !last_timing.paint_timing->first_meaningful_paint) {
     observer->OnFirstMeaningfulPaintInMainFrameDocument(new_timing);
+  }
   if (new_timing.parse_timing->parse_start &&
-      !last_timing.parse_timing->parse_start)
+      !last_timing.parse_timing->parse_start) {
     observer->OnParseStart(new_timing);
+  }
   if (new_timing.parse_timing->parse_stop &&
-      !last_timing.parse_timing->parse_stop)
+      !last_timing.parse_timing->parse_stop) {
     observer->OnParseStop(new_timing);
+  }
 }
 
 }  // namespace
@@ -296,16 +340,31 @@ void PageLoadTracker::LogAbortChainHistograms(
 
 void PageLoadTracker::PageHidden() {
   // Only log the first time we background in a given page load.
-  if (!first_background_time_.has_value()) {
+  if (!first_background_time_.has_value() ||
+      (!back_forward_cache_restores_.empty() &&
+       !back_forward_cache_restores_.back()
+            .first_background_time.has_value())) {
     // Make sure we either started in the foreground and haven't been
     // foregrounded yet, or started in the background and have already been
     // foregrounded.
     base::TimeTicks background_time;
-    DCHECK_EQ(started_in_foreground_, !first_foreground_time_.has_value());
+
+    if (!first_background_time_.has_value())
+      DCHECK_EQ(started_in_foreground_, !first_foreground_time_.has_value());
+
     background_time = base::TimeTicks::Now();
     ClampBrowserTimestampIfInterProcessTimeTickSkew(&background_time);
     DCHECK_GE(background_time, navigation_start_);
-    first_background_time_ = background_time - navigation_start_;
+
+    if (!first_background_time_.has_value())
+      first_background_time_ = background_time - navigation_start_;
+
+    if (!back_forward_cache_restores_.empty() &&
+        !back_forward_cache_restores_.back()
+             .first_background_time.has_value()) {
+      back_forward_cache_restores_.back().first_background_time =
+          background_time - navigation_start_after_back_forward_cache_restore_;
+    }
   }
   visibility_tracker_.OnHidden();
   INVOKE_AND_PRUNE_OBSERVERS(observers_, OnHidden,
@@ -331,6 +390,8 @@ void PageLoadTracker::PageShown() {
 }
 
 void PageLoadTracker::FrameDeleted(content::RenderFrameHost* rfh) {
+  metrics_update_dispatcher_.OnFrameDeleted(rfh);
+  largest_contentful_paint_handler_.OnFrameDeleted(rfh);
   for (const auto& observer : observers_) {
     observer->OnFrameDeleted(rfh);
   }
@@ -349,6 +410,13 @@ void PageLoadTracker::Commit(content::NavigationHandle* navigation_handle) {
   page_transition_ = navigation_handle->GetPageTransition();
   user_initiated_info_.user_gesture = navigation_handle->HasUserGesture();
 
+  if (navigation_handle->IsInMainFrame()) {
+    largest_contentful_paint_handler_.RecordMainFrameTreeNodeId(
+        navigation_handle->GetFrameTreeNodeId());
+    experimental_largest_contentful_paint_handler_.RecordMainFrameTreeNodeId(
+        navigation_handle->GetFrameTreeNodeId());
+  }
+
   const std::string& mime_type =
       navigation_handle->GetWebContents()->GetContentsMimeType();
   INVOKE_AND_PRUNE_OBSERVERS(observers_, ShouldObserveMimeType, mime_type);
@@ -380,6 +448,10 @@ void PageLoadTracker::ReadyToCommitNavigation(
 
 void PageLoadTracker::DidFinishSubFrameNavigation(
     content::NavigationHandle* navigation_handle) {
+  largest_contentful_paint_handler_.OnDidFinishSubFrameNavigation(
+      navigation_handle, navigation_start_);
+  experimental_largest_contentful_paint_handler_.OnDidFinishSubFrameNavigation(
+      navigation_handle, navigation_start_);
   for (const auto& observer : observers_) {
     observer->OnDidFinishSubFrameNavigation(navigation_handle);
   }
@@ -632,6 +704,17 @@ void PageLoadTracker::OnTimingChanged() {
   DCHECK(!last_dispatched_merged_page_timing_->Equals(
       metrics_update_dispatcher_.timing()));
 
+  const mojom::PaintTimingPtr& paint_timing =
+      metrics_update_dispatcher_.timing().paint_timing;
+  largest_contentful_paint_handler_.RecordTiming(
+      *paint_timing->largest_contentful_paint,
+      paint_timing->first_input_or_scroll_notified_timestamp,
+      nullptr /* subframe_rfh */);
+  experimental_largest_contentful_paint_handler_.RecordTiming(
+      *paint_timing->experimental_largest_contentful_paint,
+      paint_timing->first_input_or_scroll_notified_timestamp,
+      nullptr /* subframe_rfh */);
+
   for (const auto& observer : observers_) {
     DispatchObserverTimingCallbacks(observer.get(),
                                     *last_dispatched_merged_page_timing_,
@@ -645,6 +728,13 @@ void PageLoadTracker::OnSubFrameTimingChanged(
     content::RenderFrameHost* rfh,
     const mojom::PageLoadTiming& timing) {
   DCHECK(rfh->GetParent());
+  const mojom::PaintTimingPtr& paint_timing = timing.paint_timing;
+  largest_contentful_paint_handler_.RecordTiming(
+      *paint_timing->largest_contentful_paint,
+      paint_timing->first_input_or_scroll_notified_timestamp, rfh);
+  experimental_largest_contentful_paint_handler_.RecordTiming(
+      *paint_timing->experimental_largest_contentful_paint,
+      paint_timing->first_input_or_scroll_notified_timestamp, rfh);
   for (const auto& observer : observers_) {
     observer->OnTimingUpdate(rfh, timing);
   }
@@ -680,6 +770,11 @@ void PageLoadTracker::BroadcastEventToObservers(const void* const event_key) {
   }
 }
 
+void PageLoadTracker::DidActivatePortal(base::TimeTicks activation_time) {
+  for (const auto& observer : observers_)
+    observer->DidActivatePortal(activation_time);
+}
+
 void PageLoadTracker::UpdateFeaturesUsage(
     content::RenderFrameHost* rfh,
     const mojom::PageLoadFeatures& new_features) {
@@ -688,6 +783,14 @@ void PageLoadTracker::UpdateFeaturesUsage(
   }
 }
 
+void PageLoadTracker::UpdateThroughput(
+    mojom::ThroughputUkmDataPtr throughput_data) {
+  if (!throughput_data)
+    return;
+  for (const auto& observer : observers_)
+    observer->OnThroughputUpdate(throughput_data);
+}
+
 void PageLoadTracker::UpdateResourceDataUse(
     content::RenderFrameHost* rfh,
     const std::vector<mojom::ResourceDataUpdatePtr>& resources) {
@@ -738,6 +841,11 @@ const base::Optional<base::TimeDelta>& PageLoadTracker::GetFirstForegroundTime()
   return first_foreground_time_;
 }
 
+const PageLoadMetricsObserverDelegate::BackForwardCacheRestore&
+PageLoadTracker::GetBackForwardCacheRestore(size_t index) const {
+  return back_forward_cache_restores_[index];
+}
+
 bool PageLoadTracker::StartedInForeground() const {
   return started_in_foreground_;
 }
@@ -808,6 +916,16 @@ const ResourceTracker& PageLoadTracker::GetResourceTracker() const {
   return resource_tracker_;
 }
 
+const LargestContentfulPaintHandler&
+PageLoadTracker::GetLargestContentfulPaintHandler() const {
+  return largest_contentful_paint_handler_;
+}
+
+const LargestContentfulPaintHandler&
+PageLoadTracker::GetExperimentalLargestContentfulPaintHandler() const {
+  return experimental_largest_contentful_paint_handler_;
+}
+
 ukm::SourceId PageLoadTracker::GetSourceId() const {
   return source_id_;
 }
@@ -817,7 +935,6 @@ bool PageLoadTracker::IsFirstNavigationInWebContents() const {
 }
 
 void PageLoadTracker::OnEnterBackForwardCache() {
-  DCHECK(visibility_tracker_.currently_in_foreground());
   if (GetWebContents()->GetVisibility() == content::Visibility::VISIBLE) {
     PageHidden();
   }
@@ -826,11 +943,20 @@ void PageLoadTracker::OnEnterBackForwardCache() {
                              metrics_update_dispatcher_.timing());
 }
 
-void PageLoadTracker::OnRestoreFromBackForwardCache() {
+void PageLoadTracker::OnRestoreFromBackForwardCache(
+    content::NavigationHandle* navigation_handle) {
+  navigation_start_after_back_forward_cache_restore_ =
+      navigation_handle->NavigationStart();
+
   DCHECK(!visibility_tracker_.currently_in_foreground());
-  if (GetWebContents()->GetVisibility() == content::Visibility::VISIBLE) {
+  bool visible =
+      GetWebContents()->GetVisibility() == content::Visibility::VISIBLE;
+
+  BackForwardCacheRestore back_forward_cache_restore(visible);
+  back_forward_cache_restores_.push_back(back_forward_cache_restore);
+
+  if (visible)
     PageShown();
-  }
 
   for (const auto& observer : observers_) {
     observer->OnRestoreFromBackForwardCache(
diff --git a/chromium/components/page_load_metrics/browser/page_load_tracker.h b/chromium/components/page_load_metrics/browser/page_load_tracker.h
index 6e8ab12c4db..ffa0f1973c7 100644
--- a/chromium/components/page_load_metrics/browser/page_load_tracker.h
+++ b/chromium/components/page_load_metrics/browser/page_load_tracker.h
@@ -11,6 +11,7 @@
 #include "base/macros.h"
 #include "base/optional.h"
 #include "base/time/time.h"
+#include "components/page_load_metrics/browser/observers/largest_contentful_paint_handler.h"
 #include "components/page_load_metrics/browser/page_load_metrics_observer.h"
 #include "components/page_load_metrics/browser/page_load_metrics_observer_delegate.h"
 #include "components/page_load_metrics/browser/page_load_metrics_update_dispatcher.h"
@@ -203,14 +204,17 @@ class PageLoadTracker : public PageLoadMetricsUpdateDispatcher::Client,
   void OnFrameIntersectionUpdate(
       content::RenderFrameHost* rfh,
       const mojom::FrameIntersectionUpdate& frame_intersection_update) override;
+  void UpdateThroughput(mojom::ThroughputUkmDataPtr throughput_data) override;
 
-  // PageLoadMetricsDelegate implementation:
+  // PageLoadMetricsObserverDelegate implementation:
   content::WebContents* GetWebContents() const override;
   base::TimeTicks GetNavigationStart() const override;
   const base::Optional<base::TimeDelta>& GetFirstBackgroundTime()
       const override;
   const base::Optional<base::TimeDelta>& GetFirstForegroundTime()
       const override;
+  const BackForwardCacheRestore& GetBackForwardCacheRestore(
+      size_t index) const override;
   bool StartedInForeground() const override;
   const UserInitiatedInfo& GetUserInitiatedInfo() const override;
   const GURL& GetUrl() const override;
@@ -226,6 +230,10 @@ class PageLoadTracker : public PageLoadMetricsUpdateDispatcher::Client,
   const PageRenderData& GetMainFrameRenderData() const override;
   const ui::ScopedVisibilityTracker& GetVisibilityTracker() const override;
   const ResourceTracker& GetResourceTracker() const override;
+  const LargestContentfulPaintHandler& GetLargestContentfulPaintHandler()
+      const override;
+  const LargestContentfulPaintHandler&
+  GetExperimentalLargestContentfulPaintHandler() const override;
   ukm::SourceId GetSourceId() const override;
   bool IsFirstNavigationInWebContents() const override;
 
@@ -356,7 +364,12 @@ class PageLoadTracker : public PageLoadMetricsUpdateDispatcher::Client,
   void BroadcastEventToObservers(const void* const event_key);
 
   void OnEnterBackForwardCache();
-  void OnRestoreFromBackForwardCache();
+  void OnRestoreFromBackForwardCache(
+      content::NavigationHandle* navigation_handle);
+
+  // Called when the page tracked was just activated after being loaded inside a
+  // portal.
+  void DidActivatePortal(base::TimeTicks activation_time);
 
  private:
   // This function converts a TimeTicks value taken in the browser process
@@ -389,6 +402,10 @@ class PageLoadTracker : public PageLoadMetricsUpdateDispatcher::Client,
   // The navigation start in TimeTicks, not the wall time reported by Blink.
   const base::TimeTicks navigation_start_;
 
+  // The navigation start after the last time when back-forward cache is
+  // restored.
+  base::TimeTicks navigation_start_after_back_forward_cache_restore_;
+
   // The most recent URL of this page load. Updated at navigation start, upon
   // redirection, and at commit time.
   GURL url_;
@@ -424,7 +441,8 @@ class PageLoadTracker : public PageLoadMetricsUpdateDispatcher::Client,
   // when they occur in the background.
   base::Optional<base::TimeDelta> first_background_time_;
   base::Optional<base::TimeDelta> first_foreground_time_;
-  bool started_in_foreground_;
+  std::vector<BackForwardCacheRestore> back_forward_cache_restores_;
+  const bool started_in_foreground_;
 
   mojom::PageLoadTimingPtr last_dispatched_merged_page_timing_;
 
@@ -463,6 +481,11 @@ class PageLoadTracker : public PageLoadMetricsUpdateDispatcher::Client,
 
   const bool is_first_navigation_in_web_contents_;
 
+  page_load_metrics::LargestContentfulPaintHandler
+      largest_contentful_paint_handler_;
+  page_load_metrics::LargestContentfulPaintHandler
+      experimental_largest_contentful_paint_handler_;
+
   DISALLOW_COPY_AND_ASSIGN(PageLoadTracker);
 };
 
diff --git a/chromium/components/page_load_metrics/common/page_end_reason.h b/chromium/components/page_load_metrics/common/page_end_reason.h
index 94f3444267d..f6ab8eb2d36 100644
--- a/chromium/components/page_load_metrics/common/page_end_reason.h
+++ b/chromium/components/page_load_metrics/common/page_end_reason.h
@@ -15,7 +15,9 @@ namespace page_load_metrics {
 // numeric values should never be reused. For any additions, also update the
 // corresponding PageEndReason enum in enums.xml.
 enum PageEndReason {
-  // Page lifetime has not yet ended (page is still active).
+  // Page lifetime has not yet ended (page is still active). Pages that
+  // become hidden are logged in END_HIDDEN, so we expect low numbers in this
+  // bucket from the end of May 2020, i.e. in Navigation.PageEndReason2.
   END_NONE = 0,
 
   // The page was reloaded, possibly by the user.
@@ -50,6 +52,10 @@ enum PageEndReason {
   // without committing, either without error or with net::ERR_ABORTED.
   END_OTHER = 9,
 
+  // The page became hidden but is still active. Added end of May 2020 for
+  // Navigation.PageEndReason2.
+  END_HIDDEN = 10,
+
   PAGE_END_REASON_COUNT
 };
 
diff --git a/chromium/components/page_load_metrics/common/page_load_metrics.mojom b/chromium/components/page_load_metrics/common/page_load_metrics.mojom
index c40451d875a..f4c41890dd2 100644
--- a/chromium/components/page_load_metrics/common/page_load_metrics.mojom
+++ b/chromium/components/page_load_metrics/common/page_load_metrics.mojom
@@ -19,6 +19,22 @@ struct DocumentTiming {
   mojo_base.mojom.TimeDelta? load_event_start;
 };
 
+struct LargestContentfulPaintTiming {
+  // Time when the page's largest image is painted. Removed images are excluded.
+  mojo_base.mojom.TimeDelta? largest_image_paint;
+
+  // Size of the largest image of the largest image paint, by
+  // Size = Height * Width. Removed images are excluded.
+  uint64 largest_image_paint_size;
+
+  // Time when the page's largest text is painted. Removed text is excluded.
+  mojo_base.mojom.TimeDelta? largest_text_paint;
+
+  // Size of the largest text of the largest text paint, by
+  // Size = Height * Width. Removed text is excluded.
+  uint64 largest_text_paint_size;
+};
+
 // TimeDeltas below relative to navigation start.
 struct PaintTiming {
   // Time when the first paint is performed.
@@ -33,23 +49,23 @@ struct PaintTiming {
   // (Experimental) Time when the page's primary content is painted.
   mojo_base.mojom.TimeDelta? first_meaningful_paint;
 
-  // (Experimental) Time when the page's largest image is painted.
-  mojo_base.mojom.TimeDelta? largest_image_paint;
+  // Largest contentful paint, which excludes removed content.
+  LargestContentfulPaintTiming largest_contentful_paint;
 
-  // (Experimental) Size of the largest image of the largest image paint, by
-  // Size = Height * Width.
-  uint64 largest_image_paint_size;
+  // (Experimental) largest contentful paint including removed content.
+  LargestContentfulPaintTiming experimental_largest_contentful_paint;
 
-  // (Experimental) Time when the page's largest text is painted.
-  mojo_base.mojom.TimeDelta? largest_text_paint;
-
-  // (Experimental) Size of the largest text of the largest text paint, by
-  // Size = Height * Width.
-  uint64 largest_text_paint_size;
+  // (Experimental) Time when the frame is first eligible to be painted, i.e.
+  // is first not render-throttled. Will be null if frame is throttled,
+  // unless there has already been a |first_paint|.
+  mojo_base.mojom.TimeDelta? first_eligible_to_paint;
 
   // (Experimental) Time when first input or scroll is received, causing the
   // largest contentful paint algorithm to stop.
   mojo_base.mojom.TimeDelta? first_input_or_scroll_notified_timestamp;
+
+  // Time when the first paint happens after a portal activation.
+  mojo_base.mojom.TimeTicks? portal_activated_paint;
 };
 
 // TimeDeltas below represent durations of time during the page load.
@@ -105,6 +121,16 @@ struct InteractiveTiming {
 
   // The timestamp of the event whose delay is reported as longest_input_delay.
   mojo_base.mojom.TimeDelta? longest_input_timestamp;
+
+  // The latency between user input and display update for the first scroll after
+  // a navigation.
+  mojo_base.mojom.TimeDelta? first_scroll_delay;
+
+  // The timestamp of the user's first scroll after a navigation.
+  mojo_base.mojom.TimeDelta? first_scroll_timestamp;
+
+  // The duration of event handlers processing the first input event.
+  mojo_base.mojom.TimeDelta? first_input_processing_time;
 };
 
 // PageLoadTiming contains timing metrics associated with a page load. Many of
@@ -124,6 +150,11 @@ struct PageLoadTiming {
   InteractiveTiming interactive_timing;
   PaintTiming paint_timing;
   ParseTiming parse_timing;
+
+  // List of back-forward cache timings, one for each time a page was restored
+  // from the cache.
+  array<BackForwardCacheTiming> back_forward_cache_timings;
+
   // Time between user input and navigation start. This is set for navigations
   // where the input start timing is known; currently when the navigation is
   // initiated by a link click in the renderer, or from the desktop omnibox.
@@ -291,6 +322,21 @@ struct InputTiming {
   uint64 num_input_events = 0;
 };
 
+struct PercentOptional {
+  int8 percent;
+};
+
+// The throughput data for this page.
+struct ThroughputUkmData {
+  // The source id for the ukm.
+  int64 source_id;
+  // The throughput of the page of different threads: main, compositor, and the
+  // aggregated throughput of main && compositor thread.
+  int8 aggregated_throughput_percent;
+  int8 impl_throughput_percent;
+  PercentOptional? main_throughput_percent;
+};
+
 // Sent from renderer to browser process when the PageLoadTiming for the
 // associated frame changed.
 interface PageLoadMetrics {
@@ -306,4 +352,24 @@ interface PageLoadMetrics {
                CpuTiming cpu_load_timing,
                DeferredResourceCounts new_deferred_resource_data,
                InputTiming input_timing_delta);
+
+  // The renderer submit throughput data to the browser process. The browser
+  // process aggregates these data, and reports the aggregated value to UKM when
+  // the page shuts down or navigates away.
+  // TODO(xidachen): The interface exists for every frame, but this method is
+  // only called for LocalRoots. Should limit the visibility to LocalRoots only.
+  SubmitThroughputData(ThroughputUkmData throughput_data);
+};
+
+// TimeDelta below relative to the navigation start of the navigation restoring
+// page from the back- forward cache.
+struct BackForwardCacheTiming {
+  // Time when the first paint is performed after the time when the page
+  // is restored from the back-forward cache.
+  mojo_base.mojom.TimeDelta first_paint_after_back_forward_cache_restore;
+
+  // Queueing Time of the first click, tap, key press, cancellable touchstart,
+  // or pointer down followed by a pointer up after the time when the page is
+  // restored from the back-forward cache.
+  mojo_base.mojom.TimeDelta? first_input_delay_after_back_forward_cache_restore;
 };
diff --git a/chromium/components/page_load_metrics/common/page_load_timing.cc b/chromium/components/page_load_metrics/common/page_load_timing.cc
index 6ec07e64bb9..09eae81d8e9 100644
--- a/chromium/components/page_load_metrics/common/page_load_timing.cc
+++ b/chromium/components/page_load_metrics/common/page_load_timing.cc
@@ -10,7 +10,13 @@ mojom::PageLoadTimingPtr CreatePageLoadTiming() {
   return mojom::PageLoadTiming::New(
       base::Time(), base::Optional<base::TimeDelta>(),
       mojom::DocumentTiming::New(), mojom::InteractiveTiming::New(),
-      mojom::PaintTiming::New(), mojom::ParseTiming::New(),
+      mojom::PaintTiming::New(base::nullopt, base::nullopt, base::nullopt,
+                              base::nullopt,
+                              mojom::LargestContentfulPaintTiming::New(),
+                              mojom::LargestContentfulPaintTiming::New(),
+                              base::nullopt, base::nullopt, base::nullopt),
+      mojom::ParseTiming::New(),
+      std::vector<mojo::StructPtr<mojom::BackForwardCacheTiming>>{},
       base::Optional<base::TimeDelta>());
 }
 
@@ -20,7 +26,9 @@ bool IsEmpty(const page_load_metrics::mojom::DocumentTiming& timing) {
 
 bool IsEmpty(const page_load_metrics::mojom::InteractiveTiming& timing) {
   return !timing.first_input_delay && !timing.first_input_timestamp &&
-         !timing.longest_input_delay && !timing.longest_input_timestamp;
+         !timing.longest_input_delay && !timing.longest_input_timestamp &&
+         !timing.first_scroll_delay && !timing.first_scroll_timestamp &&
+         !timing.first_input_processing_time;
 }
 
 bool IsEmpty(const page_load_metrics::mojom::InputTiming& timing) {
@@ -32,7 +40,11 @@ bool IsEmpty(const page_load_metrics::mojom::InputTiming& timing) {
 bool IsEmpty(const page_load_metrics::mojom::PaintTiming& timing) {
   return !timing.first_paint && !timing.first_image_paint &&
          !timing.first_contentful_paint && !timing.first_meaningful_paint &&
-         !timing.largest_image_paint && !timing.largest_text_paint;
+         !timing.largest_contentful_paint->largest_image_paint &&
+         !timing.largest_contentful_paint->largest_text_paint &&
+         !timing.experimental_largest_contentful_paint->largest_image_paint &&
+         !timing.experimental_largest_contentful_paint->largest_text_paint &&
+         !timing.first_eligible_to_paint;
 }
 
 bool IsEmpty(const page_load_metrics::mojom::ParseTiming& timing) {
@@ -52,14 +64,20 @@ bool IsEmpty(const page_load_metrics::mojom::PageLoadTiming& timing) {
          (!timing.paint_timing ||
           page_load_metrics::IsEmpty(*timing.paint_timing)) &&
          (!timing.parse_timing ||
-          page_load_metrics::IsEmpty(*timing.parse_timing));
+          page_load_metrics::IsEmpty(*timing.parse_timing)) &&
+         timing.back_forward_cache_timings.empty();
 }
 
 void InitPageLoadTimingForTest(mojom::PageLoadTiming* timing) {
   timing->document_timing = mojom::DocumentTiming::New();
   timing->interactive_timing = mojom::InteractiveTiming::New();
   timing->paint_timing = mojom::PaintTiming::New();
+  timing->paint_timing->largest_contentful_paint =
+      mojom::LargestContentfulPaintTiming::New();
+  timing->paint_timing->experimental_largest_contentful_paint =
+      mojom::LargestContentfulPaintTiming::New();
   timing->parse_timing = mojom::ParseTiming::New();
+  timing->back_forward_cache_timings.clear();
 }
 
 }  // namespace page_load_metrics
diff --git a/chromium/components/page_load_metrics/renderer/metrics_render_frame_observer.cc b/chromium/components/page_load_metrics/renderer/metrics_render_frame_observer.cc
index f0d615cfac0..da17af31f96 100644
--- a/chromium/components/page_load_metrics/renderer/metrics_render_frame_observer.cc
+++ b/chromium/components/page_load_metrics/renderer/metrics_render_frame_observer.cc
@@ -39,12 +39,16 @@ base::TimeTicks ClampToStart(base::TimeTicks event, base::TimeTicks start) {
 
 class MojoPageTimingSender : public PageTimingSender {
  public:
-  explicit MojoPageTimingSender(content::RenderFrame* render_frame) {
+  explicit MojoPageTimingSender(content::RenderFrame* render_frame,
+                                bool limited_sending_mode)
+      : limited_sending_mode_(limited_sending_mode) {
     DCHECK(render_frame);
     render_frame->GetRemoteAssociatedInterfaces()->GetInterface(
         &page_load_metrics_);
   }
+
   ~MojoPageTimingSender() override = default;
+
   void SendTiming(const mojom::PageLoadTimingPtr& timing,
                   const mojom::FrameMetadataPtr& metadata,
                   mojom::PageLoadFeaturesPtr new_features,
@@ -55,12 +59,34 @@ class MojoPageTimingSender : public PageTimingSender {
                   mojom::InputTimingPtr input_timing_delta) override {
     DCHECK(page_load_metrics_);
     page_load_metrics_->UpdateTiming(
-        timing->Clone(), metadata->Clone(), std::move(new_features),
-        std::move(resources), render_data.Clone(), cpu_timing->Clone(),
+        limited_sending_mode_ ? CreatePageLoadTiming() : timing->Clone(),
+        metadata->Clone(), std::move(new_features), std::move(resources),
+        render_data.Clone(), cpu_timing->Clone(),
         std::move(new_deferred_resource_data), std::move(input_timing_delta));
   }
 
+  void SubmitThroughputData(ukm::SourceId source_id,
+                            int aggregated_percent,
+                            int impl_percent,
+                            base::Optional<int> main_percent) {
+    DCHECK(page_load_metrics_);
+    mojom::PercentOptionalPtr main_ptr =
+        main_percent.has_value()
+            ? mojom::PercentOptional::New(main_percent.value())
+            : nullptr;
+    mojom::ThroughputUkmDataPtr throughput_data = mojom::ThroughputUkmData::New(
+        source_id, aggregated_percent, impl_percent, std::move(main_ptr));
+    page_load_metrics_->SubmitThroughputData(std::move(throughput_data));
+  }
+
  private:
+  // Indicates that this sender should not send timing updates or frame render
+  // data updates.
+  // TODO(https://crbug.com/1097127): When timing updates are handled for cases
+  // where we have a subframe document and no committed navigation, this can be
+  // removed.
+  bool limited_sending_mode_ = false;
+
   // Use associated interface to make sure mojo messages are ordered with regard
   // to legacy IPC messages.
   mojo::AssociatedRemote<mojom::PageLoadMetrics> page_load_metrics_;
@@ -246,17 +272,49 @@ void MetricsRenderFrameObserver::DidFailProvisionalLoad() {
   provisional_frame_resource_data_use_.reset();
 }
 
-void MetricsRenderFrameObserver::DidCommitProvisionalLoad(
-    bool is_same_document_navigation,
-    ui::PageTransition transition) {
-  // Same-document navigations (e.g. a navigation from a fragment link) aren't
-  // full page loads, since they don't go to network to load the main HTML
-  // resource. DidStartProvisionalLoad doesn't get invoked for same document
-  // navigations, so we may still have an active page_timing_metrics_sender_ at
-  // this point.
-  if (is_same_document_navigation)
+void MetricsRenderFrameObserver::DidCreateDocumentElement() {
+  // If we do not have a render frame or are already tracking this frame, ignore
+  // the new document element.
+  if (HasNoRenderFrame() || page_timing_metrics_sender_)
+    return;
+
+  // We should only track committed navigations for the main frame so ignore new
+  // document elements in the main frame.
+  if (render_frame()->IsMainFrame())
     return;
 
+  // Every frame creates an initial about:blank document element prior to
+  // receiving a navigation to about:blank. Ignore this initial document
+  // element.
+  if (!first_document_observed_) {
+    first_document_observed_ = true;
+    return;
+  }
+
+  // A new document element was created in a frame that did not commit a
+  // provisional load. This can be due to a doc.write in the frame that aborted
+  // a navigation. Create a page timing sender to track this load. This sender
+  // will only send resource usage updates to the browser process. There
+  // currently is not infrastructure in the browser process to monitor this case
+  // and properly handle timing updates without a committed load.
+  // TODO(https://crbug.com/1097127): Implement proper handling of timing
+  // updates in the browser process and create a normal page timing sender.
+
+  // It should not be possible to have a |provisional_frame_resource_data_use_|
+  // object at this point. If we did, it means we reached
+  // ReadyToCommitNavigation() and aborted prior to load commit which should not
+  // be possible.
+  DCHECK(!provisional_frame_resource_data_use_);
+
+  Timing timing = GetTiming();
+  page_timing_metrics_sender_ = std::make_unique<PageTimingMetricsSender>(
+      CreatePageTimingSender(true /* limited_sending_mode */), CreateTimer(),
+      std::move(timing.relative_timing), timing.monotonic_timing,
+      std::make_unique<PageResourceDataUse>());
+}
+
+void MetricsRenderFrameObserver::DidCommitProvisionalLoad(
+    ui::PageTransition transition) {
   // Make sure to release the sender for a previous navigation, if we have one.
   page_timing_metrics_sender_.reset();
 
@@ -274,7 +332,7 @@ void MetricsRenderFrameObserver::DidCommitProvisionalLoad(
 
   Timing timing = GetTiming();
   page_timing_metrics_sender_ = std::make_unique<PageTimingMetricsSender>(
-      CreatePageTimingSender(), CreateTimer(),
+      CreatePageTimingSender(false /* limited_sending_mode*/), CreateTimer(),
       std::move(timing.relative_timing), timing.monotonic_timing,
       std::move(provisional_frame_resource_data_use_));
 }
@@ -301,6 +359,18 @@ void MetricsRenderFrameObserver::OnMainFrameDocumentIntersectionChanged(
         main_frame_document_intersection);
 }
 
+void MetricsRenderFrameObserver::OnThroughputDataAvailable(
+    ukm::SourceId source_id,
+    int aggregated_percent,
+    int impl_percent,
+    base::Optional<int> main_percent) {
+  std::unique_ptr<MojoPageTimingSender> sender =
+      std::make_unique<MojoPageTimingSender>(render_frame(),
+                                             false /* limited_sending_mode */);
+  sender->SubmitThroughputData(source_id, aggregated_percent, impl_percent,
+                               main_percent);
+}
+
 void MetricsRenderFrameObserver::MaybeSetCompletedBeforeFCP(int request_id) {
   if (HasNoRenderFrame())
     return;
@@ -410,6 +480,17 @@ MetricsRenderFrameObserver::Timing MetricsRenderFrameObserver::GetTiming()
     timing->interactive_timing->longest_input_timestamp =
         ClampDelta((*perf.LongestInputTimestamp()).InSecondsF(), start);
   }
+  if (perf.FirstInputProcessingTime().has_value()) {
+    timing->interactive_timing->first_input_processing_time =
+        *perf.FirstInputProcessingTime();
+  }
+  if (perf.FirstScrollDelay().has_value()) {
+    timing->interactive_timing->first_scroll_delay = *perf.FirstScrollDelay();
+  }
+  if (perf.FirstScrollTimestamp().has_value()) {
+    timing->interactive_timing->first_scroll_timestamp =
+        ClampDelta((*perf.FirstScrollTimestamp()).InSecondsF(), start);
+  }
   if (perf.ResponseStart() > 0.0)
     timing->response_start = ClampDelta(perf.ResponseStart(), start);
   if (perf.DomContentLoadedEventStart() > 0.0) {
@@ -422,11 +503,36 @@ MetricsRenderFrameObserver::Timing MetricsRenderFrameObserver::GetTiming()
   }
   if (perf.FirstPaint() > 0.0)
     timing->paint_timing->first_paint = ClampDelta(perf.FirstPaint(), start);
+  if (!perf.BackForwardCacheRestore().empty()) {
+    blink::WebPerformance::BackForwardCacheRestoreTimings restore_timings =
+        perf.BackForwardCacheRestore();
+    for (const auto& restore_timing : restore_timings) {
+      double navigation_start = restore_timing.navigation_start;
+      double first_paint = restore_timing.first_paint;
+      base::Optional<base::TimeDelta> first_input_delay =
+          restore_timing.first_input_delay;
+
+      auto back_forward_cache_timing = mojom::BackForwardCacheTiming::New();
+      if (first_paint) {
+        back_forward_cache_timing
+            ->first_paint_after_back_forward_cache_restore =
+            ClampDelta(first_paint, navigation_start);
+      }
+      if (first_input_delay.has_value()) {
+        back_forward_cache_timing
+            ->first_input_delay_after_back_forward_cache_restore =
+            ClampDelta(first_input_delay->InSecondsF(), navigation_start);
+      }
+      timing->back_forward_cache_timings.push_back(
+          std::move(back_forward_cache_timing));
+    }
+  }
   if (perf.FirstImagePaint() > 0.0) {
     timing->paint_timing->first_image_paint =
         ClampDelta(perf.FirstImagePaint(), start);
   }
   if (perf.FirstContentfulPaint() > 0.0) {
+    DCHECK(perf.FirstEligibleToPaint() > 0);
     timing->paint_timing->first_contentful_paint =
         ClampDelta(perf.FirstContentfulPaint(), start);
     monotonic_timing.first_contentful_paint =
@@ -438,13 +544,13 @@ MetricsRenderFrameObserver::Timing MetricsRenderFrameObserver::GetTiming()
         ClampDelta(perf.FirstMeaningfulPaint(), start);
   }
   if (perf.LargestImagePaintSize() > 0) {
-    timing->paint_timing->largest_image_paint_size =
+    timing->paint_timing->largest_contentful_paint->largest_image_paint_size =
         perf.LargestImagePaintSize();
     // Note that size can be nonzero while the time is 0 since a time of 0 is
     // sent when the image is painting. We assign the time even when it is 0 so
     // that it's not ignored, but need to be careful when doing operations on
     // the value.
-    timing->paint_timing->largest_image_paint =
+    timing->paint_timing->largest_contentful_paint->largest_image_paint =
         perf.LargestImagePaint() == 0.0
             ? base::TimeDelta()
             : ClampDelta(perf.LargestImagePaint(), start);
@@ -453,9 +559,43 @@ MetricsRenderFrameObserver::Timing MetricsRenderFrameObserver::GetTiming()
     // LargestTextPaint and LargestTextPaintSize should be available at the
     // same time. This is a renderer side DCHECK to ensure this.
     DCHECK(perf.LargestTextPaint());
-    timing->paint_timing->largest_text_paint =
+    timing->paint_timing->largest_contentful_paint->largest_text_paint =
         ClampDelta(perf.LargestTextPaint(), start);
-    timing->paint_timing->largest_text_paint_size = perf.LargestTextPaintSize();
+    timing->paint_timing->largest_contentful_paint->largest_text_paint_size =
+        perf.LargestTextPaintSize();
+  }
+  if (perf.ExperimentalLargestImagePaintSize() > 0) {
+    timing->paint_timing->experimental_largest_contentful_paint
+        ->largest_image_paint_size = perf.ExperimentalLargestImagePaintSize();
+    // Note that size can be nonzero while the time is 0 since a time of 0 is
+    // sent when the image is painting. We assign the time even when it is 0 so
+    // that it's not ignored, but need to be careful when doing operations on
+    // the value.
+    timing->paint_timing->experimental_largest_contentful_paint
+        ->largest_image_paint =
+        perf.ExperimentalLargestImagePaint() == 0.0
+            ? base::TimeDelta()
+            : ClampDelta(perf.ExperimentalLargestImagePaint(), start);
+  }
+  if (perf.ExperimentalLargestTextPaintSize() > 0) {
+    // ExperimentalLargestTextPaint and ExperimentalLargestTextPaintSize should
+    // be available at the same time. This is a renderer side DCHECK to ensure
+    // this.
+    DCHECK(perf.ExperimentalLargestTextPaint());
+    timing->paint_timing->experimental_largest_contentful_paint
+        ->largest_text_paint =
+        ClampDelta(perf.ExperimentalLargestTextPaint(), start);
+    timing->paint_timing->experimental_largest_contentful_paint
+        ->largest_text_paint_size = perf.ExperimentalLargestTextPaintSize();
+  }
+  // It is possible for a frame to switch from eligible for painting to
+  // ineligible for it prior to the first paint. If this occurs, we need to
+  // propagate the null value.
+  if (perf.FirstEligibleToPaint() > 0) {
+    timing->paint_timing->first_eligible_to_paint =
+        ClampDelta(perf.FirstEligibleToPaint(), start);
+  } else {
+    timing->paint_timing->first_eligible_to_paint.reset();
   }
   if (perf.FirstInputOrScrollNotifiedTimestamp() > 0) {
     timing->paint_timing->first_input_or_scroll_notified_timestamp =
@@ -482,6 +622,10 @@ MetricsRenderFrameObserver::Timing MetricsRenderFrameObserver::GetTiming()
         base::TimeDelta::FromSecondsD(
             perf.ParseBlockedOnScriptExecutionFromDocumentWriteDuration());
   }
+  if (perf.LastPortalActivatedPaint().has_value()) {
+    timing->paint_timing->portal_activated_paint =
+        *perf.LastPortalActivatedPaint();
+  }
 
   return Timing(std::move(timing), monotonic_timing);
 }
@@ -491,9 +635,9 @@ std::unique_ptr<base::OneShotTimer> MetricsRenderFrameObserver::CreateTimer() {
 }
 
 std::unique_ptr<PageTimingSender>
-MetricsRenderFrameObserver::CreatePageTimingSender() {
+MetricsRenderFrameObserver::CreatePageTimingSender(bool limited_sending_mode) {
   return base::WrapUnique<PageTimingSender>(
-      new MojoPageTimingSender(render_frame()));
+      new MojoPageTimingSender(render_frame(), limited_sending_mode));
 }
 
 bool MetricsRenderFrameObserver::HasNoRenderFrame() const {
diff --git a/chromium/components/page_load_metrics/renderer/metrics_render_frame_observer.h b/chromium/components/page_load_metrics/renderer/metrics_render_frame_observer.h
index 9dc048cb1a4..c37e1cf91f9 100644
--- a/chromium/components/page_load_metrics/renderer/metrics_render_frame_observer.h
+++ b/chromium/components/page_load_metrics/renderer/metrics_render_frame_observer.h
@@ -77,8 +77,8 @@ class MetricsRenderFrameObserver
   void ReadyToCommitNavigation(
       blink::WebDocumentLoader* document_loader) override;
   void DidFailProvisionalLoad() override;
-  void DidCommitProvisionalLoad(bool is_same_document_navigation,
-                                ui::PageTransition transition) override;
+  void DidCommitProvisionalLoad(ui::PageTransition transition) override;
+  void DidCreateDocumentElement() override;
   void OnDestruct() override;
 
   // Invoked when a frame is going away. This is our last chance to send IPCs
@@ -96,6 +96,11 @@ class MetricsRenderFrameObserver
   void OnMainFrameDocumentIntersectionChanged(
       const blink::WebRect& main_frame_document_intersection) override;
 
+  void OnThroughputDataAvailable(ukm::SourceId source_id,
+                                 int aggregated_percent,
+                                 int impl_percent,
+                                 base::Optional<int> main_percent) override;
+
  protected:
   // The relative and monotonic page load timings.
   struct Timing {
@@ -125,9 +130,14 @@ class MetricsRenderFrameObserver
   void SendMetrics();
   virtual Timing GetTiming() const;
   virtual std::unique_ptr<base::OneShotTimer> CreateTimer();
-  virtual std::unique_ptr<PageTimingSender> CreatePageTimingSender();
+  virtual std::unique_ptr<PageTimingSender> CreatePageTimingSender(
+      bool limited_sending_mode);
   virtual bool HasNoRenderFrame() const;
 
+  // Whether the initial about:blank document loaded into every frame was
+  // observed.
+  bool first_document_observed_ = false;
+
   // Collects the data use of the frame request for a provisional load until the
   // load is committed. We want to collect data use for completed navigations in
   // this class, but the various navigation callbacks do not provide enough data
diff --git a/chromium/components/page_load_metrics/renderer/metrics_render_frame_observer_unittest.cc b/chromium/components/page_load_metrics/renderer/metrics_render_frame_observer_unittest.cc
index 6bc88c9ef83..a4789646bb0 100644
--- a/chromium/components/page_load_metrics/renderer/metrics_render_frame_observer_unittest.cc
+++ b/chromium/components/page_load_metrics/renderer/metrics_render_frame_observer_unittest.cc
@@ -32,7 +32,8 @@ class TestMetricsRenderFrameObserver : public MetricsRenderFrameObserver,
     return std::move(timer);
   }
 
-  std::unique_ptr<PageTimingSender> CreatePageTimingSender() override {
+  std::unique_ptr<PageTimingSender> CreatePageTimingSender(
+      bool limited_sending_mode) override {
     return base::WrapUnique<PageTimingSender>(
         new FakePageTimingSender(&validator_));
   }
@@ -88,7 +89,7 @@ TEST_F(MetricsRenderFrameObserverTest, SingleMetric) {
   observer.ExpectPageLoadTiming(timing);
   observer.DidStartNavigation(GURL(), base::nullopt);
   observer.ReadyToCommitNavigation(nullptr);
-  observer.DidCommitProvisionalLoad(false, ui::PAGE_TRANSITION_LINK);
+  observer.DidCommitProvisionalLoad(ui::PAGE_TRANSITION_LINK);
   observer.GetMockTimer()->Fire();
 
   timing.parse_timing->parse_start = base::TimeDelta::FromMilliseconds(10);
@@ -111,7 +112,7 @@ TEST_F(MetricsRenderFrameObserverTest, SingleCpuMetric) {
   observer.ExpectPageLoadTiming(timing);
   observer.DidStartNavigation(GURL(), base::nullopt);
   observer.ReadyToCommitNavigation(nullptr);
-  observer.DidCommitProvisionalLoad(false, ui::PAGE_TRANSITION_LINK);
+  observer.DidCommitProvisionalLoad(ui::PAGE_TRANSITION_LINK);
 
   // Send cpu timing updates and verify the expected result.
   observer.DidChangeCpuTiming(base::TimeDelta::FromMilliseconds(110));
@@ -133,7 +134,7 @@ TEST_F(MetricsRenderFrameObserverTest, MultipleMetrics) {
   observer.ExpectPageLoadTiming(timing);
   observer.DidStartNavigation(GURL(), base::nullopt);
   observer.ReadyToCommitNavigation(nullptr);
-  observer.DidCommitProvisionalLoad(false, ui::PAGE_TRANSITION_LINK);
+  observer.DidCommitProvisionalLoad(ui::PAGE_TRANSITION_LINK);
   observer.GetMockTimer()->Fire();
 
   timing.document_timing->dom_content_loaded_event_start = dom_event;
@@ -179,7 +180,7 @@ TEST_F(MetricsRenderFrameObserverTest, MultipleNavigations) {
   observer.ExpectPageLoadTiming(timing);
   observer.DidStartNavigation(GURL(), base::nullopt);
   observer.ReadyToCommitNavigation(nullptr);
-  observer.DidCommitProvisionalLoad(false, ui::PAGE_TRANSITION_LINK);
+  observer.DidCommitProvisionalLoad(ui::PAGE_TRANSITION_LINK);
   observer.GetMockTimer()->Fire();
 
   timing.document_timing->dom_content_loaded_event_start = dom_event;
@@ -205,7 +206,7 @@ TEST_F(MetricsRenderFrameObserverTest, MultipleNavigations) {
   observer.ExpectPageLoadTiming(timing_2);
   observer.DidStartNavigation(GURL(), base::nullopt);
   observer.ReadyToCommitNavigation(nullptr);
-  observer.DidCommitProvisionalLoad(false, ui::PAGE_TRANSITION_LINK);
+  observer.DidCommitProvisionalLoad(ui::PAGE_TRANSITION_LINK);
   observer.GetMockTimer()->Fire();
 
   timing_2.document_timing->dom_content_loaded_event_start = dom_event_2;
diff --git a/chromium/components/page_load_metrics/renderer/page_timing_metrics_sender.cc b/chromium/components/page_load_metrics/renderer/page_timing_metrics_sender.cc
index 36625df9f45..3cd64fefc99 100644
--- a/chromium/components/page_load_metrics/renderer/page_timing_metrics_sender.cc
+++ b/chromium/components/page_load_metrics/renderer/page_timing_metrics_sender.cc
@@ -44,9 +44,9 @@ PageTimingMetricsSender::PageTimingMetricsSender(
       new_deferred_resource_data_(mojom::DeferredResourceCounts::New()),
       buffer_timer_delay_ms_(kBufferTimerDelayMillis),
       metadata_recorder_(initial_monotonic_timing) {
+  const auto resource_id = initial_request->resource_id();
   page_resource_data_use_.emplace(
-      std::piecewise_construct,
-      std::forward_as_tuple(initial_request->resource_id()),
+      std::piecewise_construct, std::forward_as_tuple(resource_id),
       std::forward_as_tuple(std::move(initial_request)));
   buffer_timer_delay_ms_ = base::GetFieldTrialParamByFeatureAsInt(
       kPageLoadMetricsTimerDelayFeature, "BufferTimerDelayMillis",