base::Bind: Convert StreamSocket::Connect.

net/socket/socket_test_util.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/socket_test_util.h"
 
 #include <algorithm>
 #include <vector>
 
-
 #include "base/basictypes.h"
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "net/base/address_family.h"
 #include "net/base/address_list.h"
 #include "net/base/auth.h"
 #include "net/base/ssl_cert_request_info.h"
 #include "net/base/ssl_info.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_request_headers.h"
@@ skipping 601 matching lines @@
       new MockSSLClientSocket(transport_socket, host_and_port, ssl_config,
                               ssl_host_info, mock_ssl_data_.GetNext());
   ssl_client_sockets_.push_back(socket);
   return socket;
 }
 
 void MockClientSocketFactory::ClearSSLSessionCache() {
 }
 
 MockClientSocket::MockClientSocket(net::NetLog* net_log)
-    : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
+    : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       connected_(false),
       net_log_(NetLog::Source(), net_log) {
 }
 
 bool MockClientSocket::SetReceiveBufferSize(int32 size) {
   return true;
 }
 
 bool MockClientSocket::SetSendBufferSize(int32 size) {
   return true;
@@ skipping 51 matching lines @@
 MockClientSocket::GetNextProto(std::string* proto) {
   proto->clear();
   return SSLClientSocket::kNextProtoUnsupported;
 }
 
 MockClientSocket::~MockClientSocket() {}
 
 void MockClientSocket::RunCallbackAsync(net::OldCompletionCallback* callback,
                                         int result) {
   MessageLoop::current()->PostTask(FROM_HERE,
-      method_factory_.NewRunnableMethod(
-          &MockClientSocket::RunCallback, callback, result));
+      base::Bind(&MockClientSocket::RunOldCallback, weak_factory_.GetWeakPtr(),
+                 callback, result));
+}
+void MockClientSocket::RunCallbackAsync(const net::CompletionCallback& callback,
+                                        int result) {
+  MessageLoop::current()->PostTask(FROM_HERE,
+      base::Bind(&MockClientSocket::RunCallback, weak_factory_.GetWeakPtr(),
+                 callback, result));
 }
 
-void MockClientSocket::RunCallback(net::OldCompletionCallback* callback,
-                                   int result) {
+void MockClientSocket::RunOldCallback(net::OldCompletionCallback* callback,
+                                      int result) {
   if (callback)
     callback->Run(result);
 }
+void MockClientSocket::RunCallback(const net::CompletionCallback& callback,
+                                   int result) {
+  if (!callback.is_null())
+    callback.Run(result);
+}
 
 MockTCPClientSocket::MockTCPClientSocket(const net::AddressList& addresses,
                                          net::NetLog* net_log,
                                          net::SocketDataProvider* data)
     : MockClientSocket(net_log),
       addresses_(addresses),
       data_(data),
       read_offset_(0),
       num_bytes_read_(0),
       read_data_(false, net::ERR_UNEXPECTED),
@@ skipping 65 matching lines @@
   if (connected_)
     return net::OK;
   connected_ = true;
   peer_closed_connection_ = false;
   if (data_->connect_data().async) {
     RunCallbackAsync(callback, data_->connect_data().result);
     return net::ERR_IO_PENDING;
   }
   return data_->connect_data().result;
 }
+int MockTCPClientSocket::Connect(const net::CompletionCallback& callback) {
+  if (connected_)
+    return net::OK;
+
+  connected_ = true;
+  peer_closed_connection_ = false;
+  if (data_->connect_data().async) {
+    RunCallbackAsync(callback, data_->connect_data().result);
+    return net::ERR_IO_PENDING;
+  }
+
+  return data_->connect_data().result;
+}
 
 void MockTCPClientSocket::Disconnect() {
   MockClientSocket::Disconnect();
   pending_callback_ = NULL;
 }
 
 bool MockTCPClientSocket::IsConnected() const {
   return connected_ && !peer_closed_connection_;
 }
 
@@ skipping 36 matching lines @@
 
   read_data_ = data;
   need_read_data_ = false;
 
   // The caller is simulating that this IO completes right now.  Don't
   // let CompleteRead() schedule a callback.
   read_data_.async = false;
 
   net::OldCompletionCallback* callback = pending_callback_;
   int rv = CompleteRead();
-  RunCallback(callback, rv);
+  RunOldCallback(callback, rv);
 }
 
 int MockTCPClientSocket::CompleteRead() {
   DCHECK(pending_buf_);
   DCHECK(pending_buf_len_ > 0);
 
   was_used_to_convey_data_ = true;
 
   // Save the pending async IO data and reset our |pending_| state.
   net::IOBuffer* buf = pending_buf_;
@@ skipping 132 matching lines @@
     net::OldCompletionCallback* callback) {
   if (connected_)
     return net::OK;
   connected_ = true;
   if (data_->connect_data().async) {
     RunCallbackAsync(callback, data_->connect_data().result);
     return net::ERR_IO_PENDING;
   }
   return data_->connect_data().result;
 }
+int DeterministicMockTCPClientSocket::Connect(
+    const net::CompletionCallback& callback) {
+  if (connected_)
+    return net::OK;
+
+  connected_ = true;
+  if (data_->connect_data().async) {
+    RunCallbackAsync(callback, data_->connect_data().result);
+    return net::ERR_IO_PENDING;
+  }
+
+  return data_->connect_data().result;
+}
 
 void DeterministicMockTCPClientSocket::Disconnect() {
   MockClientSocket::Disconnect();
 }
 
 bool DeterministicMockTCPClientSocket::IsConnected() const {
   return connected_;
 }
 
 bool DeterministicMockTCPClientSocket::IsConnectedAndIdle() const {
@@ skipping 11 matching lines @@
 int64 DeterministicMockTCPClientSocket::NumBytesRead() const {
   return -1;
 }
 
 base::TimeDelta DeterministicMockTCPClientSocket::GetConnectTimeMicros() const {
   return base::TimeDelta::FromMicroseconds(-1);
 }
 
 void DeterministicMockTCPClientSocket::OnReadComplete(const MockRead& data) {}
 
-class MockSSLClientSocket::ConnectCallback
-    : public net::OldCompletionCallbackImpl<MockSSLClientSocket::ConnectCallback> {
+class MockSSLClientSocket::OldConnectCallback
+    : public net::OldCompletionCallbackImpl<
+          MockSSLClientSocket::OldConnectCallback> {
  public:
-  ConnectCallback(MockSSLClientSocket *ssl_client_socket,
-                  net::OldCompletionCallback* user_callback,
-                  int rv)
+  OldConnectCallback(MockSSLClientSocket *ssl_client_socket,
+                     net::OldCompletionCallback* user_callback,
+                     int rv)
       : ALLOW_THIS_IN_INITIALIZER_LIST(
-          net::OldCompletionCallbackImpl<MockSSLClientSocket::ConnectCallback>(
-                this, &ConnectCallback::Wrapper)),
+          net::OldCompletionCallbackImpl<
+              MockSSLClientSocket::OldConnectCallback>(
+                  this, &OldConnectCallback::Wrapper)),
         ssl_client_socket_(ssl_client_socket),
         user_callback_(user_callback),
         rv_(rv) {
   }
 
  private:
   void Wrapper(int rv) {
     if (rv_ == net::OK)
       ssl_client_socket_->connected_ = true;
     user_callback_->Run(rv_);
     delete this;
   }
 
   MockSSLClientSocket* ssl_client_socket_;
   net::OldCompletionCallback* user_callback_;
   int rv_;
 };
+class MockSSLClientSocket::ConnectCallback {
+ public:
+  ConnectCallback(MockSSLClientSocket *ssl_client_socket,
+                  const CompletionCallback& user_callback,
+                  int rv)
+      : ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
+          base::Bind(&ConnectCallback::Wrapper, base::Unretained(this)))),
+        ssl_client_socket_(ssl_client_socket),
+        user_callback_(user_callback),
+        rv_(rv) {
+  }
+
+  const CompletionCallback& callback() const { return callback_; }
+
+ private:
+  void Wrapper(int rv) {
+    if (rv_ == net::OK)
+      ssl_client_socket_->connected_ = true;
+    user_callback_.Run(rv_);
+  }
+
+  CompletionCallback callback_;
+  MockSSLClientSocket* ssl_client_socket_;
+  CompletionCallback user_callback_;
+  int rv_;
+};
 
 MockSSLClientSocket::MockSSLClientSocket(
     net::ClientSocketHandle* transport_socket,
     const HostPortPair& host_port_pair,
     const net::SSLConfig& ssl_config,
     SSLHostInfo* ssl_host_info,
     net::SSLSocketDataProvider* data)
     : MockClientSocket(transport_socket->socket()->NetLog().net_log()),
       transport_(transport_socket),
       data_(data),
@@ skipping 11 matching lines @@
                               net::OldCompletionCallback* callback) {
   return transport_->socket()->Read(buf, buf_len, callback);
 }
 
 int MockSSLClientSocket::Write(net::IOBuffer* buf, int buf_len,
                                net::OldCompletionCallback* callback) {
   return transport_->socket()->Write(buf, buf_len, callback);
 }
 
 int MockSSLClientSocket::Connect(net::OldCompletionCallback* callback) {
-  ConnectCallback* connect_callback = new ConnectCallback(
+  OldConnectCallback* connect_callback = new OldConnectCallback(
       this, callback, data_->connect.result);
   int rv = transport_->socket()->Connect(connect_callback);
   if (rv == net::OK) {
     delete connect_callback;
     if (data_->connect.result == net::OK)
       connected_ = true;
     if (data_->connect.async) {
       RunCallbackAsync(callback, data_->connect.result);
       return net::ERR_IO_PENDING;
     }
     return data_->connect.result;
   }
   return rv;
 }
+int MockSSLClientSocket::Connect(const net::CompletionCallback& callback) {
+  ConnectCallback connect_callback(this, callback, data_->connect.result);
+  int rv = transport_->socket()->Connect(connect_callback.callback());
+  if (rv == net::OK) {
+    if (data_->connect.result == net::OK)
+      connected_ = true;
+    if (data_->connect.async) {
+      RunCallbackAsync(callback, data_->connect.result);
+      return net::ERR_IO_PENDING;
+    }
+    return data_->connect.result;
+  }
+  return rv;
+}
 
 void MockSSLClientSocket::Disconnect() {
   MockClientSocket::Disconnect();
   if (transport_->socket() != NULL)
     transport_->socket()->Disconnect();
 }
 
 bool MockSSLClientSocket::IsConnected() const {
   return transport_->socket()->IsConnected();
 }
@@ skipping 57 matching lines @@
                                          net::NetLog* net_log)
     : connected_(false),
       data_(data),
       read_offset_(0),
       read_data_(false, net::ERR_UNEXPECTED),
       need_read_data_(true),
       pending_buf_(NULL),
       pending_buf_len_(0),
       pending_callback_(NULL),
       net_log_(NetLog::Source(), net_log),
-      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   DCHECK(data_);
   data_->Reset();
 }
 
 MockUDPClientSocket::~MockUDPClientSocket() {}
 
 int MockUDPClientSocket::Read(net::IOBuffer* buf, int buf_len,
                               net::OldCompletionCallback* callback) {
   if (!connected_)
     return net::ERR_UNEXPECTED;
@@ skipping 122 matching lines @@
     DCHECK(callback);
     RunCallbackAsync(callback, result);
     return net::ERR_IO_PENDING;
   }
   return result;
 }
 
 void MockUDPClientSocket::RunCallbackAsync(net::OldCompletionCallback* callback,
                                            int result) {
   MessageLoop::current()->PostTask(FROM_HERE,
-      method_factory_.NewRunnableMethod(
-          &MockUDPClientSocket::RunCallback, callback, result));
+      base::Bind(&MockUDPClientSocket::RunCallback, weak_factory_.GetWeakPtr(),
+                 callback, result));
 }
 
 void MockUDPClientSocket::RunCallback(net::OldCompletionCallback* callback,
                                       int result) {
   if (callback)
     callback->Run(result);
 }
 
 TestSocketRequest::TestSocketRequest(
     std::vector<TestSocketRequest*>* request_order,
@@ skipping 263 matching lines @@
 
 const char kSOCKS5OkRequest[] =
     { 0x05, 0x01, 0x00, 0x03, 0x04, 'h', 'o', 's', 't', 0x00, 0x50 };
 const int kSOCKS5OkRequestLength = arraysize(kSOCKS5OkRequest);
 
 const char kSOCKS5OkResponse[] =
     { 0x05, 0x00, 0x00, 0x01, 127, 0, 0, 1, 0x00, 0x50 };
 const int kSOCKS5OkResponseLength = arraysize(kSOCKS5OkResponse);
 
 }  // namespace net