Report page load timing information for child frames.

chrome/browser/page_load_metrics/page_load_metrics_browsertest.cc

 // Copyright 2015 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 "base/command_line.h"
+#include "base/feature_list.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/test/histogram_tester.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "chrome/browser/page_load_metrics/metrics_web_contents_observer.h"
 #include "chrome/browser/page_load_metrics/observers/aborts_page_load_metrics_observer.h"
 #include "chrome/browser/page_load_metrics/observers/core_page_load_metrics_observer.h"
 #include "chrome/browser/page_load_metrics/observers/document_write_page_load_metrics_observer.h"
 #include "chrome/browser/page_load_metrics/observers/no_state_prefetch_page_load_metrics_observer.h"
 #include "chrome/browser/page_load_metrics/page_load_tracker.h"
 #include "chrome/browser/prerender/prerender_histograms.h"
 #include "chrome/browser/prerender/prerender_origin.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_navigator_params.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/page_load_metrics/page_load_metrics_messages.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
+#include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/download_test_observer.h"
+#include "net/dns/mock_host_resolver.h"
 #include "net/http/failing_http_transaction_factory.h"
 #include "net/http/http_cache.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/url_request/url_request_failed_job.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace {
 
 // Waits until specified timing and metadata expectations are satisfied.
 class PageLoadMetricsWaiter
     : public page_load_metrics::MetricsWebContentsObserver::TestingObserver {
  public:
   // A bitvector to express which timing fields to match on.
   enum ExpectedTimingFields {

[jkarlin, 2017/05/10 16:55:28]

enum class

[Bryan McQuade, 2017/05/10 18:06:15]

thanks! i moved this whole change to https://codereview.chromium.org/2868213003
since this one got quite large, and addressed this comment there. once that
lands i'll merge it into this patch.

-    FIRST_PAINT = 1 << 0,
-    FIRST_CONTENTFUL_PAINT = 1 << 1,
-    STYLE_UPDATE_BEFORE_FCP = 1 << 2
+    FIRST_LAYOUT = 1 << 0,
+    FIRST_PAINT = 1 << 1,
+    FIRST_CONTENTFUL_PAINT = 1 << 2,
+    STYLE_UPDATE_BEFORE_FCP = 1 << 3,
+    DOCUMENT_WRITE_BLOCK_RELOAD = 1 << 4
   };
 
   explicit PageLoadMetricsWaiter(content::WebContents* web_contents)
       : TestingObserver(web_contents) {}
 
   ~PageLoadMetricsWaiter() override { DCHECK_EQ(nullptr, run_loop_.get()); }
 
   // Add the given expectation to match on.
-  void AddExpectation(ExpectedTimingFields fields) {
-    matching_fields_ |= fields;
+  void AddMainFrameExpectation(ExpectedTimingFields fields) {
+    main_frame_expected_fields_ |= fields;
   }
-
-  // Instructs observer to also watch for |count|
-  // WebLoadingBehaviorDocumentWriteBlockReload events.
-  void ExpectDocumentWriteBlockReload(int count) {
-    match_document_write_block_reload_ = count;
+  void AddSubFrameExpectation(ExpectedTimingFields fields) {
+    child_frame_expected_fields_ |= fields;
   }
 
   // Waits for a TimingUpdated IPC that matches the fields set by
   // |AddExpectation|.  All matching fields must be set in a TimingUpdated
   // IPC for it to end this wait.
   void Wait() {
     if (expectations_satisfied_)
       return;
 
     run_loop_.reset(new base::RunLoop());
     run_loop_->Run();
     run_loop_.reset(nullptr);
 
     EXPECT_TRUE(expectations_satisfied_);
   }
 
  private:
+  static int GetMatchedBits(
+      const page_load_metrics::PageLoadTiming& timing,
+      const page_load_metrics::PageLoadMetadata& metadata) {
+    int matched_bits = 0;
+    if (timing.document_timing.first_layout)
+      matched_bits |= FIRST_LAYOUT;
+    if (timing.paint_timing.first_paint)
+      matched_bits |= FIRST_PAINT;
+    if (timing.paint_timing.first_contentful_paint)
+      matched_bits |= FIRST_CONTENTFUL_PAINT;
+    if (timing.style_sheet_timing.update_style_duration_before_fcp)
+      matched_bits |= STYLE_UPDATE_BEFORE_FCP;
+    if (metadata.behavior_flags &
+        blink::WebLoadingBehaviorFlag::
+            kWebLoadingBehaviorDocumentWriteBlockReload)
+      matched_bits |= DOCUMENT_WRITE_BLOCK_RELOAD;
+
+    return matched_bits;
+  }
+
   void OnTimingUpdated(
+      bool is_main_frame,
       const page_load_metrics::PageLoadTiming& timing,
       const page_load_metrics::PageLoadMetadata& metadata) override {
-    if (match_document_write_block_reload_ > 0 &&
-        metadata.behavior_flags &
-            blink::WebLoadingBehaviorFlag::
-                kWebLoadingBehaviorDocumentWriteBlockReload) {
-      --match_document_write_block_reload_;
-    }
+    if (expectations_satisfied_)
+      return;
 
-    if (match_document_write_block_reload_ > 0) {
-      return;
-    }
+    int matched_bits = GetMatchedBits(timing, metadata);
+    if (is_main_frame)
+      main_frame_expected_fields_ &= ~matched_bits;

[jkarlin, 2017/05/10 16:55:28]

Maybe add a comment that we're incrementally removing the matched bits.

[Bryan McQuade, 2017/05/10 18:06:15]

i think the refactor i did in the other change makes this cleaerer - i wrapped
the bitset operations in a helper class. take a look at that change and see what
you think. thanks!

+    else
+      child_frame_expected_fields_ &= ~matched_bits;
 
-    if ((!(matching_fields_ & FIRST_PAINT) ||
-         timing.paint_timing.first_paint) &&
-        (!(matching_fields_ & FIRST_CONTENTFUL_PAINT) ||
-         timing.paint_timing.first_contentful_paint) &&
-        (!(matching_fields_ & STYLE_UPDATE_BEFORE_FCP) ||
-         timing.style_sheet_timing.update_style_duration_before_fcp)) {
+    if (main_frame_expected_fields_ == 0 && child_frame_expected_fields_ == 0) {
       expectations_satisfied_ = true;
       if (run_loop_)
         run_loop_->Quit();
     }
   }
 
   std::unique_ptr<base::RunLoop> run_loop_;
-  int matching_fields_ = 0;  // A bitvector composed from ExpectedTimingFields.
+
+  // Bitvectors composed from ExpectedTimingFields.
+  int child_frame_expected_fields_ = 0;
+  int main_frame_expected_fields_ = 0;
+
   bool expectations_satisfied_ = false;

[jkarlin, 2017/05/10 16:55:28]

expectations_satisfied_ can be replaced with main_frame_expected_fields ==
child_frame_expected_fields_ == 0

[Bryan McQuade, 2017/05/10 18:06:15]

done in other change

-  int match_document_write_block_reload_ = 0;
 };
 
+// Due to crbug/705315, paints in child frames are associated with the main
+// frame, unless the child frame is cross-origin and Chrome is running with out
+// of process cross-origin child frames. As a result, some tests wait for
+// different behavior to be observed depending on which mode we are in.
+// TODO(crbug/705315): remove this method once the bug is addressed.
+static bool AreCrossOriginChildFramesOutOfProcess() {
+  return base::CommandLine::ForCurrentProcess()->HasSwitch(
+             switches::kSitePerProcess) ||
+         base::CommandLine::ForCurrentProcess()->HasSwitch(
+             switches::kTopDocumentIsolation);
+}
+
 }  // namespace
 
 class PageLoadMetricsBrowserTest : public InProcessBrowserTest {
  public:
   PageLoadMetricsBrowserTest() {}
   ~PageLoadMetricsBrowserTest() override {}
 
  protected:
   void NavigateToUntrackedUrl() {
     ui_test_utils::NavigateToURL(browser(), GURL(url::kAboutBlankURL));
   }
 
+  // TODO(crbug/705315): remove this method once the bug is addressed.
+  void SetUpOnMainThread() override {
+    InProcessBrowserTest::SetUpOnMainThread();
+    host_resolver()->AddRule("a.com", "127.0.0.1");
+    host_resolver()->AddRule("b.com", "127.0.0.1");
+    host_resolver()->AddRule("c.com", "127.0.0.1");
+    content::SetupCrossSiteRedirector(embedded_test_server());
+  }
+
   bool NoPageLoadMetricsRecorded() {
     // Determine whether any 'public' page load metrics are recorded. We exclude
     // 'internal' metrics as these may be recorded for debugging purposes.
     size_t total_pageload_histograms =
         histogram_tester_.GetTotalCountsForPrefix("PageLoad.").size();
     size_t total_internal_histograms =
         histogram_tester_.GetTotalCountsForPrefix("PageLoad.Internal.").size();
     DCHECK_GE(total_pageload_histograms, total_internal_histograms);
     return total_pageload_histograms - total_internal_histograms == 0;
   }
@@ skipping 24 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest, NoNavigation) {
   ASSERT_TRUE(embedded_test_server()->Start());
   EXPECT_TRUE(NoPageLoadMetricsRecorded());
 }
 
 IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest, NewPage) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
+  std::unique_ptr<PageLoadMetricsWaiter> timing_waiter =
+      CreatePageLoadMetricsWaiter();
+  timing_waiter->AddMainFrameExpectation(PageLoadMetricsWaiter::FIRST_PAINT);
   ui_test_utils::NavigateToURL(browser(),
                                embedded_test_server()->GetURL("/title1.html"));
+  timing_waiter->Wait();
   NavigateToUntrackedUrl();
 
   histogram_tester_.ExpectTotalCount(internal::kHistogramDomContentLoaded, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramLoad, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstLayout, 1);
+  histogram_tester_.ExpectTotalCount(internal::kHistogramFirstPaint, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramParseDuration, 1);
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramParseBlockedOnScriptLoad, 1);
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramParseBlockedOnScriptExecution, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramTotalBytes, 1);
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramPageTimingForegroundDuration, 1);
 
   // Verify that NoPageLoadMetricsRecorded returns false when PageLoad metrics
   // have been recorded.
   EXPECT_FALSE(NoPageLoadMetricsRecorded());
 }
 
+IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest, NoPaintForEmptyDocument) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  std::unique_ptr<PageLoadMetricsWaiter> timing_waiter =
+      CreatePageLoadMetricsWaiter();
+  timing_waiter->AddMainFrameExpectation(PageLoadMetricsWaiter::FIRST_LAYOUT);
+  ui_test_utils::NavigateToURL(browser(),
+                               embedded_test_server()->GetURL("/empty.html"));
+  timing_waiter->Wait();
+
+  histogram_tester_.ExpectTotalCount(internal::kHistogramFirstLayout, 1);
+  histogram_tester_.ExpectTotalCount(internal::kHistogramFirstPaint, 0);
+  histogram_tester_.ExpectTotalCount(internal::kHistogramFirstContentfulPaint,
+                                     0);
+}
+
+IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest,
+                       NoPaintForEmptyDocumentInChildFrame) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  std::unique_ptr<PageLoadMetricsWaiter> timing_waiter =
+      CreatePageLoadMetricsWaiter();
+  timing_waiter->AddMainFrameExpectation(PageLoadMetricsWaiter::FIRST_LAYOUT);
+  timing_waiter->AddSubFrameExpectation(PageLoadMetricsWaiter::FIRST_LAYOUT);
+  // TODO(crbug/705315): remove the a.com domain once the bug is addressed.
+  GURL a_url(embedded_test_server()->GetURL(
+      "a.com", "/page_load_metrics/empty_iframe.html"));
+  ui_test_utils::NavigateToURL(browser(), a_url);
+  timing_waiter->Wait();
+
+  histogram_tester_.ExpectTotalCount(internal::kHistogramFirstLayout, 1);
+  histogram_tester_.ExpectTotalCount(internal::kHistogramFirstPaint, 0);
+  histogram_tester_.ExpectTotalCount(internal::kHistogramFirstContentfulPaint,
+                                     0);
+}
+
+IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest, PaintInChildFrame) {

[jkarlin, 2017/05/10 16:55:28]

I'd like to see a set of tests w/ mocked navigations and timings so we can see
that the page-level paint timing is correct based on which frame paints first. 

I don't see much utility in verifying that the frames got their timing bits.

[Bryan McQuade, 2017/05/10 18:06:15]

i'd like to do this in a unit test too, and we once pitched adding a
MockNavigationHandle to clamy, but guidance was that people often misuse mocked
versions of these classes and don't test the right things. it's been a
longstanding issue that it's very hard for us to mock out navigation_start from
the nav handle. i started down the path of adding a helper class that could be
used to fake timing data out but concluded it was not worthwhile given the
complexity (basically we had to ask the helper what the nav handle's nav start
should be, and then have different impls of the helper in tests vs prod, but it
got really messy).

i think the main thing we benefit from here in the browsertest is verifying
proper end to end routing of timing data between render and browser processes.
that seems important & valuable to me.

+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  std::unique_ptr<PageLoadMetricsWaiter> timing_waiter =
+      CreatePageLoadMetricsWaiter();
+  // TODO(crbug/705315): Once the bug is fixed, remove the else case and make
+  // the if case the default behavior.
+  if (AreCrossOriginChildFramesOutOfProcess()) {
+    timing_waiter->AddSubFrameExpectation(PageLoadMetricsWaiter::FIRST_PAINT);
+    timing_waiter->AddSubFrameExpectation(
+        PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
+  } else {
+    timing_waiter->AddMainFrameExpectation(PageLoadMetricsWaiter::FIRST_PAINT);
+    timing_waiter->AddMainFrameExpectation(
+        PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
+  }
+  // TODO(crbug/705315): remove the a.com domain once the bug is addressed.
+  GURL a_url(embedded_test_server()->GetURL("a.com",
+                                            "/page_load_metrics/iframe.html"));
+  ui_test_utils::NavigateToURL(browser(), a_url);
+  timing_waiter->Wait();
+
+  histogram_tester_.ExpectTotalCount(internal::kHistogramFirstLayout, 1);
+  histogram_tester_.ExpectTotalCount(internal::kHistogramFirstPaint, 1);
+}
+
+IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest, PaintInMultipleChildFrames) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  std::unique_ptr<PageLoadMetricsWaiter> timing_waiter =
+      CreatePageLoadMetricsWaiter();
+  // TODO(crbug/705315): Once the bug is fixed, remove the else case and make
+  // the if case the default behavior.
+  if (AreCrossOriginChildFramesOutOfProcess()) {
+    timing_waiter->AddSubFrameExpectation(PageLoadMetricsWaiter::FIRST_PAINT);
+    timing_waiter->AddSubFrameExpectation(
+        PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
+  } else {
+    timing_waiter->AddMainFrameExpectation(PageLoadMetricsWaiter::FIRST_PAINT);
+    timing_waiter->AddMainFrameExpectation(
+        PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
+  }
+
+  // TODO(crbug/705315): remove the a.com domain once the bug is addressed.
+  GURL a_url(embedded_test_server()->GetURL("a.com",
+                                            "/page_load_metrics/iframes.html"));
+  ui_test_utils::NavigateToURL(browser(), a_url);
+  timing_waiter->Wait();
+
+  histogram_tester_.ExpectTotalCount(internal::kHistogramFirstLayout, 1);
+  histogram_tester_.ExpectTotalCount(internal::kHistogramFirstPaint, 1);
+}
+
+IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest, PaintInMainAndChildFrame) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  std::unique_ptr<PageLoadMetricsWaiter> timing_waiter =
+      CreatePageLoadMetricsWaiter();
+  timing_waiter->AddMainFrameExpectation(PageLoadMetricsWaiter::FIRST_PAINT);
+  timing_waiter->AddMainFrameExpectation(
+      PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
+  // TODO(crbug/705315): Once the bug is fixed, make the if case the default
+  // behavior.
+  if (AreCrossOriginChildFramesOutOfProcess()) {
+    timing_waiter->AddSubFrameExpectation(PageLoadMetricsWaiter::FIRST_PAINT);
+    timing_waiter->AddSubFrameExpectation(
+        PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
+  }
+
+  // TODO(crbug/705315): remove the a.com domain once the bug is addressed.
+  GURL a_url(embedded_test_server()->GetURL(
+      "a.com", "/page_load_metrics/main_frame_with_iframe.html"));
+  ui_test_utils::NavigateToURL(browser(), a_url);
+  timing_waiter->Wait();
+
+  histogram_tester_.ExpectTotalCount(internal::kHistogramFirstLayout, 1);
+  histogram_tester_.ExpectTotalCount(internal::kHistogramFirstPaint, 1);
+}
+
 IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest, SameDocumentNavigation) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   ui_test_utils::NavigateToURL(browser(),
                                embedded_test_server()->GetURL("/title1.html"));
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL("/title1.html#hash"));
   NavigateToUntrackedUrl();
 
   histogram_tester_.ExpectTotalCount(internal::kHistogramDomContentLoaded, 1);
@@ skipping 88 matching lines @@
 
   NavigateToUntrackedUrl();
   EXPECT_TRUE(NoPageLoadMetricsRecorded());
 }
 
 IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest, PreloadDocumentWrite) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   std::unique_ptr<PageLoadMetricsWaiter> fcp_waiter =
       CreatePageLoadMetricsWaiter();
-  fcp_waiter->AddExpectation(PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
+  fcp_waiter->AddMainFrameExpectation(
+      PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
 
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(
                      "/page_load_metrics/document_write_external_script.html"));
   fcp_waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramDocWriteParseStartToFirstContentfulPaint, 1);
 }
 
 IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest, NoPreloadDocumentWrite) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(
                      "/page_load_metrics/document_write_no_script.html"));
   NavigateToUntrackedUrl();
 
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramDocWriteParseStartToFirstContentfulPaint, 0);
 }
 
 IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest, NoDocumentWrite) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   std::unique_ptr<PageLoadMetricsWaiter> fcp_waiter =
       CreatePageLoadMetricsWaiter();
-  fcp_waiter->AddExpectation(PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
+  fcp_waiter->AddMainFrameExpectation(
+      PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
 
   ui_test_utils::NavigateToURL(browser(),
                                embedded_test_server()->GetURL("/title1.html"));
   fcp_waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramDocWriteParseStartToFirstContentfulPaint, 0);
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramDocWriteBlockParseStartToFirstContentfulPaint, 0);
   histogram_tester_.ExpectTotalCount(internal::kHistogramDocWriteBlockCount, 0);
 }
 
 IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest, DocumentWriteBlock) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   std::unique_ptr<PageLoadMetricsWaiter> fcp_waiter =
       CreatePageLoadMetricsWaiter();
-  fcp_waiter->AddExpectation(PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
+  fcp_waiter->AddMainFrameExpectation(
+      PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
 
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(
                      "/page_load_metrics/document_write_script_block.html"));
   fcp_waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramDocWriteBlockParseStartToFirstContentfulPaint, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramDocWriteBlockCount, 1);
 }
 
 IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest, DocumentWriteReload) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   std::unique_ptr<PageLoadMetricsWaiter> fcp_waiter =
       CreatePageLoadMetricsWaiter();
-  fcp_waiter->AddExpectation(PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
-  std::unique_ptr<PageLoadMetricsWaiter> reload_waiter =
-      CreatePageLoadMetricsWaiter();
-  reload_waiter->ExpectDocumentWriteBlockReload(2);
-
+  fcp_waiter->AddMainFrameExpectation(
+      PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(
                      "/page_load_metrics/document_write_script_block.html"));
+  fcp_waiter->Wait();
+
+  histogram_tester_.ExpectTotalCount(
+      internal::kHistogramDocWriteBlockParseStartToFirstContentfulPaint, 1);
+  histogram_tester_.ExpectTotalCount(internal::kHistogramDocWriteBlockCount, 1);
 
   // Reload should not log the histogram as the script is not blocked.
+  std::unique_ptr<PageLoadMetricsWaiter> reload_waiter =
+      CreatePageLoadMetricsWaiter();
+  reload_waiter->AddMainFrameExpectation(
+      PageLoadMetricsWaiter::DOCUMENT_WRITE_BLOCK_RELOAD);
+  reload_waiter->AddMainFrameExpectation(
+      PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(
                      "/page_load_metrics/document_write_script_block.html"));
+  reload_waiter->Wait();
 
+  reload_waiter = CreatePageLoadMetricsWaiter();
+  reload_waiter->AddMainFrameExpectation(
+      PageLoadMetricsWaiter::DOCUMENT_WRITE_BLOCK_RELOAD);
+  reload_waiter->AddMainFrameExpectation(
+      PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(
                      "/page_load_metrics/document_write_script_block.html"));
-
-  histogram_tester_.ExpectTotalCount(
-      internal::kHistogramDocWriteBlockParseStartToFirstContentfulPaint, 1);
-
-  fcp_waiter->Wait();
   reload_waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramDocWriteBlockParseStartToFirstContentfulPaint, 1);
 
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramDocWriteBlockReloadCount, 2);
   histogram_tester_.ExpectTotalCount(internal::kHistogramDocWriteBlockCount, 1);
 }
 
@@ skipping 40 matching lines @@
 #if defined(OS_LINUX) && !defined(NDEBUG)
 #define MAYBE_BadXhtml DISABLED_BadXhtml
 #else
 #define MAYBE_BadXhtml BadXhtml
 #endif
 IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest, MAYBE_BadXhtml) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   std::unique_ptr<PageLoadMetricsWaiter> timing_waiter =
       CreatePageLoadMetricsWaiter();
-  timing_waiter->AddExpectation(PageLoadMetricsWaiter::FIRST_PAINT);
+  timing_waiter->AddMainFrameExpectation(PageLoadMetricsWaiter::FIRST_PAINT);
 
   // When an XHTML page contains invalid XML, it causes a paint of the error
   // message without a layout. Page load metrics currently treats this as an
   // error. Eventually, we'll fix this by special casing the handling of
   // documents with non-well-formed XML on the blink side. See crbug.com/627607
   // for more.
   ui_test_utils::NavigateToURL(
       browser(),
       embedded_test_server()->GetURL("/page_load_metrics/badxml.xhtml"));
 
@@ skipping 179 matching lines @@
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramParseStartToFirstMeaningfulPaint, 1);
 }
 
 IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest,
                        FirstMeaningfulPaintNotRecorded) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   std::unique_ptr<PageLoadMetricsWaiter> fcp_waiter =
       CreatePageLoadMetricsWaiter();
-  fcp_waiter->AddExpectation(PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
+  fcp_waiter->AddMainFrameExpectation(
+      PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
 
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(
                      "/page_load_metrics/page_with_active_connections.html"));
   fcp_waiter->Wait();
 
   // Navigate away before a FMP is reported.
   NavigateToUntrackedUrl();
 
   histogram_tester_.ExpectUniqueSample(
       internal::kHistogramFirstMeaningfulPaintStatus,
       internal::FIRST_MEANINGFUL_PAINT_DID_NOT_REACH_NETWORK_STABLE, 1);
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramFirstMeaningfulPaint, 0);
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramParseStartToFirstMeaningfulPaint, 0);
 }
 
 IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest,
                        NoStatePrefetchObserverCacheable) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   std::unique_ptr<PageLoadMetricsWaiter> fcp_waiter =
       CreatePageLoadMetricsWaiter();
-  fcp_waiter->AddExpectation(PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
+  fcp_waiter->AddMainFrameExpectation(
+      PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
 
   ui_test_utils::NavigateToURL(browser(),
                                embedded_test_server()->GetURL("/title1.html"));
 
   fcp_waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(
       "Prerender.none_PrefetchTTFCP.Reference.NoStore.Visible", 0);
   histogram_tester_.ExpectTotalCount(
       "Prerender.none_PrefetchTTFCP.Reference.Cacheable.Visible", 1);
 }
 
 IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest,
                        NoStatePrefetchObserverNoStore) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   std::unique_ptr<PageLoadMetricsWaiter> fcp_waiter =
       CreatePageLoadMetricsWaiter();
-  fcp_waiter->AddExpectation(PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
+  fcp_waiter->AddMainFrameExpectation(
+      PageLoadMetricsWaiter::FIRST_CONTENTFUL_PAINT);
 
   ui_test_utils::NavigateToURL(browser(),
                                embedded_test_server()->GetURL("/nostore.html"));
 
   fcp_waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(
       "Prerender.none_PrefetchTTFCP.Reference.NoStore.Visible", 1);
   histogram_tester_.ExpectTotalCount(
       "Prerender.none_PrefetchTTFCP.Reference.Cacheable.Visible", 0);
 }
 
 IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest, CSSTiming) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   std::unique_ptr<PageLoadMetricsWaiter> fcp_waiter =
       CreatePageLoadMetricsWaiter();
-  fcp_waiter->AddExpectation(PageLoadMetricsWaiter::STYLE_UPDATE_BEFORE_FCP);
+  fcp_waiter->AddMainFrameExpectation(
+      PageLoadMetricsWaiter::STYLE_UPDATE_BEFORE_FCP);
 
   // Careful: Blink code clamps timestamps to 5us, so any CSS parsing we do here
   // must take >> 5us, otherwise we'll log 0 for the value and it will remain
   // unset here.
   ui_test_utils::NavigateToURL(
       browser(),
       embedded_test_server()->GetURL("/page_load_metrics/page_with_css.html"));
   NavigateToUntrackedUrl();
   fcp_waiter->Wait();
 
@@ skipping 13 matching lines @@
   ui_test_utils::NavigateToURL(browser(), embedded_test_server()->GetURL(
                                               "/page_load_metrics/large.html"));
   NavigateToUntrackedUrl();
 
   histogram_tester_.ExpectTotalCount(internal::kHistogramTotalBytes, 1);
 
   // Verify that there is a single sample recorded in the 10kB bucket (the size
   // of the main HTML response).
   histogram_tester_.ExpectBucketCount(internal::kHistogramTotalBytes, 10, 1);
 }