[Page Load Metrics] Add mojom file to page load metrics.

chrome/browser/page_load_metrics/metrics_web_contents_observer_unittest.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 "chrome/browser/page_load_metrics/metrics_web_contents_observer.h"
 
 #include <memory>
 #include <vector>
 
 #include "base/macros.h"
@@ skipping 26 matching lines @@
 const char kFilteredCommitUrl[] = "https://whatever.com/ignore-on-commit";
 
 // Simple PageLoadMetricsObserver that copies observed PageLoadTimings into the
 // provided std::vector, so they can be analyzed by unit tests.
 class TestPageLoadMetricsObserver
     : public PageLoadMetricsObserver,
       public MetricsWebContentsObserver::TestingObserver {
  public:
   TestPageLoadMetricsObserver(
       content::WebContents* web_contents,
-      std::vector<PageLoadTiming>* updated_timings,
-      std::vector<PageLoadTiming>* updated_subframe_timings,
-      std::vector<PageLoadTiming>* complete_timings,
+      std::vector<mojom::PageLoadTimingPtr>* updated_timings,
+      std::vector<mojom::PageLoadTimingPtr>* updated_subframe_timings,
+      std::vector<mojom::PageLoadTimingPtr>* complete_timings,
       std::vector<GURL>* observed_committed_urls)
       : MetricsWebContentsObserver::TestingObserver(web_contents),
         updated_timings_(updated_timings),
         updated_subframe_timings_(updated_subframe_timings),
         complete_timings_(complete_timings),
         observed_committed_urls_(observed_committed_urls) {}
 
   ObservePolicy OnStart(content::NavigationHandle* navigation_handle,
                const GURL& currently_committed_url,
                bool started_in_foreground) override {
     observed_committed_urls_->push_back(currently_committed_url);
     return CONTINUE_OBSERVING;
   }
 
-  void OnTimingUpdate(const PageLoadTiming& timing,
+  void OnTimingUpdate(const mojom::PageLoadTiming& timing,
                       const PageLoadExtraInfo& extra_info) override {
-    updated_timings_->push_back(timing);
+    updated_timings_->push_back(timing.Clone());
   }
 
   void OnTimingUpdated(bool is_main_frame,
-                       const PageLoadTiming& timing,
-                       const PageLoadMetadata& metadata) override {
+                       const mojom::PageLoadTiming& timing,
+                       const mojom::PageLoadMetadata& metadata) override {
     if (!is_main_frame) {
-      updated_subframe_timings_->push_back(timing);
+      updated_subframe_timings_->push_back(timing.Clone());
     }
   }
 
-  void OnComplete(const PageLoadTiming& timing,
+  void OnComplete(const mojom::PageLoadTiming& timing,
                   const PageLoadExtraInfo& extra_info) override {
-    complete_timings_->push_back(timing);
+    complete_timings_->push_back(timing.Clone());
   }
 
   ObservePolicy FlushMetricsOnAppEnterBackground(
-      const PageLoadTiming& timing,
+      const mojom::PageLoadTiming& timing,
       const PageLoadExtraInfo& extra_info) override {
     return STOP_OBSERVING;
   }
 
  private:
-  std::vector<PageLoadTiming>* const updated_timings_;
-  std::vector<PageLoadTiming>* const updated_subframe_timings_;
-  std::vector<PageLoadTiming>* const complete_timings_;
+  std::vector<mojom::PageLoadTimingPtr>* const updated_timings_;
+  std::vector<mojom::PageLoadTimingPtr>* const updated_subframe_timings_;
+  std::vector<mojom::PageLoadTimingPtr>* const complete_timings_;
   std::vector<GURL>* const observed_committed_urls_;
 };
 
 // Test PageLoadMetricsObserver that stops observing page loads with certain
 // substrings in the URL.
 class FilteringPageLoadMetricsObserver : public PageLoadMetricsObserver {
  public:
   explicit FilteringPageLoadMetricsObserver(
       std::vector<GURL>* completed_filtered_urls)
       : completed_filtered_urls_(completed_filtered_urls) {}
 
   ObservePolicy OnStart(content::NavigationHandle* handle,
                         const GURL& currently_committed_url,
                         bool started_in_foreground) override {
     const bool should_ignore =
         handle->GetURL().spec().find("ignore-on-start") != std::string::npos;
     return should_ignore ? STOP_OBSERVING : CONTINUE_OBSERVING;
   }
 
   ObservePolicy OnCommit(content::NavigationHandle* handle) override {
     const bool should_ignore =
         handle->GetURL().spec().find("ignore-on-commit") != std::string::npos;
     return should_ignore ? STOP_OBSERVING : CONTINUE_OBSERVING;
   }
 
-  void OnComplete(const PageLoadTiming& timing,
+  void OnComplete(const mojom::PageLoadTiming& timing,
                   const PageLoadExtraInfo& extra_info) override {
     completed_filtered_urls_->push_back(extra_info.url);
   }
 
  private:
   std::vector<GURL>* const completed_filtered_urls_;
 };
 
 class TestPageLoadMetricsEmbedderInterface
     : public PageLoadMetricsEmbedderInterface {
  public:
   explicit TestPageLoadMetricsEmbedderInterface(
       content::WebContents* web_contents)
       : web_contents_(web_contents), is_ntp_(false) {}
 
   bool IsNewTabPageUrl(const GURL& url) override { return is_ntp_; }
   void set_is_ntp(bool is_ntp) { is_ntp_ = is_ntp; }
   void RegisterObservers(PageLoadTracker* tracker) override {
     tracker->AddObserver(base::MakeUnique<TestPageLoadMetricsObserver>(
         web_contents_, &updated_timings_, &updated_subframe_timings_,
         &complete_timings_, &observed_committed_urls_));
     tracker->AddObserver(base::MakeUnique<FilteringPageLoadMetricsObserver>(
         &completed_filtered_urls_));
   }
-  const std::vector<PageLoadTiming>& updated_timings() const {
+  const std::vector<mojom::PageLoadTimingPtr>& updated_timings() const {
     return updated_timings_;
   }
-  const std::vector<PageLoadTiming>& complete_timings() const {
+  const std::vector<mojom::PageLoadTimingPtr>& complete_timings() const {
     return complete_timings_;
   }
-  const std::vector<PageLoadTiming>& updated_subframe_timings() const {
+  const std::vector<mojom::PageLoadTimingPtr>& updated_subframe_timings()
+      const {
     return updated_subframe_timings_;
   }
 
   // currently_committed_urls passed to OnStart().
   const std::vector<GURL>& observed_committed_urls_from_on_start() const {
     return observed_committed_urls_;
   }
 
   // committed URLs passed to FilteringPageLoadMetricsObserver::OnComplete().
   const std::vector<GURL>& completed_filtered_urls() const {
     return completed_filtered_urls_;
   }
 
  private:
-  std::vector<PageLoadTiming> updated_timings_;
-  std::vector<PageLoadTiming> updated_subframe_timings_;
-  std::vector<PageLoadTiming> complete_timings_;
+  std::vector<mojom::PageLoadTimingPtr> updated_timings_;
+  std::vector<mojom::PageLoadTimingPtr> updated_subframe_timings_;
+  std::vector<mojom::PageLoadTimingPtr> complete_timings_;
   std::vector<GURL> observed_committed_urls_;
   std::vector<GURL> completed_filtered_urls_;
   content::WebContents* web_contents_;
   bool is_ntp_;
 };
 
 }  //  namespace
 
 class MetricsWebContentsObserverTest : public ChromeRenderViewHostTestHarness {
  public:
   MetricsWebContentsObserverTest() : num_errors_(0) {}
 
   void SetUp() override {
     ChromeRenderViewHostTestHarness::SetUp();
     AttachObserver();
   }
 
   void NavigateToUntrackedUrl() {
     content::WebContentsTester::For(web_contents())
         ->NavigateAndCommit(GURL(url::kAboutBlankURL));
   }
 
-  void SimulateTimingUpdate(const PageLoadTiming& timing) {
+  void SimulateTimingUpdate(const mojom::PageLoadTiming& timing) {
     SimulateTimingUpdate(timing, web_contents()->GetMainFrame());
   }
 
-  void SimulateTimingUpdate(const PageLoadTiming& timing,
+  void SimulateTimingUpdate(const mojom::PageLoadTiming& timing,
                             content::RenderFrameHost* render_frame_host) {
-    observer_->OnTimingUpdated(render_frame_host, timing, PageLoadMetadata());
+    observer_->OnTimingUpdated(render_frame_host, timing,
+                               mojom::PageLoadMetadata());
   }
 
   void AttachObserver() {
     embedder_interface_ =
         new TestPageLoadMetricsEmbedderInterface(web_contents());
     // Owned by the web_contents. Tests must be careful not to call
     // SimulateTimingUpdate after they call DeleteContents() without also
     // calling AttachObserver() again. Otherwise they will use-after-free the
     // observer_.
     observer_ = MetricsWebContentsObserver::CreateForWebContents(
@@ skipping 10 matching lines @@
     histogram_tester_.ExpectTotalCount(internal::kErrorEvents, num_errors_);
   }
 
   void CheckNoErrorEvents() {
     histogram_tester_.ExpectTotalCount(internal::kErrorEvents, 0);
   }
 
   int CountEmptyCompleteTimingReported() {
     int empty = 0;
     for (const auto& timing : embedder_interface_->complete_timings()) {
-      if (timing.IsEmpty())
+      if (page_load_metrics::IsEmpty(*timing))
         ++empty;
     }
     return empty;
   }
 
-  const std::vector<PageLoadTiming>& updated_timings() const {
+  const std::vector<mojom::PageLoadTimingPtr>& updated_timings() const {
     return embedder_interface_->updated_timings();
   }
-  const std::vector<PageLoadTiming>& complete_timings() const {
+  const std::vector<mojom::PageLoadTimingPtr>& complete_timings() const {
     return embedder_interface_->complete_timings();
   }
-  const std::vector<PageLoadTiming>& updated_subframe_timings() const {
+  const std::vector<mojom::PageLoadTimingPtr>& updated_subframe_timings()
+      const {
     return embedder_interface_->updated_subframe_timings();
   }
   int CountCompleteTimingReported() { return complete_timings().size(); }
   int CountUpdatedTimingReported() { return updated_timings().size(); }
   int CountUpdatedSubFrameTimingReported() {
     return updated_subframe_timings().size();
   }
 
   const std::vector<GURL>& observed_committed_urls_from_on_start() const {
     return embedder_interface_->observed_committed_urls_from_on_start();
   }
 
   const std::vector<GURL>& completed_filtered_urls() const {
     return embedder_interface_->completed_filtered_urls();
   }
 
  protected:
   base::HistogramTester histogram_tester_;
   TestPageLoadMetricsEmbedderInterface* embedder_interface_;
   MetricsWebContentsObserver* observer_;
 
  private:
   int num_errors_;
 
   DISALLOW_COPY_AND_ASSIGN(MetricsWebContentsObserverTest);
 };
 
 TEST_F(MetricsWebContentsObserverTest, SuccessfulMainFrameNavigation) {
-  PageLoadTiming timing;
+  mojom::PageLoadTiming timing;
+  page_load_metrics::InitPageLoadTimingForTest(&timing);
   timing.navigation_start = base::Time::FromDoubleT(1);
 
   content::WebContentsTester* web_contents_tester =
       content::WebContentsTester::For(web_contents());
 
   ASSERT_TRUE(observed_committed_urls_from_on_start().empty());
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
   ASSERT_EQ(1u, observed_committed_urls_from_on_start().size());
   ASSERT_TRUE(observed_committed_urls_from_on_start().at(0).is_empty());
 
   ASSERT_EQ(0, CountUpdatedTimingReported());
   SimulateTimingUpdate(timing);
   ASSERT_EQ(1, CountUpdatedTimingReported());
   ASSERT_EQ(0, CountCompleteTimingReported());
 
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl2));
   ASSERT_EQ(1, CountCompleteTimingReported());
   ASSERT_EQ(0, CountEmptyCompleteTimingReported());
   ASSERT_EQ(2u, observed_committed_urls_from_on_start().size());
   ASSERT_EQ(kDefaultTestUrl,
             observed_committed_urls_from_on_start().at(1).spec());
   ASSERT_EQ(1, CountUpdatedTimingReported());
   ASSERT_EQ(0, CountUpdatedSubFrameTimingReported());
 
   CheckNoErrorEvents();
 }
 
 TEST_F(MetricsWebContentsObserverTest, SubFrame) {
-  PageLoadTiming timing;
+  mojom::PageLoadTiming timing;
+  page_load_metrics::InitPageLoadTimingForTest(&timing);
   timing.navigation_start = base::Time::FromDoubleT(1);
 
   content::WebContentsTester* web_contents_tester =
       content::WebContentsTester::For(web_contents());
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
   SimulateTimingUpdate(timing);
 
   content::RenderFrameHostTester* rfh_tester =
       content::RenderFrameHostTester::For(main_rfh());
   content::RenderFrameHost* subframe = rfh_tester->AppendChild("subframe");
 
-  PageLoadTiming subframe_timing;
+  mojom::PageLoadTiming subframe_timing;
+  page_load_metrics::InitPageLoadTimingForTest(&subframe_timing);
   subframe_timing.navigation_start = base::Time::FromDoubleT(2);
   content::RenderFrameHostTester* subframe_tester =
       content::RenderFrameHostTester::For(subframe);
   subframe_tester->SimulateNavigationStart(GURL(kDefaultTestUrl2));
   subframe_tester->SimulateNavigationCommit(GURL(kDefaultTestUrl2));
   SimulateTimingUpdate(subframe_timing, subframe);
   subframe_tester->SimulateNavigationStop();
 
   // Navigate again to see if the timing updated for a subframe message.
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl2));
 
   ASSERT_EQ(1, CountCompleteTimingReported());
   ASSERT_EQ(1, CountUpdatedTimingReported());
   ASSERT_EQ(0, CountEmptyCompleteTimingReported());
-  EXPECT_EQ(timing, updated_timings().at(0));
+  EXPECT_TRUE(timing.Equals(*updated_timings().at(0)));
 
   ASSERT_EQ(1, CountUpdatedSubFrameTimingReported());
-  EXPECT_EQ(subframe_timing, updated_subframe_timings().at(0));
+  EXPECT_TRUE(subframe_timing.Equals(*updated_subframe_timings().at(0)));
 
   CheckNoErrorEvents();
 }
 
 TEST_F(MetricsWebContentsObserverTest, SameDocumentNoTrigger) {
-  PageLoadTiming timing;
+  mojom::PageLoadTiming timing;
+  page_load_metrics::InitPageLoadTimingForTest(&timing);
   timing.navigation_start = base::Time::FromDoubleT(1);
 
   content::WebContentsTester* web_contents_tester =
       content::WebContentsTester::For(web_contents());
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
   ASSERT_EQ(0, CountUpdatedTimingReported());
   SimulateTimingUpdate(timing);
   ASSERT_EQ(1, CountUpdatedTimingReported());
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrlAnchor));
   // Send the same timing update. The original tracker for kDefaultTestUrl
   // should dedup the update, and the tracker for kDefaultTestUrlAnchor should
   // have been destroyed as a result of its being a same page navigation, so
   // CountUpdatedTimingReported() should continue to return 1.
   SimulateTimingUpdate(timing);
 
   ASSERT_EQ(1, CountUpdatedTimingReported());
   ASSERT_EQ(0, CountCompleteTimingReported());
 
   // Navigate again to force histogram logging.
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl2));
 
   // A same page navigation shouldn't trigger logging UMA for the original.
   ASSERT_EQ(1, CountUpdatedTimingReported());
   ASSERT_EQ(1, CountCompleteTimingReported());
   ASSERT_EQ(0, CountEmptyCompleteTimingReported());
   CheckNoErrorEvents();
 }
 
 TEST_F(MetricsWebContentsObserverTest, DontLogNewTabPage) {
-  PageLoadTiming timing;
+  mojom::PageLoadTiming timing;
+  page_load_metrics::InitPageLoadTimingForTest(&timing);
   timing.navigation_start = base::Time::FromDoubleT(1);
 
   content::WebContentsTester* web_contents_tester =
       content::WebContentsTester::For(web_contents());
   embedder_interface_->set_is_ntp(true);
 
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
   SimulateTimingUpdate(timing);
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl2));
   ASSERT_EQ(0, CountUpdatedTimingReported());
   ASSERT_EQ(0, CountCompleteTimingReported());
   CheckErrorEvent(ERR_IPC_WITH_NO_RELEVANT_LOAD, 1);
   CheckTotalErrorEvents();
 }
 
 TEST_F(MetricsWebContentsObserverTest, DontLogIrrelevantNavigation) {
-  PageLoadTiming timing;
+  mojom::PageLoadTiming timing;
+  page_load_metrics::InitPageLoadTimingForTest(&timing);
   timing.navigation_start = base::Time::FromDoubleT(10);
 
   content::WebContentsTester* web_contents_tester =
       content::WebContentsTester::For(web_contents());
 
   GURL about_blank_url = GURL("about:blank");
   web_contents_tester->NavigateAndCommit(about_blank_url);
   SimulateTimingUpdate(timing);
   ASSERT_EQ(0, CountUpdatedTimingReported());
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
   ASSERT_EQ(0, CountUpdatedTimingReported());
   ASSERT_EQ(0, CountCompleteTimingReported());
 
   CheckErrorEvent(ERR_IPC_FROM_BAD_URL_SCHEME, 1);
   CheckErrorEvent(ERR_IPC_WITH_NO_RELEVANT_LOAD, 1);
   CheckTotalErrorEvents();
 }
 
 TEST_F(MetricsWebContentsObserverTest, EmptyTimingError) {
-  PageLoadTiming timing;
+  mojom::PageLoadTiming timing;
+  page_load_metrics::InitPageLoadTimingForTest(&timing);
 
   content::WebContentsTester* web_contents_tester =
       content::WebContentsTester::For(web_contents());
 
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
   SimulateTimingUpdate(timing);
   ASSERT_EQ(0, CountUpdatedTimingReported());
   NavigateToUntrackedUrl();
   ASSERT_EQ(0, CountUpdatedTimingReported());
   ASSERT_EQ(1, CountCompleteTimingReported());
 
   CheckErrorEvent(ERR_BAD_TIMING_IPC_INVALID_TIMING, 1);
   CheckErrorEvent(ERR_NO_IPCS_RECEIVED, 1);
   CheckTotalErrorEvents();
 
   histogram_tester_.ExpectTotalCount(
       page_load_metrics::internal::kPageLoadTimingStatus, 1);
   histogram_tester_.ExpectBucketCount(
       page_load_metrics::internal::kPageLoadTimingStatus,
       page_load_metrics::internal::INVALID_EMPTY_TIMING, 1);
 }
 
 TEST_F(MetricsWebContentsObserverTest, NullNavigationStartError) {
-  PageLoadTiming timing;
-  timing.parse_timing.parse_start = base::TimeDelta::FromMilliseconds(1);
+  mojom::PageLoadTiming timing;
+  page_load_metrics::InitPageLoadTimingForTest(&timing);
+  timing.parse_timing->parse_start = base::TimeDelta::FromMilliseconds(1);
 
   content::WebContentsTester* web_contents_tester =
       content::WebContentsTester::For(web_contents());
 
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
   SimulateTimingUpdate(timing);
   ASSERT_EQ(0, CountUpdatedTimingReported());
   NavigateToUntrackedUrl();
   ASSERT_EQ(0, CountUpdatedTimingReported());
   ASSERT_EQ(1, CountCompleteTimingReported());
 
   CheckErrorEvent(ERR_BAD_TIMING_IPC_INVALID_TIMING, 1);
   CheckErrorEvent(ERR_NO_IPCS_RECEIVED, 1);
   CheckTotalErrorEvents();
 
   histogram_tester_.ExpectTotalCount(
       page_load_metrics::internal::kPageLoadTimingStatus, 1);
   histogram_tester_.ExpectBucketCount(
       page_load_metrics::internal::kPageLoadTimingStatus,
       page_load_metrics::internal::INVALID_NULL_NAVIGATION_START, 1);
 }
 
 TEST_F(MetricsWebContentsObserverTest, TimingOrderError) {
-  PageLoadTiming timing;
+  mojom::PageLoadTiming timing;
+  page_load_metrics::InitPageLoadTimingForTest(&timing);
   timing.navigation_start = base::Time::FromDoubleT(1);
-  timing.parse_timing.parse_stop = base::TimeDelta::FromMilliseconds(1);
+  timing.parse_timing->parse_stop = base::TimeDelta::FromMilliseconds(1);
 
   content::WebContentsTester* web_contents_tester =
       content::WebContentsTester::For(web_contents());
 
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
   SimulateTimingUpdate(timing);
   ASSERT_EQ(0, CountUpdatedTimingReported());
   NavigateToUntrackedUrl();
   ASSERT_EQ(0, CountUpdatedTimingReported());
   ASSERT_EQ(1, CountCompleteTimingReported());
 
   CheckErrorEvent(ERR_BAD_TIMING_IPC_INVALID_TIMING, 1);
   CheckErrorEvent(ERR_NO_IPCS_RECEIVED, 1);
   CheckTotalErrorEvents();
 
   histogram_tester_.ExpectTotalCount(
       page_load_metrics::internal::kPageLoadTimingStatus, 1);
   histogram_tester_.ExpectBucketCount(
       page_load_metrics::internal::kPageLoadTimingStatus,
       page_load_metrics::internal::INVALID_ORDER_PARSE_START_PARSE_STOP, 1);
 }
 
 TEST_F(MetricsWebContentsObserverTest, BadIPC) {
-  PageLoadTiming timing;
+  mojom::PageLoadTiming timing;
+  page_load_metrics::InitPageLoadTimingForTest(&timing);
   timing.navigation_start = base::Time::FromDoubleT(10);
-  PageLoadTiming timing2;
+  mojom::PageLoadTiming timing2;
+  page_load_metrics::InitPageLoadTimingForTest(&timing2);
   timing2.navigation_start = base::Time::FromDoubleT(100);
 
   content::WebContentsTester* web_contents_tester =
       content::WebContentsTester::For(web_contents());
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
 
   SimulateTimingUpdate(timing);
   ASSERT_EQ(1, CountUpdatedTimingReported());
   SimulateTimingUpdate(timing2);
   ASSERT_EQ(1, CountUpdatedTimingReported());
 
   CheckErrorEvent(ERR_BAD_TIMING_IPC_INVALID_TIMING_DESCENDENT, 1);
   CheckTotalErrorEvents();
 }
 
 TEST_F(MetricsWebContentsObserverTest, ObservePartialNavigation) {
   // Reset the state of the tests, and attach the MetricsWebContentsObserver in
   // the middle of a navigation. This tests that the class is robust to only
   // observing some of a navigation.
   DeleteContents();
   SetContents(CreateTestWebContents());
 
-  PageLoadTiming timing;
+  mojom::PageLoadTiming timing;
+  page_load_metrics::InitPageLoadTimingForTest(&timing);
   timing.navigation_start = base::Time::FromDoubleT(10);
 
   content::WebContentsTester* web_contents_tester =
       content::WebContentsTester::For(web_contents());
   content::RenderFrameHostTester* rfh_tester =
       content::RenderFrameHostTester::For(main_rfh());
 
   // Start the navigation, then start observing the web contents. This used to
   // crash us. Make sure we bail out and don't log histograms.
   web_contents_tester->StartNavigation(GURL(kDefaultTestUrl));
@@ skipping 171 matching lines @@
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl2));
   ASSERT_EQ(std::vector<GURL>({GURL(kDefaultTestUrl)}),
             completed_filtered_urls());
 
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
   ASSERT_EQ(std::vector<GURL>({GURL(kDefaultTestUrl), GURL(kDefaultTestUrl2)}),
             completed_filtered_urls());
 }
 
 }  // namespace page_load_metrics