Fixing DataReductionProxy.BypassedBytes.LocalBypassRules

components/data_reduction_proxy/browser/data_reduction_proxy_usage_stats.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_usage_stats.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
@@ skipping 143 matching lines @@
 }
 
 void DataReductionProxyUsageStats::SetBypassType(
     DataReductionProxyBypassType type) {
   last_bypass_type_ = type;
   triggering_request_ = true;
 }
 
 void DataReductionProxyUsageStats::RecordBypassedBytesHistograms(
     net::URLRequest& request,
-    const BooleanPrefMember& data_reduction_proxy_enabled) {
+    const BooleanPrefMember& data_reduction_proxy_enabled,
+    const net::ProxyConfig& data_reduction_proxy_config) {
   int64 content_length = request.received_response_content_length();
+
+  if (!data_reduction_proxy_config.Equals(

[bengr, 2014/09/02 05:11:38]

Does this "Equals" do the right thing? E.g., what if the config IDs are
different? They will be even when both configs are for the data reduction proxy.

[megjablon, 2014/09/02 21:00:16]

Yes. This equals compares ignoring the differences in id and source.

+          request.context()->proxy_service()->config())) {
+    RecordBypassedBytes(last_bypass_type_,
+                        DataReductionProxyUsageStats::MANAGED_PROXY_CONFIG,
+                        content_length);
+    return;
+  }
+
   if (data_reduction_proxy_params_->WasDataReductionProxyUsed(&request, NULL)) {
     RecordBypassedBytes(last_bypass_type_,
                         DataReductionProxyUsageStats::NOT_BYPASSED,
                         content_length);
     return;
   }
 
   if (data_reduction_proxy_enabled.GetValue() &&
       request.url().SchemeIs(url::kHttpsScheme)) {
     RecordBypassedBytes(last_bypass_type_,
                         DataReductionProxyUsageStats::SSL,
                         content_length);
     return;
   }
 
   if (data_reduction_proxy_enabled.GetValue() &&
-      !data_reduction_proxy_params_->IsDataReductionProxyEligible(&request)) {
+      data_reduction_proxy_params_->IsBypassedByDataReductionProxyLocalRules(
+          request, data_reduction_proxy_config)) {
     RecordBypassedBytes(last_bypass_type_,
                         DataReductionProxyUsageStats::LOCAL_BYPASS_RULES,
                         content_length);
     return;
   }
 
   if (triggering_request_) {
-    RecordBypassedBytes(last_bypass_type_,
-                        DataReductionProxyUsageStats::TRIGGERING_REQUEST,
-                        content_length);
-    triggering_request_ = false;
-
     // We only record when audio or video triggers a bypass. We don't care
     // about audio and video bypassed as collateral damage.
     std::string mime_type;
     request.GetMimeType(&mime_type);
     // MIME types are named by <media-type>/<subtype>. We check to see if the
     // media type is audio or video.
     if (mime_type.compare(0, 6, "audio/") == 0  ||
         mime_type.compare(0, 6, "video/") == 0) {
       RecordBypassedBytes(last_bypass_type_,
                           DataReductionProxyUsageStats::AUDIO_VIDEO,
                           content_length);
+      return;
     }
+
+    RecordBypassedBytes(last_bypass_type_,
+                        DataReductionProxyUsageStats::TRIGGERING_REQUEST,
+                        content_length);
+    triggering_request_ = false;
+    return;
   }
 
   if (last_bypass_type_ != BYPASS_EVENT_TYPE_MAX) {
     RecordBypassedBytes(last_bypass_type_,
                         DataReductionProxyUsageStats::BYPASSED_BYTES_TYPE_MAX,
                         content_length);
     return;
   }
 
   if (data_reduction_proxy_params_->
@@ skipping 41 matching lines @@
       break;
     case DataReductionProxyUsageStats::SSL:
       UMA_HISTOGRAM_COUNTS(
           "DataReductionProxy.BypassedBytes.SSL", content_length);
       break;
     case DataReductionProxyUsageStats::LOCAL_BYPASS_RULES:
       UMA_HISTOGRAM_COUNTS(
           "DataReductionProxy.BypassedBytes.LocalBypassRules",
           content_length);
       break;
+    case DataReductionProxyUsageStats::MANAGED_PROXY_CONFIG:
+      UMA_HISTOGRAM_COUNTS(
+          "DataReductionProxy.BypassedBytes.ManagedProxyConfig",
+          content_length);
+      break;
     case DataReductionProxyUsageStats::AUDIO_VIDEO:
       if (last_bypass_type_ == BYPASS_EVENT_TYPE_SHORT) {
         UMA_HISTOGRAM_COUNTS(
             "DataReductionProxy.BypassedBytes.ShortAudioVideo",
             content_length);
       }
       break;
     case DataReductionProxyUsageStats::TRIGGERING_REQUEST:
       switch (bypass_type) {
         case BYPASS_EVENT_TYPE_SHORT:
@@ skipping 72 matching lines @@
         default:
           break;
       }
       break;
   }
 }
 
 }  // namespace data_reduction_proxy