Rename DataReductionProxyUsageStats to DataReductionProxyBypassStats

components/data_reduction_proxy/core/browser/data_reduction_proxy_bypass_protocol_unittest.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_bypass_protocol.h"
 
 #include <utility>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.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_test_utils.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_interceptor.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_test_utils.h"
-#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_usage_stats.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_headers.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_params_test_utils.h"
 #include "net/base/completion_callback.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_flags.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/network_delegate.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_transaction_test_util.h"
 #include "net/proxy/proxy_server.h"
@@ skipping 83 matching lines @@
     context_.reset(new TestURLRequestContext(true));
 
     proxy_service_.reset(proxy_service);
     context_->set_client_socket_factory(&mock_socket_factory_);
     context_->set_proxy_service(proxy_service_.get());
     network_delegate_.reset(new net::TestNetworkDelegate());
     context_->set_network_delegate(network_delegate_.get());
     // This is needed to prevent the test context from adding language headers
     // to requests.
     context_->set_http_user_agent_settings(&http_user_agent_settings_);
-    usage_stats_.reset(new DataReductionProxyUsageStats(
+    bypass_stats_.reset(new DataReductionProxyBypassStats(
         test_context_->config(),
         test_context_->unreachable_callback(),
         test_context_->task_runner()));
 
     DataReductionProxyInterceptor* interceptor =
         new DataReductionProxyInterceptor(test_context_->config(),
-                                          usage_stats_.get(),
+                                          bypass_stats_.get(),
                                           test_context_->event_store());
     scoped_ptr<net::URLRequestJobFactoryImpl> job_factory_impl(
         new net::URLRequestJobFactoryImpl());
     job_factory_.reset(new net::URLRequestInterceptingJobFactory(
         job_factory_impl.Pass(), make_scoped_ptr(interceptor)));
 
     context_->set_job_factory(job_factory_.get());
     context_->Init();
   }
 
@@ skipping 184 matching lines @@
   }
 
  protected:
   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
 
   scoped_ptr<net::URLRequestInterceptor> simple_interceptor_;
   net::MockClientSocketFactory mock_socket_factory_;
   scoped_ptr<net::TestNetworkDelegate> network_delegate_;
   scoped_ptr<ProxyService> proxy_service_;
   scoped_ptr<DataReductionProxyTestContext> test_context_;
-  scoped_ptr<DataReductionProxyUsageStats> usage_stats_;
+  scoped_ptr<DataReductionProxyBypassStats> bypass_stats_;
   net::StaticHttpUserAgentSettings http_user_agent_settings_;
 
   scoped_ptr<net::URLRequestInterceptingJobFactory> job_factory_;
   scoped_ptr<TestURLRequestContext> context_;
 };
 
 // Tests that request are deemed idempotent or not according to the method used.
 TEST_F(DataReductionProxyProtocolTest, TestIdempotency) {
   net::TestURLRequestContext context;
   const struct {
@@ skipping 408 matching lines @@
             primary, net::ProxyServer::SCHEME_HTTP).ToPacString() + "; " +
             net::ProxyServer::FromURI(
                 fallback,
                 net::ProxyServer::SCHEME_HTTP).ToPacString() + "; DIRECT"));
     TestProxyFallback(tests[i].method,
                       tests[i].first_response,
                       tests[i].expected_retry,
                       tests[i].generate_response_error,
                       tests[i].expected_bad_proxy_count,
                       tests[i].expect_response_body);
-    EXPECT_EQ(tests[i].expected_bypass_type, usage_stats_->GetBypassType());
+    EXPECT_EQ(tests[i].expected_bypass_type, bypass_stats_->GetBypassType());
     // We should also observe the bad proxy in the retry list.
     TestBadProxies(tests[i].expected_bad_proxy_count,
                    tests[i].expected_duration,
                    primary, fallback);
   }
 }
 
 TEST_F(DataReductionProxyProtocolTest,
        RelaxedMissingViaHeaderOtherBypassLogic) {
   std::string primary = test_context_->config()->test_params()->DefaultOrigin();
@@ skipping 14 matching lines @@
   // This response with the DRP via header should be accepted without causing a
   // bypass.
   TestProxyFallback("GET",
                     "HTTP/1.1 200 OK\r\n"
                     "Server: proxy\r\n"
                     "Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
                     false /* expected_retry */,
                     false /* generate_response_error */,
                     0u /* expected_bad_proxy_count */,
                     true /* expect_response_body */);
-  EXPECT_EQ(BYPASS_EVENT_TYPE_MAX, usage_stats_->GetBypassType());
+  EXPECT_EQ(BYPASS_EVENT_TYPE_MAX, bypass_stats_->GetBypassType());
   TestBadProxies(0u, -1, primary, fallback);
 
   // This non-4xx response without the DRP via header should not cause a bypass
   // because a DRP via header has been seen since the last network change.
   TestProxyFallback("GET",
                     "HTTP/1.1 200 OK\r\n\r\n",
                     false /* expected_retry */,
                     false /* generate_response_error */,
                     0u /* expected_bad_proxy_count */,
                     true /* expect_response_body */);
-  EXPECT_EQ(BYPASS_EVENT_TYPE_MAX, usage_stats_->GetBypassType());
+  EXPECT_EQ(BYPASS_EVENT_TYPE_MAX, bypass_stats_->GetBypassType());
   TestBadProxies(0u, -1, primary, fallback);
 
   // The first response after a network change is missing the DRP via header, so
   // this should cause a bypass.
   net::NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   test_context_->RunUntilIdle();
   TestProxyFallback("GET",
                     "HTTP/1.1 200 OK\r\n\r\n",
                     true /* expected_retry */,
                     false /* generate_response_error */,
                     1u /* expected_bad_proxy_count */,
                     true /* expect_response_body */);
   EXPECT_EQ(BYPASS_EVENT_TYPE_MISSING_VIA_HEADER_OTHER,
-            usage_stats_->GetBypassType());
+            bypass_stats_->GetBypassType());
   TestBadProxies(1u, 0, primary, fallback);
 }
 
 TEST_F(DataReductionProxyProtocolTest,
        ProxyBypassIgnoredOnDirectConnection) {
   // Verify that a Chrome-Proxy header is ignored when returned from a directly
   // connected origin server.
   ConfigureTestDependencies(ProxyService::CreateFixedFromPacResult("DIRECT"));
 
   MockRead data_reads[] = {
@@ skipping 27 matching lines @@
   EXPECT_EQ(net::URLRequestStatus::SUCCESS, r->status().status());
   EXPECT_EQ(net::OK, r->status().error());
 
   EXPECT_EQ("Bypass message", d.data_received());
 
   // We should have no entries in our bad proxy list.
   TestBadProxies(0, -1, "", "");
 }
 
 }  // namespace data_reduction_proxy