base::Bind: Convert net/proxy.

net/proxy/multi_threaded_proxy_resolver_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/multi_threaded_proxy_resolver.h"
 
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
@@ skipping 17 matching lines @@
 //       - returns a single-item proxy list with the query's host.
 class MockProxyResolver : public ProxyResolver {
  public:
   MockProxyResolver()
       : ProxyResolver(true /*expects_pac_bytes*/),
         wrong_loop_(MessageLoop::current()),
         request_count_(0),
         purge_count_(0),
         resolve_latency_ms_(0) {}
 
-  // ProxyResolver implementation:
+  // ProxyResolver implementation.
   virtual int GetProxyForURL(const GURL& query_url,
                              ProxyInfo* results,
-                             OldCompletionCallback* callback,
+                             const CompletionCallback& callback,
                              RequestHandle* request,
                              const BoundNetLog& net_log) OVERRIDE {
     if (resolve_latency_ms_)
       base::PlatformThread::Sleep(resolve_latency_ms_);
 
     CheckIsOnWorkerThread();
 
-    EXPECT_TRUE(callback == NULL);
+    EXPECT_TRUE(callback.is_null());
     EXPECT_TRUE(request == NULL);
 
     // Write something into |net_log| (doesn't really have any meaning.)
     net_log.BeginEvent(NetLog::TYPE_PAC_JAVASCRIPT_DNS_RESOLVE, NULL);
 
     results->UseNamedProxy(query_url.host());
 
     // Return a success code which represents the request's order.
     return request_count_++;
   }
@@ skipping 12 matching lines @@
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
   virtual void CancelSetPacScript() OVERRIDE {
     NOTREACHED();
   }
 
   virtual int SetPacScript(
       const scoped_refptr<ProxyResolverScriptData>& script_data,
-      OldCompletionCallback* callback) OVERRIDE {
+      const CompletionCallback& callback) OVERRIDE {
     CheckIsOnWorkerThread();
     last_script_data_ = script_data;
     return OK;
   }
 
   virtual void PurgeMemory() OVERRIDE {
     CheckIsOnWorkerThread();
     ++purge_count_;
   }
 
@@ skipping 48 matching lines @@
     blocked_.Reset();
     unblocked_.Signal();
   }
 
   void WaitUntilBlocked() {
     blocked_.Wait();
   }
 
   virtual int GetProxyForURL(const GURL& query_url,
                              ProxyInfo* results,
-                             OldCompletionCallback* callback,
+                             const CompletionCallback& callback,
                              RequestHandle* request,
                              const BoundNetLog& net_log) OVERRIDE {
     if (should_block_) {
       blocked_.Signal();
       unblocked_.Wait();
     }
 
     return MockProxyResolver::GetProxyForURL(
         query_url, results, callback, request, net_log);
   }
 
  private:
   bool should_block_;
   base::WaitableEvent unblocked_;
   base::WaitableEvent blocked_;
 };
 
 // ForwardingProxyResolver forwards all requests to |impl|.
 class ForwardingProxyResolver : public ProxyResolver {
  public:
   explicit ForwardingProxyResolver(ProxyResolver* impl)
       : ProxyResolver(impl->expects_pac_bytes()),
         impl_(impl) {}
 
   virtual int GetProxyForURL(const GURL& query_url,
                              ProxyInfo* results,
-                             OldCompletionCallback* callback,
+                             const CompletionCallback& callback,
                              RequestHandle* request,
                              const BoundNetLog& net_log) OVERRIDE {
     return impl_->GetProxyForURL(
         query_url, results, callback, request, net_log);
   }
 
   virtual void CancelRequest(RequestHandle request) OVERRIDE {
     impl_->CancelRequest(request);
   }
 
   virtual LoadState GetLoadState(RequestHandle request) const OVERRIDE {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
   virtual LoadState GetLoadStateThreadSafe(
       RequestHandle request) const OVERRIDE {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
   virtual void CancelSetPacScript() OVERRIDE {
     impl_->CancelSetPacScript();
   }
 
   virtual int SetPacScript(
       const scoped_refptr<ProxyResolverScriptData>& script_data,
-      OldCompletionCallback* callback) OVERRIDE {
+      const CompletionCallback& callback) OVERRIDE {
     return impl_->SetPacScript(script_data, callback);
   }
 
   virtual void PurgeMemory() OVERRIDE {
     impl_->PurgeMemory();
   }
 
  private:
   ProxyResolver* impl_;
 };
@@ skipping 42 matching lines @@
   scoped_ptr<MockProxyResolver> mock(new MockProxyResolver);
   MultiThreadedProxyResolver resolver(
       new ForwardingProxyResolverFactory(mock.get()), kNumThreads);
 
   int rv;
 
   EXPECT_TRUE(resolver.expects_pac_bytes());
 
   // Call SetPacScriptByData() -- verify that it reaches the synchronous
   // resolver.
-  TestOldCompletionCallback set_script_callback;
+  TestCompletionCallback set_script_callback;
   rv = resolver.SetPacScript(
       ProxyResolverScriptData::FromUTF8("pac script bytes"),
-      &set_script_callback);
+      set_script_callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, set_script_callback.WaitForResult());
   EXPECT_EQ(ASCIIToUTF16("pac script bytes"),
             mock->last_script_data()->utf16());
 
   // Start request 0.
-  TestOldCompletionCallback callback0;
+  TestCompletionCallback callback0;
   CapturingBoundNetLog log0(CapturingNetLog::kUnbounded);
   ProxyInfo results0;
-  rv = resolver.GetProxyForURL(
-      GURL("http://request0"), &results0, &callback0, NULL, log0.bound());
+  rv = resolver.GetProxyForURL(GURL("http://request0"), &results0,
+                               callback0.callback(), NULL, log0.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Wait for request 0 to finish.
   rv = callback0.WaitForResult();
   EXPECT_EQ(0, rv);
   EXPECT_EQ("PROXY request0:80", results0.ToPacString());
 
   // The mock proxy resolver should have written 1 log entry. And
   // on completion, this should have been copied into |log0|.
   // We also have 1 log entry that was emitted by the
   // MultiThreadedProxyResolver.
   net::CapturingNetLog::EntryList entries0;
   log0.GetEntries(&entries0);
 
   ASSERT_EQ(2u, entries0.size());
   EXPECT_EQ(NetLog::TYPE_SUBMITTED_TO_RESOLVER_THREAD, entries0[0].type);
 
   // Start 3 more requests (request1 to request3).
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
   ProxyInfo results1;
-  rv = resolver.GetProxyForURL(
-      GURL("http://request1"), &results1, &callback1, NULL, BoundNetLog());
+  rv = resolver.GetProxyForURL(GURL("http://request1"), &results1,
+                               callback1.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   ProxyInfo results2;
-  rv = resolver.GetProxyForURL(
-      GURL("http://request2"), &results2, &callback2, NULL, BoundNetLog());
+  rv = resolver.GetProxyForURL(GURL("http://request2"), &results2,
+                               callback2.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  TestOldCompletionCallback callback3;
+  TestCompletionCallback callback3;
   ProxyInfo results3;
-  rv = resolver.GetProxyForURL(
-      GURL("http://request3"), &results3, &callback3, NULL, BoundNetLog());
+  rv = resolver.GetProxyForURL(GURL("http://request3"), &results3,
+                               callback3.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Wait for the requests to finish (they must finish in the order they were
   // started, which is what we check for from their magic return value)
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(1, rv);
   EXPECT_EQ("PROXY request1:80", results1.ToPacString());
 
   rv = callback2.WaitForResult();
   EXPECT_EQ(2, rv);
   EXPECT_EQ("PROXY request2:80", results2.ToPacString());
 
   rv = callback3.WaitForResult();
   EXPECT_EQ(3, rv);
   EXPECT_EQ("PROXY request3:80", results3.ToPacString());
 
   // Ensure that PurgeMemory() reaches the wrapped resolver and happens on the
   // right thread.
   EXPECT_EQ(0, mock->purge_count());
   resolver.PurgeMemory();
   // There is no way to get a callback directly when PurgeMemory() completes, so
   // we queue up a dummy request after the PurgeMemory() call and wait until it
   // finishes to ensure PurgeMemory() has had a chance to run.
-  TestOldCompletionCallback dummy_callback;
+  TestCompletionCallback dummy_callback;
   rv = resolver.SetPacScript(ProxyResolverScriptData::FromUTF8("dummy"),
-                             &dummy_callback);
+                             dummy_callback.callback());
   EXPECT_EQ(OK, dummy_callback.WaitForResult());
   EXPECT_EQ(1, mock->purge_count());
 }
 
 // Tests that the NetLog is updated to include the time the request was waiting
 // to be scheduled to a thread.
 TEST(MultiThreadedProxyResolverTest,
      SingleThread_UpdatesNetLogWithThreadWait) {
   const size_t kNumThreads = 1u;
   scoped_ptr<BlockableProxyResolver> mock(new BlockableProxyResolver);
   MultiThreadedProxyResolver resolver(
       new ForwardingProxyResolverFactory(mock.get()), kNumThreads);
 
   int rv;
 
   // Initialize the resolver.
-  TestOldCompletionCallback init_callback;
+  TestCompletionCallback init_callback;
   rv = resolver.SetPacScript(ProxyResolverScriptData::FromUTF8("foo"),
-                             &init_callback);
+                             init_callback.callback());
   EXPECT_EQ(OK, init_callback.WaitForResult());
 
   // Block the proxy resolver, so no request can complete.
   mock->Block();
 
   // Start request 0.
   ProxyResolver::RequestHandle request0;
-  TestOldCompletionCallback callback0;
+  TestCompletionCallback callback0;
   ProxyInfo results0;
   CapturingBoundNetLog log0(CapturingNetLog::kUnbounded);
-  rv = resolver.GetProxyForURL(
-      GURL("http://request0"), &results0, &callback0, &request0, log0.bound());
+  rv = resolver.GetProxyForURL(GURL("http://request0"), &results0,
+                               callback0.callback(), &request0, log0.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Start 2 more requests (request1 and request2).
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
   ProxyInfo results1;
   CapturingBoundNetLog log1(CapturingNetLog::kUnbounded);
-  rv = resolver.GetProxyForURL(
-      GURL("http://request1"), &results1, &callback1, NULL, log1.bound());
+  rv = resolver.GetProxyForURL(GURL("http://request1"), &results1,
+                               callback1.callback(), NULL, log1.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ProxyResolver::RequestHandle request2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   ProxyInfo results2;
   CapturingBoundNetLog log2(CapturingNetLog::kUnbounded);
-  rv = resolver.GetProxyForURL(
-      GURL("http://request2"), &results2, &callback2, &request2, log2.bound());
+  rv = resolver.GetProxyForURL(GURL("http://request2"), &results2,
+                               callback2.callback(), &request2, log2.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Unblock the worker thread so the requests can continue running.
   mock->WaitUntilBlocked();
   mock->Unblock();
 
   // Check that request 0 completed as expected.
   // The NetLog has 1 entry that came from the MultiThreadedProxyResolver, and
   // 1 entry from the mock proxy resolver.
   EXPECT_EQ(0, callback0.WaitForResult());
@@ skipping 42 matching lines @@
 TEST(MultiThreadedProxyResolverTest, SingleThread_CancelRequest) {
   const size_t kNumThreads = 1u;
   scoped_ptr<BlockableProxyResolver> mock(new BlockableProxyResolver);
   MultiThreadedProxyResolver resolver(
       new ForwardingProxyResolverFactory(mock.get()),
                                       kNumThreads);
 
   int rv;
 
   // Initialize the resolver.
-  TestOldCompletionCallback init_callback;
+  TestCompletionCallback init_callback;
   rv = resolver.SetPacScript(ProxyResolverScriptData::FromUTF8("foo"),
-                             &init_callback);
+                             init_callback.callback());
   EXPECT_EQ(OK, init_callback.WaitForResult());
 
   // Block the proxy resolver, so no request can complete.
   mock->Block();
 
   // Start request 0.
   ProxyResolver::RequestHandle request0;
-  TestOldCompletionCallback callback0;
+  TestCompletionCallback callback0;
   ProxyInfo results0;
-  rv = resolver.GetProxyForURL(
-      GURL("http://request0"), &results0, &callback0, &request0, BoundNetLog());
+  rv = resolver.GetProxyForURL(GURL("http://request0"), &results0,
+                               callback0.callback(), &request0, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Wait until requests 0 reaches the worker thread.
   mock->WaitUntilBlocked();
 
   // Start 3 more requests (request1 : request3).
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
   ProxyInfo results1;
-  rv = resolver.GetProxyForURL(
-      GURL("http://request1"), &results1, &callback1, NULL, BoundNetLog());
+  rv = resolver.GetProxyForURL(GURL("http://request1"), &results1,
+                               callback1.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ProxyResolver::RequestHandle request2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   ProxyInfo results2;
-  rv = resolver.GetProxyForURL(
-      GURL("http://request2"), &results2, &callback2, &request2, BoundNetLog());
+  rv = resolver.GetProxyForURL(GURL("http://request2"), &results2,
+                               callback2.callback(), &request2, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  TestOldCompletionCallback callback3;
+  TestCompletionCallback callback3;
   ProxyInfo results3;
-  rv = resolver.GetProxyForURL(
-      GURL("http://request3"), &results3, &callback3, NULL, BoundNetLog());
+  rv = resolver.GetProxyForURL(GURL("http://request3"), &results3,
+                               callback3.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Cancel request0 (inprogress) and request2 (pending).
   resolver.CancelRequest(request0);
   resolver.CancelRequest(request2);
 
   // Unblock the worker thread so the requests can continue running.
   mock->Unblock();
 
   // Wait for requests 1 and 3 to finish.
@@ skipping 19 matching lines @@
 TEST(MultiThreadedProxyResolverTest, SingleThread_CancelRequestByDeleting) {
   const size_t kNumThreads = 1u;
   scoped_ptr<BlockableProxyResolver> mock(new BlockableProxyResolver);
   scoped_ptr<MultiThreadedProxyResolver> resolver(
       new MultiThreadedProxyResolver(
           new ForwardingProxyResolverFactory(mock.get()), kNumThreads));
 
   int rv;
 
   // Initialize the resolver.
-  TestOldCompletionCallback init_callback;
+  TestCompletionCallback init_callback;
   rv = resolver->SetPacScript(ProxyResolverScriptData::FromUTF8("foo"),
-                              &init_callback);
+                              init_callback.callback());
   EXPECT_EQ(OK, init_callback.WaitForResult());
 
   // Block the proxy resolver, so no request can complete.
   mock->Block();
 
   // Start 3 requests.
 
-  TestOldCompletionCallback callback0;
+  TestCompletionCallback callback0;
   ProxyInfo results0;
-  rv = resolver->GetProxyForURL(
-      GURL("http://request0"), &results0, &callback0, NULL, BoundNetLog());
+  rv = resolver->GetProxyForURL(GURL("http://request0"), &results0,
+                                callback0.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
   ProxyInfo results1;
-  rv = resolver->GetProxyForURL(
-      GURL("http://request1"), &results1, &callback1, NULL, BoundNetLog());
+  rv = resolver->GetProxyForURL(GURL("http://request1"), &results1,
+                                callback1.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   ProxyInfo results2;
-  rv = resolver->GetProxyForURL(
-      GURL("http://request2"), &results2, &callback2, NULL, BoundNetLog());
+  rv = resolver->GetProxyForURL(GURL("http://request2"), &results2,
+                                callback2.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Wait until request 0 reaches the worker thread.
   mock->WaitUntilBlocked();
 
   // Add some latency, to improve the chance that when
   // MultiThreadedProxyResolver is deleted below we are still running inside
   // of the worker thread. The test will pass regardless, so this race doesn't
   // cause flakiness. However the destruction during execution is a more
   // interesting case to test.
@@ skipping 15 matching lines @@
 
 // Cancel an outstanding call to SetPacScriptByData().
 TEST(MultiThreadedProxyResolverTest, SingleThread_CancelSetPacScript) {
   const size_t kNumThreads = 1u;
   scoped_ptr<BlockableProxyResolver> mock(new BlockableProxyResolver);
   MultiThreadedProxyResolver resolver(
       new ForwardingProxyResolverFactory(mock.get()), kNumThreads);
 
   int rv;
 
-  TestOldCompletionCallback set_pac_script_callback;
+  TestCompletionCallback set_pac_script_callback;
   rv = resolver.SetPacScript(ProxyResolverScriptData::FromUTF8("data"),
-                             &set_pac_script_callback);
+                             set_pac_script_callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Cancel the SetPacScriptByData request.
   resolver.CancelSetPacScript();
 
   // Start another SetPacScript request
-  TestOldCompletionCallback set_pac_script_callback2;
+  TestCompletionCallback set_pac_script_callback2;
   rv = resolver.SetPacScript(ProxyResolverScriptData::FromUTF8("data2"),
-                             &set_pac_script_callback2);
+                             set_pac_script_callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Wait for the initialization to complete.
 
   rv = set_pac_script_callback2.WaitForResult();
   EXPECT_EQ(0, rv);
   EXPECT_EQ(ASCIIToUTF16("data2"), mock->last_script_data()->utf16());
 
   // The first SetPacScript callback should never have been completed.
   EXPECT_FALSE(set_pac_script_callback.have_result());
 }
 
 // Tests setting the PAC script once, lazily creating new threads, and
 // cancelling requests.
 TEST(MultiThreadedProxyResolverTest, ThreeThreads_Basic) {
   const size_t kNumThreads = 3u;
   BlockableProxyResolverFactory* factory = new BlockableProxyResolverFactory;
   MultiThreadedProxyResolver resolver(factory, kNumThreads);
 
   int rv;
 
   EXPECT_TRUE(resolver.expects_pac_bytes());
 
   // Call SetPacScriptByData() -- verify that it reaches the synchronous
   // resolver.
-  TestOldCompletionCallback set_script_callback;
+  TestCompletionCallback set_script_callback;
   rv = resolver.SetPacScript(
       ProxyResolverScriptData::FromUTF8("pac script bytes"),
-      &set_script_callback);
+      set_script_callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, set_script_callback.WaitForResult());
   // One thread has been provisioned (i.e. one ProxyResolver was created).
   ASSERT_EQ(1u, factory->resolvers().size());
   EXPECT_EQ(ASCIIToUTF16("pac script bytes"),
             factory->resolvers()[0]->last_script_data()->utf16());
 
   const int kNumRequests = 9;
-  TestOldCompletionCallback callback[kNumRequests];
+  TestCompletionCallback callback[kNumRequests];
   ProxyInfo results[kNumRequests];
   ProxyResolver::RequestHandle request[kNumRequests];
 
   // Start request 0 -- this should run on thread 0 as there is nothing else
   // going on right now.
   rv = resolver.GetProxyForURL(
-      GURL("http://request0"), &results[0], &callback[0], &request[0],
+      GURL("http://request0"), &results[0], callback[0].callback(), &request[0],
       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Wait for request 0 to finish.
   rv = callback[0].WaitForResult();
   EXPECT_EQ(0, rv);
   EXPECT_EQ("PROXY request0:80", results[0].ToPacString());
   ASSERT_EQ(1u, factory->resolvers().size());
   EXPECT_EQ(1, factory->resolvers()[0]->request_count());
 
   MessageLoop::current()->RunAllPending();
 
   // We now start 8 requests in parallel -- this will cause the maximum of
   // three threads to be provisioned (an additional two from what we already
   // have).
 
   for (int i = 1; i < kNumRequests; ++i) {
     rv = resolver.GetProxyForURL(
         GURL(base::StringPrintf("http://request%d", i)), &results[i],
-        &callback[i], &request[i], BoundNetLog());
+        callback[i].callback(), &request[i], BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
   }
 
   // We should now have a total of 3 threads, each with its own ProxyResolver
   // that will get initialized with the same data. (We check this later since
   // the assignment happens on the worker threads and may not have occurred
   // yet.)
   ASSERT_EQ(3u, factory->resolvers().size());
 
   // Cancel 3 of the 8 oustanding requests.
   resolver.CancelRequest(request[1]);
   resolver.CancelRequest(request[3]);
   resolver.CancelRequest(request[6]);
 
   // Wait for the remaining requests to complete.
   int kNonCancelledRequests[] = {2, 4, 5, 7, 8};
   for (size_t i = 0; i < arraysize(kNonCancelledRequests); ++i) {
     int request_index = kNonCancelledRequests[i];
     EXPECT_GE(callback[request_index].WaitForResult(), 0);
   }
 
   // Check that the cancelled requests never invoked their callback.
   EXPECT_FALSE(callback[1].have_result());
   EXPECT_FALSE(callback[3].have_result());
   EXPECT_FALSE(callback[6].have_result());
 
   // We call SetPacScript again, solely to stop the current worker threads.
   // (That way we can test to see the values observed by the synchronous
   // resolvers in a non-racy manner).
-  TestOldCompletionCallback set_script_callback2;
+  TestCompletionCallback set_script_callback2;
   rv = resolver.SetPacScript(ProxyResolverScriptData::FromUTF8("xyz"),
-                             &set_script_callback2);
+                             set_script_callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, set_script_callback2.WaitForResult());
   ASSERT_EQ(4u, factory->resolvers().size());
 
   for (int i = 0; i < 3; ++i) {
     EXPECT_EQ(
         ASCIIToUTF16("pac script bytes"),
         factory->resolvers()[i]->last_script_data()->utf16()) << "i=" << i;
   }
 
@@ skipping 20 matching lines @@
 TEST(MultiThreadedProxyResolverTest, OneThreadBlocked) {
   const size_t kNumThreads = 2u;
   BlockableProxyResolverFactory* factory = new BlockableProxyResolverFactory;
   MultiThreadedProxyResolver resolver(factory, kNumThreads);
 
   int rv;
 
   EXPECT_TRUE(resolver.expects_pac_bytes());
 
   // Initialize the resolver.
-  TestOldCompletionCallback set_script_callback;
+  TestCompletionCallback set_script_callback;
   rv = resolver.SetPacScript(
       ProxyResolverScriptData::FromUTF8("pac script bytes"),
-      &set_script_callback);
+      set_script_callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, set_script_callback.WaitForResult());
   // One thread has been provisioned (i.e. one ProxyResolver was created).
   ASSERT_EQ(1u, factory->resolvers().size());
   EXPECT_EQ(ASCIIToUTF16("pac script bytes"),
             factory->resolvers()[0]->last_script_data()->utf16());
 
   const int kNumRequests = 4;
-  TestOldCompletionCallback callback[kNumRequests];
+  TestCompletionCallback callback[kNumRequests];
   ProxyInfo results[kNumRequests];
   ProxyResolver::RequestHandle request[kNumRequests];
 
   // Start a request that will block the first thread.
 
   factory->resolvers()[0]->Block();
 
   rv = resolver.GetProxyForURL(
-      GURL("http://request0"), &results[0], &callback[0], &request[0],
+      GURL("http://request0"), &results[0], callback[0].callback(), &request[0],
       BoundNetLog());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   factory->resolvers()[0]->WaitUntilBlocked();
 
   // Start 3 more requests -- they should all be serviced by thread #2
   // since thread #1 is blocked.
 
   for (int i = 1; i < kNumRequests; ++i) {
     rv = resolver.GetProxyForURL(
         GURL(base::StringPrintf("http://request%d", i)),
-        &results[i], &callback[i], &request[i], BoundNetLog());
+        &results[i], callback[i].callback(), &request[i], BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
   }
 
   // Wait for the three requests to complete (they should complete in FIFO
   // order).
   for (int i = 1; i < kNumRequests; ++i) {
     EXPECT_EQ(i - 1, callback[i].WaitForResult());
   }
 
   // Unblock the first thread.
   factory->resolvers()[0]->Unblock();
   EXPECT_EQ(0, callback[0].WaitForResult());
 
   // All in all, the first thread should have seen just 1 request. And the
   // second thread 3 requests.
   ASSERT_EQ(2u, factory->resolvers().size());
   EXPECT_EQ(1, factory->resolvers()[0]->request_count());
   EXPECT_EQ(3, factory->resolvers()[1]->request_count());
 }
 
 }  // namespace
 
 }  // namespace net