Migrate net/socket/socket.h, net/socket/stream_socket.h to base::Bind().

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 60 matching lines @@
                            arraysize(kSslClientHello));
 }
 
 base::StringPiece FakeSSLClientSocket::GetSslServerHello() {
   return base::StringPiece(reinterpret_cast<const char*>(kSslServerHello),
                            arraysize(kSslServerHello));
 }
 
 FakeSSLClientSocket::FakeSSLClientSocket(
     net::StreamSocket* transport_socket)
-    : connect_callback_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
-                        &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),
+    : transport_socket_(transport_socket),
       next_handshake_state_(STATE_NONE),
       handshake_completed_(false),
-      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) {
-  DCHECK_EQ(next_handshake_state_, STATE_NONE);
-  DCHECK(handshake_completed_);
-  return transport_socket_->Read(buf, buf_len, callback);
-}
-int FakeSSLClientSocket::Read(net::IOBuffer* buf, int buf_len,
                               const net::CompletionCallback& callback) {
   DCHECK_EQ(next_handshake_state_, STATE_NONE);
   DCHECK(handshake_completed_);
   return transport_socket_->Read(buf, buf_len, callback);
 }
 
 int FakeSSLClientSocket::Write(net::IOBuffer* buf, int buf_len,
-                              net::OldCompletionCallback* callback) {
+                               const net::CompletionCallback& callback) {
   DCHECK_EQ(next_handshake_state_, STATE_NONE);
   DCHECK(handshake_completed_);
   return transport_socket_->Write(buf, buf_len, callback);
 }
 
 bool FakeSSLClientSocket::SetReceiveBufferSize(int32 size) {
   return transport_socket_->SetReceiveBufferSize(size);
 }
 
 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(!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);
 
@@ skipping 27 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;
-  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);
-  }
+  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_);
+  int status = transport_socket_->Connect(
+      base::Bind(&FakeSSLClientSocket::OnConnectDone, base::Unretained(this)));
   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(old_user_connect_callback_ || !user_connect_callback_.is_null());
+  DCHECK(!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_);
+      base::Bind(&FakeSSLClientSocket::OnSendClientHelloDone,
+                 base::Unretained(this)));
   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(old_user_connect_callback_ || !user_connect_callback_.is_null());
+  DCHECK(!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()));
   DCHECK_EQ(read_buf_->BytesConsumed(), 0);
   if (written < static_cast<size_t>(write_buf_->BytesRemaining())) {
     next_handshake_state_ = STATE_SEND_CLIENT_HELLO;
     write_buf_->DidConsume(written);
   } else {
     next_handshake_state_ = STATE_VERIFY_SERVER_HELLO;
   }
 }
 
 int FakeSSLClientSocket::DoVerifyServerHello() {
   int status = transport_socket_->Read(
       read_buf_, read_buf_->BytesRemaining(),
-      &verify_server_hello_callback_);
+      base::Bind(&FakeSSLClientSocket::OnVerifyServerHelloDone,
+                 base::Unretained(this)));
   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(old_user_connect_callback_ || !user_connect_callback_.is_null());
+  DCHECK(!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;
-  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 {
@@ skipping 30 matching lines @@
 
 int64 FakeSSLClientSocket::NumBytesRead() const {
   return transport_socket_->NumBytesRead();
 }
 
 base::TimeDelta FakeSSLClientSocket::GetConnectTimeMicros() const {
   return transport_socket_->GetConnectTimeMicros();
 }
 
 }  // namespace notifier