Rename DataReductionProxyUsageStats to DataReductionProxyBypassStats

components/data_reduction_proxy/core/browser/data_reduction_proxy_bypass_stats_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_usage_stats.h"
+#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_bypass_stats.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/test/histogram_tester.h"
@@ skipping 34 matching lines @@
 namespace data_reduction_proxy {
 
 namespace {
 
 const std::string kBody = "hello";
 const std::string kNextBody = "hello again";
 const std::string kErrorBody = "bad";
 
 }  // namespace
 
-class DataReductionProxyUsageStatsTest : public testing::Test {
+class DataReductionProxyBypassStatsTest : public testing::Test {
  public:
-  DataReductionProxyUsageStatsTest()
-      : context_(true) {
+  DataReductionProxyBypassStatsTest() : context_(true) {
     context_.Init();
 
     // The |test_job_factory_| takes ownership of the interceptor.
     test_job_interceptor_ = new net::TestJobInterceptor();
     EXPECT_TRUE(test_job_factory_.SetProtocolHandler(url::kHttpScheme,
                                                      test_job_interceptor_));
 
     context_.set_job_factory(&test_job_factory_);
 
     test_context_ =
@@ skipping 30 matching lines @@
 
     EXPECT_TRUE(fake_request->response_headers() != NULL);
     return fake_request.Pass();
   }
 
   bool IsUnreachable() const {
     return test_context_->settings()->IsDataReductionProxyUnreachable();
   }
 
  protected:
-  scoped_ptr<DataReductionProxyUsageStats> BuildUsageStats() {
+  scoped_ptr<DataReductionProxyBypassStats> BuildBypassStats() {
     return make_scoped_ptr(
-        new DataReductionProxyUsageStats(
+        new DataReductionProxyBypassStats(
             test_context_->config(),
             test_context_->unreachable_callback(),
             test_context_->task_runner())).Pass();
   }
 
   net::URLRequest* url_request() {
     return mock_url_request_.get();
   }
 
   MockDataReductionProxyConfig* config() const {
     return test_context_->mock_config();
   }
 
   void RunUntilIdle() {
     test_context_->RunUntilIdle();
   }
 
  private:
   net::TestURLRequestContext context_;
   net::TestDelegate delegate_;
   scoped_ptr<net::URLRequest> mock_url_request_;
   // |test_job_interceptor_| is owned by |test_job_factory_|.
   net::TestJobInterceptor* test_job_interceptor_;
   net::URLRequestJobFactoryImpl test_job_factory_;
   scoped_ptr<DataReductionProxyTestContext> test_context_;
 };
 
-TEST_F(DataReductionProxyUsageStatsTest, IsDataReductionProxyUnreachable) {
+TEST_F(DataReductionProxyBypassStatsTest, IsDataReductionProxyUnreachable) {
   net::ProxyServer fallback_proxy_server =
       net::ProxyServer::FromURI("foo.com", net::ProxyServer::SCHEME_HTTP);
   data_reduction_proxy::DataReductionProxyTypeInfo proxy_info;
   struct TestCase {
     bool fallback_proxy_server_is_data_reduction_proxy;
     bool was_proxy_used;
     bool is_unreachable;
   };
   const TestCase test_cases[] = {
     {
@@ skipping 16 matching lines @@
       false,
       true
     }
   };
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     TestCase test_case = test_cases[i];
 
     EXPECT_CALL(*config(), IsDataReductionProxy(testing::_, testing::_))
         .WillRepeatedly(testing::Return(
             test_case.fallback_proxy_server_is_data_reduction_proxy));
-    EXPECT_CALL(*config(),
-                WasDataReductionProxyUsed(url_request(), testing::_))
+    EXPECT_CALL(*config(), WasDataReductionProxyUsed(url_request(), testing::_))
         .WillRepeatedly(testing::Return(test_case.was_proxy_used));
 
-    scoped_ptr<DataReductionProxyUsageStats> usage_stats = BuildUsageStats();
+    scoped_ptr<DataReductionProxyBypassStats> bypass_stats = BuildBypassStats();
 
-    usage_stats->OnProxyFallback(fallback_proxy_server,
-                                 net::ERR_PROXY_CONNECTION_FAILED);
-    usage_stats->OnUrlRequestCompleted(url_request(), false);
+    bypass_stats->OnProxyFallback(fallback_proxy_server,
+                                  net::ERR_PROXY_CONNECTION_FAILED);
+    bypass_stats->OnUrlRequestCompleted(url_request(), false);
     RunUntilIdle();
 
     EXPECT_EQ(test_case.is_unreachable, IsUnreachable());
   }
 }
 
-TEST_F(DataReductionProxyUsageStatsTest, ProxyUnreachableThenReachable) {
+TEST_F(DataReductionProxyBypassStatsTest, ProxyUnreachableThenReachable) {
   net::ProxyServer fallback_proxy_server =
       net::ProxyServer::FromURI("foo.com", net::ProxyServer::SCHEME_HTTP);
-  scoped_ptr<DataReductionProxyUsageStats> usage_stats = BuildUsageStats();
+  scoped_ptr<DataReductionProxyBypassStats> bypass_stats = BuildBypassStats();
   EXPECT_CALL(*config(), IsDataReductionProxy(testing::_, testing::_))
       .WillOnce(testing::Return(true));
-  EXPECT_CALL(*config(),
-              WasDataReductionProxyUsed(url_request(), testing::_))
+  EXPECT_CALL(*config(), WasDataReductionProxyUsed(url_request(), testing::_))
       .WillOnce(testing::Return(true));
 
   // proxy falls back
-  usage_stats->OnProxyFallback(fallback_proxy_server,
-                               net::ERR_PROXY_CONNECTION_FAILED);
+  bypass_stats->OnProxyFallback(fallback_proxy_server,
+                                net::ERR_PROXY_CONNECTION_FAILED);
   RunUntilIdle();
   EXPECT_TRUE(IsUnreachable());
 
   // proxy succeeds
-  usage_stats->OnUrlRequestCompleted(url_request(), false);
+  bypass_stats->OnUrlRequestCompleted(url_request(), false);
   RunUntilIdle();
   EXPECT_FALSE(IsUnreachable());
 }
 
-TEST_F(DataReductionProxyUsageStatsTest, ProxyReachableThenUnreachable) {
+TEST_F(DataReductionProxyBypassStatsTest, ProxyReachableThenUnreachable) {
   net::ProxyServer fallback_proxy_server =
       net::ProxyServer::FromURI("foo.com", net::ProxyServer::SCHEME_HTTP);
-  scoped_ptr<DataReductionProxyUsageStats> usage_stats = BuildUsageStats();
-  EXPECT_CALL(*config(),
-              WasDataReductionProxyUsed(url_request(), testing::_))
+  scoped_ptr<DataReductionProxyBypassStats> bypass_stats = BuildBypassStats();
+  EXPECT_CALL(*config(), WasDataReductionProxyUsed(url_request(), testing::_))
       .WillOnce(testing::Return(true));
   EXPECT_CALL(*config(), IsDataReductionProxy(testing::_, testing::_))
       .WillRepeatedly(testing::Return(true));
 
   // Proxy succeeds.
-  usage_stats->OnUrlRequestCompleted(url_request(), false);
+  bypass_stats->OnUrlRequestCompleted(url_request(), false);
   RunUntilIdle();
   EXPECT_FALSE(IsUnreachable());
 
   // Then proxy falls back indefinitely.
-  usage_stats->OnProxyFallback(fallback_proxy_server,
-                               net::ERR_PROXY_CONNECTION_FAILED);
-  usage_stats->OnProxyFallback(fallback_proxy_server,
-                               net::ERR_PROXY_CONNECTION_FAILED);
-  usage_stats->OnProxyFallback(fallback_proxy_server,
-                               net::ERR_PROXY_CONNECTION_FAILED);
-  usage_stats->OnProxyFallback(fallback_proxy_server,
-                               net::ERR_PROXY_CONNECTION_FAILED);
+  bypass_stats->OnProxyFallback(fallback_proxy_server,
+                                net::ERR_PROXY_CONNECTION_FAILED);
+  bypass_stats->OnProxyFallback(fallback_proxy_server,
+                                net::ERR_PROXY_CONNECTION_FAILED);
+  bypass_stats->OnProxyFallback(fallback_proxy_server,
+                                net::ERR_PROXY_CONNECTION_FAILED);
+  bypass_stats->OnProxyFallback(fallback_proxy_server,
+                                net::ERR_PROXY_CONNECTION_FAILED);
   RunUntilIdle();
   EXPECT_TRUE(IsUnreachable());
 }
 
-TEST_F(DataReductionProxyUsageStatsTest,
+TEST_F(DataReductionProxyBypassStatsTest,
        DetectAndRecordMissingViaHeaderResponseCode) {
   const std::string kPrimaryHistogramName =
       "DataReductionProxy.MissingViaHeader.ResponseCode.Primary";
   const std::string kFallbackHistogramName =
       "DataReductionProxy.MissingViaHeader.ResponseCode.Fallback";
 
   struct TestCase {
     bool is_primary;
     const char* headers;
     int expected_primary_sample;   // -1 indicates no expected sample.
@@ skipping 52 matching lines @@
     }
   };
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     base::HistogramTester histogram_tester;
     std::string raw_headers(test_cases[i].headers);
     HeadersToRaw(&raw_headers);
     scoped_refptr<net::HttpResponseHeaders> headers(
         new net::HttpResponseHeaders(raw_headers));
 
-    DataReductionProxyUsageStats::DetectAndRecordMissingViaHeaderResponseCode(
+    DataReductionProxyBypassStats::DetectAndRecordMissingViaHeaderResponseCode(
         test_cases[i].is_primary, headers.get());
 
     if (test_cases[i].expected_primary_sample == -1) {
       histogram_tester.ExpectTotalCount(kPrimaryHistogramName, 0);
     } else {
       histogram_tester.ExpectUniqueSample(
           kPrimaryHistogramName, test_cases[i].expected_primary_sample, 1);
     }
 
     if (test_cases[i].expected_fallback_sample == -1) {
       histogram_tester.ExpectTotalCount(kFallbackHistogramName, 0);
     } else {
       histogram_tester.ExpectUniqueSample(
           kFallbackHistogramName, test_cases[i].expected_fallback_sample, 1);
     }
   }
 }
 
-TEST_F(DataReductionProxyUsageStatsTest, RecordMissingViaHeaderBytes) {
+TEST_F(DataReductionProxyBypassStatsTest, RecordMissingViaHeaderBytes) {
   const std::string k4xxHistogramName =
       "DataReductionProxy.MissingViaHeader.Bytes.4xx";
   const std::string kOtherHistogramName =
       "DataReductionProxy.MissingViaHeader.Bytes.Other";
   const int64 kResponseContentLength = 100;
 
   struct TestCase {
     bool was_proxy_used;
     const char* headers;
     bool is_4xx_sample_expected;
@@ skipping 65 matching lines @@
     {
       true,
       "HTTP/1.1 500 Internal Server Error\n",
       false,
       true
     }
   };
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     base::HistogramTester histogram_tester;
-    scoped_ptr<DataReductionProxyUsageStats> usage_stats = BuildUsageStats();
+    scoped_ptr<DataReductionProxyBypassStats> bypass_stats = BuildBypassStats();
 
     std::string raw_headers(test_cases[i].headers);
     HeadersToRaw(&raw_headers);
 
     scoped_ptr<net::URLRequest> fake_request(
         CreateURLRequestWithResponseHeaders(GURL("http://www.google.com/"),
                                             raw_headers));
     fake_request->set_received_response_content_length(kResponseContentLength);
 
     EXPECT_CALL(*config(),
                 WasDataReductionProxyUsed(fake_request.get(), testing::_))
         .WillRepeatedly(Return(test_cases[i].was_proxy_used));
 
-    usage_stats->RecordMissingViaHeaderBytes(*fake_request);
+    bypass_stats->RecordMissingViaHeaderBytes(*fake_request);
 
     if (test_cases[i].is_4xx_sample_expected) {
       histogram_tester.ExpectUniqueSample(k4xxHistogramName,
                                           kResponseContentLength, 1);
     } else {
       histogram_tester.ExpectTotalCount(k4xxHistogramName, 0);
     }
 
     if (test_cases[i].is_other_sample_expected) {
       histogram_tester.ExpectUniqueSample(kOtherHistogramName,
                                           kResponseContentLength, 1);
     } else {
       histogram_tester.ExpectTotalCount(kOtherHistogramName, 0);
     }
   }
 }
 
-TEST_F(DataReductionProxyUsageStatsTest, RequestCompletionErrorCodes) {
+TEST_F(DataReductionProxyBypassStatsTest, RequestCompletionErrorCodes) {
   const std::string kPrimaryHistogramName =
       "DataReductionProxy.RequestCompletionErrorCodes.Primary";
   const std::string kFallbackHistogramName =
       "DataReductionProxy.RequestCompletionErrorCodes.Fallback";
   const std::string kPrimaryMainFrameHistogramName =
       "DataReductionProxy.RequestCompletionErrorCodes.MainFrame.Primary";
   const std::string kFallbackMainFrameHistogramName =
       "DataReductionProxy.RequestCompletionErrorCodes.MainFrame.Fallback";
 
   struct TestCase {
     bool was_proxy_used;
     bool is_load_bypass_proxy;
     bool is_fallback;
     bool is_main_frame;
     net::Error net_error;
   };
 
   const TestCase test_cases[] = {
-    {false, true, false, true, net::OK},
-    {false, true, false, false, net::ERR_TOO_MANY_REDIRECTS},
-    {false, false, false, true, net::OK},
-    {false, false, false, false, net::ERR_TOO_MANY_REDIRECTS},
-    {true, false, false, true, net::OK},
-    {true, false, false, true, net::ERR_TOO_MANY_REDIRECTS},
-    {true, false, false, false, net::OK},
-    {true, false, false, false, net::ERR_TOO_MANY_REDIRECTS},
-    {true, false, true, true, net::OK},
-    {true, false, true, true, net::ERR_TOO_MANY_REDIRECTS},
-    {true, false, true, false, net::OK},
-    {true, false, true, false, net::ERR_TOO_MANY_REDIRECTS}
+    { false, true, false, true, net::OK },
+    { false, true, false, false, net::ERR_TOO_MANY_REDIRECTS },
+    { false, false, false, true, net::OK },
+    { false, false, false, false, net::ERR_TOO_MANY_REDIRECTS },
+    { true, false, false, true, net::OK },
+    { true, false, false, true, net::ERR_TOO_MANY_REDIRECTS },
+    { true, false, false, false, net::OK },
+    { true, false, false, false, net::ERR_TOO_MANY_REDIRECTS },
+    { true, false, true, true, net::OK },
+    { true, false, true, true, net::ERR_TOO_MANY_REDIRECTS },
+    { true, false, true, false, net::OK },
+    { true, false, true, false, net::ERR_TOO_MANY_REDIRECTS }
   };
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     base::HistogramTester histogram_tester;
-    scoped_ptr<DataReductionProxyUsageStats> usage_stats = BuildUsageStats();
+    scoped_ptr<DataReductionProxyBypassStats> bypass_stats = BuildBypassStats();
 
     std::string raw_headers("HTTP/1.1 200 OK\n"
                             "Via: 1.1 Chrome-Compression-Proxy\n");
     HeadersToRaw(&raw_headers);
     scoped_ptr<net::URLRequest> fake_request(
         CreateURLRequestWithResponseHeaders(GURL("http://www.google.com/"),
                                             raw_headers));
     if (test_cases[i].is_load_bypass_proxy) {
       fake_request->SetLoadFlags(fake_request->load_flags() |
                                  net::LOAD_BYPASS_PROXY);
     }
     if (test_cases[i].is_main_frame) {
       fake_request->SetLoadFlags(fake_request->load_flags() |
                                  net::LOAD_MAIN_FRAME);
     }
 
     int net_error_int = static_cast<int>(test_cases[i].net_error);
     if (test_cases[i].net_error != net::OK) {
       fake_request->CancelWithError(net_error_int);
     }
 
     DataReductionProxyTypeInfo proxy_info;
     proxy_info.is_fallback = test_cases[i].is_fallback;
     EXPECT_CALL(*config(), WasDataReductionProxyUsed(fake_request.get(),
                                                      testing::NotNull()))
         .WillRepeatedly(testing::DoAll(testing::SetArgPointee<1>(proxy_info),
                                        Return(test_cases[i].was_proxy_used)));
 
-    usage_stats->OnUrlRequestCompleted(fake_request.get(), false);
+    bypass_stats->OnUrlRequestCompleted(fake_request.get(), false);
 
     if (test_cases[i].was_proxy_used && !test_cases[i].is_load_bypass_proxy &&
         !test_cases[i].is_fallback) {
       histogram_tester.ExpectUniqueSample(
           kPrimaryHistogramName, -net_error_int, 1);
     } else {
       histogram_tester.ExpectTotalCount(kPrimaryHistogramName, 0);
     }
     if (test_cases[i].was_proxy_used && !test_cases[i].is_load_bypass_proxy &&
         test_cases[i].is_fallback) {
@@ skipping 13 matching lines @@
         test_cases[i].is_fallback && test_cases[i].is_main_frame) {
       histogram_tester.ExpectUniqueSample(
           kFallbackMainFrameHistogramName, -net_error_int, 1);
     } else {
       histogram_tester.ExpectTotalCount(kFallbackMainFrameHistogramName, 0);
     }
   }
 }
 
 // End-to-end tests for the DataReductionProxy.BypassedBytes histograms.
-class DataReductionProxyUsageStatsEndToEndTest : public testing::Test {
+class DataReductionProxyBypassStatsEndToEndTest : public testing::Test {
  public:
-  DataReductionProxyUsageStatsEndToEndTest()
+  DataReductionProxyBypassStatsEndToEndTest()
       : context_(true), context_storage_(&context_) {}
 
-  ~DataReductionProxyUsageStatsEndToEndTest() override {
+  ~DataReductionProxyBypassStatsEndToEndTest() override {
     drp_test_context_->io_data()->ShutdownOnUIThread();
     drp_test_context_->RunUntilIdle();
   }
 
   void SetUp() override {
     // Only use the primary data reduction proxy in order to make it easier to
     // test bypassed bytes due to proxy fallbacks. This way, a test just needs
     // to cause one proxy fallback in order for the data reduction proxy to be
     // fully bypassed.
     drp_test_context_ =
@@ skipping 137 matching lines @@
   }
 
  private:
   net::TestDelegate delegate_;
   net::MockClientSocketFactory mock_socket_factory_;
   net::TestURLRequestContext context_;
   net::URLRequestContextStorage context_storage_;
   scoped_ptr<DataReductionProxyTestContext> drp_test_context_;
 };
 
-TEST_F(DataReductionProxyUsageStatsEndToEndTest, BypassedBytesNoRetry) {
+TEST_F(DataReductionProxyBypassStatsEndToEndTest, BypassedBytesNoRetry) {
   struct TestCase {
     GURL url;
     const char* histogram_name;
     const char* initial_response_headers;
   };
   const TestCase test_cases[] = {
     { GURL("http://foo.com"),
       "DataReductionProxy.BypassedBytes.NotBypassed",
       "HTTP/1.1 200 OK\r\n"
       "Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
@@ skipping 15 matching lines @@
     CreateAndExecuteRequest(test_case.url, test_case.initial_response_headers,
                             kBody.c_str(), nullptr, nullptr);
 
     histogram_tester.ExpectUniqueSample(test_case.histogram_name, kBody.size(),
                                         1);
     ExpectOtherBypassedBytesHistogramsEmpty(histogram_tester,
                                             test_case.histogram_name);
   }
 }
 
-TEST_F(DataReductionProxyUsageStatsEndToEndTest, BypassedBytesProxyOverridden) {
+TEST_F(DataReductionProxyBypassStatsEndToEndTest,
+       BypassedBytesProxyOverridden) {
   scoped_ptr<net::ProxyService> proxy_service(
       net::ProxyService::CreateFixed("http://test.com:80"));
   set_proxy_service(proxy_service.get());
   InitializeContext();
 
   base::HistogramTester histogram_tester;
   CreateAndExecuteRequest(GURL("http://foo.com"), "HTTP/1.1 200 OK\r\n\r\n",
                           kBody.c_str(), nullptr, nullptr);
 
   histogram_tester.ExpectUniqueSample(
       "DataReductionProxy.BypassedBytes.ProxyOverridden", kBody.size(), 1);
   ExpectOtherBypassedBytesHistogramsEmpty(
       histogram_tester, "DataReductionProxy.BypassedBytes.ProxyOverridden");
 }
 
-TEST_F(DataReductionProxyUsageStatsEndToEndTest, BypassedBytesCurrent) {
+TEST_F(DataReductionProxyBypassStatsEndToEndTest, BypassedBytesCurrent) {
   InitializeContext();
   base::HistogramTester histogram_tester;
   CreateAndExecuteRequest(GURL("http://foo.com"),
                           "HTTP/1.1 502 Bad Gateway\r\n"
                           "Via: 1.1 Chrome-Compression-Proxy\r\n"
                           "Chrome-Proxy: block-once\r\n\r\n",
                           kErrorBody.c_str(), "HTTP/1.1 200 OK\r\n\r\n",
                           kBody.c_str());
 
   histogram_tester.ExpectUniqueSample(
       "DataReductionProxy.BypassedBytes.Current", kBody.size(), 1);
   ExpectOtherBypassedBytesHistogramsEmpty(
       histogram_tester, "DataReductionProxy.BypassedBytes.Current");
 }
 
-TEST_F(DataReductionProxyUsageStatsEndToEndTest, BypassedBytesShortAudioVideo) {
+TEST_F(DataReductionProxyBypassStatsEndToEndTest,
+       BypassedBytesShortAudioVideo) {
   InitializeContext();
   base::HistogramTester histogram_tester;
   CreateAndExecuteRequest(GURL("http://foo.com"),
                           "HTTP/1.1 502 Bad Gateway\r\n"
                           "Via: 1.1 Chrome-Compression-Proxy\r\n"
                           "Chrome-Proxy: block=1\r\n\r\n",
                           kErrorBody.c_str(),
                           "HTTP/1.1 200 OK\r\n"
                           "Content-Type: video/mp4\r\n\r\n",
                           kBody.c_str());
 
   histogram_tester.ExpectUniqueSample(
       "DataReductionProxy.BypassedBytes.ShortAudioVideo", kBody.size(), 1);
   ExpectOtherBypassedBytesHistogramsEmpty(
       histogram_tester, "DataReductionProxy.BypassedBytes.ShortAudioVideo");
 }
 
-TEST_F(DataReductionProxyUsageStatsEndToEndTest, BypassedBytesExplicitBypass) {
+TEST_F(DataReductionProxyBypassStatsEndToEndTest, BypassedBytesExplicitBypass) {
   struct TestCase {
     const char* triggering_histogram_name;
     const char* all_histogram_name;
     const char* initial_response_headers;
   };
   const TestCase test_cases[] = {
     { "DataReductionProxy.BypassedBytes.ShortTriggeringRequest",
       "DataReductionProxy.BypassedBytes.ShortAll",
       "HTTP/1.1 502 Bad Gateway\r\n"
       "Via: 1.1 Chrome-Compression-Proxy\r\n"
@@ skipping 29 matching lines @@
     histogram_tester.ExpectUniqueSample(test_case.triggering_histogram_name,
                                         kBody.size(), 1);
     histogram_tester.ExpectUniqueSample(test_case.all_histogram_name,
                                         kNextBody.size(), 1);
     ExpectOtherBypassedBytesHistogramsEmpty(histogram_tester,
                                             test_case.triggering_histogram_name,
                                             test_case.all_histogram_name);
   }
 }
 
-TEST_F(DataReductionProxyUsageStatsEndToEndTest,
+TEST_F(DataReductionProxyBypassStatsEndToEndTest,
        BypassedBytesClientSideFallback) {
   struct TestCase {
     const char* histogram_name;
     const char* initial_response_headers;
   };
   const TestCase test_cases[] = {
     { "DataReductionProxy.BypassedBytes.MissingViaHeader4xx",
       "HTTP/1.1 414 Request-URI Too Long\r\n\r\n",
     },
     { "DataReductionProxy.BypassedBytes.MissingViaHeaderOther",
@@ skipping 29 matching lines @@
     histogram_tester.ExpectTotalCount(test_case.histogram_name, 2);
     histogram_tester.ExpectBucketCount(test_case.histogram_name, kBody.size(),
                                        1);
     histogram_tester.ExpectBucketCount(test_case.histogram_name,
                                        kNextBody.size(), 1);
     ExpectOtherBypassedBytesHistogramsEmpty(histogram_tester,
                                             test_case.histogram_name);
   }
 }
 
-TEST_F(DataReductionProxyUsageStatsEndToEndTest, BypassedBytesNetErrorOther) {
+TEST_F(DataReductionProxyBypassStatsEndToEndTest, BypassedBytesNetErrorOther) {
   // Make the data reduction proxy host fail to resolve.
   scoped_ptr<net::MockHostResolver> host_resolver(new net::MockHostResolver());
   host_resolver->rules()->AddSimulatedFailure(
       config()->test_params()->origin().host_port_pair().host());
   set_host_resolver(host_resolver.get());
   InitializeContext();
 
   base::HistogramTester histogram_tester;
   CreateAndExecuteRequest(GURL("http://foo.com"), "HTTP/1.1 200 OK\r\n\r\n",
                           kBody.c_str(), nullptr, nullptr);
 
   histogram_tester.ExpectUniqueSample(
       "DataReductionProxy.BypassedBytes.NetworkErrorOther", kBody.size(), 1);
   ExpectOtherBypassedBytesHistogramsEmpty(
       histogram_tester, "DataReductionProxy.BypassedBytes.NetworkErrorOther");
   histogram_tester.ExpectUniqueSample(
       "DataReductionProxy.BypassOnNetworkErrorPrimary",
       -net::ERR_PROXY_CONNECTION_FAILED, 1);
 }
 
 }  // namespace data_reduction_proxy