Add page load abort metrics to PageLoadMetrics system

components/page_load_metrics/browser/metrics_web_contents_observer.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 "components/page_load_metrics/browser/metrics_web_contents_observer.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "components/page_load_metrics/common/page_load_metrics_messages.h"
 #include "components/page_load_metrics/common/page_load_timing.h"
@@ skipping 42 matching lines @@
 }
 
 }  // namespace
 
 #define PAGE_LOAD_HISTOGRAM(name, sample)                           \
   UMA_HISTOGRAM_CUSTOM_TIMES(name, sample,                          \
                              base::TimeDelta::FromMilliseconds(10), \
                              base::TimeDelta::FromMinutes(10), 100)
 
 PageLoadTracker::PageLoadTracker(bool in_foreground)
-    : has_commit_(false), started_in_foreground_(in_foreground) {}
+    : has_commit_(false), started_in_foreground_(in_foreground) {
+  RecordEvent(PAGE_LOAD_STARTED);
+}
 
 PageLoadTracker::~PageLoadTracker() {
+  // Even a load that failed a provisional load should log
+  // that it aborted before first layout.
+  if (timing_.first_layout.is_zero())
+    RecordEvent(PAGE_LOAD_ABORTED_BEFORE_FIRST_LAYOUT);
+
   if (has_commit_)
     RecordTimingHistograms();
 }
 
 void PageLoadTracker::WebContentsHidden() {
   // Only log the first time we background in a given page load.
   if (background_time_.is_null()) {
     background_time_ = base::TimeTicks::Now();
   }
 }
@@ skipping 45 matching lines @@
                           timing_.load_event_start);
     } else {
       PAGE_LOAD_HISTOGRAM("PageLoad.Timing2.NavigationToLoadEventFired.BG",
                           timing_.load_event_start);
     }
   }
   if (!timing_.first_layout.is_zero()) {
     if (timing_.first_layout < background_delta) {
       PAGE_LOAD_HISTOGRAM("PageLoad.Timing2.NavigationToFirstLayout",
                           timing_.first_layout);
+      RecordEvent(PAGE_LOAD_SUCCESSFUL_FIRST_LAYOUT_FOREGROUND);
     } else {
       PAGE_LOAD_HISTOGRAM("PageLoad.Timing2.NavigationToFirstLayout.BG",
                           timing_.first_layout);
+      RecordEvent(PAGE_LOAD_SUCCESSFUL_FIRST_LAYOUT_BACKGROUND);
     }
   }
+
+}
+
+void PageLoadTracker::RecordEvent(PageLoadEvent event) {
+  UMA_HISTOGRAM_ENUMERATION(
+      "PageLoad.EventCounts", event, PAGE_LOAD_LAST_ENTRY);
 }
 
 MetricsWebContentsObserver::MetricsWebContentsObserver(
     content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents), in_foreground_(false) {}
 
 MetricsWebContentsObserver::~MetricsWebContentsObserver() {}
 
 bool MetricsWebContentsObserver::OnMessageReceived(
     const IPC::Message& message,
@@ skipping 22 matching lines @@
 
 void MetricsWebContentsObserver::DidFinishNavigation(
     content::NavigationHandle* navigation_handle) {
   if (!navigation_handle->IsInMainFrame())
     return;
 
   scoped_ptr<PageLoadTracker> finished_nav(
       provisional_loads_.take_and_erase(navigation_handle));
   DCHECK(finished_nav);
 
-  // TODO(csharrison) handle the two error cases:
-  // 1. Error pages that replace the previous page.
-  // 2. Error pages that leave the user on the previous page.
-  // For now these cases will be ignored.
-  if (!navigation_handle->HasCommitted())
+  // Handle a pre-commit error here. Navigations that result in an error page
+  // will be ignored.
+  // TODO(csharrison) filter out error codes that shouldn't result in us logging
+  // an aborted provisional load.
+  if (!navigation_handle->HasCommitted()) {
+    finished_nav->RecordEvent(PAGE_LOAD_FAILED_BEFORE_COMMIT);
+    if (navigation_handle->GetNetErrorCode() == net::ERR_ABORTED)
+      finished_nav->RecordEvent(PAGE_LOAD_ABORTED_BEFORE_COMMIT);
     return;
+  }
 
   // Don't treat a same-page nav as a new page load.
   if (navigation_handle->IsSamePage())
     return;
 
   // Eagerly log the previous UMA even if we don't care about the current
   // navigation.
   committed_load_.reset();
 
   if (!IsRelevantNavigation(navigation_handle))
@@ skipping 51 matching lines @@
   // sure here that we aren't logging UMA for internal pages.
   const GURL& browser_url = web_contents()->GetLastCommittedURL();
   return navigation_handle->IsInMainFrame() &&
          !navigation_handle->IsSamePage() &&
          !navigation_handle->IsErrorPage() &&
          navigation_handle->GetURL().SchemeIsHTTPOrHTTPS() &&
          browser_url.SchemeIsHTTPOrHTTPS();
 }
 
 }  // namespace page_load_metrics