Remove the concept of threading from ProxyService, and move it into the Proxy...

net/proxy/proxy_service_unittest.cc

 // Copyright (c) 2006-2008 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 "base/compiler_specific.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_errors.h"
+#include "net/proxy/single_threaded_proxy_resolver.h"
 #include "net/proxy/proxy_config_service.h"
 #include "net/proxy/proxy_resolver.h"
 #include "net/proxy/proxy_script_fetcher.h"
 #include "net/proxy/proxy_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 class MockProxyConfigService: public net::ProxyConfigService {
  public:
   MockProxyConfigService() {}  // Direct connect.
   explicit MockProxyConfigService(const net::ProxyConfig& pc) : config(pc) {}
   explicit MockProxyConfigService(const std::string& pac_url) {
     config.pac_url = GURL(pac_url);
   }
 
   virtual int GetProxyConfig(net::ProxyConfig* results) {
     *results = config;
     return net::OK;
   }
 
   net::ProxyConfig config;
 };
 
-class MockProxyResolver : public net::ProxyResolver {
+class SyncMockProxyResolver : public net::ProxyResolver {
  public:
-  MockProxyResolver() : net::ProxyResolver(true),
-                        fail_get_proxy_for_url(false) {
+  SyncMockProxyResolver() : net::ProxyResolver(false /*expects_pac_bytes*/),
+                            fail_get_proxy_for_url(false) {
   }
 
+  // ProxyResolver implementation:
   virtual int GetProxyForURL(const GURL& query_url,
-                             const GURL& pac_url,
-                             net::ProxyInfo* results) {
+                             net::ProxyInfo* results,
+                             net::CompletionCallback* callback,
+                             RequestHandle* request) {
     if (fail_get_proxy_for_url)
       return net::ERR_FAILED;
     if (GURL(query_url).host() == info_predicate_query_host) {
       results->Use(info);
     } else {
       results->UseDirect();
     }
     return net::OK;
   }
 
+  virtual void CancelRequest(RequestHandle request) {
+    NOTREACHED();
+  }
+
+  virtual void SetPacScriptByUrlInternal(const GURL& pac_url) {}
+
+
   net::ProxyInfo info;
 
   // info is only returned if query_url in GetProxyForURL matches this:
   std::string info_predicate_query_host;
 
   // If true, then GetProxyForURL will fail, which simulates failure to
   // download or execute the PAC file.
   bool fail_get_proxy_for_url;
 };
 
+class MockProxyResolver : public net::SingleThreadedProxyResolver {
+ public:
+  MockProxyResolver()
+      : net::SingleThreadedProxyResolver(new SyncMockProxyResolver) {
+    x = reinterpret_cast<SyncMockProxyResolver*>(resolver());
+  }
+
+  // TODO(eroman): cleanup.
+  SyncMockProxyResolver* x;
+};
+
 // ResultFuture is a handle to get at the result from
 // ProxyService::ResolveProxyForURL() that ran on another thread.
 class ResultFuture : public base::RefCountedThreadSafe<ResultFuture> {
  public:
   // |service| is the ProxyService to issue requests on, and |io_message_loop|
   // is the message loop where ProxyService lives.
   ResultFuture(MessageLoop* io_message_loop,
                net::ProxyService* service)
        : io_message_loop_(io_message_loop),
          service_(service),
@@ skipping 248 matching lines @@
     scoped_refptr<ResultFuture> result;
     service_.ResetConfigService(&result, new_proxy_config_service);
     return result->GetResultCode();
   }
 
  private:
   ProxyServiceWithFutures service_;
 };
 
 // A ProxyResolver which can be set to block upon reaching GetProxyForURL.
-class BlockableProxyResolver : public net::ProxyResolver {
+class SyncBlockableProxyResolver : public net::ProxyResolver {
  public:
-  BlockableProxyResolver() : net::ProxyResolver(true),
-                             should_block_(false),
-                             unblocked_(true, true),
-      blocked_(true, false) {
+  SyncBlockableProxyResolver()
+      : net::ProxyResolver(false /*expects_pac_bytes*/),
+        should_block_(false),
+        unblocked_(true, true),
+        blocked_(true, false) {
   }
 
   void Block() {
     should_block_ = true;
     unblocked_.Reset();
   }
 
   void Unblock() {
     should_block_ = false;
     blocked_.Reset();
     unblocked_.Signal();
   }
 
   void WaitUntilBlocked() {
     blocked_.Wait();
   }
 
   // net::ProxyResolver implementation:
   virtual int GetProxyForURL(const GURL& query_url,
-                             const GURL& pac_url,
-                             net::ProxyInfo* results) {
+                             net::ProxyInfo* results,
+                             net::CompletionCallback* callback,
+                             RequestHandle* request) {
     if (should_block_) {
       blocked_.Signal();
       unblocked_.Wait();
     }
 
     results->UseNamedProxy(query_url.host());
     return net::OK;
   }
 
+  virtual void CancelRequest(RequestHandle request) {
+    NOTREACHED();
+  }
+
+  virtual void SetPacScriptByUrlInternal(const GURL& pac_url) {}
+
  private:
   bool should_block_;
   base::WaitableEvent unblocked_;
   base::WaitableEvent blocked_;
 };
 
+class BlockableProxyResolver : public net::SingleThreadedProxyResolver {
+ public:
+  BlockableProxyResolver()
+      : net::SingleThreadedProxyResolver(new SyncBlockableProxyResolver) {
+    x = reinterpret_cast<SyncBlockableProxyResolver*>(resolver());
+  }
+
+  // TODO(eroman): cleanup.
+  SyncBlockableProxyResolver* x;
+};
+
 // A mock ProxyResolverWithoutFetch which concatenates the query's host with
 // the last download PAC contents.  This way the result describes what the last
 // downloaded PAC script's contents were, in addition to the query url itself.
-class MockProxyResolverWithoutFetch : public net::ProxyResolver {
+class SyncMockProxyResolverWithoutFetch : public net::ProxyResolver {
  public:
-  MockProxyResolverWithoutFetch() : net::ProxyResolver(false),
-                                    last_pac_contents_("NONE") {}
+  SyncMockProxyResolverWithoutFetch()
+      : net::ProxyResolver(true /*expects_pac_bytes*/),
+        last_pac_contents_("NONE") {}
 
   // net::ProxyResolver implementation:
   virtual int GetProxyForURL(const GURL& query_url,
-                             const GURL& pac_url,
-                             net::ProxyInfo* results) {
+                             net::ProxyInfo* results,
+                             net::CompletionCallback* callback,
+                             RequestHandle* request) {
     results->UseNamedProxy(last_pac_contents_ + "." + query_url.host());
     return net::OK;
   }
 
-  virtual void SetPacScript(const std::string& bytes) {
+  virtual void SetPacScriptByDataInternal(const std::string& bytes) {
     last_pac_contents_ = bytes;
   }
 
+  virtual void CancelRequest(RequestHandle request) {
+    NOTREACHED();
+  }
+
  private:
   std::string last_pac_contents_;
 };
 
+class MockProxyResolverWithoutFetch : public net::SingleThreadedProxyResolver {
+ public:
+  MockProxyResolverWithoutFetch()
+      : net::SingleThreadedProxyResolver(
+            new SyncMockProxyResolverWithoutFetch) {
+    x = reinterpret_cast<SyncMockProxyResolverWithoutFetch*>(resolver());
+  }
+
+  // TODO(eroman): cleanup.
+  SyncMockProxyResolverWithoutFetch* x;
+};
+
+
 }  // namespace
 
 // A mock ProxyScriptFetcher. No result will be returned to the fetch client
 // until we call NotifyFetchCompletion() to set the results.
 class MockProxyScriptFetcher : public net::ProxyScriptFetcher {
  public:
   MockProxyScriptFetcher() : pending_request_loop_(NULL),
       pending_request_callback_(NULL), pending_request_bytes_(NULL) {}
 
   // net::ProxyScriptFetcher implementation.
@@ skipping 53 matching lines @@
   int rv = service.ResolveProxy(url, &info);
   EXPECT_EQ(rv, net::OK);
   EXPECT_TRUE(info.is_direct());
 }
 
 TEST(ProxyServiceTest, PAC) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockProxyResolver* resolver = new MockProxyResolver;
-  resolver->info.UseNamedProxy("foopy");
-  resolver->info_predicate_query_host = "www.google.com";
+  resolver->x->info.UseNamedProxy("foopy");
+  resolver->x->info_predicate_query_host = "www.google.com";
 
   SyncProxyService service(config_service, resolver);
 
   GURL url("http://www.google.com/");
 
   net::ProxyInfo info;
   int rv = service.ResolveProxy(url, &info);
   EXPECT_EQ(rv, net::OK);
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy:80", info.proxy_server().ToURI());
 }
 
 TEST(ProxyServiceTest, PAC_FailoverToDirect) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockProxyResolver* resolver = new MockProxyResolver;
-  resolver->info.UseNamedProxy("foopy:8080");
-  resolver->info_predicate_query_host = "www.google.com";
+  resolver->x->info.UseNamedProxy("foopy:8080");
+  resolver->x->info_predicate_query_host = "www.google.com";
 
   SyncProxyService service(config_service, resolver);
 
   GURL url("http://www.google.com/");
 
   net::ProxyInfo info;
   int rv = service.ResolveProxy(url, &info);
   EXPECT_EQ(rv, net::OK);
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy:8080", info.proxy_server().ToURI());
 
   // Now, imagine that connecting to foopy:8080 fails.
   rv = service.ReconsiderProxyAfterError(url, &info);
   EXPECT_EQ(rv, net::OK);
   EXPECT_TRUE(info.is_direct());
 }
 
 TEST(ProxyServiceTest, PAC_FailsToDownload) {
   // Test what happens when we fail to download the PAC URL.
 
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockProxyResolver* resolver = new MockProxyResolver;
-  resolver->info.UseNamedProxy("foopy:8080");
-  resolver->info_predicate_query_host = "www.google.com";
-  resolver->fail_get_proxy_for_url = true;
+  resolver->x->info.UseNamedProxy("foopy:8080");
+  resolver->x->info_predicate_query_host = "www.google.com";
+  resolver->x->fail_get_proxy_for_url = true;
 
   SyncProxyService service(config_service, resolver);
 
   // The first resolve fails in the MockProxyResolver.
   GURL url("http://www.google.com/");
   net::ProxyInfo info;
   int rv = service.ResolveProxy(url, &info);
   EXPECT_EQ(rv, net::ERR_FAILED);
 
   // The second resolve request will automatically select direct connect,
   // because it has cached the configuration as being bad.
   rv = service.ResolveProxy(url, &info);
   EXPECT_EQ(rv, net::OK);
   EXPECT_TRUE(info.is_direct());
 
-  resolver->fail_get_proxy_for_url = false;
-  resolver->info.UseNamedProxy("foopy_valid:8080");
+  resolver->x->fail_get_proxy_for_url = false;
+  resolver->x->info.UseNamedProxy("foopy_valid:8080");
 
   // But, if that fails, then we should give the proxy config another shot
   // since we have never tried it with this URL before.
   rv = service.ReconsiderProxyAfterError(url, &info);
   EXPECT_EQ(rv, net::OK);
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy_valid:8080", info.proxy_server().ToURI());
 }
 
 TEST(ProxyServiceTest, ProxyFallback) {
   // Test what happens when we specify multiple proxy servers and some of them
   // are bad.
 
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockProxyResolver* resolver = new MockProxyResolver;
-  resolver->info.UseNamedProxy("foopy1:8080;foopy2:9090");
-  resolver->info_predicate_query_host = "www.google.com";
-  resolver->fail_get_proxy_for_url = false;
+  resolver->x->info.UseNamedProxy("foopy1:8080;foopy2:9090");
+  resolver->x->info_predicate_query_host = "www.google.com";
+  resolver->x->fail_get_proxy_for_url = false;
 
   SyncProxyService service(config_service, resolver);
 
   GURL url("http://www.google.com/");
 
   // Get the proxy information.
   net::ProxyInfo info;
   int rv = service.ResolveProxy(url, &info);
   EXPECT_EQ(rv, net::OK);
   EXPECT_FALSE(info.is_direct());
 
   // The first item is valid.
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   // Fake an error on the proxy.
   rv = service.ReconsiderProxyAfterError(url, &info);
   EXPECT_EQ(rv, net::OK);
 
   // The second proxy should be specified.
   EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
 
   // Create a new resolver that returns 3 proxies. The second one is already
   // known to be bad.
   config_service->config.pac_url = GURL("http://foopy/proxy.pac");
-  resolver->info.UseNamedProxy("foopy3:7070;foopy1:8080;foopy2:9090");
-  resolver->info_predicate_query_host = "www.google.com";
-  resolver->fail_get_proxy_for_url = false;
+  resolver->x->info.UseNamedProxy("foopy3:7070;foopy1:8080;foopy2:9090");
+  resolver->x->info_predicate_query_host = "www.google.com";
+  resolver->x->fail_get_proxy_for_url = false;
 
   rv = service.ResolveProxy(url, &info);
   EXPECT_EQ(rv, net::OK);
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy3:7070", info.proxy_server().ToURI());
 
   // We fake another error. It should now try the third one.
   rv = service.ReconsiderProxyAfterError(url, &info);
   EXPECT_EQ(rv, net::OK);
   EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
@@ skipping 10 matching lines @@
   // TODO(nsylvain): Test that the proxy can be retried after the delay.
 }
 
 TEST(ProxyServiceTest, ProxyFallback_NewSettings) {
   // Test proxy failover when new settings are available.
 
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockProxyResolver* resolver = new MockProxyResolver;
-  resolver->info.UseNamedProxy("foopy1:8080;foopy2:9090");
-  resolver->info_predicate_query_host = "www.google.com";
-  resolver->fail_get_proxy_for_url = false;
+  resolver->x->info.UseNamedProxy("foopy1:8080;foopy2:9090");
+  resolver->x->info_predicate_query_host = "www.google.com";
+  resolver->x->fail_get_proxy_for_url = false;
 
   SyncProxyService service(config_service, resolver);
 
   GURL url("http://www.google.com/");
 
   // Get the proxy information.
   net::ProxyInfo info;
   int rv = service.ResolveProxy(url, &info);
   EXPECT_EQ(rv, net::OK);
   EXPECT_FALSE(info.is_direct());
@@ skipping 26 matching lines @@
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 }
 
 TEST(ProxyServiceTest, ProxyFallback_BadConfig) {
   // Test proxy failover when the configuration is bad.
 
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockProxyResolver* resolver = new MockProxyResolver;
-  resolver->info.UseNamedProxy("foopy1:8080;foopy2:9090");
-  resolver->info_predicate_query_host = "www.google.com";
-  resolver->fail_get_proxy_for_url = false;
+  resolver->x->info.UseNamedProxy("foopy1:8080;foopy2:9090");
+  resolver->x->info_predicate_query_host = "www.google.com";
+  resolver->x->fail_get_proxy_for_url = false;
 
   SyncProxyService service(config_service, resolver);
 
   GURL url("http://www.google.com/");
 
   // Get the proxy information.
   net::ProxyInfo info;
   int rv = service.ResolveProxy(url, &info);
   EXPECT_EQ(rv, net::OK);
   EXPECT_FALSE(info.is_direct());
 
   // The first item is valid.
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   // Fake a proxy error.
   rv = service.ReconsiderProxyAfterError(url, &info);
   EXPECT_EQ(rv, net::OK);
 
   // The first proxy is ignored, and the second one is selected.
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
 
   // Fake a PAC failure.
   net::ProxyInfo info2;
-  resolver->fail_get_proxy_for_url = true;
+  resolver->x->fail_get_proxy_for_url = true;
   rv = service.ResolveProxy(url, &info2);
   EXPECT_EQ(rv, net::ERR_FAILED);
 
   // No proxy servers are returned. It's a direct connection.
   EXPECT_TRUE(info2.is_direct());
 
   // The PAC is now fixed and will return a proxy server.
   // It should also clear the list of bad proxies.
-  resolver->fail_get_proxy_for_url = false;
+  resolver->x->fail_get_proxy_for_url = false;
 
   // Try to resolve, it will still return "direct" because we have no reason
   // to check the config since everything works.
   net::ProxyInfo info3;
   rv = service.ResolveProxy(url, &info3);
   EXPECT_EQ(rv, net::OK);
   EXPECT_TRUE(info3.is_direct());
 
   // But if the direct connection fails, we check if the ProxyInfo tried to
   // resolve the proxy before, and if not (like in this case), we give the
@@ skipping 286 matching lines @@
 // Test cancellation of a queued request.
 TEST(ProxyServiceTest, CancelQueuedRequest) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   BlockableProxyResolver* resolver = new BlockableProxyResolver;
 
   ProxyServiceWithFutures service(config_service, resolver);
 
   // Cause requests to pile up, by having them block in the PAC thread.
-  resolver->Block();
+  resolver->x->Block();
 
   // Start 3 requests.
   scoped_refptr<ResultFuture> result1;
   service.ResolveProxy(&result1, GURL("http://request1"));
 
   scoped_refptr<ResultFuture> result2;
   service.ResolveProxy(&result2, GURL("http://request2"));
 
   scoped_refptr<ResultFuture> result3;
   service.ResolveProxy(&result3, GURL("http://request3"));
 
   // Wait until the first request has become blocked in the PAC thread.
-  resolver->WaitUntilBlocked();
+  resolver->x->WaitUntilBlocked();
 
   // Cancel the second request
   result2->Cancel();
 
   // Unblock the PAC thread.
-  resolver->Unblock();
+  resolver->x->Unblock();
 
   // Wait for the final request to complete.
   result3->WaitUntilCompleted();
 
   // Verify that requests ran as expected.
 
   EXPECT_TRUE(result1->IsCompleted());
   EXPECT_EQ(net::OK, result1->GetResultCode());
   EXPECT_EQ("request1:80", result1->GetProxyInfo().proxy_server().ToURI());
 
   EXPECT_FALSE(result2->IsCompleted());  // Cancelled.
 
   EXPECT_TRUE(result3->IsCompleted());
   EXPECT_EQ(net::OK, result3->GetResultCode());
   EXPECT_EQ("request3:80", result3->GetProxyInfo().proxy_server().ToURI());
 }
 
 // Test cancellation of an in-progress request.
 TEST(ProxyServiceTest, CancelInprogressRequest) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   BlockableProxyResolver* resolver = new BlockableProxyResolver;
 
   ProxyServiceWithFutures service(config_service, resolver);
 
   // Cause requests to pile up, by having them block in the PAC thread.
-  resolver->Block();
+  resolver->x->Block();
 
   // Start 3 requests.
   scoped_refptr<ResultFuture> result1;
   service.ResolveProxy(&result1, GURL("http://request1"));
 
   scoped_refptr<ResultFuture> result2;
   service.ResolveProxy(&result2, GURL("http://request2"));
 
   scoped_refptr<ResultFuture> result3;
   service.ResolveProxy(&result3, GURL("http://request3"));
 
   // Wait until the first request has become blocked in the PAC thread.
-  resolver->WaitUntilBlocked();
+  resolver->x->WaitUntilBlocked();
 
   // Cancel the first request
   result1->Cancel();
 
   // Unblock the PAC thread.
-  resolver->Unblock();
+  resolver->x->Unblock();
 
   // Wait for the final request to complete.
   result3->WaitUntilCompleted();
 
   // Verify that requests ran as expected.
 
   EXPECT_FALSE(result1->IsCompleted());  // Cancelled.
 
   EXPECT_TRUE(result2->IsCompleted());
   EXPECT_EQ(net::OK, result2->GetResultCode());
@@ skipping 106 matching lines @@
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   net::ProxyConfig config2;
   config2.proxy_rules.ParseFromString("foopy2:8080");
   config2.auto_detect = false;
   int result = service->ResetConfigService(new MockProxyConfigService(config2));
   DCHECK(result == 0);
   service->ResolveProxy(GURL("http://request2"), &info);
   EXPECT_EQ("foopy2:8080", info.proxy_server().ToURI());
 }