Measure network error rates with and without data reduction proxy

chrome/browser/net/chrome_network_delegate.cc

 // Copyright (c) 2012 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/net/chrome_network_delegate.h"
 
 #include <stdlib.h>
 
 #include <vector>
 
 #include "base/base_paths.h"
 #include "base/debug/alias.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/debug/stack_trace.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
+#include "base/metrics/sparse_histogram.h"
 #include "base/metrics/user_metrics.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_member.h"
 #include "base/prefs/pref_service.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
@@ skipping 208 matching lines @@
     reason = DATA_URL;
   else if (target_url.SchemeIs(url::kHttpScheme))
     reason = HTTP_URL;
   base::debug::Alias(&reason);
   base::RecordAction(
       base::UserMetricsAction("Net.URLRequest_StartJob_InvalidReferrer"));
   base::debug::DumpWithoutCrashing();
   NOTREACHED();
 }
 
+// Determine whether the specified |request| is for a main frame resource. Used
+// for histograms.
+bool IsMainFrameResourceRequest(const net::URLRequest* request) {
+  const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
+  return info && info->GetResourceType() == content::RESOURCE_TYPE_MAIN_FRAME;
+}
+
+// Record network errors that requests complete with, including OK and ABORTED.
+void RecordNetworkErrorHistograms(const net::URLRequest* request) {
+  if (request->url().SchemeIs("http")) {
+    UMA_HISTOGRAM_SPARSE_SLOWLY("Net.HttpRequestCompletionErrorCodes",
+                                std::abs(request->status().error()));
+
+    if (IsMainFrameResourceRequest(request)) {
+      UMA_HISTOGRAM_SPARSE_SLOWLY(
+          "Net.HttpRequestCompletionErrorCodes.MainFrame",
+          std::abs(request->status().error()));
+    }
+  }
+}
+
 }  // namespace
 
 ChromeNetworkDelegate::ChromeNetworkDelegate(
     extensions::EventRouterForwarder* event_router,
     BooleanPrefMember* enable_referrers)
     : profile_(NULL),
       enable_referrers_(enable_referrers),
       enable_do_not_track_(NULL),
       force_safe_search_(NULL),
       force_google_safe_search_(NULL),
@@ skipping 286 matching lines @@
             "423948 ChromeNetworkDelegate::OnRawBytesRead2"));
 
     task_manager->model()->NotifyBytesRead(request, bytes_read);
   }
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ChromeNetworkDelegate::OnCompleted(net::URLRequest* request,
                                         bool started) {
   if (data_reduction_proxy_usage_stats_)
-    data_reduction_proxy_usage_stats_->OnUrlRequestCompleted(request, started);
+    data_reduction_proxy_usage_stats_->OnUrlRequestCompleted(

[bengr, 2014/12/09 23:44:13]

After megjablon@'s CL lands, this will be in DataReductionProxyNetworkDelegate.
Note that this, unlike ChromeNetworkDelegate, cannot depend on content.

[sclittle, 2014/12/10 00:05:03]

Darn. Being able to single out main frame resource loads from other requests
using the Net.ErrorCodesForMainFrame3 histogram has helped identify net errors
that are likely a problem for the DRP, so having them singled out here could be
quite helpful as well. There must be a way to plumb this information through,
even if it requires injecting a callback, or putting some stuff in
components/data_reduction_proxy/content.

How close is megjablon@'s CL to landing? Should I hold off on this CL so that
they can be integrated together more nicely?

+        request, started, IsMainFrameResourceRequest(request));
+
+  RecordNetworkErrorHistograms(request);
 
   TRACE_EVENT_ASYNC_END0("net", "URLRequest", request);
   if (request->status().status() == net::URLRequestStatus::SUCCESS) {
     // For better accuracy, we use the actual bytes read instead of the length
     // specified with the Content-Length header, which may be inaccurate,
     // or missing, as is the case with chunked encoding.
     int64 received_content_length = request->received_response_content_length();
 
 #if defined(OS_ANDROID)
     if (precache::PrecacheManager::IsPrecachingEnabled()) {
@@ skipping 269 matching lines @@
   if (data_reduction_proxy_statistics_prefs_) {
     StoreAccumulatedContentLength(received_content_length,
                                   original_content_length,
                                   request_type,
                                   reinterpret_cast<Profile*>(profile_),
                                   data_reduction_proxy_statistics_prefs_);
   }
   received_content_length_ += received_content_length;
   original_content_length_ += original_content_length;
 }