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

content/renderer/p2p/p2p_transport_impl_unittest.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/renderer/p2p/p2p_transport_impl.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
@@ skipping 33 matching lines @@
 
 class UdpChannelTester : public base::RefCountedThreadSafe<UdpChannelTester> {
  public:
   UdpChannelTester(MessageLoop* message_loop,
                 net::Socket* write_socket,
                 net::Socket* read_socket)
       : message_loop_(message_loop),
         write_socket_(write_socket),
         read_socket_(read_socket),
         done_(false),
-        ALLOW_THIS_IN_INITIALIZER_LIST(
-            write_cb_(this, &UdpChannelTester::OnWritten)),
-        ALLOW_THIS_IN_INITIALIZER_LIST(
-            read_cb_(this, &UdpChannelTester::OnRead)),
         write_errors_(0),
         read_errors_(0),
         packets_sent_(0),
         packets_received_(0),
         broken_packets_(0) {
   }
 
   virtual ~UdpChannelTester() { }
 
   void Start() {
@@ skipping 29 matching lines @@
       Done();
       return;
     }
 
     scoped_refptr<net::IOBuffer> packet(new net::IOBuffer(kMessageSize));
     memset(packet->data(), 123, kMessageSize);
     sent_packets_[packets_sent_] = packet;
     // Put index of this packet in the beginning of the packet body.
     memcpy(packet->data(), &packets_sent_, sizeof(packets_sent_));
 
-    int result = write_socket_->Write(packet, kMessageSize, &write_cb_);
+    int result = write_socket_->Write(packet, kMessageSize,
+                                      base::Bind(&UdpChannelTester::OnWritten,
+                                                 base::Unretained(this)));
     HandleWriteResult(result);
   }
 
   void OnWritten(int result) {
     HandleWriteResult(result);
   }
 
   void HandleWriteResult(int result) {
     if (result <= 0 && result != net::ERR_IO_PENDING) {
       LOG(ERROR) << "Received error " << result << " when trying to write";
       write_errors_++;
       Done();
     } else if (result > 0) {
       EXPECT_EQ(kMessageSize, result);
       packets_sent_++;
       message_loop_->PostDelayedTask(
           FROM_HERE, base::Bind(&UdpChannelTester::DoWrite, this),
           kUdpWriteDelayMs);
     }
   }
 
   void DoRead() {
     int result = 1;
     while (result > 0) {
       int kReadSize = kMessageSize * 2;
       read_buffer_ = new net::IOBuffer(kReadSize);
 
-      result = read_socket_->Read(read_buffer_, kReadSize, &read_cb_);
+      result = read_socket_->Read(read_buffer_, kReadSize,
+                                      base::Bind(&UdpChannelTester::OnRead,
+                                                 base::Unretained(this)));
       HandleReadResult(result);
     };
   }
 
   void OnRead(int result) {
     HandleReadResult(result);
     DoRead();
   }
 
   void HandleReadResult(int result) {
@@ skipping 26 matching lines @@
 
  private:
   MessageLoop* message_loop_;
   net::Socket* write_socket_;
   net::Socket* read_socket_;
   bool done_;
 
   scoped_refptr<net::IOBuffer> sent_packets_[kMessages];
   scoped_refptr<net::IOBuffer> read_buffer_;
 
-  net::OldCompletionCallbackImpl<UdpChannelTester> write_cb_;
-  net::OldCompletionCallbackImpl<UdpChannelTester> read_cb_;
   int write_errors_;
   int read_errors_;
   int packets_sent_;
   int packets_received_;
   int broken_packets_;
 };
 
 class TcpChannelTester : public base::RefCountedThreadSafe<TcpChannelTester> {
  public:
   TcpChannelTester(MessageLoop* message_loop,
                 net::Socket* write_socket,
                 net::Socket* read_socket)
       : message_loop_(message_loop),
         write_socket_(write_socket),
         read_socket_(read_socket),
         done_(false),
-        ALLOW_THIS_IN_INITIALIZER_LIST(
-            write_cb_(this, &TcpChannelTester::OnWritten)),
-        ALLOW_THIS_IN_INITIALIZER_LIST(
-            read_cb_(this, &TcpChannelTester::OnRead)),
         write_errors_(0),
         read_errors_(0) {
   }
 
   virtual ~TcpChannelTester() { }
 
   void Init() {
     // Initialize |send_buffer_|.
     send_buffer_ = new net::DrainableIOBuffer(new net::IOBuffer(kTcpDataSize),
                                               kTcpDataSize);
@@ skipping 29 matching lines @@
     done_ = true;
     message_loop_->PostTask(FROM_HERE, new MessageLoop::QuitTask());
   }
 
   void DoWrite() {
     if (send_buffer_->BytesRemaining() == 0) {
       return;
     }
 
     int result = write_socket_->Write(
-        send_buffer_, send_buffer_->BytesRemaining(), &write_cb_);
+        send_buffer_, send_buffer_->BytesRemaining(),
+        base::Bind(&TcpChannelTester::OnWritten, base::Unretained(this)));
     HandleWriteResult(result);
   }
 
   void OnWritten(int result) {
     HandleWriteResult(result);
   }
 
   void HandleWriteResult(int result) {
     if (result <= 0 && result != net::ERR_IO_PENDING) {
       LOG(ERROR) << "Received error " << result << " when trying to write";
       write_errors_++;
       Done();
     } else if (result > 0) {
       send_buffer_->DidConsume(result);
       message_loop_->PostDelayedTask(
           FROM_HERE, base::Bind(&TcpChannelTester::DoWrite, this),
           kTcpWriteDelayMs);
     }
   }
 
   void DoRead() {
     int result = 1;
     while (result > 0) {
       int kReadSize = kMessageSize * 2;
       read_buffer_ = new net::IOBuffer(kReadSize);
 
-      result = read_socket_->Read(read_buffer_, kReadSize, &read_cb_);
+      result = read_socket_->Read(
+          read_buffer_, kReadSize,
+          base::Bind(&TcpChannelTester::OnRead, base::Unretained(this)));
       HandleReadResult(result);
     };
   }
 
   void OnRead(int result) {
     HandleReadResult(result);
     DoRead();
   }
 
   void HandleReadResult(int result) {
@@ skipping 17 matching lines @@
   net::Socket* write_socket_;
   net::Socket* read_socket_;
   bool done_;
 
   scoped_refptr<net::DrainableIOBuffer> send_buffer_;
   scoped_refptr<net::IOBuffer> read_buffer_;
 
   std::vector<char> sent_data_;
   std::vector<char> received_data_;
 
-  net::OldCompletionCallbackImpl<TcpChannelTester> write_cb_;
-  net::OldCompletionCallbackImpl<TcpChannelTester> read_cb_;
   int write_errors_;
   int read_errors_;
 };
 
 }  // namespace
 
 namespace content {
 
 class MockP2PEventHandler : public P2PTransport::EventHandler {
  public:
@@ skipping 151 matching lines @@
 
   message_loop_.PostDelayedTask(FROM_HERE, new MessageLoop::QuitTask(),
                                 TestTimeouts::action_max_timeout_ms());
 
   channel_tester->Init();
   message_loop_.Run();
   channel_tester->CheckResults();
 }
 
 }  // namespace content