[Prerender] first contentful paint histograms.

chrome/browser/prerender/prerender_browsertest.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <deque>
 #include <set>
 #include <string>
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/scoped_observer.h"
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/scoped_feature_list.h"
+#include "base/test/simple_test_tick_clock.h"
 #include "base/test/test_timeouts.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_factory.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_test_util.h"
 #include "chrome/browser/chrome_content_browser_client.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/extensions/api/web_navigation/web_navigation_api.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/external_protocol/external_protocol_handler.h"
 #include "chrome/browser/net/prediction_options.h"
+#include "chrome/browser/page_load_metrics/observers/page_load_metrics_observer_test_harness.h"
+#include "chrome/browser/page_load_metrics/observers/prerender_page_load_metrics_observer.h"
 #include "chrome/browser/password_manager/password_store_factory.h"
 #include "chrome/browser/predictors/autocomplete_action_predictor.h"
 #include "chrome/browser/predictors/autocomplete_action_predictor_factory.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/browser/prerender/prerender_field_trial.h"
 #include "chrome/browser/prerender/prerender_handle.h"
 #include "chrome/browser/prerender/prerender_link_manager.h"
 #include "chrome/browser/prerender/prerender_link_manager_factory.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
+#include "chrome/browser/prerender/prerender_tab_helper.h"
 #include "chrome/browser/prerender/prerender_test_utils.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_io_data.h"
 #include "chrome/browser/task_manager/mock_web_contents_task_manager.h"
 #include "chrome/browser/task_manager/providers/web_contents/web_contents_tags_manager.h"
 #include "chrome/browser/task_manager/task_manager_browsertest_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_window.h"
@@ skipping 650 matching lines @@
         tab,
         "window.domAutomationController.send(DidBackToOriginalPagePass())",
         &js_result));
     EXPECT_TRUE(js_result);
   }
 
   void DisableJavascriptCalls() {
     call_javascript_ = false;
   }
 
+  void EnableJavascriptCalls() { call_javascript_ = true; }
+
   void DisableLoadEventCheck() {
     check_load_events_ = false;
   }
 
   const PrerenderLinkManager* GetPrerenderLinkManager() const {
     PrerenderLinkManager* prerender_link_manager =
         PrerenderLinkManagerFactory::GetForProfile(
             current_browser()->profile());
     return prerender_link_manager;
   }
@@ skipping 134 matching lines @@
   }
 
   void AddPrerender(const GURL& url, int index) {
     std::string javascript = base::StringPrintf(
         "AddPrerender('%s', %d)", url.spec().c_str(), index);
     RenderFrameHost* render_frame_host = GetActiveWebContents()->GetMainFrame();
     render_frame_host->ExecuteJavaScriptForTests(
         base::ASCIIToUTF16(javascript));
   }
 
+  base::SimpleTestTickClock* OverridePrerenderManagerTimeTicks() {
+    auto clock = base::MakeUnique<base::SimpleTestTickClock>();
+    auto clock_ptr = clock.get();
+    // The default zero time causes the prerender manager to do strange things.
+    clock->Advance(base::TimeDelta::FromSeconds(1));
+    GetPrerenderManager()->SetTickClockForTesting(std::move(clock));
+    return clock_ptr;
+  }
+
+  void SetMidLoadClockAdvance(base::SimpleTestTickClock* clock,
+                              base::TimeDelta delta) {
+    mid_load_clock_ = clock;
+    mid_load_clock_tick_advance_ = delta;
+  }
+
+  void ClearMidLoadClock() {
+    mid_load_clock_tick_advance_ = base::TimeDelta();
+    mid_load_clock_ = nullptr;
+  }
+
  private:
   // TODO(davidben): Remove this altogether so the tests don't globally assume
   // only one prerender.
   TestPrerenderContents* GetPrerenderContents() const {
     return GetPrerenderContentsFor(dest_url_);
   }
 
   std::vector<std::unique_ptr<TestPrerender>> PrerenderTestURLImpl(
       const GURL& prerender_url,
       const std::vector<FinalStatus>& expected_final_status_queue,
       int expected_number_of_loads) {
     dest_url_ = prerender_url;
 
     GURL loader_url = ServeLoaderURL(loader_path_, "REPLACE_WITH_PRERENDER_URL",
                                      prerender_url, "&" + loader_query_);
     GURL::Replacements loader_replacements;
     if (!loader_host_override_.empty())
       loader_replacements.SetHostStr(loader_host_override_);
     loader_url = loader_url.ReplaceComponents(loader_replacements);
 
     std::vector<std::unique_ptr<TestPrerender>> prerenders =
         NavigateWithPrerenders(loader_url, expected_final_status_queue);
     prerenders[0]->WaitForLoads(expected_number_of_loads);
 
+    if (!mid_load_clock_tick_advance_.is_zero()) {
+      EXPECT_TRUE(mid_load_clock_);
+      mid_load_clock_->Advance(mid_load_clock_tick_advance_);
+    }
+
     FinalStatus expected_final_status = expected_final_status_queue.front();
     if (ShouldAbortPrerenderBeforeSwap(expected_final_status)) {
       // The prerender will abort on its own. Assert it does so correctly.
       prerenders[0]->WaitForStop();
       EXPECT_FALSE(prerenders[0]->contents());
       EXPECT_TRUE(DidReceivePrerenderStopEventForLinkNumber(0));
     } else {
       // Otherwise, check that it prerendered correctly.
       TestPrerenderContents* prerender_contents = prerenders[0]->contents();
       CHECK(prerender_contents);
@@ skipping 72 matching lines @@
     }
   }
 
   GURL dest_url_;
   bool call_javascript_;
   bool check_load_events_;
   std::string loader_host_override_;
   std::string loader_path_;
   std::string loader_query_;
   base::test::ScopedFeatureList feature_list_;
+  base::TimeDelta mid_load_clock_tick_advance_;
+  base::SimpleTestTickClock* mid_load_clock_;
 };
 
 // Checks that a page is correctly prerendered in the case of a
 // <link rel=prerender> tag and then loaded into a tab in response to a
 // navigation.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPage) {
+  test_utils::FirstContentfulPaintManagerWaiter* fcp_waiter =
+      test_utils::FirstContentfulPaintManagerWaiter::Create(
+          GetPrerenderManager());
   PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
   EXPECT_EQ(1, GetPrerenderDomContentLoadedEventCountForLinkNumber(0));
   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
   histogram_tester().ExpectTotalCount(
       "Prerender.none_PerceivedPLTMatchedComplete", 0);
   histogram_tester().ExpectTotalCount(
       "Prerender.websame_PrerenderNotSwappedInPLT", 1);
 
   ChannelDestructionWatcher channel_close_watcher;
   channel_close_watcher.WatchChannel(
       GetActiveWebContents()->GetRenderProcessHost());
   NavigateToDestURL();
   channel_close_watcher.WaitForChannelClose();
+  fcp_waiter->Wait();
 
   histogram_tester().ExpectTotalCount("Prerender.websame_PerceivedPLT", 1);
   histogram_tester().ExpectTotalCount("Prerender.websame_PerceivedPLTMatched",
                                       1);
   histogram_tester().ExpectTotalCount(
       "Prerender.websame_PerceivedPLTMatchedComplete", 1);
+  histogram_tester().ExpectTotalCount(
+      "Prerender.websame_PrefetchTTFCP.Warm.Cacheable.Visible", 1);
+  histogram_tester().ExpectTotalCount(
+      "Prerender.websame_PerceivedTTFCPRecorded.Visible", 1);
 
   ASSERT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
+// Checks that the correct page load metrics observers are produced with and
+// without a prerender.
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PageLoadMetrics) {
+  // Simple load. The prefetch page is used as a simple page with a nonempty
+  // layout; no prefetching is performed.
+  test_utils::FirstContentfulPaintManagerWaiter* simple_fcp_waiter =
+      test_utils::FirstContentfulPaintManagerWaiter::Create(
+          GetPrerenderManager());
+  ui_test_utils::NavigateToURL(
+      current_browser(), src_server()->GetURL("/prerender/prefetch_page.html"));
+  simple_fcp_waiter->Wait();
+
+  // Prerendered load.
+  test_utils::FirstContentfulPaintManagerWaiter* prerender_fcp_waiter =
+      test_utils::FirstContentfulPaintManagerWaiter::Create(
+          GetPrerenderManager());
+  PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
+  NavigateToDestURL();
+  prerender_fcp_waiter->Wait();
+
+  // Histogram only emitted during the simple load.
+  histogram_tester().ExpectTotalCount(
+      "Prerender.none_PrefetchTTFCP.Reference.Cacheable.Visible", 1);
+  // Histogram only emitted during prerender.
+  histogram_tester().ExpectTotalCount(
+      "Prerender.websame_PrefetchTTFCP.Warm.Cacheable.Visible", 1);
+  // Histogram only emitted during the two simple loads: the NavigateToURL call,
+  // and the page containing the link rel=prerender.
+  histogram_tester().ExpectTotalCount(
+      "PageLoad.DocumentTiming.NavigationToFirstLayout", 2);
+}
+
 // Checks that cross-domain prerenders emit the correct histograms.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageCrossDomain) {
+  test_utils::FirstContentfulPaintManagerWaiter* fcp_waiter =
+      test_utils::FirstContentfulPaintManagerWaiter::Create(
+          GetPrerenderManager());
   PrerenderTestURL(GetCrossDomainTestUrl("prerender/prerender_page.html"),
                    FINAL_STATUS_USED, 1);
   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
   histogram_tester().ExpectTotalCount(
       "Prerender.none_PerceivedPLTMatchedComplete", 0);
   histogram_tester().ExpectTotalCount(
       "Prerender.webcross_PrerenderNotSwappedInPLT", 1);
 
   NavigateToDestURL();
+  fcp_waiter->Wait();
+
   histogram_tester().ExpectTotalCount("Prerender.webcross_PerceivedPLT", 1);
   histogram_tester().ExpectTotalCount("Prerender.webcross_PerceivedPLTMatched",
                                       1);
   histogram_tester().ExpectTotalCount(
       "Prerender.webcross_PerceivedPLTMatchedComplete", 1);
+  histogram_tester().ExpectTotalCount(
+      "Prerender.webcross_PrefetchTTFCP.Warm.Cacheable.Visible", 1);
 }
 
 // Checks that pending prerenders launch and receive proper event treatment.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPagePending) {
   std::unique_ptr<TestPrerender> prerender = PrerenderTestURL(
       "/prerender/prerender_page_pending.html", FINAL_STATUS_USED, 1);
 
   // Navigate to the prerender.
   std::unique_ptr<TestPrerender> prerender2 =
       ExpectPrerender(FINAL_STATUS_USED);
@@ skipping 2117 matching lines @@
                  done_url, empty_file, done_counter.AsWeakPtr()));
   // Loading may finish or be interrupted. The final result is important only.
   DisableLoadEventCheck();
   // TestPrenderContents is always created before the Autosignin JS can run, so
   // waiting for PrerenderContents to stop should be reliable.
   PrerenderTestURL("/password/autosignin.html",
                    FINAL_STATUS_CREDENTIAL_MANAGER_API, 0);
   EXPECT_EQ(0, done_counter.count());
 }
 
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, FirstContentfulPaintTimingSimple) {
+  GetPrerenderManager()->DisablePageLoadMetricsObserverForTesting();
+  base::SimpleTestTickClock* clock = OverridePrerenderManagerTimeTicks();
+  PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
+
+  base::TimeTicks load_start = clock->NowTicks();
+  clock->Advance(base::TimeDelta::FromSeconds(1));
+  NavigateToDestURL();
+
+  test_utils::TestPrerenderPageLoadMetricsObserver observer(
+      GetPrerenderManager(), GetActiveWebContents());
+  observer.SetNavigationStartTo(load_start);
+
+  page_load_metrics::PageLoadTiming timing;
+  timing.navigation_start = base::Time::FromDoubleT(1);
+  timing.first_contentful_paint = base::TimeDelta::FromMilliseconds(2654);
+  page_load_metrics::PageLoadMetricsObserverTestHarness::
+      PopulateRequiredTimingFields(&timing);
+  observer.OnFirstContentfulPaint(
+      timing,
+      page_load_metrics::PageLoadExtraInfo(
+          base::TimeDelta(), base::TimeDelta(), false, false, dest_url(),
+          dest_url(), page_load_metrics::ABORT_NONE, false, base::TimeDelta(),
+          0, 0, page_load_metrics::PageLoadMetadata()));
+
+  histogram_tester().ExpectTotalCount(
+      "Prerender.websame_PrefetchTTFCP.Warm.Cacheable.Visible", 1);
+  histogram_tester().ExpectUniqueSample(
+      "Prerender.websame_PrefetchTTFCP.Warm.Cacheable.Visible", 1654, 1);

[droger, 2016/11/29 15:54:39]

It may be nice to have base::TimeDelta::FromMilliseconds(2654) and
base::Time::FromDoubleT(1) defined as constants, and compute 1654 as the
difference between the two.

Here and in other tests.

[mattcary, 2016/11/29 16:39:45]

That's not quite true, however: this is the lower edge of the bucket the
timestamp ends up in. I set the times so that we end up right on the edge, under
the theory that would catch more errors, but it seems misleading to claim that
bucket = paint - start time. There seems to be no good GetBucketLowerBound
function here which would make the calculation you suggest accurate.

+}
+
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, FirstContentfulPaintTimingReuse) {
+  GetPrerenderManager()->DisablePageLoadMetricsObserverForTesting();
+  base::SimpleTestTickClock* clock = OverridePrerenderManagerTimeTicks();
+
+  GURL url = embedded_test_server()->GetURL("/prerender/prerender_page.html");
+  DisableJavascriptCalls();
+  PrerenderTestURL(url, FINAL_STATUS_CANCELLED, 0);
+
+  // This prerender cancels and reuses the first.
+  clock->Advance(base::TimeDelta::FromSeconds(1));
+  base::TimeTicks load_start = clock->NowTicks();
+  EnableJavascriptCalls();
+  PrerenderTestURL(url, FINAL_STATUS_USED, 1);
+  clock->Advance(base::TimeDelta::FromSeconds(1));
+
+  NavigateToDestURL();
+  test_utils::TestPrerenderPageLoadMetricsObserver observer(
+      GetPrerenderManager(), GetActiveWebContents());
+  observer.SetNavigationStartTo(load_start);
+
+  page_load_metrics::PageLoadTiming timing;
+  timing.navigation_start = base::Time::FromDoubleT(1);
+  timing.first_contentful_paint = base::TimeDelta::FromMilliseconds(2361);
+  page_load_metrics::PageLoadMetricsObserverTestHarness::
+      PopulateRequiredTimingFields(&timing);
+  observer.OnFirstContentfulPaint(
+      timing,
+      page_load_metrics::PageLoadExtraInfo(
+          base::TimeDelta(), base::TimeDelta(), false, false, dest_url(),
+          dest_url(), page_load_metrics::ABORT_NONE, false, base::TimeDelta(),
+          0, 0, page_load_metrics::PageLoadMetadata()));
+
+  histogram_tester().ExpectTotalCount(
+      "Prerender.websame_PrefetchTTFCP.Warm.Cacheable.Visible", 1);
+  // If the first prerender had been used, the perceived TTFCP would have been
+  // under a second: 2362ms - 2 sec worth of Advance().
+  histogram_tester().ExpectUniqueSample(
+      "Prerender.websame_PrefetchTTFCP.Warm.Cacheable.Visible", 1361, 1);
+}
+
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
+                       FirstContentfulPaintTimingTimeout) {
+  GetPrerenderManager()->DisablePageLoadMetricsObserverForTesting();
+  base::SimpleTestTickClock* clock = OverridePrerenderManagerTimeTicks();
+
+  // Make the first prerender time out.
+  base::TimeDelta time_out_delta =
+      GetPrerenderManager()->config().time_to_live +
+      base::TimeDelta::FromSeconds(10);
+  SetMidLoadClockAdvance(clock, time_out_delta);
+
+  GURL url = embedded_test_server()->GetURL("/prerender/prerender_page.html");
+  PrerenderTestURL(url, FINAL_STATUS_TIMED_OUT, 1);
+
+  ClearMidLoadClock();
+  base::TimeTicks load_start = clock->NowTicks();
+  PrerenderTestURL(url, FINAL_STATUS_USED, 1);
+
+  clock->Advance(base::TimeDelta::FromSeconds(1));
+  NavigateToDestURL();
+
+  test_utils::TestPrerenderPageLoadMetricsObserver observer(
+      GetPrerenderManager(), GetActiveWebContents());
+  observer.SetNavigationStartTo(load_start);
+
+  page_load_metrics::PageLoadTiming timing;
+  timing.navigation_start = base::Time::FromDoubleT(1);
+  timing.first_contentful_paint = base::TimeDelta::FromMilliseconds(2361);
+  page_load_metrics::PageLoadMetricsObserverTestHarness::
+      PopulateRequiredTimingFields(&timing);
+  observer.OnFirstContentfulPaint(
+      timing,
+      page_load_metrics::PageLoadExtraInfo(
+          base::TimeDelta(), base::TimeDelta(), false, false, dest_url(),
+          dest_url(), page_load_metrics::ABORT_NONE, false, base::TimeDelta(),
+          0, 0, page_load_metrics::PageLoadMetadata()));
+
+  histogram_tester().ExpectTotalCount(
+      "Prerender.websame_PrefetchTTFCP.Warm.Cacheable.Visible", 1);
+  // If the timed out had been used, the perceived TTFCP would have been
+  // negative.
+  histogram_tester().ExpectUniqueSample(
+      "Prerender.websame_PrefetchTTFCP.Warm.Cacheable.Visible", 1361, 1);
+}
+
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
+                       FirstContentfulPaintTimingNoCommit) {
+  GetPrerenderManager()->DisablePageLoadMetricsObserverForTesting();
+  base::SimpleTestTickClock* clock = OverridePrerenderManagerTimeTicks();
+
+  GURL url = embedded_test_server()->GetURL("/prerender/prerender_page.html");
+  base::FilePath url_file = ui_test_utils::GetTestFilePath(
+      base::FilePath(),
+      base::FilePath(FILE_PATH_LITERAL("prerender/prerender_page.html")));
+
+  base::RunLoop prerender_start_loop;
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&CreateHangingFirstRequestInterceptorOnIO, url, url_file,
+                 prerender_start_loop.QuitClosure()));
+  DisableJavascriptCalls();
+  PrerenderTestURL(url, FINAL_STATUS_NAVIGATION_UNCOMMITTED, 0);
+  prerender_start_loop.Run();
+
+  clock->Advance(base::TimeDelta::FromSeconds(1));
+  NavigateToDestURLWithDisposition(WindowOpenDisposition::CURRENT_TAB, false);
+
+  test_utils::TestPrerenderPageLoadMetricsObserver observer(
+      GetPrerenderManager(), GetActiveWebContents());
+  observer.SetNavigationStartTo(clock->NowTicks());
+
+  page_load_metrics::PageLoadTiming timing;
+  timing.navigation_start = base::Time::FromDoubleT(1);
+  timing.first_contentful_paint = base::TimeDelta::FromMilliseconds(2362);
+  page_load_metrics::PageLoadMetricsObserverTestHarness::
+      PopulateRequiredTimingFields(&timing);
+  observer.OnFirstContentfulPaint(
+      timing,
+      page_load_metrics::PageLoadExtraInfo(
+          base::TimeDelta(), base::TimeDelta(), false, false, dest_url(),
+          dest_url(), page_load_metrics::ABORT_NONE, false, base::TimeDelta(),
+          0, 0, page_load_metrics::PageLoadMetadata()));
+
+  histogram_tester().ExpectTotalCount(
+      "Prerender.none_PrefetchTTFCP.Warm.Cacheable.Visible", 0);
+  histogram_tester().ExpectTotalCount(
+      "Prerender.none_PerceivedTTFCPRecorded.Visible", 1);
+
+  // Check that the prerender didn't happen with a defined origin.
+  histogram_tester().ExpectTotalCount(
+      "Prerender.websame_PrefetchTTFCP.Warm.Cacheable.Visible", 0);
+  histogram_tester().ExpectTotalCount(
+      "Prerender.websame_PerceivedTTFCPRecorded.Visible", 0);
+
+  // A FCP is fired by the observer, but the manager should detect that the
+  // perceived time is not set and so update the following histogram.
+  histogram_tester().ExpectUniqueSample(
+      "Prerender.none_PerceivedTTFCPRecorded.Visible", 0, 1);
+}
+
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
+                       FirstContentfulPaintTimingTwoPages) {
+  GetPrerenderManager()->DisablePageLoadMetricsObserverForTesting();
+  base::SimpleTestTickClock* clock = OverridePrerenderManagerTimeTicks();
+
+  DisableJavascriptCalls();
+  // First prerender a different page from the usual target.
+  PrerenderTestURL("/prerender/prefetch_page.html", FINAL_STATUS_CANCELLED, 0);
+
+  clock->Advance(base::TimeDelta::FromSeconds(1));
+  base::TimeTicks load_start = clock->NowTicks();
+  EnableJavascriptCalls();
+  PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
+
+  clock->Advance(base::TimeDelta::FromSeconds(1));
+  NavigateToDestURL();
+
+  test_utils::TestPrerenderPageLoadMetricsObserver observer(
+      GetPrerenderManager(), GetActiveWebContents());
+  observer.SetNavigationStartTo(load_start);
+
+  page_load_metrics::PageLoadTiming timing;
+  timing.navigation_start = base::Time::FromDoubleT(1);
+  // The FCP time should end up on the edge of the bucket.
+  timing.first_contentful_paint = base::TimeDelta::FromMilliseconds(2654);
+  page_load_metrics::PageLoadMetricsObserverTestHarness::
+      PopulateRequiredTimingFields(&timing);
+  observer.OnFirstContentfulPaint(
+      timing,
+      page_load_metrics::PageLoadExtraInfo(
+          base::TimeDelta(), base::TimeDelta(), false, false, dest_url(),
+          dest_url(), page_load_metrics::ABORT_NONE, false, base::TimeDelta(),
+          0, 0, page_load_metrics::PageLoadMetadata()));
+
+  histogram_tester().ExpectTotalCount(
+      "Prerender.websame_PrefetchTTFCP.Warm.Cacheable.Visible", 1);
+  histogram_tester().ExpectUniqueSample(
+      "Prerender.websame_PrefetchTTFCP.Warm.Cacheable.Visible", 1654, 1);
+}
+
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, FirstContentfulPaintHidden) {
+  GetPrerenderManager()->DisablePageLoadMetricsObserverForTesting();
+  base::SimpleTestTickClock* clock = OverridePrerenderManagerTimeTicks();
+  base::TimeTicks load_start = clock->NowTicks();
+  PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
+
+  clock->Advance(base::TimeDelta::FromSeconds(1));
+  NavigateToDestURL();
+
+  test_utils::TestPrerenderPageLoadMetricsObserver observer(
+      GetPrerenderManager(), GetActiveWebContents());
+  observer.SetNavigationStartTo(load_start);
+
+  page_load_metrics::PageLoadExtraInfo extra_info(
+      base::TimeDelta(), base::TimeDelta(), false, false, dest_url(),
+      dest_url(), page_load_metrics::ABORT_NONE, false, base::TimeDelta(), 0, 0,
+      page_load_metrics::PageLoadMetadata());
+  EXPECT_EQ(page_load_metrics::PageLoadMetricsObserver::CONTINUE_OBSERVING,
+            observer.OnHidden(page_load_metrics::PageLoadTiming(), extra_info));
+
+  page_load_metrics::PageLoadTiming timing;
+  timing.navigation_start = base::Time::FromDoubleT(1);
+  timing.first_contentful_paint = base::TimeDelta::FromMilliseconds(2654);
+  page_load_metrics::PageLoadMetricsObserverTestHarness::
+      PopulateRequiredTimingFields(&timing);
+  observer.OnFirstContentfulPaint(timing, extra_info);
+
+  histogram_tester().ExpectTotalCount(
+      "Prerender.websame_PrefetchTTFCP.Warm.Cacheable.Hidden", 1);
+  histogram_tester().ExpectUniqueSample(
+      "Prerender.websame_PrefetchTTFCP.Warm.Cacheable.Hidden", 1654, 1);
+}
+
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
+                       FirstContentfulPaintHiddenNoCommit) {
+  GetPrerenderManager()->DisablePageLoadMetricsObserverForTesting();
+  base::SimpleTestTickClock* clock = OverridePrerenderManagerTimeTicks();
+
+  GURL url = embedded_test_server()->GetURL("/prerender/prerender_page.html");
+  base::FilePath url_file = ui_test_utils::GetTestFilePath(
+      base::FilePath(),
+      base::FilePath(FILE_PATH_LITERAL("prerender/prerender_page.html")));
+
+  base::RunLoop prerender_start_loop;
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&CreateHangingFirstRequestInterceptorOnIO, url, url_file,
+                 prerender_start_loop.QuitClosure()));
+  DisableJavascriptCalls();
+  PrerenderTestURL(url, FINAL_STATUS_NAVIGATION_UNCOMMITTED, 0);
+  prerender_start_loop.Run();
+
+  clock->Advance(base::TimeDelta::FromSeconds(1));
+  NavigateToDestURLWithDisposition(WindowOpenDisposition::CURRENT_TAB, false);
+
+  test_utils::TestPrerenderPageLoadMetricsObserver observer(
+      GetPrerenderManager(), GetActiveWebContents());
+  observer.SetNavigationStartTo(clock->NowTicks());
+
+  page_load_metrics::PageLoadExtraInfo extra_info(
+      base::TimeDelta(), base::TimeDelta(), false, false, dest_url(),
+      dest_url(), page_load_metrics::ABORT_NONE, false, base::TimeDelta(), 0, 0,
+      page_load_metrics::PageLoadMetadata());
+  EXPECT_EQ(page_load_metrics::PageLoadMetricsObserver::CONTINUE_OBSERVING,
+            observer.OnHidden(page_load_metrics::PageLoadTiming(), extra_info));
+
+  page_load_metrics::PageLoadTiming timing;
+  timing.navigation_start = base::Time::FromDoubleT(1);
+  timing.first_contentful_paint = base::TimeDelta::FromMilliseconds(2362);
+  page_load_metrics::PageLoadMetricsObserverTestHarness::
+      PopulateRequiredTimingFields(&timing);
+  observer.OnFirstContentfulPaint(timing, extra_info);
+
+  histogram_tester().ExpectTotalCount(
+      "Prerender.none_PrefetchTTFCP.Warm.Cacheable.Hidden", 0);
+  histogram_tester().ExpectTotalCount(
+      "Prerender.none_PerceivedTTFCPRecorded.Hidden", 1);
+
+  // Check that the prerender didn't happen with a defined origin.
+  histogram_tester().ExpectTotalCount(
+      "Prerender.websame_PrefetchTTFCP.Warm.Cacheable.Hidden", 0);
+  histogram_tester().ExpectTotalCount(
+      "Prerender.websame_PerceivedTTFCPRecorded.Hidden", 0);
+
+  // A FCP is fired by the observer, but the manager should detect that the
+  // perceived time is not set and so update the following histogram.
+  histogram_tester().ExpectUniqueSample(
+      "Prerender.none_PerceivedTTFCPRecorded.Hidden", 0, 1);
+}
+
 class PrerenderIncognitoBrowserTest : public PrerenderBrowserTest {
  public:
   void SetUpOnMainThread() override {
     Profile* normal_profile = current_browser()->profile();
     set_browser(OpenURLOffTheRecord(normal_profile, GURL("about:blank")));
     PrerenderBrowserTest::SetUpOnMainThread();
   }
 };
 
 // Checks that prerendering works in incognito mode.
@@ skipping 135 matching lines @@
       browser()->tab_strip_model()->GetActiveWebContents();
   bool display_test_result = false;
   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(web_contents,
                                                    "DidDisplayReallyPass()",
                                                    &display_test_result));
   ASSERT_TRUE(display_test_result);
 }
 #endif  // !defined(DISABLE_NACL)
 
 }  // namespace prerender