Add a MockAsyncProxyResolverFactory and update some tests to use it.

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 <vector>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 222 matching lines @@
 
  private:
   bool on_proxy_fallback_called_;
   ProxyServer proxy_server_;
   int proxy_fallback_net_error_;
 };
 
 }  // namespace
 
 TEST_F(ProxyServiceTest, Direct) {
-  MockAsyncProxyResolver resolver;
+  MockAsyncProxyResolverFactory factory(false);
   ProxyService service(
       new MockProxyConfigService(ProxyConfig::CreateDirect()),
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);

[eroman, 2015/04/22 16:30:38]

Would it be clearer to just get rid of ForwardingProxyResolverFactory?

The pattern would change to:

MockAsyncProxyResolverFactory* factory = new
MockAsyncProxyResolverFactory(false);
ProxyService service(..., make_scoped_ptr(factory), ...);

[Sam McNally, 2015/04/23 03:04:44]

Done.

 
   GURL url("http://www.google.com/");
 
   ProxyInfo info;
   TestCompletionCallback callback;
   BoundTestNetLog log;
   int rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback.callback(), NULL, NULL,
       log.bound());
   EXPECT_EQ(OK, rv);
-  EXPECT_TRUE(resolver.pending_requests().empty());
+  EXPECT_TRUE(factory.pending_requests().empty());
 
   EXPECT_TRUE(info.is_direct());
   EXPECT_TRUE(info.proxy_resolve_start_time().is_null());
   EXPECT_TRUE(info.proxy_resolve_end_time().is_null());
 
   // Check the NetLog was filled correctly.
   TestNetLog::CapturedEntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(3u, entries.size());
@@ skipping 108 matching lines @@
        bypass_url, net::LOAD_NORMAL, &info, callback.callback(), NULL,
        &delegate, log.bound());
   EXPECT_TRUE(info.is_direct());
 }
 
 TEST_F(ProxyServiceTest, PAC) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver resolver;
+  MockAsyncProxyResolverFactory factory(false);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   GURL url("http://www.google.com/");
 
   ProxyInfo info;
   TestCompletionCallback callback;
   ProxyService::PacRequest* request;
   BoundTestNetLog log;
 
   int rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback.callback(), &request, NULL,
       log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(LOAD_STATE_RESOLVING_PROXY_FOR_URL, service.GetLoadState(request));
 
+  ASSERT_EQ(1u, factory.pending_requests().size());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
-            resolver.pending_set_pac_script_request()->script_data()->url());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->url());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // Set the result in proxy resolver.
   resolver.pending_requests()[0]->results()->UseNamedProxy("foopy");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_FALSE(info.is_direct());
@@ skipping 19 matching lines @@
       entries, 4, NetLog::TYPE_PROXY_SERVICE));
 }
 
 // Test that the proxy resolver does not see the URL's username/password
 // or its reference section.
 TEST_F(ProxyServiceTest, PAC_NoIdentityOrHash) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver resolver;
+  MockAsyncProxyResolverFactory factory(false);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   GURL url("http://username:password@www.google.com/?ref#hash#hash");
 
   ProxyInfo info;
   TestCompletionCallback callback;
   int rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback.callback(), NULL, NULL,
       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
-            resolver.pending_set_pac_script_request()->script_data()->url());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->url());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   // The URL should have been simplified, stripping the username/password/hash.
   EXPECT_EQ(GURL("http://www.google.com/?ref"),
             resolver.pending_requests()[0]->url());
 
   // We end here without ever completing the request -- destruction of
   // ProxyService will cancel the outstanding request.
 }
 
 TEST_F(ProxyServiceTest, PAC_FailoverWithoutDirect) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
   MockAsyncProxyResolver resolver;
+  MockAsyncProxyResolverFactory factory(false);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   GURL url("http://www.google.com/");
 
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback1.callback(), NULL, NULL,
       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
-            resolver.pending_set_pac_script_request()->script_data()->url());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->url());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // Set the result in proxy resolver.
   resolver.pending_requests()[0]->results()->UseNamedProxy("foopy:8080");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_FALSE(info.is_direct());
@@ skipping 17 matching lines @@
   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");
   MockAsyncProxyResolver resolver;
+  MockAsyncProxyResolverFactory factory(false);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   GURL url("http://this-causes-js-error/");
 
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback1.callback(), NULL, NULL,
       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
-            resolver.pending_set_pac_script_request()->script_data()->url());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->url());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // Simulate a failure in the PAC executor.
   resolver.pending_requests()[0]->CompleteNow(ERR_PAC_SCRIPT_FAILED);
 
   EXPECT_EQ(OK, callback1.WaitForResult());
 
   // Since the PAC script was non-mandatory, we should have fallen-back to
@@ skipping 21 matching lines @@
 //
 // For which we expect it to try DIRECT, then foobar:10, then DIRECT again,
 // then foobar:20, and then give up and error.
 //
 // The important check of this test is to make sure that DIRECT is not somehow
 // cached as being a bad proxy.
 TEST_F(ProxyServiceTest, PAC_FailoverAfterDirect) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
   MockAsyncProxyResolver resolver;
+  MockAsyncProxyResolverFactory factory(false);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   GURL url("http://www.google.com/");
 
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback1.callback(), NULL, NULL,
       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
-            resolver.pending_set_pac_script_request()->script_data()->url());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->url());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // Set the result in proxy resolver.
   resolver.pending_requests()[0]->results()->UsePacString(
       "DIRECT ; PROXY foobar:10 ; DIRECT ; PROXY foobar:20");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback1.WaitForResult());
@@ skipping 44 matching lines @@
 
 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);
 
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
   MockAsyncProxyResolver resolver;
+  MockAsyncProxyResolverFactory factory(false);
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   // Resolve something.
   GURL url("http://www.google.com/");
   ProxyInfo info;
   TestCompletionCallback callback;
   int rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback.callback(), NULL, NULL,
       BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
   ASSERT_EQ(1u, resolver.pending_requests().size());
 
   // Set the result in proxy resolver.
   resolver.pending_requests()[0]->results()->UseNamedProxy("foopy");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_EQ(PROXY_CONFIG_SOURCE_TEST, info.config_source());
   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());
 }
 
 TEST_F(ProxyServiceTest, ProxyResolverFails) {
   // Test what happens when the ProxyResolver fails. The download and setting
   // of the PAC script have already succeeded, so this corresponds with a
   // javascript runtime error while calling FindProxyForURL().
 
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver resolver;
+  MockAsyncProxyResolverFactory factory(false);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   // Start first resolve request.
   GURL url("http://www.google.com/");
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback1.callback(), NULL, NULL,
       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
-            resolver.pending_set_pac_script_request()->script_data()->url());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->url());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // Fail the first resolve request in MockAsyncProxyResolver.
   resolver.pending_requests()[0]->CompleteNow(ERR_FAILED);
 
   // Although the proxy resolver failed the request, ProxyService implicitly
   // falls-back to DIRECT.
   EXPECT_EQ(OK, callback1.WaitForResult());
@@ skipping 28 matching lines @@
 TEST_F(ProxyServiceTest, ProxyScriptFetcherFailsDownloadingMandatoryPac) {
   // Test what happens when the ProxyScriptResolver fails to download a
   // mandatory PAC script.
 
   ProxyConfig config(
       ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy/proxy.pac")));
   config.set_pac_mandatory(true);
 
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
 
-  MockAsyncProxyResolver resolver;
+  MockAsyncProxyResolverFactory factory(false);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   // Start first resolve request.
   GURL url("http://www.google.com/");
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback1.callback(), NULL, NULL,
       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
-            resolver.pending_set_pac_script_request()->script_data()->url());
-  resolver.pending_set_pac_script_request()->CompleteNow(ERR_FAILED);
+            factory.pending_requests()[0]->script_data()->url());
+  factory.pending_requests()[0]->CompleteNow(ERR_FAILED, nullptr);
 
-  ASSERT_EQ(0u, resolver.pending_requests().size());
-  // As the proxy resolver failed the request and is configured for a mandatory
-  // PAC script, ProxyService must not implicitly fall-back to DIRECT.
+  ASSERT_EQ(0u, factory.pending_requests().size());
+  // As the proxy resolver factory failed the request and is configured for a
+  // mandatory PAC script, ProxyService must not implicitly fall-back to DIRECT.
   EXPECT_EQ(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED,
             callback1.WaitForResult());
   EXPECT_FALSE(info.is_direct());
 
-  // As the proxy resolver failed the request and is configured for a mandatory
-  // PAC script, ProxyService must not implicitly fall-back to DIRECT.
+  // As the proxy resolver factory failed the request and is configured for a
+  // mandatory PAC script, ProxyService must not implicitly fall-back to DIRECT.
   TestCompletionCallback callback2;
   rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback2.callback(), NULL, NULL,
       BoundNetLog());
   EXPECT_EQ(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED, rv);
   EXPECT_FALSE(info.is_direct());
 }
 
 TEST_F(ProxyServiceTest, ProxyResolverFailsParsingJavaScriptMandatoryPac) {
   // Test what happens when the ProxyResolver fails that is configured to use a
   // mandatory PAC script. The download of the PAC script has already
   // succeeded but the PAC script contains no valid javascript.
 
   ProxyConfig config(
       ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy/proxy.pac")));
   config.set_pac_mandatory(true);
 
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
 
-  MockAsyncProxyResolverExpectsBytes resolver;
+  MockAsyncProxyResolverFactory factory(true);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   DhcpProxyScriptFetcher* dhcp_fetcher = new DoNothingDhcpProxyScriptFetcher();
   service.SetProxyScriptFetchers(fetcher, dhcp_fetcher);
 
   // Start resolve request.
   GURL url("http://www.google.com/");
   ProxyInfo info;
   TestCompletionCallback callback;
   int rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback.callback(), NULL, NULL,
       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  // Check that nothing has been sent to the proxy resolver yet.
-  ASSERT_EQ(0u, resolver.pending_requests().size());
+  // Check that nothing has been sent to the proxy resolver factory yet.
+  ASSERT_EQ(0u, factory.pending_requests().size());
 
   // Downloading the PAC script succeeds.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(OK, "invalid-script-contents");
 
   EXPECT_FALSE(fetcher->has_pending_request());
-  ASSERT_EQ(0u, resolver.pending_requests().size());
+  ASSERT_EQ(0u, factory.pending_requests().size());
 
   // Since ProxyScriptDecider failed to identify a valid PAC and PAC was
   // mandatory for this configuration, the ProxyService must not implicitly
   // fall-back to DIRECT.
   EXPECT_EQ(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED,
             callback.WaitForResult());
   EXPECT_FALSE(info.is_direct());
 }
 
 TEST_F(ProxyServiceTest, ProxyResolverFailsInJavaScriptMandatoryPac) {
   // Test what happens when the ProxyResolver fails that is configured to use a
   // mandatory PAC script. The download and setting of the PAC script have
   // already succeeded, so this corresponds with a javascript runtime error
   // while calling FindProxyForURL().
 
   ProxyConfig config(
       ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy/proxy.pac")));
   config.set_pac_mandatory(true);
 
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
 
   MockAsyncProxyResolver resolver;
+  MockAsyncProxyResolverFactory factory(false);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   // Start first resolve request.
   GURL url("http://www.google.com/");
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback1.callback(), NULL, NULL,
       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
-            resolver.pending_set_pac_script_request()->script_data()->url());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->url());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // Fail the first resolve request in MockAsyncProxyResolver.
   resolver.pending_requests()[0]->CompleteNow(ERR_FAILED);
 
   // As the proxy resolver failed the request and is configured for a mandatory
   // PAC script, ProxyService must not implicitly fall-back to DIRECT.
   EXPECT_EQ(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED,
@@ skipping 22 matching lines @@
 }
 
 TEST_F(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");
 
   MockAsyncProxyResolver resolver;
+  MockAsyncProxyResolverFactory factory(false);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   GURL url("http://www.google.com/");
 
   // Get the proxy information.
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback1.callback(), NULL, NULL,
       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
-            resolver.pending_set_pac_script_request()->script_data()->url());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->url());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // Set the result in proxy resolver.
   resolver.pending_requests()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   // The first item is valid.
@@ skipping 117 matching lines @@
   // TODO(nsylvain): Test that the proxy can be retried after the delay.
 }
 
 // This test is similar to ProxyFallback, but this time we have an explicit
 // fallback choice to DIRECT.
 TEST_F(ProxyServiceTest, ProxyFallbackToDirect) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver resolver;
+  MockAsyncProxyResolverFactory factory(false);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   GURL url("http://www.google.com/");
 
   // Get the proxy information.
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback1.callback(), NULL, NULL,
       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
-            resolver.pending_set_pac_script_request()->script_data()->url());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->url());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // Set the result in proxy resolver.
   resolver.pending_requests()[0]->results()->UsePacString(
       "PROXY foopy1:8080; PROXY foopy2:9090; DIRECT");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Get the first result.
@@ skipping 38 matching lines @@
   EXPECT_EQ(ERR_FAILED, rv);
 }
 
 TEST_F(ProxyServiceTest, ProxyFallback_NewSettings) {
   // Test proxy failover when new settings are available.
 
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver resolver;
+  MockAsyncProxyResolverFactory factory(false);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   GURL url("http://www.google.com/");
 
   // Get the proxy information.
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback1.callback(), NULL, NULL,
       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
-            resolver.pending_set_pac_script_request()->script_data()->url());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->url());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // Set the result in proxy resolver.
   resolver.pending_requests()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   // The first item is valid.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   // Fake an error on the proxy, and also a new configuration on the proxy.
   config_service->SetConfig(
       ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy-new/proxy.pac")));
 
   TestCompletionCallback callback2;
   rv = service.ReconsiderProxyAfterError(url, net::LOAD_NORMAL,
                                          net::ERR_PROXY_CONNECTION_FAILED,
                                          &info, callback2.callback(), NULL,
                                          NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy-new/proxy.pac"),
-            resolver.pending_set_pac_script_request()->script_data()->url());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->url());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   resolver.pending_requests()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   // The first proxy is still there since the configuration changed.
   EXPECT_EQ(OK, callback2.WaitForResult());
@@ skipping 15 matching lines @@
 
   // We fake another error. It should go back to the first proxy.
   TestCompletionCallback callback4;
   rv = service.ReconsiderProxyAfterError(url, net::LOAD_NORMAL,
                                          net::ERR_PROXY_CONNECTION_FAILED,
                                          &info, callback4.callback(), NULL,
                                          NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy-new2/proxy.pac"),
-            resolver.pending_set_pac_script_request()->script_data()->url());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->url());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   resolver.pending_requests()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback4.WaitForResult());
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   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());
 }
 
 TEST_F(ProxyServiceTest, ProxyFallback_BadConfig) {
   // Test proxy failover when the configuration is bad.
 
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver resolver;
+  MockAsyncProxyResolverFactory factory(false);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   GURL url("http://www.google.com/");
 
   // Get the proxy information.
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback1.callback(), NULL, NULL,
       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
-            resolver.pending_set_pac_script_request()->script_data()->url());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->url());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   resolver.pending_requests()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   // The first item is valid.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_FALSE(info.is_direct());
@@ skipping 63 matching lines @@
 TEST_F(ProxyServiceTest, ProxyFallback_BadConfigMandatory) {
   // Test proxy failover when the configuration is bad.
 
   ProxyConfig config(
       ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy/proxy.pac")));
 
   config.set_pac_mandatory(true);
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
 
   MockAsyncProxyResolver resolver;
+  MockAsyncProxyResolverFactory factory(false);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   GURL url("http://www.google.com/");
 
   // Get the proxy information.
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback1.callback(), NULL, NULL,
       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
-            resolver.pending_set_pac_script_request()->script_data()->url());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->url());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   resolver.pending_requests()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   // The first item is valid.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_FALSE(info.is_direct());
@@ skipping 252 matching lines @@
     EXPECT_EQ("socks4://foopy2:1080", info.proxy_server().ToURI());
   }
 }
 
 // Test cancellation of an in-progress request.
 TEST_F(ProxyServiceTest, CancelInProgressRequest) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver resolver;
+  MockAsyncProxyResolverFactory factory(false);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   // Start 3 requests.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(GURL("http://request1"), net::LOAD_NORMAL,
                                 &info1, callback1.callback(), NULL, NULL,
                                 BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  // Nothing has been sent to the proxy resolver yet, since the proxy
-  // resolver has not been configured yet.
-  ASSERT_EQ(0u, resolver.pending_requests().size());
-
   // Successfully initialize the PAC script.
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
-            resolver.pending_set_pac_script_request()->script_data()->url());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->url());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(GURL("http://request1"), resolver.pending_requests()[0]->url());
 
   ProxyInfo info2;
   TestCompletionCallback callback2;
   ProxyService::PacRequest* request2;
   rv = service.ResolveProxy(GURL("http://request2"), net::LOAD_NORMAL, &info2,
                             callback2.callback(), &request2, NULL,
                             BoundNetLog());
@@ skipping 35 matching lines @@
   EXPECT_EQ(OK, callback3.WaitForResult());
   EXPECT_EQ("request3:80", info3.proxy_server().ToURI());
 }
 
 // Test the initial PAC download for resolver that expects bytes.
 TEST_F(ProxyServiceTest, InitialPACScriptDownload) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolverExpectsBytes resolver;
+  MockAsyncProxyResolverFactory factory(true);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 3 requests.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
   ProxyService::PacRequest* request1;
@@ skipping 15 matching lines @@
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ProxyInfo info3;
   TestCompletionCallback callback3;
   ProxyService::PacRequest* request3;
   rv = service.ResolveProxy(GURL("http://request3"), net::LOAD_NORMAL, &info3,
                             callback3.callback(), &request3, NULL,
                             BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  // Nothing has been sent to the resolver yet.
-  EXPECT_TRUE(resolver.pending_requests().empty());
+  // Nothing has been sent to the factory yet.
+  EXPECT_TRUE(factory.pending_requests().empty());
 
   EXPECT_EQ(LOAD_STATE_DOWNLOADING_PROXY_SCRIPT,
             service.GetLoadState(request1));
   EXPECT_EQ(LOAD_STATE_DOWNLOADING_PROXY_SCRIPT,
             service.GetLoadState(request2));
   EXPECT_EQ(LOAD_STATE_DOWNLOADING_PROXY_SCRIPT,
             service.GetLoadState(request3));
 
   // At this point the ProxyService should be waiting for the
   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   // PAC script download completion.
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   // Now that the PAC script is downloaded, it will have been sent to the proxy
   // resolver.
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
-            resolver.pending_set_pac_script_request()->script_data()->utf16());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->utf16());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(3u, resolver.pending_requests().size());
   EXPECT_EQ(GURL("http://request1"), resolver.pending_requests()[0]->url());
   EXPECT_EQ(GURL("http://request2"), resolver.pending_requests()[1]->url());
   EXPECT_EQ(GURL("http://request3"), resolver.pending_requests()[2]->url());
 
   EXPECT_EQ(LOAD_STATE_RESOLVING_PROXY_FOR_URL, service.GetLoadState(request1));
   EXPECT_EQ(LOAD_STATE_RESOLVING_PROXY_FOR_URL, service.GetLoadState(request2));
   EXPECT_EQ(LOAD_STATE_RESOLVING_PROXY_FOR_URL, service.GetLoadState(request3));
 
@@ skipping 28 matching lines @@
   EXPECT_FALSE(info3.proxy_resolve_end_time().is_null());
   EXPECT_LE(info3.proxy_resolve_start_time(), info3.proxy_resolve_end_time());
 }
 
 // Test changing the ProxyScriptFetcher while PAC download is in progress.
 TEST_F(ProxyServiceTest, ChangeScriptFetcherWhilePACDownloadInProgress) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolverExpectsBytes resolver;
+  MockAsyncProxyResolverFactory factory(true);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 2 requests.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(GURL("http://request1"), net::LOAD_NORMAL,
@@ skipping 15 matching lines @@
   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   // PAC script download completion.
 
   // We now change out the ProxyService's script fetcher. We should restart
   // the initialization with the new fetcher.
 
   fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
-  // Nothing has been sent to the resolver yet.
-  EXPECT_TRUE(resolver.pending_requests().empty());
+  // Nothing has been sent to the factory yet.
+  EXPECT_TRUE(factory.pending_requests().empty());
 
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   // Now that the PAC script is downloaded, it will have been sent to the proxy
   // resolver.
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
-            resolver.pending_set_pac_script_request()->script_data()->utf16());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->utf16());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(2u, resolver.pending_requests().size());
   EXPECT_EQ(GURL("http://request1"), resolver.pending_requests()[0]->url());
   EXPECT_EQ(GURL("http://request2"), resolver.pending_requests()[1]->url());
 }
 
 // Test cancellation of a request, while the PAC script is being fetched.
 TEST_F(ProxyServiceTest, CancelWhilePACFetching) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolverExpectsBytes resolver;
+  MockAsyncProxyResolverFactory factory(true);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 3 requests.
   ProxyInfo info1;
   TestCompletionCallback callback1;
   ProxyService::PacRequest* request1;
   BoundTestNetLog log1;
@@ skipping 13 matching lines @@
                             callback2.callback(), &request2, NULL,
                             BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ProxyInfo info3;
   TestCompletionCallback callback3;
   rv = service.ResolveProxy(GURL("http://request3"), net::LOAD_NORMAL, &info3,
                             callback3.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  // Nothing has been sent to the resolver yet.
-  EXPECT_TRUE(resolver.pending_requests().empty());
+  // Nothing has been sent to the factory yet.
+  EXPECT_TRUE(factory.pending_requests().empty());
 
   // Cancel the first 2 requests.
   service.CancelPacRequest(request1);
   service.CancelPacRequest(request2);
 
   // At this point the ProxyService should be waiting for the
   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   // PAC script download completion.
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   // Now that the PAC script is downloaded, it will have been sent to the
   // proxy resolver.
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
-            resolver.pending_set_pac_script_request()->script_data()->utf16());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->utf16());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(GURL("http://request3"), resolver.pending_requests()[0]->url());
 
   // Complete all the requests.
   resolver.pending_requests()[0]->results()->UseNamedProxy("request3:80");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback3.WaitForResult());
   EXPECT_EQ("request3:80", info3.proxy_server().ToURI());
@@ skipping 22 matching lines @@
 
 // Test that if auto-detect fails, we fall-back to the custom pac.
 TEST_F(ProxyServiceTest, FallbackFromAutodetectToCustomPac) {
   ProxyConfig config;
   config.set_auto_detect(true);
   config.set_pac_url(GURL("http://foopy/proxy.pac"));
   config.proxy_rules().ParseFromString("http=foopy:80");  // Won't be used.
 
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
   MockAsyncProxyResolverExpectsBytes resolver;
+  MockAsyncProxyResolverFactory factory(true);
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 2 requests.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(GURL("http://request1"), net::LOAD_NORMAL,
                                 &info1, callback1.callback(), NULL, NULL,
                                 BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ProxyInfo info2;
   TestCompletionCallback callback2;
   ProxyService::PacRequest* request2;
   rv = service.ResolveProxy(GURL("http://request2"), net::LOAD_NORMAL, &info2,
                             callback2.callback(), &request2, NULL,
                             BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  // Check that nothing has been sent to the proxy resolver yet.
-  ASSERT_EQ(0u, resolver.pending_requests().size());
+  // Check that nothing has been sent to the proxy resolver factory yet.
+  ASSERT_EQ(0u, factory.pending_requests().size());
 
   // It should be trying to auto-detect first -- FAIL the autodetect during
   // the script download.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://wpad/wpad.dat"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(ERR_FAILED, std::string());
 
   // Next it should be trying the custom PAC url.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
-            resolver.pending_set_pac_script_request()->script_data()->utf16());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->utf16());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   // Now finally, the pending requests should have been sent to the resolver
   // (which was initialized with custom PAC script).
 
   ASSERT_EQ(2u, resolver.pending_requests().size());
   EXPECT_EQ(GURL("http://request1"), resolver.pending_requests()[0]->url());
   EXPECT_EQ(GURL("http://request2"), resolver.pending_requests()[1]->url());
 
   // Complete the pending requests.
   resolver.pending_requests()[1]->results()->UseNamedProxy("request2:80");
@@ skipping 18 matching lines @@
 // This is the same test as FallbackFromAutodetectToCustomPac, except
 // the auto-detect script fails parsing rather than downloading.
 TEST_F(ProxyServiceTest, FallbackFromAutodetectToCustomPac2) {
   ProxyConfig config;
   config.set_auto_detect(true);
   config.set_pac_url(GURL("http://foopy/proxy.pac"));
   config.proxy_rules().ParseFromString("http=foopy:80");  // Won't be used.
 
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
   MockAsyncProxyResolverExpectsBytes resolver;
+  MockAsyncProxyResolverFactory factory(true);
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 2 requests.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(GURL("http://request1"), net::LOAD_NORMAL,
                                 &info1, callback1.callback(), NULL, NULL,
                                 BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ProxyInfo info2;
   TestCompletionCallback callback2;
   ProxyService::PacRequest* request2;
   rv = service.ResolveProxy(GURL("http://request2"), net::LOAD_NORMAL, &info2,
                             callback2.callback(), &request2, NULL,
                             BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  // Check that nothing has been sent to the proxy resolver yet.
-  ASSERT_EQ(0u, resolver.pending_requests().size());
+  // Check that nothing has been sent to the proxy resolver factory yet.
+  ASSERT_EQ(0u, factory.pending_requests().size());
 
   // It should be trying to auto-detect first -- succeed the download.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://wpad/wpad.dat"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(OK, "invalid-script-contents");
 
   // The script contents passed failed basic verification step (since didn't
   // contain token FindProxyForURL), so it was never passed to the resolver.
 
   // Next it should be trying the custom PAC url.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
-            resolver.pending_set_pac_script_request()->script_data()->utf16());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->utf16());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   // Now finally, the pending requests should have been sent to the resolver
   // (which was initialized with custom PAC script).
 
   ASSERT_EQ(2u, resolver.pending_requests().size());
   EXPECT_EQ(GURL("http://request1"), resolver.pending_requests()[0]->url());
   EXPECT_EQ(GURL("http://request2"), resolver.pending_requests()[1]->url());
 
   // Complete the pending requests.
   resolver.pending_requests()[1]->results()->UseNamedProxy("request2:80");
@@ skipping 11 matching lines @@
 
 // Test that if all of auto-detect, a custom PAC script, and manual settings
 // are given, then we will try them in that order.
 TEST_F(ProxyServiceTest, FallbackFromAutodetectToCustomToManual) {
   ProxyConfig config;
   config.set_auto_detect(true);
   config.set_pac_url(GURL("http://foopy/proxy.pac"));
   config.proxy_rules().ParseFromString("http=foopy:80");
 
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
-  MockAsyncProxyResolverExpectsBytes resolver;
+  MockAsyncProxyResolverFactory factory(true);
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 2 requests.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(GURL("http://request1"), net::LOAD_NORMAL,
                                 &info1, callback1.callback(), NULL, NULL,
                                 BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ProxyInfo info2;
   TestCompletionCallback callback2;
   ProxyService::PacRequest* request2;
   rv = service.ResolveProxy(GURL("http://request2"), net::LOAD_NORMAL, &info2,
                             callback2.callback(), &request2, NULL,
                             BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  // Check that nothing has been sent to the proxy resolver yet.
-  ASSERT_EQ(0u, resolver.pending_requests().size());
+  // Check that nothing has been sent to the proxy resolver factory yet.
+  ASSERT_EQ(0u, factory.pending_requests().size());
 
   // It should be trying to auto-detect first -- fail the download.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://wpad/wpad.dat"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(ERR_FAILED, std::string());
 
   // Next it should be trying the custom PAC url -- fail the download.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(ERR_FAILED, std::string());
 
   // Since we never managed to initialize a resolver, nothing should have been
   // sent to it.
-  ASSERT_EQ(0u, resolver.pending_requests().size());
+  ASSERT_EQ(0u, factory.pending_requests().size());
 
   // Verify that requests ran as expected -- they should have fallen back to
   // the manual proxy configuration for HTTP urls.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("foopy:80", info1.proxy_server().ToURI());
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ("foopy:80", info2.proxy_server().ToURI());
 }
 
 // Test that the bypass rules are NOT applied when using autodetect.
 TEST_F(ProxyServiceTest, BypassDoesntApplyToPac) {
   ProxyConfig config;
   config.set_auto_detect(true);
   config.set_pac_url(GURL("http://foopy/proxy.pac"));
   config.proxy_rules().ParseFromString("http=foopy:80");  // Not used.
   config.proxy_rules().bypass_rules.ParseFromString("www.google.com");
 
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
   MockAsyncProxyResolverExpectsBytes resolver;
+  MockAsyncProxyResolverFactory factory(true);
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 1 requests.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(
       GURL("http://www.google.com"), net::LOAD_NORMAL, &info1,
       callback1.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  // Check that nothing has been sent to the proxy resolver yet.
-  ASSERT_EQ(0u, resolver.pending_requests().size());
+  // Check that nothing has been sent to the proxy resolver factory yet.
+  ASSERT_EQ(0u, factory.pending_requests().size());
 
   // It should be trying to auto-detect first -- succeed the download.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://wpad/wpad.dat"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
-            resolver.pending_set_pac_script_request()->script_data()->utf16());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->utf16());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(GURL("http://www.google.com"),
             resolver.pending_requests()[0]->url());
 
   // Complete the pending request.
   resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Verify that request ran as expected.
@@ skipping 22 matching lines @@
 
 // Delete the ProxyService while InitProxyResolver has an outstanding
 // request to the script fetcher. When run under valgrind, should not
 // have any memory errors (used to be that the ProxyScriptFetcher was
 // being deleted prior to the InitProxyResolver).
 TEST_F(ProxyServiceTest, DeleteWhileInitProxyResolverHasOutstandingFetch) {
   ProxyConfig config =
     ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy/proxy.pac"));
 
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
-  MockAsyncProxyResolverExpectsBytes resolver;
+  MockAsyncProxyResolverFactory factory(true);
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 1 request.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(GURL("http://www.google.com"), net::LOAD_NORMAL,
                                 &info1, callback1.callback(), NULL, NULL,
                                 BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  // Check that nothing has been sent to the proxy resolver yet.
-  ASSERT_EQ(0u, resolver.pending_requests().size());
+  // Check that nothing has been sent to the proxy resolver factory yet.
+  ASSERT_EQ(0u, factory.pending_requests().size());
 
   // InitProxyResolver should have issued a request to the ProxyScriptFetcher
   // and be waiting on that to complete.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 }
 
 // Delete the ProxyService while InitProxyResolver has an outstanding
 // request to the proxy resolver. When run under valgrind, should not
 // have any memory errors (used to be that the ProxyResolver was
 // being deleted prior to the InitProxyResolver).
 TEST_F(ProxyServiceTest, DeleteWhileInitProxyResolverHasOutstandingSet) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
-  MockAsyncProxyResolver resolver;
+  MockAsyncProxyResolverFactory factory(false);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   GURL url("http://www.google.com/");
 
   ProxyInfo info;
   TestCompletionCallback callback;
   int rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback.callback(), NULL, NULL,
       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
-            resolver.pending_set_pac_script_request()->script_data()->url());
+            factory.pending_requests()[0]->script_data()->url());
 }
 
 TEST_F(ProxyServiceTest, ResetProxyConfigService) {
   ProxyConfig config1;
   config1.proxy_rules().ParseFromString("foopy1:8080");
   config1.set_auto_detect(false);
   ProxyService service(new MockProxyConfigService(config1), nullptr, NULL);
 
   ProxyInfo info;
   TestCompletionCallback callback1;
@@ skipping 14 matching lines @@
   EXPECT_EQ("foopy2:8080", info.proxy_server().ToURI());
 }
 
 // Test that when going from a configuration that required PAC to one
 // that does NOT, we unset the variable |should_use_proxy_resolver_|.
 TEST_F(ProxyServiceTest, UpdateConfigFromPACToDirect) {
   ProxyConfig config = ProxyConfig::CreateAutoDetect();
 
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
   MockAsyncProxyResolver resolver;
+  MockAsyncProxyResolverFactory factory(false);
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   // Start 1 request.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(GURL("http://www.google.com"), net::LOAD_NORMAL,
                                 &info1, callback1.callback(), NULL, NULL,
                                 BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  // Check that nothing has been sent to the proxy resolver yet.
-  ASSERT_EQ(0u, resolver.pending_requests().size());
-
   // Successfully set the autodetect script.
   EXPECT_EQ(ProxyResolverScriptData::TYPE_AUTO_DETECT,
-            resolver.pending_set_pac_script_request()->script_data()->type());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->type());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   // Complete the pending request.
   ASSERT_EQ(1u, resolver.pending_requests().size());
   resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Verify that request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
 
@@ skipping 13 matching lines @@
   EXPECT_EQ(OK, rv);
 
   EXPECT_TRUE(info2.is_direct());
 }
 
 TEST_F(ProxyServiceTest, NetworkChangeTriggersPacRefetch) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolverExpectsBytes resolver;
+  MockAsyncProxyResolverFactory factory(true);
 
   TestNetLog log;
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), &log);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), &log);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Disable the "wait after IP address changes" hack, so this unit-test can
   // complete quickly.
   service.set_stall_proxy_auto_config_delay(base::TimeDelta());
 
   // Start 1 request.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(GURL("http://request1"), net::LOAD_NORMAL,
                                 &info1, callback1.callback(), NULL, NULL,
                                 BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The first request should have triggered initial download of PAC script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
-  // Nothing has been sent to the resolver yet.
-  EXPECT_TRUE(resolver.pending_requests().empty());
+  // Nothing has been sent to the factory yet.
+  EXPECT_TRUE(factory.pending_requests().empty());
 
   // At this point the ProxyService should be waiting for the
   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   // PAC script download completion.
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   // Now that the PAC script is downloaded, the request will have been sent to
   // the proxy resolver.
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
-            resolver.pending_set_pac_script_request()->script_data()->utf16());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->utf16());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(GURL("http://request1"), resolver.pending_requests()[0]->url());
 
   // Complete the pending request.
   resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
@@ skipping 10 matching lines @@
   TestCompletionCallback callback2;
   rv = service.ResolveProxy(GURL("http://request2"), net::LOAD_NORMAL, &info2,
                             callback2.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // This second request should have triggered the re-download of the PAC
   // script (since we marked the network as having changed).
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
-  // Nothing has been sent to the resolver yet.
-  EXPECT_TRUE(resolver.pending_requests().empty());
+  // Nothing has been sent to the factory yet.
+  EXPECT_TRUE(factory.pending_requests().empty());
 
   // Simulate the PAC script fetch as having completed (this time with
   // different data).
   fetcher->NotifyFetchCompletion(OK, kValidPacScript2);
 
   // Now that the PAC script is downloaded, the second request will have been
   // sent to the proxy resolver.
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript2),
-            resolver.pending_set_pac_script_request()->script_data()->utf16());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->utf16());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(GURL("http://request2"), resolver.pending_requests()[0]->url());
 
   // Complete the pending second request.
   resolver.pending_requests()[0]->results()->UseNamedProxy("request2:80");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback2.WaitForResult());
@@ skipping 19 matching lines @@
 TEST_F(ProxyServiceTest, PACScriptRefetchAfterFailure) {
   // Change the retry policy to wait a mere 1 ms before retrying, so the test
   // runs quickly.
   ImmediatePollPolicy poll_policy;
   ProxyService::set_pac_script_poll_policy(&poll_policy);
 
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolverExpectsBytes resolver;
+  MockAsyncProxyResolverFactory factory(true);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 1 request.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(
       GURL("http://request1"), net::LOAD_NORMAL, &info1, callback1.callback(),
       NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The first request should have triggered initial download of PAC script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
-  // Nothing has been sent to the resolver yet.
-  EXPECT_TRUE(resolver.pending_requests().empty());
+  // Nothing has been sent to the factory yet.
+  EXPECT_TRUE(factory.pending_requests().empty());
 
   // At this point the ProxyService should be waiting for the
   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   // PAC script download completion.
   //
   // We simulate a failed download attempt, the proxy service should now
   // fall-back to DIRECT connections.
   fetcher->NotifyFetchCompletion(ERR_FAILED, std::string());
 
-  ASSERT_TRUE(resolver.pending_requests().empty());
+  ASSERT_TRUE(factory.pending_requests().empty());
 
   // Wait for completion callback, and verify it used DIRECT.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_TRUE(info1.is_direct());
 
   // At this point we have initialized the proxy service using a PAC script,
   // however it failed and fell-back to DIRECT.
   //
   // A background task to periodically re-check the PAC script for validity will
   // have been started. We will now wait for the next download attempt to start.
   //
   // Note that we shouldn't have to wait long here, since our test enables a
   // special unit-test mode.
   fetcher->WaitUntilFetch();
 
-  ASSERT_TRUE(resolver.pending_requests().empty());
+  ASSERT_TRUE(factory.pending_requests().empty());
 
   // Make sure that our background checker is trying to download the expected
   // PAC script (same one as before). This time we will simulate a successful
   // download of the script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   base::MessageLoop::current()->RunUntilIdle();
 
   // Now that the PAC script is downloaded, it should be used to initialize the
   // ProxyResolver. Simulate a successful parse.
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
-            resolver.pending_set_pac_script_request()->script_data()->utf16());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->utf16());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   // At this point the ProxyService should have re-configured itself to use the
   // PAC script (thereby recovering from the initial fetch failure). We will
   // verify that the next Resolve request uses the resolver rather than
   // DIRECT.
 
   // Start a second request.
   ProxyInfo info2;
   TestCompletionCallback callback2;
   rv = service.ResolveProxy(
@@ skipping 21 matching lines @@
 TEST_F(ProxyServiceTest, PACScriptRefetchAfterContentChange) {
   // Change the retry policy to wait a mere 1 ms before retrying, so the test
   // runs quickly.
   ImmediatePollPolicy poll_policy;
   ProxyService::set_pac_script_poll_policy(&poll_policy);
 
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolverExpectsBytes resolver;
+  MockAsyncProxyResolverFactory factory(true);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 1 request.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(
       GURL("http://request1"), net::LOAD_NORMAL, &info1, callback1.callback(),
       NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The first request should have triggered initial download of PAC script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
-  // Nothing has been sent to the resolver yet.
-  EXPECT_TRUE(resolver.pending_requests().empty());
+  // Nothing has been sent to the factory yet.
+  EXPECT_TRUE(factory.pending_requests().empty());
 
   // At this point the ProxyService should be waiting for the
   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   // PAC script download completion.
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   // Now that the PAC script is downloaded, the request will have been sent to
   // the proxy resolver.
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
-            resolver.pending_set_pac_script_request()->script_data()->utf16());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->utf16());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(GURL("http://request1"), resolver.pending_requests()[0]->url());
 
   // Complete the pending request.
   resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
 
   // At this point we have initialized the proxy service using a PAC script.
   //
   // A background task to periodically re-check the PAC script for validity will
   // have been started. We will now wait for the next download attempt to start.
   //
   // Note that we shouldn't have to wait long here, since our test enables a
   // special unit-test mode.
   fetcher->WaitUntilFetch();
 
+  ASSERT_TRUE(factory.pending_requests().empty());
   ASSERT_TRUE(resolver.pending_requests().empty());
 
   // Make sure that our background checker is trying to download the expected
   // PAC script (same one as before). This time we will simulate a successful
   // download of a DIFFERENT script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(OK, kValidPacScript2);
 
   base::MessageLoop::current()->RunUntilIdle();
 
   // Now that the PAC script is downloaded, it should be used to initialize the
   // ProxyResolver. Simulate a successful parse.
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript2),
-            resolver.pending_set_pac_script_request()->script_data()->utf16());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->utf16());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   // At this point the ProxyService should have re-configured itself to use the
   // new PAC script.
 
   // Start a second request.
   ProxyInfo info2;
   TestCompletionCallback callback2;
   rv = service.ResolveProxy(
       GURL("http://request2"), net::LOAD_NORMAL, &info2, callback2.callback(),
       NULL, NULL, BoundNetLog());
@@ skipping 19 matching lines @@
 TEST_F(ProxyServiceTest, PACScriptRefetchAfterContentUnchanged) {
   // Change the retry policy to wait a mere 1 ms before retrying, so the test
   // runs quickly.
   ImmediatePollPolicy poll_policy;
   ProxyService::set_pac_script_poll_policy(&poll_policy);
 
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolverExpectsBytes resolver;
+  MockAsyncProxyResolverFactory factory(true);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 1 request.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(
       GURL("http://request1"), net::LOAD_NORMAL, &info1, callback1.callback(),
       NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The first request should have triggered initial download of PAC script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
-  // Nothing has been sent to the resolver yet.
-  EXPECT_TRUE(resolver.pending_requests().empty());
+  // Nothing has been sent to the factory yet.
+  EXPECT_TRUE(factory.pending_requests().empty());
 
   // At this point the ProxyService should be waiting for the
   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   // PAC script download completion.
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   // Now that the PAC script is downloaded, the request will have been sent to
   // the proxy resolver.
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
-            resolver.pending_set_pac_script_request()->script_data()->utf16());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->utf16());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(GURL("http://request1"), resolver.pending_requests()[0]->url());
 
   // Complete the pending request.
   resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
 
   // At this point we have initialized the proxy service using a PAC script.
   //
   // A background task to periodically re-check the PAC script for validity will
   // have been started. We will now wait for the next download attempt to start.
   //
   // Note that we shouldn't have to wait long here, since our test enables a
   // special unit-test mode.
   fetcher->WaitUntilFetch();
 
+  ASSERT_TRUE(factory.pending_requests().empty());
   ASSERT_TRUE(resolver.pending_requests().empty());
 
   // Make sure that our background checker is trying to download the expected
   // PAC script (same one as before). We will simulate the same response as
   // last time (i.e. the script is unchanged).
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   base::MessageLoop::current()->RunUntilIdle();
 
-  ASSERT_FALSE(resolver.has_pending_set_pac_script_request());
+  ASSERT_TRUE(factory.pending_requests().empty());
+  ASSERT_TRUE(resolver.pending_requests().empty());
 
   // At this point the ProxyService is still running the same PAC script as
   // before.
 
   // Start a second request.
   ProxyInfo info2;
   TestCompletionCallback callback2;
   rv = service.ResolveProxy(
       GURL("http://request2"), net::LOAD_NORMAL, &info2, callback2.callback(),
       NULL, NULL, BoundNetLog());
@@ skipping 19 matching lines @@
 TEST_F(ProxyServiceTest, PACScriptRefetchAfterSuccess) {
   // Change the retry policy to wait a mere 1 ms before retrying, so the test
   // runs quickly.
   ImmediatePollPolicy poll_policy;
   ProxyService::set_pac_script_poll_policy(&poll_policy);
 
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolverExpectsBytes resolver;
+  MockAsyncProxyResolverFactory factory(true);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 1 request.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(
       GURL("http://request1"), net::LOAD_NORMAL, &info1, callback1.callback(),
       NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The first request should have triggered initial download of PAC script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
-  // Nothing has been sent to the resolver yet.
-  EXPECT_TRUE(resolver.pending_requests().empty());
+  // Nothing has been sent to the factory yet.
+  EXPECT_TRUE(factory.pending_requests().empty());
 
   // At this point the ProxyService should be waiting for the
   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   // PAC script download completion.
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   // Now that the PAC script is downloaded, the request will have been sent to
   // the proxy resolver.
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
-            resolver.pending_set_pac_script_request()->script_data()->utf16());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->utf16());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(GURL("http://request1"), resolver.pending_requests()[0]->url());
 
   // Complete the pending request.
   resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
 
   // At this point we have initialized the proxy service using a PAC script.
   //
   // A background task to periodically re-check the PAC script for validity will
   // have been started. We will now wait for the next download attempt to start.
   //
   // Note that we shouldn't have to wait long here, since our test enables a
   // special unit-test mode.
   fetcher->WaitUntilFetch();
 
+  ASSERT_TRUE(factory.pending_requests().empty());
   ASSERT_TRUE(resolver.pending_requests().empty());
 
   // Make sure that our background checker is trying to download the expected
   // PAC script (same one as before). This time we will simulate a failure
   // to download the script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(ERR_FAILED, std::string());
 
   base::MessageLoop::current()->RunUntilIdle();
@@ skipping 77 matching lines @@
 // This tests the polling of the PAC script. Specifically, it tests that
 // polling occurs in response to user activity.
 TEST_F(ProxyServiceTest, PACScriptRefetchAfterActivity) {
   ImmediateAfterActivityPollPolicy poll_policy;
   ProxyService::set_pac_script_poll_policy(&poll_policy);
 
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolverExpectsBytes resolver;
+  MockAsyncProxyResolverFactory factory(true);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 1 request.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(
       GURL("http://request1"), net::LOAD_NORMAL, &info1, callback1.callback(),
       NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The first request should have triggered initial download of PAC script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
-  // Nothing has been sent to the resolver yet.
-  EXPECT_TRUE(resolver.pending_requests().empty());
+  // Nothing has been sent to the factory yet.
+  EXPECT_TRUE(factory.pending_requests().empty());
 
   // At this point the ProxyService should be waiting for the
   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   // PAC script download completion.
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   // Now that the PAC script is downloaded, the request will have been sent to
   // the proxy resolver.
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
-            resolver.pending_set_pac_script_request()->script_data()->utf16());
-  resolver.pending_set_pac_script_request()->CompleteNow(OK);
+            factory.pending_requests()[0]->script_data()->utf16());
+  factory.pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(GURL("http://request1"), resolver.pending_requests()[0]->url());
 
   // Complete the pending request.
   resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
 
   // At this point we have initialized the proxy service using a PAC script.
   // Our PAC poller is set to update ONLY in response to network activity,
   // (i.e. another call to ResolveProxy()).
 
   ASSERT_FALSE(fetcher->has_pending_request());
+  ASSERT_TRUE(factory.pending_requests().empty());
   ASSERT_TRUE(resolver.pending_requests().empty());
 
   // Start a second request.
   ProxyInfo info2;
   TestCompletionCallback callback2;
   rv = service.ResolveProxy(
       GURL("http://request2"), net::LOAD_NORMAL, &info2, callback2.callback(),
       NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ skipping 28 matching lines @@
       NULL, NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(info3.is_direct());
 }
 
 // Test that the synchronous resolution fails when a PAC script is active.
 TEST_F(ProxyServiceTest, SynchronousWithPAC) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
-  MockAsyncProxyResolver resolver;
+  MockAsyncProxyResolverFactory factory(false);
 
   ProxyService service(
       config_service,
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   GURL url("http://www.google.com/");
 
   ProxyInfo info;
   info.UseDirect();
   BoundTestNetLog log;
 
   bool synchronous_success = service.TryResolveProxySynchronously(
       url, net::LOAD_NORMAL, &info, NULL, log.bound());
   EXPECT_FALSE(synchronous_success);
 
-  // No request should have been queued.
-  EXPECT_EQ(0u, resolver.pending_requests().size());
-
   // |info| should not have been modified.
   EXPECT_TRUE(info.is_direct());
 }
 
 // Test that synchronous results are returned correctly if a fixed proxy
 // configuration is active.
 TEST_F(ProxyServiceTest, SynchronousWithFixedConfiguration) {
   ProxyConfig config;
   config.proxy_rules().ParseFromString("foopy1:8080");
   config.set_auto_detect(false);
 
-  MockAsyncProxyResolver resolver;
+  MockAsyncProxyResolverFactory factory(false);
 
   ProxyService service(
       new MockProxyConfigService(config),
-      make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
+      make_scoped_ptr(new ForwardingProxyResolverFactory(&factory)), NULL);
 
   GURL url("http://www.google.com/");
 
   ProxyInfo info;
   BoundTestNetLog log;
 
   bool synchronous_success = service.TryResolveProxySynchronously(
       url, net::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, resolver.pending_requests().size());
+  EXPECT_EQ(0u, factory.pending_requests().size());
 }
 
 }  // namespace net