base::Bind: Convert net/proxy.

net/proxy/proxy_service_unittest.cc

 // Copyright (c) 2011 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 63 matching lines @@
 }  // namespace
 
 TEST(ProxyServiceTest, Direct) {
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
   ProxyService service(new MockProxyConfigService(
           ProxyConfig::CreateDirect()), resolver, NULL);
 
   GURL url("http://www.google.com/");
 
   ProxyInfo info;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
-  int rv = service.ResolveProxy(url, &info, &callback, NULL, log.bound());
+  int rv = service.ResolveProxy(
+      url, &info, callback.callback(), NULL, log.bound());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(resolver->pending_requests().empty());
 
   EXPECT_TRUE(info.is_direct());
 
   // Check the NetLog was filled correctly.
   CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(3u, entries.size());
@@ skipping 10 matching lines @@
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   ProxyService service(config_service, resolver, NULL);
 
   GURL url("http://www.google.com/");
 
   ProxyInfo info;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
 
-  int rv = service.ResolveProxy(url, &info, &callback, NULL, log.bound());
+  int rv = service.ResolveProxy(
+      url, &info, callback.callback(), NULL, log.bound());
   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);
 
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
 
   // Set the result in proxy resolver.
@@ skipping 25 matching lines @@
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   ProxyService service(config_service, resolver, NULL);
 
   GURL url("http://username:password@www.google.com/?ref#hash#hash");
 
   ProxyInfo info;
-  TestOldCompletionCallback callback;
-  int rv = service.ResolveProxy(url, &info, &callback, NULL, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = service.ResolveProxy(
+      url, &info, callback.callback(), 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);
 
   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(ProxyServiceTest, PAC_FailoverWithoutDirect) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   ProxyService service(config_service, resolver, NULL);
 
   GURL url("http://www.google.com/");
 
   ProxyInfo info;
-  TestOldCompletionCallback callback1;
-  int rv = service.ResolveProxy(url, &info, &callback1, NULL, BoundNetLog());
+  TestCompletionCallback callback1;
+  int rv = service.ResolveProxy(
+      url, &info, callback1.callback(), 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);
 
   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());
   EXPECT_EQ("foopy:8080", info.proxy_server().ToURI());
 
   // Now, imagine that connecting to foopy:8080 fails: there is nothing
   // left to fallback to, since our proxy list was NOT terminated by
   // DIRECT.
   TestCompletionCallback callback2;
-  rv = service.ReconsiderProxyAfterError(url, &info, callback2.callback(), NULL,
-                                         BoundNetLog());
+  rv = service.ReconsiderProxyAfterError(
+      url, &info, callback2.callback(), NULL, BoundNetLog());
   // ReconsiderProxyAfterError returns error indicating nothing left.
   EXPECT_EQ(ERR_FAILED, rv);
   EXPECT_TRUE(info.is_empty());
 }
 
 // The proxy list could potentially contain the DIRECT fallback choice
 // in a location other than the very end of the list, and could even
 // specify it multiple times.
 //
 // This is not a typical usage, but we will obey it.
@@ skipping 12 matching lines @@
 TEST(ProxyServiceTest, PAC_FailoverAfterDirect) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   ProxyService service(config_service, resolver, NULL);
 
   GURL url("http://www.google.com/");
 
   ProxyInfo info;
-  TestOldCompletionCallback callback1;
-  int rv = service.ResolveProxy(url, &info, &callback1, NULL, BoundNetLog());
+  TestCompletionCallback callback1;
+  int rv = service.ResolveProxy(
+      url, &info, callback1.callback(), 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);
 
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
 
   // Set the result in proxy resolver.
@@ skipping 43 matching lines @@
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   ProxyService service(config_service, resolver, NULL);
 
   // Start first resolve request.
   GURL url("http://www.google.com/");
   ProxyInfo info;
-  TestOldCompletionCallback callback1;
-  int rv = service.ResolveProxy(url, &info, &callback1, NULL, BoundNetLog());
+  TestCompletionCallback callback1;
+  int rv = service.ResolveProxy(
+      url, &info, callback1.callback(), 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);
 
   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());
   EXPECT_TRUE(info.is_direct());
 
   // The second resolve request will try to run through the proxy resolver,
   // regardless of whether the first request failed in it.
-  TestOldCompletionCallback callback2;
-  rv = service.ResolveProxy(url, &info, &callback2, NULL, BoundNetLog());
+  TestCompletionCallback callback2;
+  rv = service.ResolveProxy(
+      url, &info, callback2.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
 
   // This time we will have the resolver succeed (perhaps the PAC script has
   // a dependency on the current time).
   resolver->pending_requests()[0]->results()->UseNamedProxy("foopy_valid:8080");
   resolver->pending_requests()[0]->CompleteNow(OK);
 
@@ skipping 12 matching lines @@
 
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
 
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   ProxyService service(config_service, resolver, NULL);
 
   // Start first resolve request.
   GURL url("http://www.google.com/");
   ProxyInfo info;
-  TestOldCompletionCallback callback1;
-  int rv = service.ResolveProxy(url, &info, &callback1, NULL, BoundNetLog());
+  TestCompletionCallback callback1;
+  int rv = service.ResolveProxy(
+      url, &info, callback1.callback(), 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);
 
   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.
   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.
-  TestOldCompletionCallback callback2;
-  rv = service.ResolveProxy(url, &info, &callback2, NULL, BoundNetLog());
+  TestCompletionCallback callback2;
+  rv = service.ResolveProxy(
+      url, &info, callback2.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED, rv);
   EXPECT_FALSE(info.is_direct());
 }
 
 TEST(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 =
       new MockAsyncProxyResolverExpectsBytes;
 
   ProxyService service(config_service, resolver, 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;
-  TestOldCompletionCallback callback;
-  int rv = service.ResolveProxy(url, &info, &callback, NULL, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = service.ResolveProxy(
+      url, &info, callback.callback(), 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());
 
   // 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");
 
@@ skipping 20 matching lines @@
 
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
 
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   ProxyService service(config_service, resolver, NULL);
 
   // Start first resolve request.
   GURL url("http://www.google.com/");
   ProxyInfo info;
-  TestOldCompletionCallback callback1;
-  int rv = service.ResolveProxy(url, &info, &callback1, NULL, BoundNetLog());
+  TestCompletionCallback callback1;
+  int rv = service.ResolveProxy(
+      url, &info, callback1.callback(), 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);
 
   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,
             callback1.WaitForResult());
   EXPECT_FALSE(info.is_direct());
 
   // The second resolve request will try to run through the proxy resolver,
   // regardless of whether the first request failed in it.
-  TestOldCompletionCallback callback2;
-  rv = service.ResolveProxy(url, &info, &callback2, NULL, BoundNetLog());
+  TestCompletionCallback callback2;
+  rv = service.ResolveProxy(
+      url, &info, callback2.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
 
   // This time we will have the resolver succeed (perhaps the PAC script has
   // a dependency on the current time).
   resolver->pending_requests()[0]->results()->UseNamedProxy("foopy_valid:8080");
   resolver->pending_requests()[0]->CompleteNow(OK);
 
@@ skipping 10 matching lines @@
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   ProxyService service(config_service, resolver, NULL);
 
   GURL url("http://www.google.com/");
 
   // Get the proxy information.
   ProxyInfo info;
-  TestOldCompletionCallback callback1;
-  int rv = service.ResolveProxy(url, &info, &callback1, NULL, BoundNetLog());
+  TestCompletionCallback callback1;
+  int rv = service.ResolveProxy(
+      url, &info, callback1.callback(), 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);
 
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
 
   // Set the result in proxy resolver.
@@ skipping 11 matching lines @@
   rv = service.ReconsiderProxyAfterError(url, &info, callback2.callback(), NULL,
                                          BoundNetLog());
   EXPECT_EQ(OK, rv);
 
   // The second proxy should be specified.
   EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
   // Report back that the second proxy worked.  This will globally mark the
   // first proxy as bad.
   service.ReportSuccess(info);
 
-  TestOldCompletionCallback callback3;
-  rv = service.ResolveProxy(url, &info, &callback3, NULL, BoundNetLog());
+  TestCompletionCallback callback3;
+  rv = service.ResolveProxy(
+      url, &info, callback3.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
 
   // Set the result in proxy resolver -- the second result is already known
   // to be bad, so we will not try to use it initially.
   resolver->pending_requests()[0]->results()->UseNamedProxy(
       "foopy3:7070;foopy1:8080;foopy2:9090");
   resolver->pending_requests()[0]->CompleteNow(OK);
@@ skipping 57 matching lines @@
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   ProxyService service(config_service, resolver, NULL);
 
   GURL url("http://www.google.com/");
 
   // Get the proxy information.
   ProxyInfo info;
-  TestOldCompletionCallback callback1;
-  int rv = service.ResolveProxy(url, &info, &callback1, NULL, BoundNetLog());
+  TestCompletionCallback callback1;
+  int rv = service.ResolveProxy(
+      url, &info, callback1.callback(), 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);
 
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
 
   // Set the result in proxy resolver.
@@ skipping 40 matching lines @@
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   ProxyService service(config_service, resolver, NULL);
 
   GURL url("http://www.google.com/");
 
   // Get the proxy information.
   ProxyInfo info;
-  TestOldCompletionCallback callback1;
-  int rv = service.ResolveProxy(url, &info, &callback1, NULL, BoundNetLog());
+  TestCompletionCallback callback1;
+  int rv = service.ResolveProxy(
+      url, &info, callback1.callback(), 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);
 
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
 
   // Set the result in proxy resolver.
@@ skipping 70 matching lines @@
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   ProxyService service(config_service, resolver, NULL);
 
   GURL url("http://www.google.com/");
 
   // Get the proxy information.
   ProxyInfo info;
-  TestOldCompletionCallback callback1;
-  int rv = service.ResolveProxy(url, &info, &callback1, NULL, BoundNetLog());
+  TestCompletionCallback callback1;
+  int rv = service.ResolveProxy(
+      url, &info, callback1.callback(), 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);
   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());
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   // Fake a proxy error.
   TestCompletionCallback callback2;
   rv = service.ReconsiderProxyAfterError(url, &info, callback2.callback(), NULL,
                                          BoundNetLog());
   EXPECT_EQ(OK, rv);
 
   // 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.
   ProxyInfo info2;
-  TestOldCompletionCallback callback3;
-  rv = service.ResolveProxy(url, &info2, &callback3, NULL, BoundNetLog());
+  TestCompletionCallback callback3;
+  rv = service.ResolveProxy(
+      url, &info2, callback3.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
 
   // This simulates a javascript runtime error in the PAC script.
   resolver->pending_requests()[0]->CompleteNow(ERR_FAILED);
 
   // Although the resolver failed, the ProxyService will implicitly fall-back
   // to a DIRECT connection.
@@ skipping 34 matching lines @@
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
 
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   ProxyService service(config_service, resolver, NULL);
 
   GURL url("http://www.google.com/");
 
   // Get the proxy information.
   ProxyInfo info;
-  TestOldCompletionCallback callback1;
-  int rv = service.ResolveProxy(url, &info, &callback1, NULL, BoundNetLog());
+  TestCompletionCallback callback1;
+  int rv = service.ResolveProxy(
+      url, &info, callback1.callback(), 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);
   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());
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   // Fake a proxy error.
   TestCompletionCallback callback2;
   rv = service.ReconsiderProxyAfterError(url, &info, callback2.callback(), NULL,
                                          BoundNetLog());
   EXPECT_EQ(OK, rv);
 
   // 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.
   ProxyInfo info2;
-  TestOldCompletionCallback callback3;
-  rv = service.ResolveProxy(url, &info2, &callback3, NULL, BoundNetLog());
+  TestCompletionCallback callback3;
+  rv = service.ResolveProxy(
+      url, &info2, callback3.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
 
   // This simulates a javascript runtime error in the PAC script.
   resolver->pending_requests()[0]->CompleteNow(ERR_FAILED);
 
   // Although the resolver failed, the ProxyService will NOT fall-back
   // to a DIRECT connection as it is configured as mandatory.
@@ skipping 21 matching lines @@
   // The first proxy is not there since the it was added to the bad proxies
   // list by the earlier ReconsiderProxyAfterError().
   EXPECT_EQ(OK, callback4.WaitForResult());
   EXPECT_FALSE(info3.is_direct());
   EXPECT_EQ("foopy1:8080", info3.proxy_server().ToURI());
 }
 
 TEST(ProxyServiceTest, ProxyBypassList) {
   // Test that the proxy bypass rules are consulted.
 
-  TestOldCompletionCallback callback[2];
+  TestCompletionCallback callback[2];
   ProxyInfo info[2];
   ProxyConfig config;
   config.proxy_rules().ParseFromString("foopy1:8080;foopy2:9090");
   config.set_auto_detect(false);
   config.proxy_rules().bypass_rules.ParseFromString("*.org");
 
   ProxyService service(
       new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
 
   int rv;
   GURL url1("http://www.webkit.org");
   GURL url2("http://www.webkit.com");
 
   // Request for a .org domain should bypass proxy.
-  rv = service.ResolveProxy(url1, &info[0], &callback[0], NULL, BoundNetLog());
+  rv = service.ResolveProxy(
+      url1, &info[0], callback[0].callback(), NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(info[0].is_direct());
 
   // Request for a .com domain hits the proxy.
-  rv = service.ResolveProxy(url2, &info[1], &callback[1], NULL, BoundNetLog());
+  rv = service.ResolveProxy(
+      url2, &info[1], callback[1].callback(), NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("foopy1:8080", info[1].proxy_server().ToURI());
 }
 
 
 TEST(ProxyServiceTest, PerProtocolProxyTests) {
   ProxyConfig config;
   config.proxy_rules().ParseFromString("http=foopy1:8080;https=foopy2:8080");
   config.set_auto_detect(false);
   {
     ProxyService service(
         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
     GURL test_url("http://www.msn.com");
     ProxyInfo info;
-    TestOldCompletionCallback callback;
-    int rv = service.ResolveProxy(test_url, &info, &callback, NULL,
+    TestCompletionCallback callback;
+    int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
                                   BoundNetLog());
     EXPECT_EQ(OK, rv);
     EXPECT_FALSE(info.is_direct());
     EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
   }
   {
     ProxyService service(
         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
     GURL test_url("ftp://ftp.google.com");
     ProxyInfo info;
-    TestOldCompletionCallback callback;
-    int rv = service.ResolveProxy(test_url, &info, &callback, NULL,
+    TestCompletionCallback callback;
+    int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
                                   BoundNetLog());
     EXPECT_EQ(OK, rv);
     EXPECT_TRUE(info.is_direct());
     EXPECT_EQ("direct://", info.proxy_server().ToURI());
   }
   {
     ProxyService service(
         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
     GURL test_url("https://webbranch.techcu.com");
     ProxyInfo info;
-    TestOldCompletionCallback callback;
-    int rv = service.ResolveProxy(test_url, &info, &callback, NULL,
+    TestCompletionCallback callback;
+    int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
                                   BoundNetLog());
     EXPECT_EQ(OK, rv);
     EXPECT_FALSE(info.is_direct());
     EXPECT_EQ("foopy2:8080", info.proxy_server().ToURI());
   }
   {
     config.proxy_rules().ParseFromString("foopy1:8080");
     ProxyService service(
         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
     GURL test_url("http://www.microsoft.com");
     ProxyInfo info;
-    TestOldCompletionCallback callback;
-    int rv = service.ResolveProxy(test_url, &info, &callback, NULL,
+    TestCompletionCallback callback;
+    int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
                                   BoundNetLog());
     EXPECT_EQ(OK, rv);
     EXPECT_FALSE(info.is_direct());
     EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
   }
 }
 
 // If only HTTP and a SOCKS proxy are specified, check if ftp/https queries
 // fall back to the SOCKS proxy.
 TEST(ProxyServiceTest, DefaultProxyFallbackToSOCKS) {
   ProxyConfig config;
   config.proxy_rules().ParseFromString("http=foopy1:8080;socks=foopy2:1080");
   config.set_auto_detect(false);
   EXPECT_EQ(ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME,
             config.proxy_rules().type);
 
   {
     ProxyService service(
         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
     GURL test_url("http://www.msn.com");
     ProxyInfo info;
-    TestOldCompletionCallback callback;
-    int rv = service.ResolveProxy(test_url, &info, &callback, NULL,
+    TestCompletionCallback callback;
+    int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
                                   BoundNetLog());
     EXPECT_EQ(OK, rv);
     EXPECT_FALSE(info.is_direct());
     EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
   }
   {
     ProxyService service(
         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
     GURL test_url("ftp://ftp.google.com");
     ProxyInfo info;
-    TestOldCompletionCallback callback;
-    int rv = service.ResolveProxy(test_url, &info, &callback, NULL,
+    TestCompletionCallback callback;
+    int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
                                   BoundNetLog());
     EXPECT_EQ(OK, rv);
     EXPECT_FALSE(info.is_direct());
     EXPECT_EQ("socks4://foopy2:1080", info.proxy_server().ToURI());
   }
   {
     ProxyService service(
         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
     GURL test_url("https://webbranch.techcu.com");
     ProxyInfo info;
-    TestOldCompletionCallback callback;
-    int rv = service.ResolveProxy(test_url, &info, &callback, NULL,
+    TestCompletionCallback callback;
+    int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
                                   BoundNetLog());
     EXPECT_EQ(OK, rv);
     EXPECT_FALSE(info.is_direct());
     EXPECT_EQ("socks4://foopy2:1080", info.proxy_server().ToURI());
   }
   {
     ProxyService service(
         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
     GURL test_url("unknown://www.microsoft.com");
     ProxyInfo info;
-    TestOldCompletionCallback callback;
-    int rv = service.ResolveProxy(test_url, &info, &callback, NULL,
+    TestCompletionCallback callback;
+    int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
                                   BoundNetLog());
     EXPECT_EQ(OK, rv);
     EXPECT_FALSE(info.is_direct());
     EXPECT_EQ("socks4://foopy2:1080", info.proxy_server().ToURI());
   }
 }
 
 // Test cancellation of an in-progress request.
 TEST(ProxyServiceTest, CancelInProgressRequest) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   ProxyService service(config_service, resolver, NULL);
 
   // Start 3 requests.
 
   ProxyInfo info1;
-  TestOldCompletionCallback callback1;
-  int rv = service.ResolveProxy(
-      GURL("http://request1"), &info1, &callback1, NULL, BoundNetLog());
+  TestCompletionCallback callback1;
+  int rv = service.ResolveProxy(GURL("http://request1"), &info1,
+                                callback1.callback(), 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);
 
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(GURL("http://request1"), resolver->pending_requests()[0]->url());
 
   ProxyInfo info2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   ProxyService::PacRequest* request2;
-  rv = service.ResolveProxy(
-      GURL("http://request2"), &info2, &callback2, &request2, BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request2"), &info2,
+                            callback2.callback(), &request2, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   ASSERT_EQ(2u, resolver->pending_requests().size());
   EXPECT_EQ(GURL("http://request2"), resolver->pending_requests()[1]->url());
 
   ProxyInfo info3;
-  TestOldCompletionCallback callback3;
-  rv = service.ResolveProxy(
-      GURL("http://request3"), &info3, &callback3, NULL, BoundNetLog());
+  TestCompletionCallback callback3;
+  rv = service.ResolveProxy(GURL("http://request3"), &info3,
+                            callback3.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   ASSERT_EQ(3u, resolver->pending_requests().size());
   EXPECT_EQ(GURL("http://request3"), resolver->pending_requests()[2]->url());
 
   // Cancel the second request
   service.CancelPacRequest(request2);
 
   ASSERT_EQ(2u, resolver->pending_requests().size());
   EXPECT_EQ(GURL("http://request1"), resolver->pending_requests()[0]->url());
   EXPECT_EQ(GURL("http://request3"), resolver->pending_requests()[1]->url());
@@ skipping 28 matching lines @@
 
   ProxyService service(config_service, resolver, NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 3 requests.
 
   ProxyInfo info1;
-  TestOldCompletionCallback callback1;
-  int rv = service.ResolveProxy(
-      GURL("http://request1"), &info1, &callback1, NULL, BoundNetLog());
+  TestCompletionCallback callback1;
+  int rv = service.ResolveProxy(GURL("http://request1"), &info1,
+                                callback1.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The first request should have triggered download of PAC script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
   ProxyInfo info2;
-  TestOldCompletionCallback callback2;
-  rv = service.ResolveProxy(
-      GURL("http://request2"), &info2, &callback2, NULL, BoundNetLog());
+  TestCompletionCallback callback2;
+  rv = service.ResolveProxy(GURL("http://request2"), &info2,
+                            callback2.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ProxyInfo info3;
-  TestOldCompletionCallback callback3;
-  rv = service.ResolveProxy(
-      GURL("http://request3"), &info3, &callback3, NULL, BoundNetLog());
+  TestCompletionCallback callback3;
+  rv = service.ResolveProxy(GURL("http://request3"), &info3,
+                            callback3.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Nothing has been sent to the resolver yet.
   EXPECT_TRUE(resolver->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);
 
@@ skipping 41 matching lines @@
 
   ProxyService service(config_service, resolver, NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 2 requests.
 
   ProxyInfo info1;
-  TestOldCompletionCallback callback1;
-  int rv = service.ResolveProxy(
-      GURL("http://request1"), &info1, &callback1, NULL, BoundNetLog());
+  TestCompletionCallback callback1;
+  int rv = service.ResolveProxy(GURL("http://request1"), &info1,
+                                callback1.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The first request should have triggered download of PAC script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
   ProxyInfo info2;
-  TestOldCompletionCallback callback2;
-  rv = service.ResolveProxy(
-      GURL("http://request2"), &info2, &callback2, NULL, BoundNetLog());
+  TestCompletionCallback callback2;
+  rv = service.ResolveProxy(GURL("http://request2"), &info2,
+                            callback2.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // At this point the ProxyService should be waiting for the
   // 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;
@@ skipping 25 matching lines @@
       new MockAsyncProxyResolverExpectsBytes;
 
   ProxyService service(config_service, resolver, NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 3 requests.
   ProxyInfo info1;
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
   ProxyService::PacRequest* request1;
   CapturingBoundNetLog log1(CapturingNetLog::kUnbounded);
-  int rv = service.ResolveProxy(
-      GURL("http://request1"), &info1, &callback1, &request1, log1.bound());
+  int rv = service.ResolveProxy(GURL("http://request1"), &info1,
+                                callback1.callback(), &request1, log1.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The first request should have triggered download of PAC script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
   ProxyInfo info2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   ProxyService::PacRequest* request2;
-  rv = service.ResolveProxy(
-      GURL("http://request2"), &info2, &callback2, &request2, BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request2"), &info2,
+                            callback2.callback(), &request2, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ProxyInfo info3;
-  TestOldCompletionCallback callback3;
-  rv = service.ResolveProxy(
-      GURL("http://request3"), &info3, &callback3, NULL, BoundNetLog());
+  TestCompletionCallback callback3;
+  rv = service.ResolveProxy(GURL("http://request3"), &info3,
+                            callback3.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Nothing has been sent to the resolver yet.
   EXPECT_TRUE(resolver->pending_requests().empty());
 
   // Cancel the first 2 requests.
   service.CancelPacRequest(request1);
   service.CancelPacRequest(request2);
 
   // At this point the ProxyService should be waiting for the
@@ skipping 51 matching lines @@
       new MockAsyncProxyResolverExpectsBytes;
   ProxyService service(config_service, resolver, NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 2 requests.
 
   ProxyInfo info1;
-  TestOldCompletionCallback callback1;
-  int rv = service.ResolveProxy(
-      GURL("http://request1"), &info1, &callback1, NULL, BoundNetLog());
+  TestCompletionCallback callback1;
+  int rv = service.ResolveProxy(GURL("http://request1"), &info1,
+                                callback1.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ProxyInfo info2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   ProxyService::PacRequest* request2;
-  rv = service.ResolveProxy(
-      GURL("http://request2"), &info2, &callback2, &request2, BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request2"), &info2,
+                            callback2.callback(), &request2, 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());
 
   // 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, "");
@@ skipping 41 matching lines @@
       new MockAsyncProxyResolverExpectsBytes;
   ProxyService service(config_service, resolver, NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 2 requests.
 
   ProxyInfo info1;
-  TestOldCompletionCallback callback1;
-  int rv = service.ResolveProxy(
-      GURL("http://request1"), &info1, &callback1, NULL, BoundNetLog());
+  TestCompletionCallback callback1;
+  int rv = service.ResolveProxy(GURL("http://request1"), &info1,
+                                callback1.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ProxyInfo info2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   ProxyService::PacRequest* request2;
-  rv = service.ResolveProxy(
-      GURL("http://request2"), &info2, &callback2, &request2, BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request2"), &info2,
+                            callback2.callback(), &request2, 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());
 
   // 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");
 
@@ skipping 43 matching lines @@
       new MockAsyncProxyResolverExpectsBytes;
   ProxyService service(config_service, resolver, NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 2 requests.
 
   ProxyInfo info1;
-  TestOldCompletionCallback callback1;
-  int rv = service.ResolveProxy(
-      GURL("http://request1"), &info1, &callback1, NULL, BoundNetLog());
+  TestCompletionCallback callback1;
+  int rv = service.ResolveProxy(GURL("http://request1"), &info1,
+                                callback1.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ProxyInfo info2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   ProxyService::PacRequest* request2;
-  rv = service.ResolveProxy(
-      GURL("http://request2"), &info2, &callback2, &request2, BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request2"), &info2,
+                            callback2.callback(), &request2, 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());
 
   // 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, "");
 
@@ skipping 28 matching lines @@
       new MockAsyncProxyResolverExpectsBytes;
   ProxyService service(config_service, resolver, NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 1 requests.
 
   ProxyInfo info1;
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
   int rv = service.ResolveProxy(
-      GURL("http://www.google.com"), &info1, &callback1, NULL, BoundNetLog());
+      GURL("http://www.google.com"), &info1, callback1.callback(), 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());
 
   // 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);
 
   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.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
 
   // Start another request, it should pickup the bypass item.
   ProxyInfo info2;
-  TestOldCompletionCallback callback2;
-  rv = service.ResolveProxy(
-      GURL("http://www.google.com"), &info2, &callback2, NULL, BoundNetLog());
+  TestCompletionCallback callback2;
+  rv = service.ResolveProxy(GURL("http://www.google.com"), &info2,
+                            callback2.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   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("request2:80");
   resolver->pending_requests()[0]->CompleteNow(OK);
 
@@ skipping 14 matching lines @@
       new MockAsyncProxyResolverExpectsBytes;
   ProxyService service(config_service, resolver, NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 1 request.
 
   ProxyInfo info1;
-  TestOldCompletionCallback callback1;
-  int rv = service.ResolveProxy(
-      GURL("http://www.google.com"), &info1, &callback1, NULL, BoundNetLog());
+  TestCompletionCallback callback1;
+  int rv = service.ResolveProxy(GURL("http://www.google.com"), &info1,
+                                callback1.callback(), 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());
 
   // 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(ProxyServiceTest, DeleteWhileInitProxyResolverHasOutstandingSet) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   ProxyService service(config_service, resolver, NULL);
 
   GURL url("http://www.google.com/");
 
   ProxyInfo info;
-  TestOldCompletionCallback callback;
-  int rv = service.ResolveProxy(url, &info, &callback, NULL, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = service.ResolveProxy(
+      url, &info, callback.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
             resolver->pending_set_pac_script_request()->script_data()->url());
 }
 
 TEST(ProxyServiceTest, ResetProxyConfigService) {
   ProxyConfig config1;
   config1.proxy_rules().ParseFromString("foopy1:8080");
   config1.set_auto_detect(false);
   ProxyService service(
       new MockProxyConfigService(config1),
       new MockAsyncProxyResolverExpectsBytes, NULL);
 
   ProxyInfo info;
-  TestOldCompletionCallback callback1;
-  int rv = service.ResolveProxy(
-      GURL("http://request1"), &info, &callback1, NULL, BoundNetLog());
+  TestCompletionCallback callback1;
+  int rv = service.ResolveProxy(GURL("http://request1"), &info,
+                                callback1.callback(), NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   ProxyConfig config2;
   config2.proxy_rules().ParseFromString("foopy2:8080");
   config2.set_auto_detect(false);
   service.ResetConfigService(new MockProxyConfigService(config2));
-  TestOldCompletionCallback callback2;
-  rv = service.ResolveProxy(
-      GURL("http://request2"), &info, &callback2, NULL, BoundNetLog());
+  TestCompletionCallback callback2;
+  rv = service.ResolveProxy(GURL("http://request2"), &info,
+                            callback2.callback(), NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
   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(ProxyServiceTest, UpdateConfigFromPACToDirect) {
   ProxyConfig config = ProxyConfig::CreateAutoDetect();
 
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
   ProxyService service(config_service, resolver, NULL);
 
   // Start 1 request.
 
   ProxyInfo info1;
-  TestOldCompletionCallback callback1;
-  int rv = service.ResolveProxy(
-      GURL("http://www.google.com"), &info1, &callback1, NULL, BoundNetLog());
+  TestCompletionCallback callback1;
+  int rv = service.ResolveProxy(GURL("http://www.google.com"), &info1,
+                                callback1.callback(), 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);
 
   // 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());
 
   // Force the ProxyService to pull down a new proxy configuration.
   // (Even though the configuration isn't old/bad).
   //
   // This new configuration no longer has auto_detect set, so
   // requests should complete synchronously now as direct-connect.
   config_service->SetConfig(ProxyConfig::CreateDirect());
 
   // Start another request -- the effective configuration has changed.
   ProxyInfo info2;
-  TestOldCompletionCallback callback2;
-  rv = service.ResolveProxy(
-      GURL("http://www.google.com"), &info2, &callback2, NULL, BoundNetLog());
+  TestCompletionCallback callback2;
+  rv = service.ResolveProxy(GURL("http://www.google.com"), &info2,
+                            callback2.callback(), NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
 
   EXPECT_TRUE(info2.is_direct());
 }
 
 TEST(ProxyServiceTest, NetworkChangeTriggersPacRefetch) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolverExpectsBytes* resolver =
       new MockAsyncProxyResolverExpectsBytes;
 
   CapturingNetLog log(CapturingNetLog::kUnbounded);
 
   ProxyService service(config_service, resolver, &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;
-  TestOldCompletionCallback callback1;
-  int rv = service.ResolveProxy(
-      GURL("http://request1"), &info1, &callback1, NULL, BoundNetLog());
+  TestCompletionCallback callback1;
+  int rv = service.ResolveProxy(GURL("http://request1"), &info1,
+                                callback1.callback(), 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());
 
   // At this point the ProxyService should be waiting for the
@@ skipping 19 matching lines @@
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
 
   // Now simluate a change in the network. The ProxyConfigService is still
   // going to return the same PAC URL as before, but this URL needs to be
   // refetched on the new network.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   MessageLoop::current()->RunAllPending();  // Notification happens async.
 
   // Start a second request.
   ProxyInfo info2;
-  TestOldCompletionCallback callback2;
-  rv = service.ResolveProxy(
-      GURL("http://request2"), &info2, &callback2, NULL, BoundNetLog());
+  TestCompletionCallback callback2;
+  rv = service.ResolveProxy(GURL("http://request2"), &info2,
+                            callback2.callback(), 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());
 
@@ skipping 11 matching lines @@
   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());
   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
 
-  // Check that the expected events were outputted to the log stream.
-  // In particular, PROXY_CONFIG_CHANGED should have only been emitted once
-  // (for the initial setup), and NOT a second time when the IP address
-  // changed.
+  // Check that the expected events were output to the log stream. In particular
+  // PROXY_CONFIG_CHANGED should have only been emitted once (for the initial
+  // setup), and NOT a second time when the IP address changed.
   CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_TRUE(LogContainsEntryWithType(entries, 0,
                                        NetLog::TYPE_PROXY_CONFIG_CHANGED));
   ASSERT_EQ(9u, entries.size());
   for (size_t i = 1; i < entries.size(); ++i)
     EXPECT_NE(NetLog::TYPE_PROXY_CONFIG_CHANGED, entries[i].type);
 }
 
 }  // namespace net