Revert of Moving proxy resolution logic out of NetworkDelegate and into ProxyDelegate

net/base/layered_network_delegate_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 "net/base/layered_network_delegate.h"
 
 #include <map>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/auth.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_delegate_impl.h"
 #include "net/base/request_priority.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_response_headers.h"
 #include "net/proxy/proxy_config_service.h"
 #include "net/proxy/proxy_info.h"
+#include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace net {
 namespace {
 
 typedef std::map<const char*, int> CountersMap;
 
 class TestNetworkDelegateImpl : public NetworkDelegateImpl {
  public:
   TestNetworkDelegateImpl(CountersMap* layered_network_delegate_counters)
       : layered_network_delegate_counters_(layered_network_delegate_counters) {}
 
   ~TestNetworkDelegateImpl() override {}
 
   // NetworkDelegateImpl implementation:
   int OnBeforeURLRequest(URLRequest* request,
                          const CompletionCallback& callback,
                          GURL* new_url) override {
     IncrementAndCompareCounter("on_before_url_request_count");
     return OK;
   }
 
+  void OnResolveProxy(const GURL& url,
+                      int load_flags,
+                      const ProxyService& proxy_service,
+                      ProxyInfo* result) override {
+    IncrementAndCompareCounter("on_resolve_proxy_count");
+  }
+
+  void OnProxyFallback(const ProxyServer& bad_proxy, int net_error) override {
+    IncrementAndCompareCounter("on_proxy_fallback_count");
+  }
+
   int OnBeforeSendHeaders(URLRequest* request,
                           const CompletionCallback& callback,
                           HttpRequestHeaders* headers) override {
     IncrementAndCompareCounter("on_before_send_headers_count");
     return OK;
   }
 
   void OnBeforeSendProxyHeaders(URLRequest* request,
                                 const ProxyInfo& proxy_info,
                                 HttpRequestHeaders* headers) override {
@@ skipping 114 matching lines @@
   ~TestLayeredNetworkDelegate() override {}
 
   void CallAndVerify() {
     scoped_refptr<AuthChallengeInfo> auth_challenge(new AuthChallengeInfo());
     scoped_ptr<URLRequest> request =
         context_.CreateRequest(GURL(), IDLE, &delegate_);
     scoped_ptr<HttpRequestHeaders> request_headers(new HttpRequestHeaders());
     scoped_refptr<HttpResponseHeaders> response_headers(
         new HttpResponseHeaders(""));
     TestCompletionCallback completion_callback;
+    scoped_ptr<ProxyService> proxy_service(ProxyService::CreateDirect());
+    scoped_ptr<ProxyInfo> proxy_info(new ProxyInfo());
 
     EXPECT_EQ(OK, OnBeforeURLRequest(request.get(),
                                      completion_callback.callback(), NULL));
+    OnResolveProxy(GURL(), 0, *proxy_service, proxy_info.get());
+    OnProxyFallback(ProxyServer(), 0);
     EXPECT_EQ(OK, OnBeforeSendHeaders(NULL, completion_callback.callback(),
                                       request_headers.get()));
     OnBeforeSendProxyHeaders(NULL, ProxyInfo(), request_headers.get());
     OnSendHeaders(NULL, *request_headers);
     OnNetworkBytesSent(request.get(), 42);
     EXPECT_EQ(OK, OnHeadersReceived(NULL, completion_callback.callback(),
                                     response_headers.get(), NULL, NULL));
     OnResponseStarted(request.get());
     OnNetworkBytesReceived(request.get(), 42);
     OnCompleted(request.get(), false);
@@ skipping 11 matching lines @@
   }
 
  protected:
   void OnBeforeURLRequestInternal(URLRequest* request,
                                   const CompletionCallback& callback,
                                   GURL* new_url) override {
     ++(*counters_)["on_before_url_request_count"];
     EXPECT_EQ(1, (*counters_)["on_before_url_request_count"]);
   }
 
+  void OnResolveProxyInternal(const GURL& url,
+                              int load_flags,
+                              const ProxyService& proxy_service,
+                              ProxyInfo* result) override {
+    ++(*counters_)["on_resolve_proxy_count"];
+    EXPECT_EQ(1, (*counters_)["on_resolve_proxy_count"]);
+  }
+
+  void OnProxyFallbackInternal(const ProxyServer& bad_proxy,
+                               int net_error) override {
+    ++(*counters_)["on_proxy_fallback_count"];
+    EXPECT_EQ(1, (*counters_)["on_proxy_fallback_count"]);
+  }
+
   void OnBeforeSendHeadersInternal(URLRequest* request,
                                    const CompletionCallback& callback,
                                    HttpRequestHeaders* headers) override {
     ++(*counters_)["on_before_send_headers_count"];
     EXPECT_EQ(1, (*counters_)["on_before_send_headers_count"]);
   }
 
   void OnBeforeSendProxyHeadersInternal(URLRequest* request,
                                         const ProxyInfo& proxy_info,
                                         HttpRequestHeaders* headers) override {
@@ skipping 126 matching lines @@
   CountersMap layered_network_delegate_counters;
   TestNetworkDelegateImpl* test_network_delegate_;
   scoped_ptr<TestLayeredNetworkDelegate> layered_network_delegate_;
 };
 
 TEST_F(LayeredNetworkDelegateTest, VerifyLayeredNetworkDelegateInternal) {
   layered_network_delegate_->CallAndVerify();
 }
 
 }  // namespace net