Bypassed Bytes UMAs

components/data_reduction_proxy/browser/data_reduction_proxy_metrics.cc

 // Copyright 2014 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/data_reduction_proxy/browser/data_reduction_proxy_metrics.h"
 
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_settings.h"
 #include "components/data_reduction_proxy/common/data_reduction_proxy_headers.h"
 #include "components/data_reduction_proxy/common/data_reduction_proxy_pref_names.h"
 #include "net/base/host_port_pair.h"
 #include "net/http/http_response_headers.h"
 #include "net/proxy/proxy_retry_info.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request_context.h"
 
 namespace data_reduction_proxy {
 
 namespace {
 
+#if defined(SPDY_PROXY_AUTH_ORIGIN)
 // A bypass delay more than this is treated as a long delay.
 const int kLongBypassDelayInSeconds = 30 * 60;
+#endif
 
 // Increments an int64, stored as a string, in a ListPref at the specified
 // index.  The value must already exist and be a string representation of a
 // number.
 void AddInt64ToListPref(size_t index,
                         int64 length,
                         base::ListValue* list_update) {
   int64 value = 0;
   std::string old_string_value;
   bool rv = list_update->GetString(index, &old_string_value);
@@ skipping 246 matching lines @@
   }
   int64 GetReceivedListPrefValue(size_t index) {
     return received_.GetListPrefValue(index);
   }
 
  private:
   DailyContentLengthUpdate original_;
   DailyContentLengthUpdate received_;
 };
 
-// Returns true if the request is bypassed by all configured data reduction
-// proxies. It returns the bypass delay in delay_seconds (if not NULL). If
-// the request is bypassed by more than one proxy, delay_seconds returns
-// shortest delay.
-bool IsBypassRequest(const net::URLRequest* request, int64* delay_seconds) {
-  // TODO(bengr): Add support for other data reduction proxy configurations.
-#if defined(SPDY_PROXY_AUTH_ORIGIN)
-  DataReductionProxyParams params(
-      DataReductionProxyParams::kAllowed |
-      DataReductionProxyParams::kFallbackAllowed |
-      DataReductionProxyParams::kPromoAllowed);
-  DataReductionProxyParams::DataReductionProxyList proxies =
-      params.GetAllowedProxies();
-  if (proxies.size() == 0)
-    return false;
-
-  if (request == NULL || request->context() == NULL ||
-      request->context()->proxy_service() == NULL) {
-    return false;
-  }
-
-  const net::ProxyRetryInfoMap& retry_map =
-      request->context()->proxy_service()->proxy_retry_info();
-  if (retry_map.size() == 0)
-    return false;
-
-  int64 shortest_delay = 0;
-  // The request is bypassed if all configured proxies are in the retry map.
-  for (size_t i = 0; i < proxies.size(); ++i) {
-    std::string proxy = net::HostPortPair::FromURL(proxies[i]).ToString();
-    // The retry list has the scheme prefix for https but not for http.
-    if (proxies[i].SchemeIs("https"))
-      proxy = std::string("https://") + proxy;
-
-    net::ProxyRetryInfoMap::const_iterator found = retry_map.find(proxy);
-    if (found == retry_map.end())
-      return false;
-    if (shortest_delay == 0 ||
-        shortest_delay > found->second.current_delay.InSeconds()) {
-      shortest_delay = found->second.current_delay.InSeconds();
-    }
-  }
-  if (delay_seconds != NULL)
-    *delay_seconds = shortest_delay;
-  return true;
-#else
-  return false;
-#endif
-}
-
 }  // namespace
 
 DataReductionProxyRequestType GetDataReductionProxyRequestType(
     const net::URLRequest* request) {
   if (request->url().SchemeIs("https"))
     return HTTPS;
   if (!request->url().SchemeIs("http")) {
     NOTREACHED();
     return UNKNOWN_TYPE;
   }
-  int64 bypass_delay = 0;
-  if (IsBypassRequest(request, &bypass_delay)) {
-    return (bypass_delay > kLongBypassDelayInSeconds) ?
-      LONG_BYPASS : SHORT_BYPASS;
+#if defined(SPDY_PROXY_AUTH_ORIGIN)
+  DataReductionProxyParams params(
+        DataReductionProxyParams::kAllowed |
+        DataReductionProxyParams::kFallbackAllowed |
+        DataReductionProxyParams::kPromoAllowed);
+  base::TimeDelta bypass_delay;
+  if (params.AreDataReductionProxiesBypassed(*request, &bypass_delay)) {
+    if (bypass_delay > base::TimeDelta::FromSeconds(kLongBypassDelayInSeconds))
+      return LONG_BYPASS;
+    return SHORT_BYPASS;
   }
+#endif
   if (request->response_info().headers &&
       HasDataReductionProxyViaHeader(request->response_info().headers)) {
     return VIA_DATA_REDUCTION_PROXY;
   }
   return UNKNOWN_TYPE;
 }
 
 int64 GetAdjustedOriginalContentLength(
     DataReductionProxyRequestType request_type,
     int64 original_content_length,
@@ skipping 166 matching lines @@
   UpdateContentLengthPrefsForDataReductionProxy(
       received_content_length,
       original_content_length,
       with_data_reduction_proxy_enabled,
       request_type,
       base::Time::Now(),
       prefs);
 }
 
 }  // namespace data_reduction_proxy