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

content/browser/renderer_host/pepper_tcp_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 "content/browser/renderer_host/pepper_tcp_socket.h"
 
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 22 matching lines @@
 PepperTCPSocket::PepperTCPSocket(
     PepperMessageFilter* manager,
     int32 routing_id,
     uint32 plugin_dispatcher_id,
     uint32 socket_id)
     : manager_(manager),
       routing_id_(routing_id),
       plugin_dispatcher_id_(plugin_dispatcher_id),
       socket_id_(socket_id),
       connection_state_(BEFORE_CONNECT),
-      end_of_file_reached_(false),
-      ALLOW_THIS_IN_INITIALIZER_LIST(connect_callback_(
-          this, &PepperTCPSocket::OnConnectCompleted)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(ssl_handshake_callback_(
-          this, &PepperTCPSocket::OnSSLHandshakeCompleted)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          read_callback_(this, &PepperTCPSocket::OnReadCompleted)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          write_callback_(this, &PepperTCPSocket::OnWriteCompleted)) {
+      end_of_file_reached_(false) {
   DCHECK(manager);
 }
 
 PepperTCPSocket::~PepperTCPSocket() {
   // Make sure no further callbacks from socket_.
   if (socket_.get())
     socket_->Disconnect();
 }
 
 void PepperTCPSocket::Connect(const std::string& host, uint16_t port) {
@@ skipping 54 matching lines @@
   net::SSLClientSocketContext ssl_context;
   ssl_context.cert_verifier = manager_->GetCertVerifier();
   socket_.reset(factory->CreateSSLClientSocket(
       handle, host_port_pair, manager_->ssl_config(), NULL, ssl_context));
   if (!socket_.get()) {
     LOG(WARNING) << "Failed to create an SSL client socket.";
     OnSSLHandshakeCompleted(net::ERR_UNEXPECTED);
     return;
   }
 
-  int result = socket_->Connect(&ssl_handshake_callback_);
+  int result = socket_->Connect(
+      base::Bind(&PepperTCPSocket::OnSSLHandshakeCompleted,
+                 base::Unretained(this)));
   if (result != net::ERR_IO_PENDING)
     OnSSLHandshakeCompleted(result);
 }
 
 void PepperTCPSocket::Read(int32 bytes_to_read) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (!IsConnected() || end_of_file_reached_ || read_buffer_.get() ||
       bytes_to_read <= 0) {
     SendReadACKError();
     return;
   }
 
   if (bytes_to_read > ppapi::TCPSocketPrivateImpl::kMaxReadSize) {
     NOTREACHED();
     bytes_to_read = ppapi::TCPSocketPrivateImpl::kMaxReadSize;
   }
 
   read_buffer_ = new net::IOBuffer(bytes_to_read);
-  int result = socket_->Read(read_buffer_, bytes_to_read, &read_callback_);
+  int result = socket_->Read(read_buffer_, bytes_to_read,
+                             base::Bind(&PepperTCPSocket::OnReadCompleted,
+                                        base::Unretained(this)));
   if (result != net::ERR_IO_PENDING)
     OnReadCompleted(result);
 }
 
 void PepperTCPSocket::Write(const std::string& data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (!IsConnected() || write_buffer_.get() || data.empty()) {
     SendWriteACKError();
     return;
   }
 
   int data_size = data.size();
   if (data_size > ppapi::TCPSocketPrivateImpl::kMaxWriteSize) {
     NOTREACHED();
     data_size = ppapi::TCPSocketPrivateImpl::kMaxWriteSize;
   }
 
   write_buffer_ = new net::IOBuffer(data_size);
   memcpy(write_buffer_->data(), data.c_str(), data_size);
-  int result = socket_->Write(write_buffer_, data.size(), &write_callback_);
+  int result = socket_->Write(write_buffer_, data.size(),
+                              base::Bind(&PepperTCPSocket::OnWriteCompleted,
+                                         base::Unretained(this)));
   if (result != net::ERR_IO_PENDING)
     OnWriteCompleted(result);
 }
 
 void PepperTCPSocket::StartConnect(const net::AddressList& addresses) {
   DCHECK(connection_state_ == CONNECT_IN_PROGRESS);
 
   socket_.reset(
       new net::TCPClientSocket(addresses, NULL, net::NetLog::Source()));
-  int result = socket_->Connect(&connect_callback_);
+  int result = socket_->Connect(
+      base::Bind(&PepperTCPSocket::OnConnectCompleted,
+                 base::Unretained(this)));
   if (result != net::ERR_IO_PENDING)
     OnConnectCompleted(result);
 }
 
 void PepperTCPSocket::SendConnectACKError() {
   manager_->Send(new PpapiMsg_PPBTCPSocket_ConnectACK(
       routing_id_, plugin_dispatcher_id_, socket_id_, false,
       NetAddressPrivateImpl::kInvalidNetAddress,
       NetAddressPrivateImpl::kInvalidNetAddress));
 }
@@ skipping 89 matching lines @@
         routing_id_, plugin_dispatcher_id_, socket_id_, true, result));
   } else {
     SendWriteACKError();
   }
   write_buffer_ = NULL;
 }
 
 bool PepperTCPSocket::IsConnected() const {
   return connection_state_ == CONNECTED || connection_state_ == SSL_CONNECTED;
 }