[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()
+        .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());

[Zhen Wang, 2017/04/19 21:52:47]

Should this and the above IPC one be controlled by the finch trial flag? Is it
possible to control that in the test?

If that is possible, you may not need to change the expected timing error number
in the tests.

In addition, why do we get duplicated errors, but not duplicated timing updates
(CountUpdatedTimingReported())? So I guess somewhere in the code determines that
the 2nd timing update is not reported. Can you give me a pointer on that? It
feels strange that we have only one report count when we actually send twice.

+    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