Make PageLoadMetricsWaiter more resilient

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/memory/weak_ptr.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/scoped_feature_list.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"
@@ skipping 51 matching lines @@
     FIRST_LAYOUT = 1 << 0,
     FIRST_PAINT = 1 << 1,
     FIRST_CONTENTFUL_PAINT = 1 << 2,
     FIRST_MEANINGFUL_PAINT = 1 << 3,
     STYLE_UPDATE_BEFORE_FCP = 1 << 4,
     DOCUMENT_WRITE_BLOCK_RELOAD = 1 << 5,
     LOAD_EVENT = 1 << 6
   };
 
   explicit PageLoadMetricsWaiter(content::WebContents* web_contents)
-      : TestingObserver(web_contents) {}
+      : TestingObserver(web_contents), weak_factory_(this) {}
 
-  ~PageLoadMetricsWaiter() override { DCHECK_EQ(nullptr, run_loop_.get()); }
-
-  // Add the given expectation to match on.
-  void AddMainFrameExpectation(TimingField field) {
-    main_frame_expected_fields_.Set(field);
-  }
-  void AddSubFrameExpectation(TimingField field) {
-    child_frame_expected_fields_.Set(field);
+  ~PageLoadMetricsWaiter() override {
+    CHECK(did_add_observer_);

[Charlie Harrison, 2017/05/25 19:35:33]

#include "base/logging"

[Charlie Harrison, 2017/05/25 19:35:34]

Should we ASSERT instead of CHECK here?

[Bryan McQuade, 2017/05/25 19:54:05]

added include

ASSERT macros fail to compile in destructors, so I used CHECKs here.

[Charlie Harrison, 2017/05/25 19:59:44]

Weird... fine by me

+    CHECK_EQ(nullptr, run_loop_.get());
   }
 
-  // Whether the given TimingField was observed in the main frame.
-  bool DidObserveInMainFrame(TimingField field) {
-    return observed_main_frame_fields_.IsSet(field);
+  // Add a page-level expectation.
+  void AddPageExpectation(TimingField field) {
+    page_expected_fields_.Set(field);
+  }
+
+  // Add a subframe-level expectation.
+  void AddSubFrameExpectation(TimingField field) {
+    subframe_expected_fields_.Set(field);
+    // If the given field is also a page-level field, then add a page-level
+    // expectation as well
+    if (IsPageLevelField(field))
+      page_expected_fields_.Set(field);
+  }
+
+  // Whether the given TimingField was observed in the page.
+  bool DidObserveInPage(TimingField field) {
+    return observed_page_fields_.IsSet(field);
   }
 
   // Waits for a TimingUpdated IPC that matches the fields set by
-  // |AddMainFrameExpectation| and |AddSubFrameExpectation|. All matching fields
+  // |AddPageExpectation| and |AddSubFrameExpectation|. 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());

[Charlie Harrison, 2017/05/25 19:35:34]

nit: #include "base/run_loop" and use base::MakeUnique

     run_loop_->Run();
     run_loop_.reset(nullptr);
 
     EXPECT_TRUE(expectations_satisfied());

[Bryan McQuade, 2017/05/25 19:54:06]

the codereview site is refusing to show me your comment a few lines earlier, but
I've updated run_loop_ to use MakeUnique and added the include.

   }
 
+  void OnTimingUpdate(bool is_subframe,
+                      const page_load_metrics::mojom::PageLoadTiming& timing,
+                      const page_load_metrics::PageLoadExtraInfo& extra_info) {
+    if (expectations_satisfied())
+      return;
+
+    const page_load_metrics::mojom::PageLoadMetadata& metadata =
+        is_subframe ? extra_info.subframe_metadata
+                    : extra_info.main_frame_metadata;
+    TimingFieldBitSet matched_bits = GetMatchedBits(timing, metadata);
+    if (is_subframe) {
+      subframe_expected_fields_.ClearMatching(matched_bits);
+    } else {
+      page_expected_fields_.ClearMatching(matched_bits);
+      observed_page_fields_.Merge(matched_bits);
+    }
+
+    if (expectations_satisfied() && run_loop_)
+      run_loop_->Quit();
+  }
+
  private:
+  // PageLoadMetricsObserver used by the PageLoadMetricsWaiter to observe
+  // metrics updates.

[Charlie Harrison, 2017/05/25 19:35:34]

Can you explain why you need weak ptrs?

[Bryan McQuade, 2017/05/25 19:54:06]

Done - added comment to constructor.

+  class WaiterMetricsObserver
+      : public page_load_metrics::PageLoadMetricsObserver {
+   public:
+    explicit WaiterMetricsObserver(base::WeakPtr<PageLoadMetricsWaiter> waiter)
+        : waiter_(waiter) {}
+
+    void OnTimingUpdate(
+        bool is_subframe,
+        const page_load_metrics::mojom::PageLoadTiming& timing,
+        const page_load_metrics::PageLoadExtraInfo& extra_info) override {
+      if (waiter_)
+        waiter_->OnTimingUpdate(is_subframe, timing, extra_info);
+    }
+
+   private:
+    const base::WeakPtr<PageLoadMetricsWaiter> waiter_;
+  };
+
   // Manages a bitset of TimingFields.
   class TimingFieldBitSet {
    public:
     TimingFieldBitSet() {}
 
     // Returns whether this bitset has all bits unset.
     bool Empty() const { return bitmask_ == 0; }
 
     // Returns whether this bitset has the given bit set.
     bool IsSet(TimingField field) const {
       return (bitmask_ & static_cast<int>(field)) != 0;
     }
 
     // Sets the bit for the given |field|.
     void Set(TimingField field) { bitmask_ |= static_cast<int>(field); }
 
     // Merges bits set in |other| into this bitset.
     void Merge(const TimingFieldBitSet& other) { bitmask_ |= other.bitmask_; }
 
     // Clears all bits set in the |other| bitset.
     void ClearMatching(const TimingFieldBitSet& other) {
       bitmask_ &= ~other.bitmask_;
     }
 
    private:
     int bitmask_ = 0;
   };
 
+  static bool IsPageLevelField(TimingField field) {
+    switch (field) {
+      case TimingField::FIRST_PAINT:
+      case TimingField::FIRST_CONTENTFUL_PAINT:
+      case TimingField::FIRST_MEANINGFUL_PAINT:
+        return true;
+      default:
+        return false;
+    }
+  }
+
   static TimingFieldBitSet GetMatchedBits(
       const page_load_metrics::mojom::PageLoadTiming& timing,
       const page_load_metrics::mojom::PageLoadMetadata& metadata) {
     TimingFieldBitSet matched_bits;
     if (timing.document_timing->first_layout)
       matched_bits.Set(TimingField::FIRST_LAYOUT);
     if (timing.document_timing->load_event_start)
       matched_bits.Set(TimingField::LOAD_EVENT);
     if (timing.paint_timing->first_paint)
       matched_bits.Set(TimingField::FIRST_PAINT);
     if (timing.paint_timing->first_contentful_paint)
       matched_bits.Set(TimingField::FIRST_CONTENTFUL_PAINT);
     if (timing.paint_timing->first_meaningful_paint)
       matched_bits.Set(TimingField::FIRST_MEANINGFUL_PAINT);
     if (timing.style_sheet_timing->update_style_duration_before_fcp)
       matched_bits.Set(TimingField::STYLE_UPDATE_BEFORE_FCP);
     if (metadata.behavior_flags &
         blink::WebLoadingBehaviorFlag::
             kWebLoadingBehaviorDocumentWriteBlockReload)
       matched_bits.Set(TimingField::DOCUMENT_WRITE_BLOCK_RELOAD);
 
     return matched_bits;
   }
 
-  void OnTimingUpdated(
-      bool is_main_frame,
-      const page_load_metrics::mojom::PageLoadTiming& timing,
-      const page_load_metrics::mojom::PageLoadMetadata& metadata) override {
-    if (expectations_satisfied())
-      return;
-
-    TimingFieldBitSet matched_bits = GetMatchedBits(timing, metadata);
-    if (is_main_frame) {
-      main_frame_expected_fields_.ClearMatching(matched_bits);
-      observed_main_frame_fields_.Merge(matched_bits);
-    } else {
-      child_frame_expected_fields_.ClearMatching(matched_bits);
-    }
-
-    if (expectations_satisfied() && run_loop_)
-      run_loop_->Quit();
+  void OnCommit(page_load_metrics::PageLoadTracker* tracker) override {
+    // A PageLoadMetricsWaiter should only wait for events from a single page
+    // load.
+    ASSERT_FALSE(did_add_observer_);
+    tracker->AddObserver(
+        base::MakeUnique<WaiterMetricsObserver>(weak_factory_.GetWeakPtr()));
+    did_add_observer_ = true;
   }
 
   bool expectations_satisfied() const {
-    return child_frame_expected_fields_.Empty() &&
-           main_frame_expected_fields_.Empty();
+    return subframe_expected_fields_.Empty() && page_expected_fields_.Empty();
   }
 
   std::unique_ptr<base::RunLoop> run_loop_;
 
-  TimingFieldBitSet child_frame_expected_fields_;
-  TimingFieldBitSet main_frame_expected_fields_;
+  TimingFieldBitSet page_expected_fields_;
+  TimingFieldBitSet subframe_expected_fields_;
 
-  TimingFieldBitSet observed_main_frame_fields_;
+  TimingFieldBitSet observed_page_fields_;
+
+  bool did_add_observer_ = false;
+
+  base::WeakPtrFactory<PageLoadMetricsWaiter> weak_factory_;
 };
 
 using TimingField = PageLoadMetricsWaiter::TimingField;
 
 class IPCTypeVerifier
     : public page_load_metrics::MetricsWebContentsObserver::TestingObserver {
  public:
   explicit IPCTypeVerifier(content::WebContents* web_contents)
       : TestingObserver(web_contents) {}
 
@@ skipping 104 matching lines @@
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest, NoNavigation) {
   ExpectNoTimingUpdates();
   ASSERT_TRUE(embedded_test_server()->Start());
   EXPECT_TRUE(NoPageLoadMetricsRecorded());
 }
 
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest, NewPage) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::FIRST_PAINT);
+  waiter->AddPageExpectation(TimingField::FIRST_PAINT);
   ui_test_utils::NavigateToURL(browser(),
                                embedded_test_server()->GetURL("/title1.html"));
   waiter->Wait();
 
   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(
@@ skipping 10 matching lines @@
 
   // Verify that NoPageLoadMetricsRecorded returns false when PageLoad metrics
   // have been recorded.
   EXPECT_FALSE(NoPageLoadMetricsRecorded());
 }
 
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest, NoPaintForEmptyDocument) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::FIRST_LAYOUT);
-  waiter->AddMainFrameExpectation(TimingField::LOAD_EVENT);
+  waiter->AddPageExpectation(TimingField::FIRST_LAYOUT);
+  waiter->AddPageExpectation(TimingField::LOAD_EVENT);
   ui_test_utils::NavigateToURL(browser(),
                                embedded_test_server()->GetURL("/empty.html"));
   waiter->Wait();
-  EXPECT_FALSE(waiter->DidObserveInMainFrame(TimingField::FIRST_PAINT));
+  EXPECT_FALSE(waiter->DidObserveInPage(TimingField::FIRST_PAINT));
 
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstLayout, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramLoad, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstPaint, 0);
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstContentfulPaint,
                                      0);
 }
 
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest,
                        NoPaintForEmptyDocumentInChildFrame) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   GURL a_url(
       embedded_test_server()->GetURL("/page_load_metrics/empty_iframe.html"));
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::FIRST_LAYOUT);
-  waiter->AddMainFrameExpectation(TimingField::LOAD_EVENT);
+  waiter->AddPageExpectation(TimingField::FIRST_LAYOUT);
+  waiter->AddPageExpectation(TimingField::LOAD_EVENT);
   waiter->AddSubFrameExpectation(TimingField::FIRST_LAYOUT);
   waiter->AddSubFrameExpectation(TimingField::LOAD_EVENT);
   ui_test_utils::NavigateToURL(browser(), a_url);
   waiter->Wait();
-  EXPECT_FALSE(waiter->DidObserveInMainFrame(TimingField::FIRST_PAINT));
+  EXPECT_FALSE(waiter->DidObserveInPage(TimingField::FIRST_PAINT));
 
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstLayout, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramLoad, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstPaint, 0);
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstContentfulPaint,
                                      0);
 }
 
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest, PaintInChildFrame) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   GURL a_url(embedded_test_server()->GetURL("/page_load_metrics/iframe.html"));
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::FIRST_LAYOUT);
-  waiter->AddMainFrameExpectation(TimingField::LOAD_EVENT);
+  waiter->AddPageExpectation(TimingField::FIRST_LAYOUT);
+  waiter->AddPageExpectation(TimingField::LOAD_EVENT);
   waiter->AddSubFrameExpectation(TimingField::FIRST_PAINT);
   waiter->AddSubFrameExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
   ui_test_utils::NavigateToURL(browser(), a_url);
   waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstLayout, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramLoad, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstPaint, 1);
 }
 
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest, PaintInMultipleChildFrames) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   GURL a_url(embedded_test_server()->GetURL("/page_load_metrics/iframes.html"));
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::FIRST_LAYOUT);
-  waiter->AddMainFrameExpectation(TimingField::LOAD_EVENT);
+  waiter->AddPageExpectation(TimingField::FIRST_LAYOUT);
+  waiter->AddPageExpectation(TimingField::LOAD_EVENT);
   waiter->AddSubFrameExpectation(TimingField::FIRST_PAINT);
   waiter->AddSubFrameExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
   ui_test_utils::NavigateToURL(browser(), a_url);
   waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstLayout, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramLoad, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstPaint, 1);
 }
 
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest, PaintInMainAndChildFrame) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   GURL a_url(embedded_test_server()->GetURL(
       "/page_load_metrics/main_frame_with_iframe.html"));
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::FIRST_LAYOUT);
-  waiter->AddMainFrameExpectation(TimingField::LOAD_EVENT);
-  waiter->AddMainFrameExpectation(TimingField::FIRST_PAINT);
-  waiter->AddMainFrameExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
+  waiter->AddPageExpectation(TimingField::FIRST_LAYOUT);
+  waiter->AddPageExpectation(TimingField::LOAD_EVENT);
+  waiter->AddPageExpectation(TimingField::FIRST_PAINT);
+  waiter->AddPageExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
   waiter->AddSubFrameExpectation(TimingField::FIRST_PAINT);
   waiter->AddSubFrameExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
   ui_test_utils::NavigateToURL(browser(), a_url);
   waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstLayout, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramLoad, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstPaint, 1);
 }
 
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest, SameDocumentNavigation) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::FIRST_LAYOUT);
-  waiter->AddMainFrameExpectation(TimingField::LOAD_EVENT);
+  waiter->AddPageExpectation(TimingField::FIRST_LAYOUT);
+  waiter->AddPageExpectation(TimingField::LOAD_EVENT);
   ui_test_utils::NavigateToURL(browser(),
                                embedded_test_server()->GetURL("/title1.html"));
   waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(internal::kHistogramDomContentLoaded, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramLoad, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstLayout, 1);
 
   // Perform a same-document navigation. No additional metrics should be logged.
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL("/title1.html#hash"));
   NavigateToUntrackedUrl();
 
   histogram_tester_.ExpectTotalCount(internal::kHistogramDomContentLoaded, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramLoad, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstLayout, 1);
 }
 
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest, SameUrlNavigation) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::FIRST_LAYOUT);
-  waiter->AddMainFrameExpectation(TimingField::LOAD_EVENT);
+  waiter->AddPageExpectation(TimingField::FIRST_LAYOUT);
+  waiter->AddPageExpectation(TimingField::LOAD_EVENT);
   ui_test_utils::NavigateToURL(browser(),
                                embedded_test_server()->GetURL("/title1.html"));
   waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(internal::kHistogramDomContentLoaded, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramLoad, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstLayout, 1);
 
   waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::FIRST_LAYOUT);
-  waiter->AddMainFrameExpectation(TimingField::LOAD_EVENT);
+  waiter->AddPageExpectation(TimingField::FIRST_LAYOUT);
+  waiter->AddPageExpectation(TimingField::LOAD_EVENT);
   ui_test_utils::NavigateToURL(browser(),
                                embedded_test_server()->GetURL("/title1.html"));
   waiter->Wait();
 
   // We expect one histogram sample for each navigation to title1.html.
   histogram_tester_.ExpectTotalCount(internal::kHistogramDomContentLoaded, 2);
   histogram_tester_.ExpectTotalCount(internal::kHistogramLoad, 2);
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstLayout, 2);
 }
 
@@ skipping 74 matching lines @@
 
   NavigateToUntrackedUrl();
   ExpectNoTimingUpdates();
   EXPECT_TRUE(NoPageLoadMetricsRecorded());
 }
 
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest, PreloadDocumentWrite) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
+  waiter->AddPageExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
 
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(
                      "/page_load_metrics/document_write_external_script.html"));
   waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramDocWriteParseStartToFirstContentfulPaint, 1);
 }
 
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest, NoPreloadDocumentWrite) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
+  waiter->AddPageExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(
                      "/page_load_metrics/document_write_no_script.html"));
   waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstContentfulPaint,
                                      1);
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramDocWriteParseStartToFirstContentfulPaint, 0);
 }
 
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest, NoDocumentWrite) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
+  waiter->AddPageExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
 
   ui_test_utils::NavigateToURL(browser(),
                                embedded_test_server()->GetURL("/title1.html"));
   waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstContentfulPaint,
                                      1);
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramDocWriteParseStartToFirstContentfulPaint, 0);
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramDocWriteBlockParseStartToFirstContentfulPaint, 0);
   histogram_tester_.ExpectTotalCount(internal::kHistogramDocWriteBlockCount, 0);
 }
 
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest, DocumentWriteBlock) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
+  waiter->AddPageExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
 
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(
                      "/page_load_metrics/document_write_script_block.html"));
   waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramDocWriteBlockParseStartToFirstContentfulPaint, 1);
   histogram_tester_.ExpectTotalCount(internal::kHistogramDocWriteBlockCount, 1);
 }
 
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest, DocumentWriteReload) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
+  waiter->AddPageExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(
                      "/page_load_metrics/document_write_script_block.html"));
   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.
-  auto reload_waiter = CreatePageLoadMetricsWaiter();
-  reload_waiter->AddMainFrameExpectation(
-      TimingField::DOCUMENT_WRITE_BLOCK_RELOAD);
-  reload_waiter->AddMainFrameExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
+  waiter = CreatePageLoadMetricsWaiter();
+  waiter->AddPageExpectation(TimingField::DOCUMENT_WRITE_BLOCK_RELOAD);
+  waiter->AddPageExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(
                      "/page_load_metrics/document_write_script_block.html"));
-  reload_waiter->Wait();
+  waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramDocWriteBlockReloadCount, 1);
 
-  reload_waiter = CreatePageLoadMetricsWaiter();
-  reload_waiter->AddMainFrameExpectation(
-      TimingField::DOCUMENT_WRITE_BLOCK_RELOAD);
-  reload_waiter->AddMainFrameExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
+  waiter = CreatePageLoadMetricsWaiter();
+  waiter->AddPageExpectation(TimingField::DOCUMENT_WRITE_BLOCK_RELOAD);
+  waiter->AddPageExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(
                      "/page_load_metrics/document_write_script_block.html"));
-  reload_waiter->Wait();
+  waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramDocWriteBlockParseStartToFirstContentfulPaint, 1);
 
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramDocWriteBlockReloadCount, 2);
   histogram_tester_.ExpectTotalCount(internal::kHistogramDocWriteBlockCount, 1);
 }
 
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest, DocumentWriteAsync) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
+  waiter->AddPageExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(
                      "/page_load_metrics/document_write_async_script.html"));
   waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstContentfulPaint,
                                      1);
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramDocWriteBlockParseStartToFirstContentfulPaint, 0);
   histogram_tester_.ExpectTotalCount(internal::kHistogramDocWriteBlockCount, 0);
 }
 
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest, DocumentWriteSameDomain) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
+  waiter->AddPageExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(
                      "/page_load_metrics/document_write_external_script.html"));
   waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstContentfulPaint,
                                      1);
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramDocWriteBlockParseStartToFirstContentfulPaint, 0);
   histogram_tester_.ExpectTotalCount(internal::kHistogramDocWriteBlockCount, 0);
 }
 
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest, NoDocumentWriteScript) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
+  waiter->AddPageExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(
                      "/page_load_metrics/document_write_no_script.html"));
   waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstContentfulPaint,
                                      1);
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramDocWriteBlockParseStartToFirstContentfulPaint, 0);
   histogram_tester_.ExpectTotalCount(internal::kHistogramDocWriteBlockCount, 0);
 }
 
 // TODO(crbug.com/712935): Flaky on Linux dbg.
 #if defined(OS_LINUX) && !defined(NDEBUG)
 #define MAYBE_BadXhtml DISABLED_BadXhtml
 #else
 #define MAYBE_BadXhtml BadXhtml
 #endif
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest, MAYBE_BadXhtml) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
-  auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::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"));
-
-  waiter->Wait();
+  NavigateToUntrackedUrl();
 
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstLayout, 0);
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstPaint, 0);
-  histogram_tester_.ExpectTotalCount(page_load_metrics::internal::kErrorEvents,
-                                     1);
+
   histogram_tester_.ExpectBucketCount(
       page_load_metrics::internal::kErrorEvents,
       page_load_metrics::ERR_BAD_TIMING_IPC_INVALID_TIMING, 1);
 
   histogram_tester_.ExpectTotalCount(
       page_load_metrics::internal::kPageLoadTimingStatus, 1);
   histogram_tester_.ExpectBucketCount(
       page_load_metrics::internal::kPageLoadTimingStatus,
       page_load_metrics::internal::INVALID_ORDER_FIRST_LAYOUT_FIRST_PAINT, 1);
 }
@@ skipping 10 matching lines @@
       browser()->tab_strip_model()->GetActiveWebContents(), url);
 
   chrome::Navigate(&params);
   EXPECT_TRUE(manager.WaitForRequestStart());
 
   GURL url2(embedded_test_server()->GetURL("/title2.html"));
   chrome::NavigateParams params2(browser(), url2,
                                  ui::PAGE_TRANSITION_FROM_ADDRESS_BAR);
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::LOAD_EVENT);
+  waiter->AddPageExpectation(TimingField::LOAD_EVENT);
   chrome::Navigate(&params2);
   waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramAbortNewNavigationBeforeCommit, 1);
 }
 
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest, AbortReload) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   GURL url(embedded_test_server()->GetURL("/title1.html"));
   chrome::NavigateParams params(browser(), url, ui::PAGE_TRANSITION_LINK);
   content::TestNavigationManager manager(
       browser()->tab_strip_model()->GetActiveWebContents(), url);
 
   chrome::Navigate(&params);
   EXPECT_TRUE(manager.WaitForRequestStart());
 
   chrome::NavigateParams params2(browser(), url, ui::PAGE_TRANSITION_RELOAD);
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::LOAD_EVENT);
+  waiter->AddPageExpectation(TimingField::LOAD_EVENT);
   chrome::Navigate(&params2);
   waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramAbortReloadBeforeCommit, 1);
 }
 
 // TODO(crbug.com/675061): Flaky on Win7 dbg.
 #if defined(OS_WIN)
 #define MAYBE_AbortClose DISABLED_AbortClose
@@ skipping 37 matching lines @@
       browser()->tab_strip_model()->GetActiveWebContents(), url2);
   chrome::Navigate(&params2);
 
   EXPECT_TRUE(manager2.WaitForRequestStart());
   manager.WaitForNavigationFinished();
 
   GURL url3(embedded_test_server()->GetURL("/title3.html"));
   chrome::NavigateParams params3(browser(), url3, ui::PAGE_TRANSITION_TYPED);
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::LOAD_EVENT);
+  waiter->AddPageExpectation(TimingField::LOAD_EVENT);
   chrome::Navigate(&params3);
   waiter->Wait();
 
   manager2.WaitForNavigationFinished();
 
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramAbortNewNavigationBeforeCommit, 2);
 }
 
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest,
                        NoAbortMetricsOnClientRedirect) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   GURL first_url(embedded_test_server()->GetURL("/title1.html"));
   ui_test_utils::NavigateToURL(browser(), first_url);
 
   GURL second_url(embedded_test_server()->GetURL("/title2.html"));
   chrome::NavigateParams params(browser(), second_url,
                                 ui::PAGE_TRANSITION_LINK);
   content::TestNavigationManager manager(
       browser()->tab_strip_model()->GetActiveWebContents(), second_url);
   chrome::Navigate(&params);
   EXPECT_TRUE(manager.WaitForRequestStart());
 
   {
     auto waiter = CreatePageLoadMetricsWaiter();
-    waiter->AddMainFrameExpectation(TimingField::LOAD_EVENT);
-    content::TestNavigationManager reload_manager(
-        browser()->tab_strip_model()->GetActiveWebContents(), first_url);
+    waiter->AddPageExpectation(TimingField::LOAD_EVENT);
     EXPECT_TRUE(content::ExecuteScript(
         browser()->tab_strip_model()->GetActiveWebContents(),
         "window.location.reload();"));
     waiter->Wait();
   }
 
   manager.WaitForNavigationFinished();
 
   EXPECT_TRUE(histogram_tester_
                   .GetTotalCountsForPrefix("PageLoad.Experimental.AbortTiming.")
                   .empty());
 }
 
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest,
                        FirstMeaningfulPaintRecorded) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::FIRST_MEANINGFUL_PAINT);
+  waiter->AddPageExpectation(TimingField::FIRST_MEANINGFUL_PAINT);
   ui_test_utils::NavigateToURL(browser(),
                                embedded_test_server()->GetURL("/title1.html"));
   waiter->Wait();
 
   histogram_tester_.ExpectUniqueSample(
       internal::kHistogramFirstMeaningfulPaintStatus,
       internal::FIRST_MEANINGFUL_PAINT_RECORDED, 1);
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramFirstMeaningfulPaint, 1);
   histogram_tester_.ExpectTotalCount(
       internal::kHistogramParseStartToFirstMeaningfulPaint, 1);
 }
 
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest,
                        FirstMeaningfulPaintNotRecorded) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
+  waiter->AddPageExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
 
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(
                      "/page_load_metrics/page_with_active_connections.html"));
   waiter->Wait();
 
   // Navigate away before a FMP is reported.
   NavigateToUntrackedUrl();
 
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstContentfulPaint,
                                      1);
   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_P(PageLoadMetricsBrowserTest,
                        NoStatePrefetchObserverCacheable) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
+  waiter->AddPageExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
 
   ui_test_utils::NavigateToURL(browser(),
                                embedded_test_server()->GetURL("/title1.html"));
 
   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_P(PageLoadMetricsBrowserTest,
                        NoStatePrefetchObserverNoStore) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
+  waiter->AddPageExpectation(TimingField::FIRST_CONTENTFUL_PAINT);
 
   ui_test_utils::NavigateToURL(browser(),
                                embedded_test_server()->GetURL("/nostore.html"));
 
   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_P(PageLoadMetricsBrowserTest, CSSTiming) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::STYLE_UPDATE_BEFORE_FCP);
+  waiter->AddPageExpectation(TimingField::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"));
   waiter->Wait();
 
   histogram_tester_.ExpectTotalCount(internal::kHistogramFirstContentfulPaint,
                                      1);
   histogram_tester_.ExpectTotalCount(
       "PageLoad.CSSTiming.Parse.BeforeFirstContentfulPaint", 1);
   histogram_tester_.ExpectTotalCount(
       "PageLoad.CSSTiming.Update.BeforeFirstContentfulPaint", 1);
   histogram_tester_.ExpectTotalCount(
       "PageLoad.CSSTiming.ParseAndUpdate.BeforeFirstContentfulPaint", 1);
 }
 
 IN_PROC_BROWSER_TEST_P(PageLoadMetricsBrowserTest, PayloadSize) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   auto waiter = CreatePageLoadMetricsWaiter();
-  waiter->AddMainFrameExpectation(TimingField::LOAD_EVENT);
+  waiter->AddPageExpectation(TimingField::LOAD_EVENT);
   ui_test_utils::NavigateToURL(browser(), embedded_test_server()->GetURL(
                                               "/page_load_metrics/large.html"));
   waiter->Wait();
 
   // Payload histograms are only logged when a page load terminates, so force
   // navigation to another page.
   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);
 }
 
 INSTANTIATE_TEST_CASE_P(
     /* no prefix */,
     PageLoadMetricsBrowserTest,
     testing::Values(IPCType::LEGACY, IPCType::MOJO));