base::Bind: Convert StreamSocket::Connect.

jingle/notifier/base/fake_ssl_client_socket.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 "jingle/notifier/base/fake_ssl_client_socket.h"
 
 #include <cstdlib>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 71 matching lines @@
                         &FakeSSLClientSocket::OnConnectDone),
       send_client_hello_callback_(
           ALLOW_THIS_IN_INITIALIZER_LIST(this),
           &FakeSSLClientSocket::OnSendClientHelloDone),
       verify_server_hello_callback_(
           ALLOW_THIS_IN_INITIALIZER_LIST(this),
           &FakeSSLClientSocket::OnVerifyServerHelloDone),
       transport_socket_(transport_socket),
       next_handshake_state_(STATE_NONE),
       handshake_completed_(false),
-      user_connect_callback_(NULL),
+      old_user_connect_callback_(NULL),
       write_buf_(NewDrainableIOBufferWithSize(arraysize(kSslClientHello))),
       read_buf_(NewDrainableIOBufferWithSize(arraysize(kSslServerHello))) {
   CHECK(transport_socket_.get());
   std::memcpy(write_buf_->data(), kSslClientHello, arraysize(kSslClientHello));
 }
 
 FakeSSLClientSocket::~FakeSSLClientSocket() {}
 
 int FakeSSLClientSocket::Read(net::IOBuffer* buf, int buf_len,
                              net::OldCompletionCallback* callback) {
@@ skipping 16 matching lines @@
 bool FakeSSLClientSocket::SetSendBufferSize(int32 size) {
   return transport_socket_->SetSendBufferSize(size);
 }
 
 int FakeSSLClientSocket::Connect(net::OldCompletionCallback* callback) {
   // We don't support synchronous operation, even if
   // |transport_socket_| does.
   DCHECK(callback);
   DCHECK_EQ(next_handshake_state_, STATE_NONE);
   DCHECK(!handshake_completed_);
-  DCHECK(!user_connect_callback_);
+  DCHECK(!old_user_connect_callback_);
   DCHECK_EQ(write_buf_->BytesConsumed(), 0);
   DCHECK_EQ(read_buf_->BytesConsumed(), 0);
 
   next_handshake_state_ = STATE_CONNECT;
   int status = DoHandshakeLoop();
   if (status == net::ERR_IO_PENDING) {
+    old_user_connect_callback_ = callback;
+  }
+  return status;
+}
+int FakeSSLClientSocket::Connect(const net::CompletionCallback& callback) {
+  // We don't support synchronous operation, even if
+  // |transport_socket_| does.
+  DCHECK(!callback.is_null());
+  DCHECK_EQ(next_handshake_state_, STATE_NONE);
+  DCHECK(!handshake_completed_);
+  DCHECK(user_connect_callback_.is_null());
+  DCHECK_EQ(write_buf_->BytesConsumed(), 0);
+  DCHECK_EQ(read_buf_->BytesConsumed(), 0);
+
+  next_handshake_state_ = STATE_CONNECT;
+  int status = DoHandshakeLoop();
+  if (status == net::ERR_IO_PENDING)
     user_connect_callback_ = callback;
-  }
+
   return status;
 }
 
 int FakeSSLClientSocket::DoHandshakeLoop() {
   DCHECK_NE(next_handshake_state_, STATE_NONE);
   int status = net::OK;
   do {
     HandshakeState state = next_handshake_state_;
     next_handshake_state_ = STATE_NONE;
     switch (state) {
@@ skipping 12 matching lines @@
         break;
     }
   } while ((status != net::ERR_IO_PENDING) &&
            (next_handshake_state_ != STATE_NONE));
   return status;
 }
 
 void FakeSSLClientSocket::RunUserConnectCallback(int status) {
   DCHECK_LE(status, net::OK);
   next_handshake_state_ = STATE_NONE;
-  net::OldCompletionCallback* user_connect_callback = user_connect_callback_;
-  user_connect_callback_ = NULL;
-  user_connect_callback->Run(status);
+  if (old_user_connect_callback_) {
+    net::OldCompletionCallback* user_connect_callback =
+        old_user_connect_callback_;
+    old_user_connect_callback_ = NULL;
+    user_connect_callback->Run(status);
+  } else {
+    net::CompletionCallback user_connect_callback = user_connect_callback_;
+    user_connect_callback_.Reset();
+    user_connect_callback.Run(status);
+  }
 }
 
 void FakeSSLClientSocket::DoHandshakeLoopWithUserConnectCallback() {
   int status = DoHandshakeLoop();
   if (status != net::ERR_IO_PENDING) {
     RunUserConnectCallback(status);
   }
 }
 
 int FakeSSLClientSocket::DoConnect() {
   int status = transport_socket_->Connect(&connect_callback_);
   if (status != net::OK) {
     return status;
   }
   ProcessConnectDone();
   return net::OK;
 }
 
 void FakeSSLClientSocket::OnConnectDone(int status) {
   DCHECK_NE(status, net::ERR_IO_PENDING);
   DCHECK_LE(status, net::OK);
-  DCHECK(user_connect_callback_);
+  DCHECK(old_user_connect_callback_ || !user_connect_callback_.is_null());
   if (status != net::OK) {
     RunUserConnectCallback(status);
     return;
   }
   ProcessConnectDone();
   DoHandshakeLoopWithUserConnectCallback();
 }
 
 void FakeSSLClientSocket::ProcessConnectDone() {
   DCHECK_EQ(write_buf_->BytesConsumed(), 0);
   DCHECK_EQ(read_buf_->BytesConsumed(), 0);
   next_handshake_state_ = STATE_SEND_CLIENT_HELLO;
 }
 
 int FakeSSLClientSocket::DoSendClientHello() {
   int status = transport_socket_->Write(
       write_buf_, write_buf_->BytesRemaining(),
       &send_client_hello_callback_);
   if (status < net::OK) {
     return status;
   }
   ProcessSendClientHelloDone(static_cast<size_t>(status));
   return net::OK;
 }
 
 void FakeSSLClientSocket::OnSendClientHelloDone(int status) {
   DCHECK_NE(status, net::ERR_IO_PENDING);
-  DCHECK(user_connect_callback_);
+  DCHECK(old_user_connect_callback_ || !user_connect_callback_.is_null());
   if (status < net::OK) {
     RunUserConnectCallback(status);
     return;
   }
   ProcessSendClientHelloDone(static_cast<size_t>(status));
   DoHandshakeLoopWithUserConnectCallback();
 }
 
 void FakeSSLClientSocket::ProcessSendClientHelloDone(size_t written) {
   DCHECK_LE(written, static_cast<size_t>(write_buf_->BytesRemaining()));
@@ skipping 12 matching lines @@
       &verify_server_hello_callback_);
   if (status < net::OK) {
     return status;
   }
   size_t read = static_cast<size_t>(status);
   return ProcessVerifyServerHelloDone(read);
 }
 
 void FakeSSLClientSocket::OnVerifyServerHelloDone(int status) {
   DCHECK_NE(status, net::ERR_IO_PENDING);
-  DCHECK(user_connect_callback_);
+  DCHECK(old_user_connect_callback_ || !user_connect_callback_.is_null());
   if (status < net::OK) {
     RunUserConnectCallback(status);
     return;
   }
   size_t read = static_cast<size_t>(status);
   status = ProcessVerifyServerHelloDone(read);
   if (status < net::OK) {
     RunUserConnectCallback(status);
     return;
   }
@@ skipping 22 matching lines @@
     next_handshake_state_ = STATE_NONE;
     handshake_completed_ = true;
   }
   return net::OK;
 }
 
 void FakeSSLClientSocket::Disconnect() {
   transport_socket_->Disconnect();
   next_handshake_state_ = STATE_NONE;
   handshake_completed_ = false;
-  user_connect_callback_ = NULL;
+  old_user_connect_callback_ = NULL;
+  user_connect_callback_.Reset();
   write_buf_->SetOffset(0);
   read_buf_->SetOffset(0);
 }
 
 bool FakeSSLClientSocket::IsConnected() const {
   return handshake_completed_ && transport_socket_->IsConnected();
 }
 
 bool FakeSSLClientSocket::IsConnectedAndIdle() const {
   return handshake_completed_ && transport_socket_->IsConnectedAndIdle();
@@ skipping 29 matching lines @@
 
 int64 FakeSSLClientSocket::NumBytesRead() const {
   return transport_socket_->NumBytesRead();
 }
 
 base::TimeDelta FakeSSLClientSocket::GetConnectTimeMicros() const {
   return transport_socket_->GetConnectTimeMicros();
 }
 
 }  // namespace notifier