Page Abort Events for relevant navigations

components/page_load_metrics/browser/metrics_web_contents_observer_unittest.cc

 // Copyright (c) 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 "components/page_load_metrics/browser/metrics_web_contents_observer.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/process/kill.h"
 #include "base/test/histogram_tester.h"
 #include "base/time/time.h"
@@ skipping 14 matching lines @@
 const char kHistogramNameFirstLayout[] =
     "PageLoad.Timing2.NavigationToFirstLayout";
 const char kHistogramNameFirstTextPaint[] =
     "PageLoad.Timing2.NavigationToFirstTextPaint";
 const char kHistogramNameDomContent[] =
     "PageLoad.Timing2.NavigationToDOMContentLoadedEventFired";
 const char kHistogramNameLoad[] =
     "PageLoad.Timing2.NavigationToLoadEventFired";
 
 const char kBGHistogramNameFirstLayout[] =
-    "PageLoad.Timing2.NavigationToFirstLayout.BG";
+    "PageLoad.Timing2.NavigationToFirstLayout.Background";
 const char kBGHistogramNameFirstTextPaint[] =
-    "PageLoad.Timing2.NavigationToFirstTextPaint.BG";
+    "PageLoad.Timing2.NavigationToFirstTextPaint.Background";
 const char kBGHistogramNameDomContent[] =
-    "PageLoad.Timing2.NavigationToDOMContentLoadedEventFired.BG";
+    "PageLoad.Timing2.NavigationToDOMContentLoadedEventFired.Background";
 const char kBGHistogramNameLoad[] =
-    "PageLoad.Timing2.NavigationToLoadEventFired.BG";
+    "PageLoad.Timing2.NavigationToLoadEventFired.Background";
 
-const char kHistogramNameEvents[] = "PageLoad.EventCounts";
+const char kProvisionalEvents[] = "PageLoad.Events.Provisional";
+const char kCommittedEvents[] = "PageLoad.Events.Committed";
+const char kBGProvisionalEvents[] = "PageLoad.Events.Provisional.Background";
+const char kBGCommittedEvents[] = "PageLoad.Events.Committed.Background";
+
+const char kErrorEvents[] = "PageLoad.Events.InternalError";
 
 }  //  namespace
 
 class MetricsWebContentsObserverTest
     : public content::RenderViewHostTestHarness {
  public:
   MetricsWebContentsObserverTest() {}
 
   void SetUp() override {
     RenderViewHostTestHarness::SetUp();
     observer_ = make_scoped_ptr(new MetricsWebContentsObserver(web_contents()));
     observer_->WasShown();
+    num_provisional_events_ = 0;
+    num_committed_events_ = 0;
+    num_provisional_events_bg_ = 0;
+    num_committed_events_bg_ = 0;
+    num_errors_ = 0;

[Alexei Svitkine (slow), 2015/10/16 16:48:54]

Nit: Init these in the ctor instead.

The ctor will be re-run for each test, so there shouldn't be any behavior
difference and this will fix warnings (from some IDEs and lint tools) that
you're not initializing variables in the ctor.

[Charlie Harrison, 2015/10/16 17:29:55]

Great! Done.

   }
 
   void AssertNoHistogramsLogged() {
     histogram_tester_.ExpectTotalCount(kHistogramNameDomContent, 0);
     histogram_tester_.ExpectTotalCount(kHistogramNameLoad, 0);
     histogram_tester_.ExpectTotalCount(kHistogramNameFirstLayout, 0);
     histogram_tester_.ExpectTotalCount(kHistogramNameFirstTextPaint, 0);
   }
 
+  void CheckProvisionalEvent(ProvisionalLoadEvent event,
+                             int count,
+                             bool background) {
+    if (background) {
+      histogram_tester_.ExpectBucketCount(kBGProvisionalEvents, event, count);
+      num_provisional_events_bg_ += count;
+    } else {
+      histogram_tester_.ExpectBucketCount(kProvisionalEvents, event, count);
+      num_provisional_events_ += count;
+    }
+  }
+
+  void CheckCommittedEvent(CommittedLoadEvent event,
+                           int count,
+                           bool background) {
+    if (background) {
+      histogram_tester_.ExpectBucketCount(kBGCommittedEvents, event, count);
+      num_committed_events_bg_ += count;
+    } else {
+      histogram_tester_.ExpectBucketCount(kCommittedEvents, event, count);
+      num_committed_events_ += count;
+    }
+  }
+
+  void CheckErrorEvent(InternalErrorLoadEvent error, int count) {
+    histogram_tester_.ExpectBucketCount(kErrorEvents, error, count);
+    num_errors_ += count;
+  }
+
+  void CheckTotalEvents() {
+    histogram_tester_.ExpectTotalCount(kProvisionalEvents,
+                                       num_provisional_events_);
+    histogram_tester_.ExpectTotalCount(kCommittedEvents, num_committed_events_);
+    histogram_tester_.ExpectTotalCount(kBGProvisionalEvents,
+                                       num_provisional_events_bg_);
+    histogram_tester_.ExpectTotalCount(kBGCommittedEvents,
+                                       num_committed_events_bg_);
+    histogram_tester_.ExpectTotalCount(kErrorEvents, num_errors_);
+  }
+
  protected:
   base::HistogramTester histogram_tester_;
   scoped_ptr<MetricsWebContentsObserver> observer_;
+
+ private:
+  int num_provisional_events_;
+  int num_provisional_events_bg_;
+  int num_committed_events_;
+  int num_committed_events_bg_;
+  int num_errors_;
+
+  DISALLOW_COPY_AND_ASSIGN(MetricsWebContentsObserverTest);
 };
 
 TEST_F(MetricsWebContentsObserverTest, NoMetrics) {
   AssertNoHistogramsLogged();
 }
 
 TEST_F(MetricsWebContentsObserverTest, NotInMainFrame) {
   base::TimeDelta first_layout = base::TimeDelta::FromMilliseconds(1);
 
   PageLoadTiming timing;
@@ skipping 286 matching lines @@
   content::WebContentsTester* web_contents_tester =
       content::WebContentsTester::For(web_contents());
 
   web_contents_tester->StartNavigation(GURL(kDefaultTestUrl));
   content::RenderFrameHostTester* rfh_tester =
       content::RenderFrameHostTester::For(main_rfh());
   rfh_tester->SimulateNavigationError(GURL(kDefaultTestUrl),
                                       net::ERR_TIMED_OUT);
   rfh_tester->SimulateNavigationStop();
 
-  histogram_tester_.ExpectTotalCount(kHistogramNameEvents, 3);
-  histogram_tester_.ExpectBucketCount(kHistogramNameEvents,
-                                      PAGE_LOAD_STARTED, 1);
-  histogram_tester_.ExpectBucketCount(kHistogramNameEvents,
-                                      PAGE_LOAD_FAILED_BEFORE_COMMIT, 1);
-  histogram_tester_.ExpectBucketCount(kHistogramNameEvents,
-                                      PAGE_LOAD_ABORTED_BEFORE_FIRST_LAYOUT, 1);
-  histogram_tester_.ExpectBucketCount(kHistogramNameEvents,
-                                      PAGE_LOAD_ABORTED_BEFORE_COMMIT, 0);
+  CheckProvisionalEvent(PROVISIONAL_LOAD_ERR_FAILED_NON_ABORT, 1, false);
+  CheckProvisionalEvent(PROVISIONAL_LOAD_ERR_ABORTED, 0, false);
+  CheckTotalEvents();
 }
 
 TEST_F(MetricsWebContentsObserverTest, AbortProvisionalLoad) {
   content::WebContentsTester* web_contents_tester =
       content::WebContentsTester::For(web_contents());
 
   web_contents_tester->StartNavigation(GURL(kDefaultTestUrl));
   content::RenderFrameHostTester* rfh_tester =
       content::RenderFrameHostTester::For(main_rfh());
   rfh_tester->SimulateNavigationError(GURL(kDefaultTestUrl), net::ERR_ABORTED);
   rfh_tester->SimulateNavigationStop();
 
-  histogram_tester_.ExpectTotalCount(kHistogramNameEvents, 4);
-  histogram_tester_.ExpectBucketCount(kHistogramNameEvents,
-                                      PAGE_LOAD_STARTED, 1);
-  histogram_tester_.ExpectBucketCount(kHistogramNameEvents,
-                                      PAGE_LOAD_FAILED_BEFORE_COMMIT, 1);
-  histogram_tester_.ExpectBucketCount(kHistogramNameEvents,
-                                      PAGE_LOAD_ABORTED_BEFORE_FIRST_LAYOUT, 1);
-  histogram_tester_.ExpectBucketCount(kHistogramNameEvents,
-                                      PAGE_LOAD_ABORTED_BEFORE_COMMIT, 1);
+  CheckProvisionalEvent(PROVISIONAL_LOAD_ERR_FAILED_NON_ABORT, 0, false);
+  CheckProvisionalEvent(PROVISIONAL_LOAD_ERR_ABORTED, 1, false);
+  CheckTotalEvents();
+}
+
+TEST_F(MetricsWebContentsObserverTest, AbortProvisionalLoadInBackground) {
+  content::WebContentsTester* web_contents_tester =
+      content::WebContentsTester::For(web_contents());
+
+  observer_->WasHidden();
+  web_contents_tester->StartNavigation(GURL(kDefaultTestUrl));
+  content::RenderFrameHostTester* rfh_tester =
+      content::RenderFrameHostTester::For(main_rfh());
+  rfh_tester->SimulateNavigationError(GURL(kDefaultTestUrl), net::ERR_ABORTED);
+  rfh_tester->SimulateNavigationStop();
+
+  CheckProvisionalEvent(PROVISIONAL_LOAD_ERR_FAILED_NON_ABORT, 0, true);
+  CheckProvisionalEvent(PROVISIONAL_LOAD_ERR_ABORTED, 1, true);
+  CheckTotalEvents();
+}
+
+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);
+
+  observer_->OnMessageReceived(
+      PageLoadMetricsMsg_TimingUpdated(observer_->routing_id(), timing),
+      main_rfh());
+
+  web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
+
+  CheckProvisionalEvent(PROVISIONAL_LOAD_COMMITTED, 2, false);
+  CheckCommittedEvent(COMMITTED_LOAD_STARTED, 1, false);
+  CheckErrorEvent(ERR_IPC_FROM_BAD_URL_SCHEME, 1);
+  CheckErrorEvent(ERR_IPC_WITH_NO_COMMITTED_LOAD, 1);
+  CheckTotalEvents();
+}
+
+TEST_F(MetricsWebContentsObserverTest, NotInMainError) {
+  PageLoadTiming timing;
+  timing.navigation_start = base::Time::FromDoubleT(1);
+  timing.first_layout = base::TimeDelta::FromMilliseconds(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));
+  observer_->OnMessageReceived(
+      PageLoadMetricsMsg_TimingUpdated(observer_->routing_id(), timing),
+      subframe);
+  CheckErrorEvent(ERR_IPC_FROM_WRONG_FRAME, 1);
 }
 
 TEST_F(MetricsWebContentsObserverTest, AbortCommittedLoadBeforeFirstLayout) {
   PageLoadTiming timing;
   timing.navigation_start = base::Time::FromDoubleT(10);
 
   content::WebContentsTester* web_contents_tester =
       content::WebContentsTester::For(web_contents());
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
 
   observer_->OnMessageReceived(
       PageLoadMetricsMsg_TimingUpdated(observer_->routing_id(), timing),
       main_rfh());
   // Navigate again to force histogram logging.
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl2));
 
-  // 3 events: 2 starts and one abort before first layout.
-  histogram_tester_.ExpectTotalCount(kHistogramNameEvents, 3);
-  histogram_tester_.ExpectBucketCount(kHistogramNameEvents,
-                                      PAGE_LOAD_STARTED, 2);
-  histogram_tester_.ExpectBucketCount(
-      kHistogramNameEvents, PAGE_LOAD_ABORTED_BEFORE_FIRST_LAYOUT, 1);
+  CheckProvisionalEvent(PROVISIONAL_LOAD_COMMITTED, 2, false);
+  CheckCommittedEvent(COMMITTED_LOAD_STARTED, 2, false);
+  CheckCommittedEvent(COMMITTED_LOAD_FAILED_BEFORE_FIRST_LAYOUT, 1, false);
+  CheckTotalEvents();
 }
 
-TEST_F(MetricsWebContentsObserverTest,
-       SuccessfulFirstLayoutInForeGroundEvent) {
+TEST_F(MetricsWebContentsObserverTest, SuccessfulFirstLayoutInForegroundEvent) {
   PageLoadTiming timing;
   timing.navigation_start = base::Time::FromDoubleT(10);
   timing.first_layout = base::TimeDelta::FromMilliseconds(100);
 
   content::WebContentsTester* web_contents_tester =
       content::WebContentsTester::For(web_contents());
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
 
   observer_->OnMessageReceived(
       PageLoadMetricsMsg_TimingUpdated(observer_->routing_id(), timing),
       main_rfh());
   // Navigate again to force histogram logging.
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl2));
 
-  // 3 events: 2 starts and one successful first layout.
-  histogram_tester_.ExpectTotalCount(kHistogramNameEvents, 3);
-  histogram_tester_.ExpectBucketCount(kHistogramNameEvents,
-                                      PAGE_LOAD_STARTED, 2);
-  histogram_tester_.ExpectBucketCount(
-      kHistogramNameEvents, PAGE_LOAD_SUCCESSFUL_FIRST_LAYOUT_FOREGROUND, 1);
+  CheckProvisionalEvent(PROVISIONAL_LOAD_COMMITTED, 2, false);
+  CheckCommittedEvent(COMMITTED_LOAD_STARTED, 2, false);
+  CheckCommittedEvent(COMMITTED_LOAD_SUCCESSFUL_FIRST_LAYOUT, 1, false);
+  CheckTotalEvents();
 }
 
 TEST_F(MetricsWebContentsObserverTest,
        SuccessfulFirstLayoutInBackgroundEvent) {
   PageLoadTiming timing;
   timing.navigation_start = base::Time::FromDoubleT(
       (base::TimeTicks::Now() - base::TimeTicks::UnixEpoch()).InSecondsF() - 1);
 
   timing.first_layout = base::TimeDelta::FromSeconds(30);
 
   content::WebContentsTester* web_contents_tester =
       content::WebContentsTester::For(web_contents());
-  web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
   // Background the tab.
   observer_->WasHidden();
+  web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
 
   observer_->OnMessageReceived(
       PageLoadMetricsMsg_TimingUpdated(observer_->routing_id(), timing),
       main_rfh());
 
   observer_->WasShown();
   // Navigate again to force histogram logging.
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl2));
 
-  // 3 events: 2 starts and one successful first layout.
-  histogram_tester_.ExpectTotalCount(kHistogramNameEvents, 3);
-  histogram_tester_.ExpectBucketCount(kHistogramNameEvents,
-                                      PAGE_LOAD_STARTED, 2);
-  histogram_tester_.ExpectBucketCount(
-      kHistogramNameEvents, PAGE_LOAD_SUCCESSFUL_FIRST_LAYOUT_BACKGROUND, 1);
+  CheckProvisionalEvent(PROVISIONAL_LOAD_COMMITTED, 1, true);
+  CheckProvisionalEvent(PROVISIONAL_LOAD_COMMITTED, 1, false);
+  CheckCommittedEvent(COMMITTED_LOAD_STARTED, 1, true);
+  CheckCommittedEvent(COMMITTED_LOAD_STARTED, 1, false);
+  CheckCommittedEvent(COMMITTED_LOAD_SUCCESSFUL_FIRST_LAYOUT, 1, true);
+  CheckTotalEvents();
 }
+
+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));
+
+  observer_->OnMessageReceived(
+      PageLoadMetricsMsg_TimingUpdated(observer_->routing_id(), timing),
+      main_rfh());
+  observer_->OnMessageReceived(
+      PageLoadMetricsMsg_TimingUpdated(observer_->routing_id(), timing2),
+      main_rfh());
+
+  CheckProvisionalEvent(PROVISIONAL_LOAD_COMMITTED, 1, false);
+  CheckCommittedEvent(COMMITTED_LOAD_STARTED, 1, false);
+  CheckErrorEvent(ERR_BAD_TIMING_IPC, 1);
+  CheckTotalEvents();
+}
+
 }  // namespace page_load_metrics