[Page Load Metrics] PageLoadMetrics Mojofication.

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"
 #include "base/memory/ptr_util.h"
 #include "base/process/kill.h"
+#include "base/run_loop.h"
 #include "base/test/histogram_tester.h"
 #include "base/time/time.h"
 #include "chrome/browser/page_load_metrics/metrics_navigation_throttle.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_embedder_interface.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_observer.h"
 #include "chrome/browser/page_load_metrics/page_load_tracker.h"
 #include "chrome/common/page_load_metrics/page_load_metrics_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "content/public/browser/navigation_handle.h"
@@ skipping 141 matching lines @@
   void SimulateTimingUpdate(const PageLoadTiming& timing) {
     SimulateTimingUpdate(timing, web_contents()->GetMainFrame());
   }
 
   void SimulateTimingUpdate(const PageLoadTiming& timing,
                             content::RenderFrameHost* render_frame_host) {
     ASSERT_TRUE(observer_->OnMessageReceived(
         PageLoadMetricsMsg_TimingUpdated(observer_->routing_id(), timing,
                                          PageLoadMetadata()),
         render_frame_host));
+
+    observer_->page_load_metrics_binding_for_testing()

[Bryan McQuade, 2017/04/25 15:41:14]

I think I'm inclined to change the SimulateTimingUpdate impl to just directly
invoke OnTimingUpdated, rather than going through the IPC dispatch patch, and
not having to have the test invoke / know about both IPC and Mojo. This is a
unit test so it shouldn't really have to know about IPC or Mojo dispatch. While
it's nice to exercise slightly more code with IPC dispatch, it adds the
complexity of now also having to invoke the mojo path here, having to expose the
page_load_metrics_binding_for_testing() method on the observer, and we do also
have the browsertest for IPC/Mojo dispatch coverage so I feel it is a little
redundant to also do that here, given the complexity it now adds.

[Ken Rockot(use gerrit already), 2017/04/25 19:31:46]

+1 - I prefer to avoid going through IPC boundaries when unit-testing if
possible. Seems like unnecessary complexity.

[lpy, 2017/04/26 14:18:40]

Done.

+        .SetCurrentTargetFrameForTesting(render_frame_host);
+    mojo::Binding<page_load_metrics::mojom::PageLoadMetrics> binding(observer_);
+    mojom::PageLoadMetricsPtr ptr;
+    mojom::PageLoadMetricsRequest request = MakeRequest(&ptr);
+    binding.Bind(std::move(request));
+    ptr->UpdateTiming(timing, PageLoadMetadata());
+    base::RunLoop().RunUntilIdle();
   }
 
   void AttachObserver() {
     embedder_interface_ = new TestPageLoadMetricsEmbedderInterface();
     // 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(
         web_contents(), base::WrapUnique(embedder_interface_));
@@ skipping 94 matching lines @@
   subframe_tester->SimulateNavigationCommit(GURL(kDefaultTestUrl2));
   SimulateTimingUpdate(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(0, CountUpdatedTimingReported());
   ASSERT_EQ(1, CountCompleteTimingReported());
   ASSERT_EQ(1, CountEmptyCompleteTimingReported());
-  CheckErrorEvent(ERR_TIMING_IPC_FROM_SUBFRAME, 1);
+  CheckErrorEvent(ERR_TIMING_IPC_FROM_SUBFRAME, 2);
   CheckErrorEvent(ERR_NO_IPCS_RECEIVED, 1);
   CheckTotalErrorEvents();
 }
 
 TEST_F(MetricsWebContentsObserverTest, SameDocumentNoTrigger) {
   PageLoadTiming timing;
   timing.navigation_start = base::Time::FromDoubleT(1);
 
   content::WebContentsTester* web_contents_tester =
       content::WebContentsTester::For(web_contents());
@@ skipping 27 matching lines @@
 
   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);
+  CheckErrorEvent(ERR_IPC_WITH_NO_RELEVANT_LOAD, 2);
   CheckTotalErrorEvents();
 }
 
 TEST_F(MetricsWebContentsObserverTest, DontLogIrrelevantNavigation) {
   PageLoadTiming 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);
+  CheckErrorEvent(ERR_IPC_FROM_BAD_URL_SCHEME, 2);
+  CheckErrorEvent(ERR_IPC_WITH_NO_RELEVANT_LOAD, 2);
   CheckTotalErrorEvents();
 }
 
 TEST_F(MetricsWebContentsObserverTest, EmptyTimingError) {
   PageLoadTiming 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_BAD_TIMING_IPC_INVALID_TIMING, 2);
   CheckErrorEvent(ERR_NO_IPCS_RECEIVED, 1);
   CheckTotalErrorEvents();
 
   histogram_tester_.ExpectTotalCount(
-      page_load_metrics::internal::kPageLoadTimingStatus, 1);
+      page_load_metrics::internal::kPageLoadTimingStatus, 2);
   histogram_tester_.ExpectBucketCount(
       page_load_metrics::internal::kPageLoadTimingStatus,
-      page_load_metrics::internal::INVALID_EMPTY_TIMING, 1);
+      page_load_metrics::internal::INVALID_EMPTY_TIMING, 2);
 }
 
 TEST_F(MetricsWebContentsObserverTest, NullNavigationStartError) {
   PageLoadTiming 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_BAD_TIMING_IPC_INVALID_TIMING, 2);
   CheckErrorEvent(ERR_NO_IPCS_RECEIVED, 1);
   CheckTotalErrorEvents();
 
   histogram_tester_.ExpectTotalCount(
-      page_load_metrics::internal::kPageLoadTimingStatus, 1);
+      page_load_metrics::internal::kPageLoadTimingStatus, 2);
   histogram_tester_.ExpectBucketCount(
       page_load_metrics::internal::kPageLoadTimingStatus,
-      page_load_metrics::internal::INVALID_NULL_NAVIGATION_START, 1);
+      page_load_metrics::internal::INVALID_NULL_NAVIGATION_START, 2);
 }
 
 TEST_F(MetricsWebContentsObserverTest, TimingOrderError) {
   PageLoadTiming timing;
   timing.navigation_start = base::Time::FromDoubleT(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_BAD_TIMING_IPC_INVALID_TIMING, 2);
   CheckErrorEvent(ERR_NO_IPCS_RECEIVED, 1);
   CheckTotalErrorEvents();
 
   histogram_tester_.ExpectTotalCount(
-      page_load_metrics::internal::kPageLoadTimingStatus, 1);
+      page_load_metrics::internal::kPageLoadTimingStatus, 2);
   histogram_tester_.ExpectBucketCount(
       page_load_metrics::internal::kPageLoadTimingStatus,
-      page_load_metrics::internal::INVALID_ORDER_PARSE_START_PARSE_STOP, 1);
+      page_load_metrics::internal::INVALID_ORDER_PARSE_START_PARSE_STOP, 2);
 }
 
 TEST_F(MetricsWebContentsObserverTest, NotInMainError) {
   PageLoadTiming timing;
   timing.navigation_start = base::Time::FromDoubleT(1);
 
   content::WebContentsTester* web_contents_tester =
       content::WebContentsTester::For(web_contents());
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
 
   content::RenderFrameHostTester* rfh_tester =
       content::RenderFrameHostTester::For(main_rfh());
   content::RenderFrameHost* subframe = rfh_tester->AppendChild("subframe");
 
   content::RenderFrameHostTester* subframe_tester =
       content::RenderFrameHostTester::For(subframe);
   subframe_tester->SimulateNavigationStart(GURL(kDefaultTestUrl2));
   subframe_tester->SimulateNavigationCommit(GURL(kDefaultTestUrl2));
   SimulateTimingUpdate(timing, subframe);
-  CheckErrorEvent(ERR_TIMING_IPC_FROM_SUBFRAME, 1);
+  CheckErrorEvent(ERR_TIMING_IPC_FROM_SUBFRAME, 2);
   CheckTotalErrorEvents();
   ASSERT_EQ(0, CountUpdatedTimingReported());
   ASSERT_EQ(0, CountCompleteTimingReported());
 }
 
 TEST_F(MetricsWebContentsObserverTest, BadIPC) {
   PageLoadTiming timing;
   timing.navigation_start = base::Time::FromDoubleT(10);
   PageLoadTiming 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);
+  CheckErrorEvent(ERR_BAD_TIMING_IPC_INVALID_TIMING_DESCENDENT, 2);
   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());
 
@@ skipping 10 matching lines @@
   web_contents_tester->StartNavigation(GURL(kDefaultTestUrl));
   AttachObserver();
   rfh_tester->SimulateNavigationCommit(GURL(kDefaultTestUrl));
 
   SimulateTimingUpdate(timing);
 
   // Navigate again to force histogram logging.
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl2));
   ASSERT_EQ(0, CountCompleteTimingReported());
   ASSERT_EQ(0, CountUpdatedTimingReported());
-  CheckErrorEvent(ERR_IPC_WITH_NO_RELEVANT_LOAD, 1);
+  CheckErrorEvent(ERR_IPC_WITH_NO_RELEVANT_LOAD, 2);
   CheckTotalErrorEvents();
 }
 
 TEST_F(MetricsWebContentsObserverTest, DontLogAbortChains) {
   NavigateAndCommit(GURL(kDefaultTestUrl));
   NavigateAndCommit(GURL(kDefaultTestUrl2));
   NavigateAndCommit(GURL(kDefaultTestUrl));
   histogram_tester_.ExpectTotalCount(internal::kAbortChainSizeNewNavigation, 0);
   CheckErrorEvent(ERR_NO_IPCS_RECEIVED, 2);
   CheckTotalErrorEvents();
@@ skipping 151 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