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"
@@ skipping 39 matching lines @@
 } // namespace
 
 
 namespace data_reduction_proxy {
 
 // 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,
+      ProxyService::DataReductionProxyBypassType* bypass_type)
+      : net::NetworkDelegate(), test_data_reduction_proxy_params_(test_params),

[bengr, 2014/07/19 00:13:01]

move test_data... to the next line

[megjablon, 2014/07/21 19:44:45]

Done.

+        bypass_type_(bypass_type) {
   }
 
   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_,
         request,
         original_response_headers,
-        override_response_headers);
+        override_response_headers,
+        bypass_type_);
     return net::OK;
   }
 
   TestDataReductionProxyParams* test_data_reduction_proxy_params_;
+  ProxyService::DataReductionProxyBypassType* bypass_type_;
 };
 
 // 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));
   }
 
   // Sets up the |TestURLRequestContext| with the provided |ProxyService|.
-  void ConfigureTestDependencies(ProxyService* proxy_service) {
+  void ConfigureTestDependencies(
+      ProxyService* proxy_service,
+      ProxyService::DataReductionProxyBypassType* bypass_type) {
     // 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(), bypass_type));
 
     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 239 matching lines @@
 // was indicated. In both the single and double bypass cases, if the request
 // was idempotent, it will be retried over a direct connection.
 TEST_F(DataReductionProxyProtocolTest, BypassLogic) {
   const struct {
     const char* method;
     const char* first_response;
     bool expected_retry;
     size_t expected_bad_proxy_count;
     bool expect_response_body;
     int expected_duration;
+    ProxyService::DataReductionProxyBypassType expected_bypass_type;
   } tests[] = {
     // Valid data reduction proxy response with no bypass message.
     { "GET",
       "HTTP/1.1 200 OK\r\n"
       "Server: proxy\r\n"
       "Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
       false,
       0u,
       true,
-      -1
+      -1,
+      ProxyService::BYPASS_EVENT_TYPE_MAX,
     },
     // Valid data reduction proxy response with older, but still valid via
     // header.
     { "GET",
       "HTTP/1.1 200 OK\r\n"
       "Server: proxy\r\n"
       "Via: 1.1 Chrome Compression Proxy\r\n\r\n",
       false,
       0u,
       true,
-      -1
+      -1,
+      ProxyService::BYPASS_EVENT_TYPE_MAX
     },
     // Valid data reduction proxy response with chained via header,
     // no bypass message.
     { "GET",
       "HTTP/1.1 200 OK\r\n"
       "Server: proxy\r\n"
       "Via: 1.1 Chrome-Compression-Proxy, 1.0 some-other-proxy\r\n\r\n",
       false,
       0u,
       true,
-      -1
+      -1,
+      ProxyService::BYPASS_EVENT_TYPE_MAX
     },
     // Valid data reduction proxy response with a bypass message.
     { "GET",
       "HTTP/1.1 200 OK\r\n"
       "Server: proxy\r\n"
       "Chrome-Proxy: bypass=0\r\n"
       "Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
       true,
       1u,
       true,
-      0
+      0,
+      ProxyService::MEDIUM_BYPASS
     },
     // Valid data reduction proxy response with a bypass message.
     { "GET",
       "HTTP/1.1 200 OK\r\n"
       "Server: proxy\r\n"
       "Chrome-Proxy: bypass=1\r\n"
       "Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
       true,
       1u,
       true,
-      1
+      1,
+      ProxyService::SHORT_BYPASS
     },
     // Same as above with the OPTIONS method, which is idempotent.
     { "OPTIONS",
       "HTTP/1.1 200 OK\r\n"
       "Server: proxy\r\n"
       "Chrome-Proxy: bypass=0\r\n"
       "Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
       true,
       1u,
       true,
-      0
+      0,
+      ProxyService::MEDIUM_BYPASS
     },
     // Same as above with the HEAD method, which is idempotent.
     { "HEAD",
       "HTTP/1.1 200 OK\r\n"
       "Server: proxy\r\n"
       "Chrome-Proxy: bypass=0\r\n"
       "Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
       true,
       1u,
       false,
-      0
+      0,
+      ProxyService::MEDIUM_BYPASS
     },
     // Same as above with the PUT method, which is idempotent.
     { "PUT",
       "HTTP/1.1 200 OK\r\n"
       "Server: proxy\r\n"
       "Chrome-Proxy: bypass=0\r\n"
       "Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
       true,
       1u,
       true,
-      0
+      0,
+      ProxyService::MEDIUM_BYPASS
     },
     // Same as above with the DELETE method, which is idempotent.
     { "DELETE",
       "HTTP/1.1 200 OK\r\n"
       "Server: proxy\r\n"
       "Chrome-Proxy: bypass=0\r\n"
       "Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
       true,
       1u,
       true,
-      0
+      0,
+      ProxyService::MEDIUM_BYPASS
     },
     // Same as above with the TRACE method, which is idempotent.
     { "TRACE",
       "HTTP/1.1 200 OK\r\n"
       "Server: proxy\r\n"
       "Chrome-Proxy: bypass=0\r\n"
       "Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
       true,
       1u,
       true,
-      0
+      0,
+      ProxyService::MEDIUM_BYPASS
     },
     // 500 responses should be bypassed.
     { "GET",
       "HTTP/1.1 500 Internal Server Error\r\n"
       "Server: proxy\r\n"
       "Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
       true,
       1u,
       true,
-      0
+      0,
+      ProxyService::STATUS_500_HTTP_INTERNAL_SERVER_ERROR
     },
     // 502 responses should be bypassed.
     { "GET",
       "HTTP/1.1 502 Internal Server Error\r\n"
       "Server: proxy\r\n"
       "Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
       true,
       1u,
       true,
-      0
+      0,
+      ProxyService::STATUS_502_HTTP_BAD_GATEWAY
     },
     // 503 responses should be bypassed.
     { "GET",
       "HTTP/1.1 503 Internal Server Error\r\n"
       "Server: proxy\r\n"
       "Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
       true,
       1u,
       true,
-      0
+      0,
+      ProxyService::STATUS_503_HTTP_SERVICE_UNAVAILABLE
     },
     // Invalid data reduction proxy response. Missing Via header.
     { "GET",
       "HTTP/1.1 200 OK\r\n"
       "Server: proxy\r\n\r\n",
       true,
       1u,
       true,
-      0
+      0,
+      ProxyService::MISSING_VIA_HEADER_OTHER
     },
     // Invalid data reduction proxy response. Wrong Via header.
     { "GET",
       "HTTP/1.1 200 OK\r\n"
       "Server: proxy\r\n"
       "Via: 1.0 some-other-proxy\r\n\r\n",
       true,
       1u,
       true,
-      0
+      0,
+      ProxyService::MISSING_VIA_HEADER_OTHER
     },
     // Valid data reduction proxy response. 304 missing Via header.
     { "GET",
       "HTTP/1.1 304 Not Modified\r\n"
       "Server: proxy\r\n\r\n",
       false,
       0u,
       false,
-      0
+      0,
+      ProxyService::BYPASS_EVENT_TYPE_MAX
     },
     // Valid data reduction proxy response with a bypass message. It will
     // not be retried because the request is non-idempotent.
     { "POST",
       "HTTP/1.1 200 OK\r\n"
       "Server: proxy\r\n"
       "Chrome-Proxy: bypass=0\r\n"
       "Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
       false,
       1u,
       true,
-      0
+      0,
+      ProxyService::MEDIUM_BYPASS
     },
     // Valid data reduction proxy response with block message. Both proxies
     // should be on the retry list when it completes.
     { "GET",
       "HTTP/1.1 200 OK\r\n"
       "Server: proxy\r\n"
       "Chrome-Proxy: block=1\r\n"
       "Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
       true,
       2u,
       true,
-      1
+      1,
+      ProxyService::SHORT_BYPASS
     }
   };
   std::string primary = proxy_params_->DefaultOrigin();
   std::string fallback = proxy_params_->DefaultFallbackOrigin();
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+    ProxyService::DataReductionProxyBypassType bypass_type;
     ConfigureTestDependencies(ProxyService::CreateFixedFromPacResult(
         "PROXY " +
         HostPortPair::FromURL(GURL(primary)).ToString() + "; PROXY " +
-        HostPortPair::FromURL(GURL(fallback)).ToString() + "; DIRECT"));
+        HostPortPair::FromURL(GURL(fallback)).ToString() + "; DIRECT"),
+        &bypass_type);
     TestProxyFallback(tests[i].method,
                       tests[i].first_response,
                       tests[i].expected_retry,
                       tests[i].expect_response_body);
 
+    EXPECT_EQ(tests[i].expected_bypass_type, bypass_type);
+
     // 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,
        ProxyBypassIgnoredOnDirectConnection) {
   // Verify that a Chrome-Proxy header is ignored when returned from a directly
   // connected origin server.
-  ConfigureTestDependencies(ProxyService::CreateFixedFromPacResult("DIRECT"));
+  ConfigureTestDependencies(ProxyService::CreateFixedFromPacResult("DIRECT"),
+                            NULL);
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"
              "Chrome-Proxy: bypass=0\r\n\r\n"),
     MockRead("Bypass message"),
     MockRead(net::SYNCHRONOUS, net::OK),
   };
   MockWrite data_writes[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
@@ skipping 95 matching lines @@
   load_flags |= net::LOAD_BYPASS_DATA_REDUCTION_PROXY;
 
   OnResolveProxyHandler(url, load_flags, &test_params, &info2);
   EXPECT_FALSE(info2.is_direct());
 
   OnResolveProxyHandler(url, load_flags, &test_params, &info1);
   EXPECT_TRUE(info1.is_direct());
 }
 
 }  // namespace data_reduction_proxy