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

chrome/browser/net/network_stats.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 "chrome/browser/net/network_stats.h"
 
 #include "base/bind.h"
 #include "base/callback_old.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 64 matching lines @@
 // This specifies the starting position of the <encoded_payload> and length of
 // the <encoded_payload> in "echo response".
 static const uint32 kEncodedPayloadStart = kKeyEnd;
 
 // NetworkStats methods and members.
 NetworkStats::NetworkStats()
     : load_size_(0),
       bytes_to_read_(0),
       bytes_to_send_(0),
       encoded_message_(""),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          read_callback_(this, &NetworkStats::OnReadComplete)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          write_callback_(this, &NetworkStats::OnWriteComplete)),
       finished_callback_(NULL),
       start_time_(base::TimeTicks::Now()),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
 }
 
 NetworkStats::~NetworkStats() {
   socket_.reset();
 }
 
 bool NetworkStats::Start(net::HostResolver* host_resolver,
@@ skipping 140 matching lines @@
   int rv;
   do {
     if (!socket_.get())
       return;
 
     DCHECK(!read_buffer_.get());
 
     // We release the read_buffer_ in the destructor if there is an error.
     read_buffer_ = new net::IOBuffer(kMaxMessage);
 
-    rv = socket_->Read(read_buffer_, kMaxMessage, &read_callback_);
+    rv = socket_->Read(read_buffer_, kMaxMessage,
+                       base::Bind(&NetworkStats::OnReadComplete,
+                                  base::Unretained(this)));
     if (rv == net::ERR_IO_PENDING)
       return;
     // If we have read all the data then return.
     if (ReadComplete(rv))
       return;
   } while (rv > 0);
 }
 
 int NetworkStats::SendData() {
   DCHECK(bytes_to_send_);   // We should have data to send.
   do {
     if (!write_buffer_.get()) {
       scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(bytes_to_send_));
       GetEchoRequest(buffer);
       write_buffer_ = new net::DrainableIOBuffer(buffer, bytes_to_send_);
     }
 
     if (!socket_.get())
       return net::ERR_UNEXPECTED;
     int rv = socket_->Write(write_buffer_,
                             write_buffer_->BytesRemaining(),
-                            &write_callback_);
+                            base::Bind(&NetworkStats::OnWriteComplete,
+                                       base::Unretained(this)));
     if (rv < 0)
       return rv;
     write_buffer_->DidConsume(rv);
     bytes_to_send_ -= rv;
     if (!write_buffer_->BytesRemaining())
       write_buffer_ = NULL;
   } while (bytes_to_send_);
   return net::OK;
 }
 
@@ skipping 154 matching lines @@
   // Close the socket so that there are no more IO operations.
   net::UDPClientSocket* udp_socket =
       static_cast<net::UDPClientSocket*>(socket());
   if (udp_socket)
     udp_socket->Close();
 
   delete this;
 }
 
 // TCPStatsClient methods and members.
-TCPStatsClient::TCPStatsClient()
-    : NetworkStats(),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          connect_callback_(this, &TCPStatsClient::OnConnectComplete)) {
+TCPStatsClient::TCPStatsClient() {
 }
 
 TCPStatsClient::~TCPStatsClient() {
 }
 
 bool TCPStatsClient::DoConnect(int result) {
   if (result != net::OK) {
     Finish(RESOLVE_FAILED, result);
     return false;
   }
 
   net::TCPClientSocket* tcp_socket =
       new net::TCPClientSocket(GetAddressList(), NULL, net::NetLog::Source());
   if (!tcp_socket) {
     Finish(SOCKET_CREATE_FAILED, net::ERR_INVALID_ARGUMENT);
     return false;
   }
   set_socket(tcp_socket);
 
-  int rv = tcp_socket->Connect(&connect_callback_);
+  int rv = tcp_socket->Connect(base::Bind(&TCPStatsClient::OnConnectComplete,
+                                          base::Unretained(this)));
   if (rv == net::ERR_IO_PENDING)
     return true;
 
   return NetworkStats::ConnectComplete(rv);
 }
 
 void TCPStatsClient::OnConnectComplete(int result) {
   NetworkStats::ConnectComplete(result);
 }
 
@@ skipping 117 matching lines @@
   TCPStatsClient* small_tcp_client = new TCPStatsClient();
   small_tcp_client->Start(
       host_resolver, tcp_server_address, kSmallTestBytesToSend, NULL);
 
   TCPStatsClient* large_tcp_client = new TCPStatsClient();
   large_tcp_client->Start(
       host_resolver, tcp_server_address, kLargeTestBytesToSend, NULL);
 }
 
 }  // namespace chrome_browser_net