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 {
-    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;
+    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;
-  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);
+}
+
+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);
+}
+
+IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest, PaintInChildFrame) {
+  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);
+  } else {
+    timing_waiter->AddMainFrameExpectation(PageLoadMetricsWaiter::FIRST_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);
+  } else {
+    timing_waiter->AddMainFrameExpectation(PageLoadMetricsWaiter::FIRST_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);
+  // TODO(crbug/705315): Once the bug is fixed, make the if case the default
+  // behavior.
+  if (AreCrossOriginChildFramesOutOfProcess()) {
+    timing_waiter->AddSubFrameExpectation(PageLoadMetricsWaiter::FIRST_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);
 }