base::Bind: Convert HostResolver::Resolve.

net/socket/ssl_client_socket_pool_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/http/http_proxy_client_socket_pool.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/string_util.h"
 #include "base/time.h"
@@ skipping 657 matching lines @@
   };
 
   host_resolver_.set_synchronous_mode(true);
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_hosts); i++) {
     host_resolver_.rules()->AddIPLiteralRule(test_hosts[i].name,
         test_hosts[i].iplist, "");
 
     // This test requires that the HostResolver cache be populated.  Normal
     // code would have done this already, but we do it manually.
     HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort));
-    host_resolver_.Resolve(info, &test_hosts[i].addresses, NULL, NULL,
-                           BoundNetLog());
+    host_resolver_.Resolve(info, &test_hosts[i].addresses, CompletionCallback(),
+                           NULL, BoundNetLog());
 
     // Setup a HostPortProxyPair
     test_hosts[i].pair = HostPortProxyPair(
         HostPortPair(test_hosts[i].name, kTestPort), ProxyServer::Direct());
   }
 
   MockRead reads[] = {
       MockRead(true, ERR_IO_PENDING),
   };
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
@@ skipping 54 matching lines @@
   struct TestHosts {
     std::string name;
     std::string iplist;
     HostPortProxyPair pair;
     AddressList addresses;
   } test_hosts[] = {
     { "www.webkit.org",    "192.0.2.33,192.168.0.1,192.168.0.5" },
     { "js.webkit.org",     "192.168.0.4,192.168.0.1,192.0.2.33" },
   };
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
+  TestOldCompletionCallback old_callback;
   int rv;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_hosts); i++) {
     host_resolver_.rules()->AddIPLiteralRule(test_hosts[i].name,
         test_hosts[i].iplist, "");
 
     // This test requires that the HostResolver cache be populated.  Normal
     // code would have done this already, but we do it manually.
     HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort));
-    rv = host_resolver_.Resolve(info, &test_hosts[i].addresses, &callback,
-                                NULL, BoundNetLog());
+    rv = host_resolver_.Resolve(info, &test_hosts[i].addresses,
+                                callback.callback(), NULL, BoundNetLog());
     EXPECT_EQ(OK, callback.GetResult(rv));
 
     // Setup a HostPortProxyPair
     test_hosts[i].pair = HostPortProxyPair(
         HostPortPair(test_hosts[i].name, kTestPort), ProxyServer::Direct());
   }
 
   MockRead reads[] = {
       MockRead(true, ERR_IO_PENDING),
   };
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   socket_factory_.AddSocketDataProvider(&data);
   SSLSocketDataProvider ssl(true, OK);
   ssl.cert = X509Certificate::CreateFromBytes(
       reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der));
   ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl.next_proto = "spdy/2";
   ssl.client_cert_sent = true;
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
   CreatePool(true /* tcp pool */, false, false);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
                                                     true);
 
   scoped_ptr<ClientSocketHandle> handle(new ClientSocketHandle());
   rv = handle->Init(
-      "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog());
+      "a", params, MEDIUM, &old_callback, pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle->is_initialized());
   EXPECT_FALSE(handle->socket());
 
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_EQ(OK, old_callback.WaitForResult());
   EXPECT_TRUE(handle->is_initialized());
   EXPECT_TRUE(handle->socket());
 
   SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle->socket());
   EXPECT_TRUE(ssl_socket->was_npn_negotiated());
   std::string proto;
   ssl_socket->GetNextProto(&proto);
   EXPECT_EQ(SSLClientSocket::NextProtoFromString(proto),
             SSLClientSocket::kProtoSPDY2);
 
@@ skipping 13 matching lines @@
   EXPECT_FALSE(session_->spdy_session_pool()->HasSession(test_hosts[1].pair));
 
   session_->spdy_session_pool()->CloseAllSessions();
 }
 
 // It would be nice to also test the timeouts in SSLClientSocketPool.
 
 }  // namespace
 
 }  // namespace net