Moving proxy resolution logic out of NetworkDelegate and into ProxyDelegate for DataReductionProxy

net/proxy/proxy_service_unittest.cc

 // Copyright (c) 2012 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 "net/proxy/proxy_service.h"
 
 #include <cstdarg>
 #include <vector>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
-#include "net/base/network_delegate_impl.h"
+#include "net/base/proxy_delegate.h"
 #include "net/base/test_completion_callback.h"
 #include "net/log/net_log.h"
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_entry.h"
 #include "net/log/test_net_log_util.h"
 #include "net/proxy/dhcp_proxy_script_fetcher.h"
 #include "net/proxy/mock_proxy_resolver.h"
 #include "net/proxy/mock_proxy_script_fetcher.h"
 #include "net/proxy/proxy_config_service.h"
 #include "net/proxy/proxy_resolver.h"
@@ skipping 127 matching lines @@
                       OnProxyConfigChanged(config_, availability_));
   }
 
  private:
   ConfigAvailability availability_;
   ProxyConfig config_;
   base::ObserverList<Observer, true> observers_;
 };
 
 // A test network delegate that exercises the OnResolveProxy callback.
-class TestResolveProxyNetworkDelegate : public NetworkDelegateImpl {
+class TestResolveProxyDelegate : public ProxyDelegate {
  public:
-  TestResolveProxyNetworkDelegate()
+  TestResolveProxyDelegate()
       : on_resolve_proxy_called_(false),
         add_proxy_(false),
         remove_proxy_(false),
-        proxy_service_(NULL) {
-  }
+        proxy_service_(nullptr) {}
 
   void OnResolveProxy(const GURL& url,
                       int load_flags,
                       const ProxyService& proxy_service,
                       ProxyInfo* result) override {
     on_resolve_proxy_called_ = true;
     proxy_service_ = &proxy_service;
     DCHECK(!add_proxy_ || !remove_proxy_);
     if (add_proxy_) {
       result->UseNamedProxy("delegate_proxy.com");
@@ skipping 11 matching lines @@
   }
 
   void set_remove_proxy(bool remove_proxy) {
     remove_proxy_ = remove_proxy;
   }
 
   const ProxyService* proxy_service() const {
     return proxy_service_;
   }
 
+  void OnTunnelConnectCompleted(const HostPortPair& endpoint,
+                                const HostPortPair& proxy_server,
+                                int net_error) override {}
+  void OnFallback(const ProxyServer& bad_proxy, int net_error) override {}
+  void OnBeforeSendHeaders(URLRequest* request,
+                           const ProxyInfo& proxy_info,
+                           HttpRequestHeaders* headers) override {}
+  void OnBeforeTunnelRequest(const HostPortPair& proxy_server,
+                             HttpRequestHeaders* extra_headers) override {}
+  void OnTunnelHeadersReceived(
+      const HostPortPair& origin,
+      const HostPortPair& proxy_server,
+      const HttpResponseHeaders& response_headers) override {}
+  bool IsTrustedSpdyProxy(const net::ProxyServer& proxy_server) override {
+    return true;
+  }
+
  private:
   bool on_resolve_proxy_called_;
   bool add_proxy_;
   bool remove_proxy_;
   const ProxyService* proxy_service_;
 };
 
 // A test network delegate that exercises the OnProxyFallback callback.
-class TestProxyFallbackNetworkDelegate : public NetworkDelegateImpl {
+class TestProxyFallbackProxyDelegate : public ProxyDelegate {
  public:
-  TestProxyFallbackNetworkDelegate()
-      : on_proxy_fallback_called_(false),
-        proxy_fallback_net_error_(OK) {
-  }
+  TestProxyFallbackProxyDelegate()
+      : on_proxy_fallback_called_(false), proxy_fallback_net_error_(OK) {}
 
-  void OnProxyFallback(const ProxyServer& proxy_server,
-                       int net_error) override {
-    proxy_server_ = proxy_server;
+  // ProxyDelegate implementation:
+  void OnResolveProxy(const GURL& url,
+                      int load_flags,
+                      const ProxyService& proxy_service,
+                      ProxyInfo* result) override {}
+  void OnTunnelConnectCompleted(const HostPortPair& endpoint,
+                                const HostPortPair& proxy_server,
+                                int net_error) override {}
+  void OnFallback(const ProxyServer& bad_proxy, int net_error) override {
+    proxy_server_ = bad_proxy;
     proxy_fallback_net_error_ = net_error;
     on_proxy_fallback_called_ = true;
   }
+  void OnBeforeSendHeaders(URLRequest* request,
+                           const ProxyInfo& proxy_info,
+                           HttpRequestHeaders* headers) override {}
+  void OnBeforeTunnelRequest(const HostPortPair& proxy_server,
+                             HttpRequestHeaders* extra_headers) override {}
+  void OnTunnelHeadersReceived(
+      const HostPortPair& origin,
+      const HostPortPair& proxy_server,
+      const HttpResponseHeaders& response_headers) override {}
+  bool IsTrustedSpdyProxy(const net::ProxyServer& proxy_server) override {
+    return true;
+  }
 
   bool on_proxy_fallback_called() const {
     return on_proxy_fallback_called_;
   }
 
   const ProxyServer& proxy_server() const {
     return proxy_server_;
   }
 
   int proxy_fallback_net_error() const {
@@ skipping 124 matching lines @@
   ProxyInfo info;
   TestCompletionCallback callback;
   BoundTestNetLog log;
 
   // First, warm up the ProxyService.
   int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(),
                                 NULL, NULL, log.bound());
   EXPECT_EQ(OK, rv);
 
   // Verify that network delegate is invoked.
-  TestResolveProxyNetworkDelegate delegate;
+  TestResolveProxyDelegate delegate;
   rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(), NULL,
                             &delegate, log.bound());
   EXPECT_TRUE(delegate.on_resolve_proxy_called());
   EXPECT_EQ(&service, delegate.proxy_service());
 
-  // Verify that the NetworkDelegate's behavior is stateless across
+  // Verify that the ProxyDelegate's behavior is stateless across
   // invocations of ResolveProxy. Start by having the callback add a proxy
   // and checking that subsequent requests are not affected.
   delegate.set_add_proxy(true);
 
   // Callback should interpose:
   rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(), NULL,
                             &delegate, log.bound());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ(info.proxy_server().host_port_pair().host(), "delegate_proxy.com");
   delegate.set_add_proxy(false);
 
   // Check non-bypassed URL:
   rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(), NULL,
                             &delegate, log.bound());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ(info.proxy_server().host_port_pair().host(), "foopy1");
 
   // Check bypassed URL:
   rv = service.ResolveProxy(bypass_url, LOAD_NORMAL, &info, callback.callback(),
                             NULL, &delegate, log.bound());
   EXPECT_TRUE(info.is_direct());
 }
 
 TEST_F(ProxyServiceTest, OnResolveProxyCallbackRemoveProxy) {
   // Same as OnResolveProxyCallbackAddProxy, but verify that the
-  // NetworkDelegate's behavior is stateless across invocations after it
+  // ProxyDelegate's behavior is stateless across invocations after it
   // *removes* a proxy.
   ProxyConfig config;
   config.proxy_rules().ParseFromString("foopy1:8080");
   config.set_auto_detect(false);
   config.proxy_rules().bypass_rules.ParseFromString("*.org");
 
   ProxyService service(make_scoped_ptr(new MockProxyConfigService(config)),
                        nullptr, NULL);
 
   GURL url("http://www.google.com/");
   GURL bypass_url("http://internet.org");
 
   ProxyInfo info;
   TestCompletionCallback callback;
   BoundTestNetLog log;
 
   // First, warm up the ProxyService.
   int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(),
                                 NULL, NULL, log.bound());
   EXPECT_EQ(OK, rv);
 
-  TestResolveProxyNetworkDelegate delegate;
+  TestResolveProxyDelegate delegate;
   delegate.set_remove_proxy(true);
 
   // Callback should interpose:
   rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(), NULL,
                             &delegate, log.bound());
   EXPECT_TRUE(info.is_direct());
   delegate.set_remove_proxy(false);
 
   // Check non-bypassed URL:
   rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(), NULL,
@@ skipping 135 matching lines @@
   EXPECT_EQ("foopy:8080", info.proxy_server().ToURI());
   EXPECT_TRUE(info.did_use_pac_script());
 
   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
 
   // Now, imagine that connecting to foopy:8080 fails: there is nothing
   // left to fallback to, since our proxy list was NOT terminated by
   // DIRECT.
-  NetworkDelegateImpl network_delegate;
+  TestResolveProxyDelegate proxy_delegate;
   TestCompletionCallback callback2;
   ProxyServer expected_proxy_server = info.proxy_server();
   rv = service.ReconsiderProxyAfterError(
       url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
-      callback2.callback(), NULL, &network_delegate, BoundNetLog());
+      callback2.callback(), NULL, &proxy_delegate, BoundNetLog());
   // ReconsiderProxyAfterError returns error indicating nothing left.
   EXPECT_EQ(ERR_FAILED, rv);
   EXPECT_TRUE(info.is_empty());
 }
 
 // Test that if the execution of the PAC script fails (i.e. javascript runtime
 // error), and the PAC settings are non-mandatory, that we fall-back to direct.
 TEST_F(ProxyServiceTest, PAC_RuntimeError) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
@@ skipping 88 matching lines @@
   // Fallback 1.
   TestCompletionCallback callback2;
   rv = service.ReconsiderProxyAfterError(
       url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
       callback2.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foobar:10", info.proxy_server().ToURI());
 
   // Fallback 2.
-  NetworkDelegateImpl network_delegate;
+  TestResolveProxyDelegate proxy_delegate;
   ProxyServer expected_proxy_server3 = info.proxy_server();
   TestCompletionCallback callback3;
   rv = service.ReconsiderProxyAfterError(
       url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
-      callback3.callback(), NULL, &network_delegate, BoundNetLog());
+      callback3.callback(), NULL, &proxy_delegate, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(info.is_direct());
 
   // Fallback 3.
   ProxyServer expected_proxy_server4 = info.proxy_server();
   TestCompletionCallback callback4;
   rv = service.ReconsiderProxyAfterError(
       url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
-      callback4.callback(), NULL, &network_delegate, BoundNetLog());
+      callback4.callback(), NULL, &proxy_delegate, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foobar:20", info.proxy_server().ToURI());
 
   // Fallback 4 -- Nothing to fall back to!
   ProxyServer expected_proxy_server5 = info.proxy_server();
   TestCompletionCallback callback5;
   rv = service.ReconsiderProxyAfterError(
       url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
-      callback5.callback(), NULL, &network_delegate, BoundNetLog());
+      callback5.callback(), NULL, &proxy_delegate, BoundNetLog());
   EXPECT_EQ(ERR_FAILED, rv);
   EXPECT_TRUE(info.is_empty());
 }
 
 TEST_F(ProxyServiceTest, PAC_ConfigSourcePropagates) {
   // Test whether the ProxyConfigSource set by the ProxyConfigService is applied
   // to ProxyInfo after the proxy is resolved via a PAC script.
   ProxyConfig config =
       ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy/proxy.pac"));
   config.set_source(PROXY_CONFIG_SOURCE_TEST);
@@ skipping 440 matching lines @@
   EXPECT_EQ(OK, rv);
 
   // Proxy times should not have been modified by fallback.
   EXPECT_EQ(proxy_resolve_start_time, info.proxy_resolve_start_time());
   EXPECT_EQ(proxy_resolve_end_time, info.proxy_resolve_end_time());
 
   // The second proxy should be specified.
   EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
   // Report back that the second proxy worked.  This will globally mark the
   // first proxy as bad.
-  TestProxyFallbackNetworkDelegate test_delegate;
+  TestProxyFallbackProxyDelegate test_delegate;
   service.ReportSuccess(info, &test_delegate);
   EXPECT_EQ("foopy1:8080", test_delegate.proxy_server().ToURI());
   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED,
             test_delegate.proxy_fallback_net_error());
 
   TestCompletionCallback callback3;
   rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback3.callback(), NULL,
                             NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ skipping 2188 matching lines @@
       url, LOAD_NORMAL, &info, NULL, log.bound());
   EXPECT_TRUE(synchronous_success);
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy1", info.proxy_server().host_port_pair().host());
 
   // No request should have been queued.
   EXPECT_EQ(0u, factory->pending_requests().size());
 }
 
 }  // namespace net