base::Bind: Convert proxy_resolving_client_socket.[cc,h] and deps.

net/socket/transport_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/socket/transport_client_socket_pool.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/threading/platform_thread.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/sys_addrinfo.h"
@@ skipping 477 matching lines @@
   ai = ai->ai_next;
   EXPECT_EQ(AF_INET, ai->ai_family);
   ai = ai->ai_next;
   EXPECT_EQ(AF_INET6, ai->ai_family);
   ai = ai->ai_next;
   EXPECT_EQ(AF_INET6, ai->ai_family);
   EXPECT_TRUE(ai->ai_next == NULL);
 }
 
 TEST_F(TransportClientSocketPoolTest, Basic) {
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ClientSocketHandle handle;
-  int rv = handle.Init("a", low_params_, LOW, &callback, &pool_, BoundNetLog());
+  int rv = handle.Init("a", low_params_, LOW, callback.callback(), &pool_,
+                       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
 
   handle.Reset();
 }
 
 TEST_F(TransportClientSocketPoolTest, InitHostResolutionFailure) {
   host_resolver_->rules()->AddSimulatedFailure("unresolvable.host.name");
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ClientSocketHandle handle;
   HostPortPair host_port_pair("unresolvable.host.name", 80);
   scoped_refptr<TransportSocketParams> dest(new TransportSocketParams(
           host_port_pair, kDefaultPriority, false, false));
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init("a", dest, kDefaultPriority, &callback, &pool_,
-                        BoundNetLog()));
+            handle.Init("a", dest, kDefaultPriority, callback.callback(),
+                        &pool_, BoundNetLog()));
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback.WaitForResult());
 }
 
 TEST_F(TransportClientSocketPoolTest, InitConnectionFailure) {
   client_socket_factory_.set_client_socket_type(
       MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET);
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ClientSocketHandle handle;
-  EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", params_, kDefaultPriority,
-                                        &callback, &pool_, BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle.Init("a", params_, kDefaultPriority, callback.callback(),
+                        &pool_, BoundNetLog()));
   EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
 
   // Make the host resolutions complete synchronously this time.
   host_resolver_->set_synchronous_mode(true);
-  EXPECT_EQ(ERR_CONNECTION_FAILED, handle.Init("a", params_,
-                                               kDefaultPriority, &callback,
-                                               &pool_, BoundNetLog()));
+  EXPECT_EQ(ERR_CONNECTION_FAILED,
+            handle.Init("a", params_, kDefaultPriority, callback.callback(),
+                        &pool_, BoundNetLog()));
 }
 
 TEST_F(TransportClientSocketPoolTest, PendingRequests) {
   // First request finishes asynchronously.
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
   EXPECT_EQ(OK, (*requests())[0]->WaitForResult());
 
   // Make all subsequent host resolutions complete synchronously.
   host_resolver_->set_synchronous_mode(true);
 
@@ skipping 82 matching lines @@
             client_socket_factory_.allocation_count());
 
   // First asynchronous request, and then last 5 pending requests.
   EXPECT_EQ(6U, completion_count());
 }
 
 // This test will start up a RequestSocket() and then immediately Cancel() it.
 // The pending host resolution will eventually complete, and destroy the
 // ClientSocketPool which will crash if the group was not cleared properly.
 TEST_F(TransportClientSocketPoolTest, CancelRequestClearGroup) {
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ClientSocketHandle handle;
-  EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", params_, kDefaultPriority,
-                                        &callback, &pool_, BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle.Init("a", params_, kDefaultPriority, callback.callback(),
+                        &pool_, BoundNetLog()));
   handle.Reset();
 }
 
 TEST_F(TransportClientSocketPoolTest, TwoRequestsCancelOne) {
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ClientSocketHandle handle2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
 
-  EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", params_, kDefaultPriority,
-                                        &callback, &pool_, BoundNetLog()));
-  EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a", params_, kDefaultPriority,
-                                         &callback2, &pool_, BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle.Init("a", params_, kDefaultPriority, callback.callback(),
+                        &pool_, BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle2.Init("a", params_, kDefaultPriority, callback2.callback(),
+                         &pool_, BoundNetLog()));
 
   handle.Reset();
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   handle2.Reset();
 }
 
 TEST_F(TransportClientSocketPoolTest, ConnectCancelConnect) {
   client_socket_factory_.set_client_socket_type(
       MockClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET);
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
-  EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", params_, kDefaultPriority,
-                                        &callback, &pool_, BoundNetLog()));
+  TestCompletionCallback callback;
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle.Init("a", params_, kDefaultPriority, callback.callback(),
+                        &pool_, BoundNetLog()));
 
   handle.Reset();
 
-  TestOldCompletionCallback callback2;
-  EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", params_, kDefaultPriority,
-                                        &callback2, &pool_, BoundNetLog()));
+  TestCompletionCallback callback2;
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle.Init("a", params_, kDefaultPriority, callback2.callback(),
+                        &pool_, BoundNetLog()));
 
   host_resolver_->set_synchronous_mode(true);
   // At this point, handle has two ConnectingSockets out for it.  Due to the
   // setting the mock resolver into synchronous mode, the host resolution for
   // both will return in the same loop of the MessageLoop.  The client socket
   // is a pending socket, so the Connect() will asynchronously complete on the
   // next loop of the MessageLoop.  That means that the first
   // ConnectingSocket will enter OnIOComplete, and then the second one will.
   // If the first one is not cancelled, it will advance the load state, and
   // then the second one will crash.
@@ skipping 56 matching lines @@
   EXPECT_EQ(11, GetOrderOfRequest(12));
   EXPECT_EQ(8, GetOrderOfRequest(13));
   EXPECT_EQ(12, GetOrderOfRequest(14));
   EXPECT_EQ(13, GetOrderOfRequest(15));
   EXPECT_EQ(15, GetOrderOfRequest(16));
 
   // Make sure we test order of all requests made.
   EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(17));
 }
 
-class RequestSocketCallback : public CallbackRunner< Tuple1<int> > {
+class RequestSocketCallback : public TestCompletionCallbackBase {
  public:
   RequestSocketCallback(ClientSocketHandle* handle,
                         TransportClientSocketPool* pool)
       : handle_(handle),
         pool_(pool),
-        within_callback_(false) {}
+        within_callback_(false),
+        ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
+            base::Bind(&RequestSocketCallback::OnComplete,
+                       base::Unretained(this)))) {
+  }
 
-  virtual void RunWithParams(const Tuple1<int>& params) {
-    callback_.RunWithParams(params);
-    ASSERT_EQ(OK, params.a);
+  virtual ~RequestSocketCallback() {}
+
+  const CompletionCallback& callback() const { return callback_; }
+
+ private:
+  void OnComplete(int result) {
+    SetResult(result);
+    ASSERT_EQ(OK, result);
 
     if (!within_callback_) {
       // Don't allow reuse of the socket.  Disconnect it and then release it and
       // run through the MessageLoop once to get it completely released.
       handle_->socket()->Disconnect();
       handle_->Reset();
       {
         MessageLoop::ScopedNestableTaskAllower nestable(
             MessageLoop::current());
         MessageLoop::current()->RunAllPending();
       }
       within_callback_ = true;
       scoped_refptr<TransportSocketParams> dest(new TransportSocketParams(
           HostPortPair("www.google.com", 80), LOWEST, false, false));
-      int rv = handle_->Init("a", dest, LOWEST, this, pool_, BoundNetLog());
+      int rv = handle_->Init("a", dest, LOWEST, callback(), pool_,
+                             BoundNetLog());
       EXPECT_EQ(OK, rv);
     }
   }
 
-  int WaitForResult() {
-    return callback_.WaitForResult();
-  }
-
- private:
   ClientSocketHandle* const handle_;
   TransportClientSocketPool* const pool_;
   bool within_callback_;
-  TestOldCompletionCallback callback_;
+  CompletionCallback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(RequestSocketCallback);
 };
 
 TEST_F(TransportClientSocketPoolTest, RequestTwice) {
   ClientSocketHandle handle;
   RequestSocketCallback callback(&handle, &pool_);
   scoped_refptr<TransportSocketParams> dest(new TransportSocketParams(
       HostPortPair("www.google.com", 80), LOWEST, false, false));
-  int rv = handle.Init("a", dest, LOWEST, &callback, &pool_,
+  int rv = handle.Init("a", dest, LOWEST, callback.callback(), &pool_,
                        BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   // The callback is going to request "www.google.com". We want it to complete
   // synchronously this time.
   host_resolver_->set_synchronous_mode(true);
 
   EXPECT_EQ(OK, callback.WaitForResult());
 
   handle.Reset();
@@ skipping 40 matching lines @@
 
   // Queue up all the requests
   for (int i = 0; i < kNumRequests; i++)
     EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
 
   for (int i = 0; i < kNumRequests; i++)
     EXPECT_EQ(ERR_CONNECTION_FAILED, (*requests())[i]->WaitForResult());
 }
 
 TEST_F(TransportClientSocketPoolTest, ResetIdleSocketsOnIPAddressChange) {
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ClientSocketHandle handle;
-  int rv = handle.Init("a", low_params_, LOW, &callback, &pool_, BoundNetLog());
+  int rv = handle.Init("a", low_params_, LOW, callback.callback(), &pool_,
+                       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
 
   handle.Reset();
 
@@ skipping 32 matching lines @@
   MockClientSocketFactory::ClientSocketType* cases[2] = {
     case1_types,
     case2_types
   };
 
   for (size_t index = 0; index < arraysize(cases); ++index) {
     client_socket_factory_.set_client_socket_types(cases[index], 2);
 
     EXPECT_EQ(0, pool_.IdleSocketCount());
 
-    TestOldCompletionCallback callback;
+    TestCompletionCallback callback;
     ClientSocketHandle handle;
-    int rv = handle.Init("b", low_params_, LOW, &callback, &pool_,
+    int rv = handle.Init("b", low_params_, LOW, callback.callback(), &pool_,
                          BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
     EXPECT_FALSE(handle.is_initialized());
     EXPECT_FALSE(handle.socket());
 
     // Create the first socket, set the timer.
     MessageLoop::current()->RunAllPending();
 
     // Wait for the backup socket timer to fire.
     base::PlatformThread::Sleep(
@@ skipping 19 matching lines @@
 // of the backup socket, but then we cancelled the request after that.
 TEST_F(TransportClientSocketPoolTest, BackupSocketCancel) {
   client_socket_factory_.set_client_socket_type(
       MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET);
 
   enum { CANCEL_BEFORE_WAIT, CANCEL_AFTER_WAIT };
 
   for (int index = CANCEL_BEFORE_WAIT; index < CANCEL_AFTER_WAIT; ++index) {
     EXPECT_EQ(0, pool_.IdleSocketCount());
 
-    TestOldCompletionCallback callback;
+    TestCompletionCallback callback;
     ClientSocketHandle handle;
-    int rv = handle.Init("c", low_params_, LOW, &callback, &pool_,
+    int rv = handle.Init("c", low_params_, LOW, callback.callback(), &pool_,
                          BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
     EXPECT_FALSE(handle.is_initialized());
     EXPECT_FALSE(handle.socket());
 
     // Create the first socket, set the timer.
     MessageLoop::current()->RunAllPending();
 
     if (index == CANCEL_AFTER_WAIT) {
       // Wait for the backup socket timer to fire.
@@ skipping 22 matching lines @@
     // The first socket will not connect.
     MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET,
     // The second socket will fail immediately.
     MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET
   };
 
   client_socket_factory_.set_client_socket_types(case_types, 2);
 
   EXPECT_EQ(0, pool_.IdleSocketCount());
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ClientSocketHandle handle;
-  int rv = handle.Init("b", low_params_, LOW, &callback, &pool_, BoundNetLog());
+  int rv = handle.Init("b", low_params_, LOW, callback.callback(), &pool_,
+                       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   // Create the first socket, set the timer.
   MessageLoop::current()->RunAllPending();
 
   // Wait for the backup socket timer to fire.
   base::PlatformThread::Sleep(ClientSocketPool::kMaxConnectRetryIntervalMs);
 
@@ skipping 23 matching lines @@
     MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET,
     // The second socket will not connect.
     MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET
   };
 
   client_socket_factory_.set_client_socket_types(case_types, 2);
   client_socket_factory_.set_delay_ms(5000);
 
   EXPECT_EQ(0, pool_.IdleSocketCount());
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ClientSocketHandle handle;
-  int rv = handle.Init("b", low_params_, LOW, &callback, &pool_, BoundNetLog());
+  int rv = handle.Init("b", low_params_, LOW, callback.callback(), &pool_,
+                       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   // Create the first socket, set the timer.
   MessageLoop::current()->RunAllPending();
 
   // Wait for the backup socket timer to fire.
   base::PlatformThread::Sleep(ClientSocketPool::kMaxConnectRetryIntervalMs);
 
@@ skipping 31 matching lines @@
     // This is the IPv4 socket.
     MockClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET
   };
 
   client_socket_factory_.set_client_socket_types(case_types, 2);
 
   // Resolve an AddressList with a IPv6 address first and then a IPv4 address.
   host_resolver_->rules()->AddIPLiteralRule(
       "*", "2:abcd::3:4:ff,2.2.2.2", "");
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ClientSocketHandle handle;
-  int rv = handle.Init("a", low_params_, LOW, &callback, &pool, BoundNetLog());
+  int rv = handle.Init("a", low_params_, LOW, callback.callback(), &pool,
+                       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   IPEndPoint endpoint;
   handle.socket()->GetLocalAddress(&endpoint);
   EXPECT_EQ(kIPv4AddressSize, endpoint.address().size());
@@ skipping 21 matching lines @@
   };
 
   client_socket_factory_.set_client_socket_types(case_types, 2);
   client_socket_factory_.set_delay_ms(
       TransportConnectJob::kIPv6FallbackTimerInMs + 50);
 
   // Resolve an AddressList with a IPv6 address first and then a IPv4 address.
   host_resolver_->rules()->AddIPLiteralRule(
       "*", "2:abcd::3:4:ff,2.2.2.2", "");
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ClientSocketHandle handle;
-  int rv = handle.Init("a", low_params_, LOW, &callback, &pool, BoundNetLog());
+  int rv = handle.Init("a", low_params_, LOW, callback.callback(), &pool,
+                       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   IPEndPoint endpoint;
   handle.socket()->GetLocalAddress(&endpoint);
   EXPECT_EQ(kIPv6AddressSize, endpoint.address().size());
@@ skipping 10 matching lines @@
                                  &client_socket_factory_,
                                  NULL);
 
   client_socket_factory_.set_client_socket_type(
       MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET);
 
   // Resolve an AddressList with only IPv6 addresses.
   host_resolver_->rules()->AddIPLiteralRule(
       "*", "2:abcd::3:4:ff,3:abcd::3:4:ff", "");
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ClientSocketHandle handle;
-  int rv = handle.Init("a", low_params_, LOW, &callback, &pool, BoundNetLog());
+  int rv = handle.Init("a", low_params_, LOW, callback.callback(), &pool,
+                       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   IPEndPoint endpoint;
   handle.socket()->GetLocalAddress(&endpoint);
   EXPECT_EQ(kIPv6AddressSize, endpoint.address().size());
@@ skipping 10 matching lines @@
                                  &client_socket_factory_,
                                  NULL);
 
   client_socket_factory_.set_client_socket_type(
       MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET);
 
   // Resolve an AddressList with only IPv4 addresses.
   host_resolver_->rules()->AddIPLiteralRule(
       "*", "1.1.1.1", "");
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ClientSocketHandle handle;
-  int rv = handle.Init("a", low_params_, LOW, &callback, &pool, BoundNetLog());
+  int rv = handle.Init("a", low_params_, LOW, callback.callback(), &pool,
+                       BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   IPEndPoint endpoint;
   handle.socket()->GetLocalAddress(&endpoint);
   EXPECT_EQ(kIPv4AddressSize, endpoint.address().size());
   EXPECT_EQ(1, client_socket_factory_.allocation_count());
 }
 
 }  // namespace
 
 }  // namespace net