Bypassed Bytes UMAs

components/data_reduction_proxy/browser/data_reduction_proxy_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/browser/data_reduction_proxy_protocol.h"
 
 #include <utility>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_params_test_utils.h"
+#include "components/data_reduction_proxy/browser/data_reduction_proxy_usage_stats.h"
 #include "net/base/completion_callback.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/network_delegate.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_transaction_test_util.h"
 #include "net/socket/socket_test_util.h"
 #include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_test_util.h"
@@ skipping 18 matching lines @@
   std::replace(headers->begin(), headers->end(), '\n', '\0');
   if (!headers->empty())
     *headers += '\0';
 }
 
 } // namespace
 
 
 namespace data_reduction_proxy {
 
+// A test DataReductionUsageStats
+class TestDataReductionProxyUsageStats : public DataReductionProxyUsageStats {
+ public:
+  TestDataReductionProxyUsageStats() : DataReductionProxyUsageStats(NULL,

[bengr, 2014/07/12 00:11:59]

Can all the params fit on the same line as the first? If so, move. If not, move
all params to the second line.

[bengr, 2014/07/14 22:04:29]

Done.

+                                                                    NULL,
+                                                                    NULL) {}
+  virtual void SetBypassType(
+      net::ProxyService::DataReductionProxyBypassType type) OVERRIDE {}

[bengr, 2014/07/14 17:44:02]

I'd add a variable, e.g., set_bypass_type_called_count_, that counts the number
of times this method is called. Then in your tests you can do EXPECT_EQ(1,
set_bypass_type_called_count_)

[megjablon, 2014/07/14 19:06:41]

With moving the SetBypassType outside of MaybeBypassProxyAndPrepareToRetry, we
don't need this class to test anymore. 

+};
+
 // A test network delegate that exercises the bypass logic of the data
 // reduction proxy.
 class TestDataReductionProxyNetworkDelegate : public net::NetworkDelegate {
  public:
   TestDataReductionProxyNetworkDelegate(
-      TestDataReductionProxyParams* test_params)
-      : net::NetworkDelegate(), test_data_reduction_proxy_params_(test_params) {
+      TestDataReductionProxyParams* test_params,
+      TestDataReductionProxyUsageStats* usage_stats)
+      : net::NetworkDelegate(), test_data_reduction_proxy_params_(test_params),
+        test_data_reduction_proxy_usage_stats_(usage_stats) {
   }
 
   virtual int OnHeadersReceived(
       URLRequest* request,
       const net::CompletionCallback& callback,
       const HttpResponseHeaders* original_response_headers,
       scoped_refptr<HttpResponseHeaders>* override_response_headers,
       GURL* allowed_unsafe_redirect_url) OVERRIDE {
     data_reduction_proxy::MaybeBypassProxyAndPrepareToRetry(
         test_data_reduction_proxy_params_,
+        test_data_reduction_proxy_usage_stats_,
         request,
         original_response_headers,
         override_response_headers);
     return net::OK;
   }
 
   TestDataReductionProxyParams* test_data_reduction_proxy_params_;
+  DataReductionProxyUsageStats* test_data_reduction_proxy_usage_stats_;
 };
 
 // Constructs a |TestURLRequestContext| that uses a |MockSocketFactory| to
 // simulate requests and responses.
 class DataReductionProxyProtocolTest : public testing::Test {
  public:
   DataReductionProxyProtocolTest() : http_user_agent_settings_("", "") {
     proxy_params_.reset(
         new TestDataReductionProxyParams(
             DataReductionProxyParams::kAllowed |
             DataReductionProxyParams::kFallbackAllowed |
             DataReductionProxyParams::kPromoAllowed,
             TestDataReductionProxyParams::HAS_EVERYTHING &
             ~TestDataReductionProxyParams::HAS_DEV_ORIGIN));
+    usage_stats_.reset(new TestDataReductionProxyUsageStats());
   }
 
   // Sets up the |TestURLRequestContext| with the provided |ProxyService|.
   void ConfigureTestDependencies(ProxyService* proxy_service) {
     // Create a context with delayed initialization.
     context_.reset(new TestURLRequestContext(true));
 
     proxy_service_.reset(proxy_service);
     network_delegate_.reset(new TestDataReductionProxyNetworkDelegate(
-        proxy_params_.get()));
+        proxy_params_.get(), usage_stats_.get()));
 
     context_->set_client_socket_factory(&mock_socket_factory_);
     context_->set_proxy_service(proxy_service_.get());
     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_);
 
     context_->Init();
   }
@@ skipping 147 matching lines @@
       EXPECT_TRUE((*i).second.current_delay <= expected_max_duration);
     }
   }
 
  protected:
   base::MessageLoopForIO loop_;
 
   net::MockClientSocketFactory mock_socket_factory_;
   scoped_ptr<ProxyService> proxy_service_;
   scoped_ptr<TestDataReductionProxyParams> proxy_params_;
+  scoped_ptr<TestDataReductionProxyUsageStats> usage_stats_;
   scoped_ptr<TestDataReductionProxyNetworkDelegate> network_delegate_;
   net::StaticHttpUserAgentSettings http_user_agent_settings_;
 
   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 328 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