Bypassed Bytes UMAs

components/data_reduction_proxy/browser/data_reduction_proxy_protocol.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_protocol.h"
 
 #include "base/memory/ref_counted.h"
 #include "base/time/time.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_params.h"
 #include "components/data_reduction_proxy/common/data_reduction_proxy_headers.h"
@@ skipping 19 matching lines @@
                                        net::ProxyServer::SCHEME_HTTPS,
                                    net::HostPortPair::FromURL(gurl));
   return true;
 }
 
 }  // namespace
 
 namespace data_reduction_proxy {
 
 bool MaybeBypassProxyAndPrepareToRetry(
+    net::ProxyService::DataReductionProxyBypassType* proxy_bypass_type,

[bengr, 2014/07/16 01:40:10]

While you're here, reorder the parameters. Parameters that get modified go at
the end.

[megjablon, 2014/07/16 23:07:14]

Done.

     const DataReductionProxyParams* data_reduction_proxy_params,
     net::URLRequest* request,
     const net::HttpResponseHeaders* original_response_headers,
     scoped_refptr<net::HttpResponseHeaders>* override_response_headers) {
   if (!data_reduction_proxy_params)
     return false;
   std::pair<GURL, GURL> data_reduction_proxies;
   if (!data_reduction_proxy_params->WasDataReductionProxyUsed(
           request, &data_reduction_proxies)) {
     return false;
   }
 
   // Empty implies either that the request was served from cache or that
   // request was served directly from the origin.
   if (request->proxy_server().IsEmpty())
     return false;
 
   if (data_reduction_proxies.first.is_empty())
     return false;
 
   DataReductionProxyInfo data_reduction_proxy_info;
   net::ProxyService::DataReductionProxyBypassType bypass_type =
-      GetDataReductionProxyBypassType(
-          original_response_headers, &data_reduction_proxy_info);
+      GetDataReductionProxyBypassType(original_response_headers,
+                                      &data_reduction_proxy_info);
+  if(proxy_bypass_type)
+    *proxy_bypass_type = bypass_type;
   if (bypass_type == net::ProxyService::BYPASS_EVENT_TYPE_MAX) {
     return false;
   }
 
   DCHECK(request->context());
   DCHECK(request->context()->proxy_service());
   net::ProxyServer proxy_server;
   SetProxyServerFromGURL(data_reduction_proxies.first, &proxy_server);
   request->context()->proxy_service()->RecordDataReductionProxyBypassInfo(
       !data_reduction_proxies.second.is_empty(),
@@ skipping 90 matching lines @@
   net::ProxyService* proxy_service = request->context()->proxy_service();
   DCHECK(proxy_service);
 
   proxy_service->MarkProxiesAsBadUntil(proxy_info,
                                        bypass_duration,
                                        fallback,
                                        request->net_log());
 }
 
 }  // namespace data_reduction_proxy