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

content/browser/renderer_host/p2p/socket_host_tcp.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/p2p/socket_host_tcp.h"
 
 #include "content/common/p2p_messages.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/sys_byteorder.h"
 #include "net/socket/tcp_client_socket.h"
 
 namespace {
 const int kReadBufferSize = 4096;
 const int kPacketHeaderSize = sizeof(uint16);
 }  // namespace
 
 namespace content {
 
 P2PSocketHostTcp::P2PSocketHostTcp(IPC::Message::Sender* message_sender,
                                    int routing_id, int id)
     : P2PSocketHost(message_sender, routing_id, id),
-      connected_(false),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          connect_callback_(this, &P2PSocketHostTcp::OnConnected)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          read_callback_(this, &P2PSocketHostTcp::OnRead)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          write_callback_(this, &P2PSocketHostTcp::OnWritten)) {
+      connected_(false) {
 }
 
 P2PSocketHostTcp::~P2PSocketHostTcp() {
   if (state_ == STATE_OPEN) {
     DCHECK(socket_.get());
     socket_.reset();
   }
 }
 
 bool P2PSocketHostTcp::InitAccepted(const net::IPEndPoint& remote_address,
@@ skipping 20 matching lines @@
       NULL, net::NetLog::Source()));
   if (tcp_socket->Bind(local_address) != net::OK) {
     OnError();
     return false;
   }
   socket_.reset(tcp_socket.release());
 
   if (socket_->SetSendBufferSize(kMaxSendBufferSize))
     LOG(WARNING) << "Failed to set send buffer size for TCP socket.";
 
-  int result = socket_->Connect(&connect_callback_);
+  int result = socket_->Connect(
+      base::Bind(&P2PSocketHostTcp::OnConnected, base::Unretained(this)));
   if (result != net::ERR_IO_PENDING) {
     OnConnected(result);
   }
 
   return state_ != STATE_ERROR;
 }
 
 void P2PSocketHostTcp::OnError() {
   socket_.reset();
 
@@ skipping 36 matching lines @@
       read_buffer_->SetCapacity(kReadBufferSize);
     } else if (read_buffer_->RemainingCapacity() < kReadBufferSize) {
       // Make sure that we always have at least kReadBufferSize of
       // remaining capacity in the read buffer. Normally all packets
       // are smaller than kReadBufferSize, so this is not really
       // required.
       read_buffer_->SetCapacity(read_buffer_->capacity() + kReadBufferSize -
                                 read_buffer_->RemainingCapacity());
     }
     result = socket_->Read(read_buffer_, read_buffer_->RemainingCapacity(),
-                           &read_callback_);
+                           base::Bind(&P2PSocketHostTcp::OnRead,
+                                      base::Unretained(this)));
     DidCompleteRead(result);
   } while (result > 0);
 }
 
 void P2PSocketHostTcp::OnRead(int result) {
   DidCompleteRead(result);
   if (state_ == STATE_OPEN) {
     DoRead();
   }
 }
@@ skipping 86 matching lines @@
   write_buffer_ = new net::DrainableIOBuffer(new net::IOBuffer(size), size);
   *reinterpret_cast<uint16*>(write_buffer_->data()) = htons(data.size());
   memcpy(write_buffer_->data() + kPacketHeaderSize, &data[0], data.size());
 
   DoWrite();
 }
 
 void P2PSocketHostTcp::DoWrite() {
   while (true) {
     int result = socket_->Write(write_buffer_, write_buffer_->BytesRemaining(),
-                                &write_callback_);
+                                base::Bind(&P2PSocketHostTcp::OnWritten,
+                                           base::Unretained(this)));
     if (result >= 0) {
       write_buffer_->DidConsume(result);
       if (write_buffer_->BytesRemaining() == 0) {
         write_buffer_ = NULL;
         break;
       }
     } else {
       if (result != net::ERR_IO_PENDING) {
         LOG(ERROR) << "Error when sending data in TCP socket: " << result;
         OnError();
@@ skipping 23 matching lines @@
 }
 
 P2PSocketHost* P2PSocketHostTcp::AcceptIncomingTcpConnection(
     const net::IPEndPoint& remote_address, int id) {
   NOTREACHED();
   OnError();
   return NULL;
 }
 
 } // namespace content