Rename DataReductionProxyUsageStats to DataReductionProxyBypassStats

components/data_reduction_proxy/core/browser/data_reduction_proxy_network_delegate.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/core/browser/data_reduction_proxy_network_delegate.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
+#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_bypass_stats.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_config.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_configurator.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_io_data.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_request_options.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_service.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_statistics_prefs.h"
-#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_usage_stats.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_params.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_server.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_status.h"
 
 namespace {
@@ skipping 49 matching lines @@
     scoped_ptr<net::NetworkDelegate> network_delegate,
     DataReductionProxyConfig* config,
     DataReductionProxyRequestOptions* request_options,
     const DataReductionProxyConfigurator* configurator)
     : LayeredNetworkDelegate(network_delegate.Pass()),
       ui_task_runner_(NULL),
       received_content_length_(0),
       original_content_length_(0),
       data_reduction_proxy_enabled_(NULL),
       data_reduction_proxy_config_(config),
-      data_reduction_proxy_usage_stats_(NULL),
+      data_reduction_proxy_bypass_stats_(NULL),
       data_reduction_proxy_request_options_(request_options),
       configurator_(configurator) {
   DCHECK(data_reduction_proxy_config_);
   DCHECK(data_reduction_proxy_request_options_);
 }
 
 DataReductionProxyNetworkDelegate::~DataReductionProxyNetworkDelegate() {
 }
 
 void DataReductionProxyNetworkDelegate::InitIODataAndUMA(
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
     DataReductionProxyIOData* io_data,
     BooleanPrefMember* data_reduction_proxy_enabled,
-    DataReductionProxyUsageStats* usage_stats) {
+    DataReductionProxyBypassStats* bypass_stats) {
   DCHECK(data_reduction_proxy_enabled);
-  DCHECK(usage_stats);
+  DCHECK(bypass_stats);
   ui_task_runner_ = ui_task_runner;
   data_reduction_proxy_io_data_ = io_data;
   data_reduction_proxy_enabled_ = data_reduction_proxy_enabled;
-  data_reduction_proxy_usage_stats_ = usage_stats;
+  data_reduction_proxy_bypass_stats_ = bypass_stats;
 }
 
 base::Value*
 DataReductionProxyNetworkDelegate::SessionNetworkStatsInfoToValue() const {
   base::DictionaryValue* dict = new base::DictionaryValue();
   // Use strings to avoid overflow. base::Value only supports 32-bit integers.
   dict->SetString("session_received_content_length",
                   base::Int64ToString(received_content_length_));
   dict->SetString("session_original_content_length",
                   base::Int64ToString(original_content_length_));
   return dict;
 }
 
 void DataReductionProxyNetworkDelegate::OnResolveProxyInternal(
     const GURL& url,
     int load_flags,
     const net::ProxyService& proxy_service,
     net::ProxyInfo* result) {
   if (configurator_) {
     OnResolveProxyHandler(
         url, load_flags, configurator_->GetProxyConfigOnIOThread(),
         proxy_service.proxy_retry_info(), data_reduction_proxy_config_, result);
   }
 }
 
 void DataReductionProxyNetworkDelegate::OnProxyFallbackInternal(
     const net::ProxyServer& bad_proxy,
     int net_error) {
-  if (data_reduction_proxy_usage_stats_) {
-    data_reduction_proxy_usage_stats_->OnProxyFallback(
+  if (data_reduction_proxy_bypass_stats_) {
+    data_reduction_proxy_bypass_stats_->OnProxyFallback(
         bad_proxy, net_error);
   }
 }
 
 void DataReductionProxyNetworkDelegate::OnBeforeSendProxyHeadersInternal(
     net::URLRequest* request,
     const net::ProxyInfo& proxy_info,
     net::HttpRequestHeaders* headers) {
   if (data_reduction_proxy_request_options_) {
     data_reduction_proxy_request_options_->MaybeAddRequestHeader(
         request, proxy_info.proxy_server(), headers);
   }
 }
 
 void DataReductionProxyNetworkDelegate::OnCompletedInternal(
     net::URLRequest* request,
     bool started) {
   DCHECK(request);
-  if (data_reduction_proxy_usage_stats_)
-    data_reduction_proxy_usage_stats_->OnUrlRequestCompleted(request, started);
+  if (data_reduction_proxy_bypass_stats_)
+    data_reduction_proxy_bypass_stats_->OnUrlRequestCompleted(request, started);
 
   // Only record for http or https urls.
   bool is_http = request->url().SchemeIs("http");
   bool is_https = request->url().SchemeIs("https");
 
   if (request->status().status() != net::URLRequestStatus::SUCCESS)
     return;
 
   // For better accuracy, we use the actual bytes read instead of the length
   // specified with the Content-Length header, which may be inaccurate,
@@ skipping 20 matching lines @@
                                          original_content_length,
                                          received_content_length);
     AccumulateContentLength(received_content_length,
                             adjusted_original_content_length,
                             request_type);
     RecordContentLengthHistograms(received_content_length,
                                   original_content_length,
                                   freshness_lifetime);
 
     if (data_reduction_proxy_enabled_ &&
-        data_reduction_proxy_usage_stats_) {
-      data_reduction_proxy_usage_stats_->RecordBytesHistograms(
+        data_reduction_proxy_bypass_stats_) {
+      data_reduction_proxy_bypass_stats_->RecordBytesHistograms(
           *request,
           *data_reduction_proxy_enabled_,
           configurator_->GetProxyConfigOnIOThread());
     }
     DVLOG(2) << __FUNCTION__
         << " received content length: " << received_content_length
         << " original content length: " << original_content_length
         << " url: " << request->url();
   }
 }
@@ skipping 76 matching lines @@
       DataReductionProxyParams::IsIncludedInCriticalPathBypassFieldTrial()) {
     if (!result->is_empty() && !result->is_direct() &&
         config->IsDataReductionProxy(result->proxy_server().host_port_pair(),
                                      NULL)) {
       result->RemoveProxiesWithoutScheme(net::ProxyServer::SCHEME_DIRECT);
     }
   }
 }
 
 }  // namespace data_reduction_proxy