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

remoting/protocol/jingle_session_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 "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/message_loop_proxy.h"
 #include "base/path_service.h"
 #include "base/time.h"
@@ skipping 445 matching lines @@
   bool done_;
 };
 
 class TCPChannelTester : public ChannelTesterBase {
  public:
   TCPChannelTester(Session* host_session,
                    Session* client_session,
                    int message_size,
                    int message_count)
       : ChannelTesterBase(host_session, client_session),
-        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),
         message_size_(message_size),
         message_count_(message_count),
         test_data_size_(message_size * message_count) {
   }
 
   virtual ~TCPChannelTester() { }
 
   virtual bool did_initialization_fail() {
@@ skipping 53 matching lines @@
     input_buffer_ = new net::GrowableIOBuffer();
   }
 
   virtual void DoWrite() {
     int result = 1;
     while (result > 0) {
       if (output_buffer_->BytesRemaining() == 0)
         break;
       int bytes_to_write = std::min(output_buffer_->BytesRemaining(),
                                     message_size_);
-      result = sockets_[0]->Write(output_buffer_, bytes_to_write, &write_cb_);
+      result = sockets_[0]->Write(output_buffer_, bytes_to_write,
+                                  base::Bind(&TCPChannelTester::OnWritten,
+                                             base::Unretained(this)));
       HandleWriteResult(result);
     };
   }
 
   void OnWritten(int result) {
     HandleWriteResult(result);
     DoWrite();
   }
 
   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) {
       output_buffer_->DidConsume(result);
     }
   }
 
   virtual void DoRead() {
     int result = 1;
     while (result > 0) {
       input_buffer_->SetCapacity(input_buffer_->offset() + message_size_);
-      result = sockets_[1]->Read(input_buffer_, message_size_, &read_cb_);
+      result = sockets_[1]->Read(input_buffer_, message_size_,
+                                 base::Bind(&TCPChannelTester::OnRead,
+                                            base::Unretained(this)));
       HandleReadResult(result);
     };
   }
 
   void OnRead(int result) {
     HandleReadResult(result);
     if (!done_)
       DoRead();  // Don't try to read again when we are done reading.
   }
 
   void HandleReadResult(int result) {
     if (result <= 0 && result != net::ERR_IO_PENDING) {
       if (!done_) {
         LOG(ERROR) << "Received error " << result << " when trying to read";
         read_errors_++;
         Done();
       }
     } else if (result > 0) {
       // Allocate memory for the next read.
       input_buffer_->set_offset(input_buffer_->offset() + result);
       if (input_buffer_->offset() == test_data_size_)
         Done();
     }
   }
 
   scoped_refptr<net::DrainableIOBuffer> output_buffer_;
   scoped_refptr<net::GrowableIOBuffer> input_buffer_;
 
-  net::OldCompletionCallbackImpl<TCPChannelTester> write_cb_;
-  net::OldCompletionCallbackImpl<TCPChannelTester> read_cb_;
   int write_errors_;
   int read_errors_;
   int message_size_;
   int message_count_;
   int test_data_size_;
 };
 
 class ChannelSpeedTester : public TCPChannelTester {
  public:
   ChannelSpeedTester(Session* host_session,
@@ skipping 20 matching lines @@
   }
 
   base::Time start_time_;
 };
 
 class UDPChannelTester : public ChannelTesterBase {
  public:
   UDPChannelTester(Session* host_session,
                    Session* client_session)
       : ChannelTesterBase(host_session, client_session),
-        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() { }
 
   virtual void CheckResults() {
@@ skipping 46 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 = sockets_[0]->Write(packet, kMessageSize, &write_cb_);
+    int result = sockets_[0]->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_++;
       MessageLoop::current()->PostDelayedTask(
           FROM_HERE, base::Bind(&UDPChannelTester::DoWrite, this),
           kUdpWriteDelayMs);
     }
   }
 
   virtual void DoRead() {
     int result = 1;
     while (result > 0) {
       int kReadSize = kMessageSize * 2;
       read_buffer_ = new net::IOBuffer(kReadSize);
 
-      result = sockets_[1]->Read(read_buffer_, kReadSize, &read_cb_);
+      result = sockets_[1]->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 21 matching lines @@
             broken_packets_++;
         }
       }
     }
   }
 
  private:
   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_;
 };
 
 // Verify that we can create and destory server objects without a connection.
 TEST_F(JingleSessionTest, CreateAndDestoy) {
   CreateServerPair(false);
@@ skipping 123 matching lines @@
   ASSERT_TRUE(tester->WaitFinished());
   LOG(INFO) << "Time for 500k bytes "
             << tester->GetElapsedTime().InMilliseconds() << " ms.";
 
   // Connections must be closed while |tester| still exists.
   CloseSessions();
 }
 
 }  // namespace protocol
 }  // namespace remoting