Move data reduction proxy to Chrome-Proxy header for authentication

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.h"
+#include "components/data_reduction_proxy/browser/data_reduction_proxy_params_test_utils.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 13 matching lines @@
 
 namespace {
 // Transform "normal"-looking headers (\n-separated) to the appropriate
 // input format for ParseRawHeaders (\0-separated).
 void HeadersToRaw(std::string* headers) {
   std::replace(headers->begin(), headers->end(), '\n', '\0');
   if (!headers->empty())
     *headers += '\0';
 }
 
-std::string GetDataReductionProxy() {
-  return "https://proxy1.com:443/";
-}
-
-std::string GetDataReductionProxyFallback() {
-  return "http://proxy2.com:80/";
-}
 } // namespace
 
 
 namespace data_reduction_proxy {
-namespace {
-class TestDataReductionProxyParams : public DataReductionProxyParams {
- public:
-  TestDataReductionProxyParams() : DataReductionProxyParams(0, false) {}
-
-  virtual bool WasDataReductionProxyUsed(
-      const net::URLRequest* request,
-      std::pair<GURL, GURL>* proxy_servers) const OVERRIDE;
-};
-
-bool TestDataReductionProxyParams::WasDataReductionProxyUsed(
-    const net::URLRequest* request,
-    std::pair<GURL, GURL>* proxy_servers) const {
-  if (net::HostPortPair::FromURL(GURL(GetDataReductionProxy())).Equals(
-          request->proxy_server())) {
-    proxy_servers->first = GURL(GetDataReductionProxy());
-    proxy_servers->second = GURL(GetDataReductionProxyFallback());
-    return true;
-  }
-  if (net::HostPortPair::FromURL(
-          GURL(GetDataReductionProxyFallback())).Equals(
-          request->proxy_server())) {
-    proxy_servers->first = GURL(GetDataReductionProxyFallback());
-    proxy_servers->second = GURL();
-    return true;
-  }
-  return false;
-}
-}  // namespace
 
 // 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) {
   }
 
@@ skipping 11 matching lines @@
     return net::OK;
   }
 
   TestDataReductionProxyParams* test_data_reduction_proxy_params_;
 };
 
 // Constructs a |TestURLRequestContext| that uses a |MockSocketFactory| to
 // simulate requests and responses.
 class DataReductionProxyProtocolTest : public testing::Test {
  public:
-  DataReductionProxyProtocolTest() : http_user_agent_settings_("", "") {}
+  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) {
     // Create a context with delayed initialization.
     context_.reset(new TestURLRequestContext(true));
 
     proxy_service_.reset(proxy_service);
-    proxy_params_.reset(new TestDataReductionProxyParams());
     network_delegate_.reset(new TestDataReductionProxyNetworkDelegate(
         proxy_params_.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_);
 
@@ skipping 234 matching lines @@
   }
 }
 
 
 // After each test, the proxy retry info will contain zero, one, or two of the
 // data reduction proxies depending on whether no bypass was indicated by the
 // initial response, a single proxy bypass was indicated, or a double bypass
 // 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) {
-  std::string primary = GetDataReductionProxy();
-  std::string fallback = GetDataReductionProxyFallback();
   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;
   } tests[] = {
     // Valid data reduction proxy response with no bypass message.
     { "GET",
@@ skipping 180 matching lines @@
       "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
     }
   };
+  std::string primary = proxy_params_->DefaultOrigin();
+  std::string fallback = proxy_params_->DefaultFallbackOrigin();
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    ConfigureTestDependencies(
-        ProxyService::CreateFixedFromPacResult("PROXY " +
-            HostPortPair::FromURL(GURL(primary)).ToString() + "; PROXY " +
-            HostPortPair::FromURL(GURL(fallback)).ToString() + "; DIRECT"));
+    ConfigureTestDependencies(ProxyService::CreateFixedFromPacResult(
+        "PROXY " +
+        HostPortPair::FromURL(GURL(primary)).ToString() + "; PROXY " +
+        HostPortPair::FromURL(GURL(fallback)).ToString() + "; DIRECT"));
     TestProxyFallback(tests[i].method,
                       tests[i].first_response,
                       tests[i].expected_retry,
                       tests[i].expect_response_body);
 
     // We should also observe the bad proxy in the retry list.
     TestBadProxies(tests[i].expected_bad_proxy_count,
                    tests[i].expected_duration,
                    primary, fallback);
   }
@@ skipping 36 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