base::Bind: Convert net/proxy.

net/proxy/sync_host_resolver_bridge_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/sync_host_resolver_bridge.h"
 
 #include "base/threading/thread.h"
 #include "base/synchronization/waitable_event.h"
 #include "net/base/address_list.h"
 #include "net/base/net_errors.h"
@@ skipping 65 matching lines @@
 
 // This implementation of ProxyResolver simply does a synchronous resolve
 // on |host_resolver| in response to GetProxyForURL().
 class SyncProxyResolver : public ProxyResolver {
  public:
   explicit SyncProxyResolver(SyncHostResolverBridge* host_resolver)
       : ProxyResolver(false), host_resolver_(host_resolver) {}
 
   virtual int GetProxyForURL(const GURL& url,
                              ProxyInfo* results,
-                             OldCompletionCallback* callback,
+                             const CompletionCallback& callback,
                              RequestHandle* request,
                              const BoundNetLog& net_log) {
-    EXPECT_FALSE(callback);
+    EXPECT_FALSE(!callback.is_null());
     EXPECT_FALSE(request);
 
     // Do a synchronous host resolve.
     HostResolver::RequestInfo info(HostPortPair::FromURL(url));
     AddressList addresses;
     int rv = host_resolver_->Resolve(info, &addresses);
 
     EXPECT_EQ(ERR_ABORTED, rv);
 
     return rv;
@@ skipping 17 matching lines @@
   virtual void Shutdown() OVERRIDE {
     host_resolver_->Shutdown();
   }
 
   virtual void CancelSetPacScript() OVERRIDE {
     NOTREACHED();
   }
 
   virtual int SetPacScript(
       const scoped_refptr<ProxyResolverScriptData>& script_data,
-      OldCompletionCallback* callback) OVERRIDE {
+      const CompletionCallback& callback) OVERRIDE {
     return OK;
   }
 
  private:
   SyncHostResolverBridge* const host_resolver_;
 };
 
 class SyncProxyResolverFactory : public ProxyResolverFactory {
  public:
   // Takes ownership of |sync_host_resolver|.
@@ skipping 33 matching lines @@
     // resolver on THIS thread.
     SyncHostResolverBridge* sync_resolver =
         new SyncHostResolverBridge(async_resolver_.get(), message_loop());
 
     proxy_resolver_.reset(
         new MultiThreadedProxyResolver(
             new SyncProxyResolverFactory(sync_resolver),
             1u));
 
     // Initialize the resolver.
-    TestOldCompletionCallback callback;
+    TestCompletionCallback callback;
     proxy_resolver_->SetPacScript(ProxyResolverScriptData::FromURL(GURL()),
-                                  &callback);
+                                  callback.callback());
     EXPECT_EQ(OK, callback.WaitForResult());
 
     // Start an asynchronous request to the proxy resolver
     // (note that it will never complete).
-    proxy_resolver_->GetProxyForURL(GURL("http://test/"), &results_,
-                                    &callback_, &request_, BoundNetLog());
+    proxy_resolver_->GetProxyForURL(
+        GURL("http://test/"), &results_, callback_.callback(), &request_,
+        BoundNetLog());
   }
 
   virtual void CleanUp() OVERRIDE {
     // Cancel the outstanding request (note however that this will not
     // unblock the PAC thread though).
     proxy_resolver_->CancelRequest(request_);
 
     // Delete the single threaded proxy resolver.
     proxy_resolver_.reset();
 
     // (There may have been a completion posted back to origin thread, avoid
     // leaking it by running).
     MessageLoop::current()->RunAllPending();
 
     // During the teardown sequence of the single threaded proxy resolver,
     // the outstanding host resolve should have been cancelled.
     EXPECT_TRUE(async_resolver_->was_request_cancelled());
   }
 
  private:
   // This (async) host resolver will outlive the thread that is operating it
   // synchronously.
   scoped_ptr<BlockableHostResolver> async_resolver_;
 
   scoped_ptr<ProxyResolver> proxy_resolver_;
 
   // Data for the outstanding request to the single threaded proxy resolver.
-  TestOldCompletionCallback callback_;
+  TestCompletionCallback callback_;
   ProxyInfo results_;
   ProxyResolver::RequestHandle request_;
 };
 
 // Test that a deadlock does not happen during shutdown when a host resolve
 // is outstanding on the SyncHostResolverBridge.
 // This is a regression test for http://crbug.com/41244.
 TEST(MultiThreadedProxyResolverTest, ShutdownIsCalledBeforeThreadJoin) {
   IOThread io_thread;
   base::Thread::Options options;
   options.message_loop_type = MessageLoop::TYPE_IO;
   ASSERT_TRUE(io_thread.StartWithOptions(options));
 
   io_thread.async_resolver()->WaitUntilRequestIsReceived();
 
   // Now upon exitting this scope, the IOThread is destroyed -- this will
   // stop the IOThread, which will in turn delete the
   // SingleThreadedProxyResolver, which in turn will stop its internal
   // PAC thread (which is currently blocked waiting on the host resolve which
   // is running on IOThread).  The IOThread::Cleanup() will verify that after
   // the PAC thread is stopped, it cancels the request on the HostResolver.
 }
 
 }  // namespace
 
 }  // namespace net