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

net/socket/web_socket_server_socket_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 "net/socket/web_socket_server_socket.h"
 
 #include <stdlib.h>
 #include <algorithm>
 
 #include "base/callback_old.h"
@@ skipping 61 matching lines @@
 
 // TODO(dilmah): consider switching to socket_test_util.h
 // Simulates reading from |sample| stream; data supplied in Write() calls are
 // stored in |answer| buffer.
 class TestingTransportSocket : public net::Socket {
  public:
   TestingTransportSocket(
       net::DrainableIOBuffer* sample, net::DrainableIOBuffer* answer)
       : sample_(sample),
         answer_(answer),
-        old_final_read_callback_(NULL),
-        method_factory_(this) {
+        ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   }
 
   ~TestingTransportSocket() {
-    if (old_final_read_callback_) {
+    if (!final_read_callback_.is_null()) {
       MessageLoop::current()->PostTask(FROM_HERE,
-          method_factory_.NewRunnableMethod(
-              &TestingTransportSocket::DoOldReadCallback,
-                  old_final_read_callback_, 0));
-    } else if (!final_read_callback_.is_null()) {
-      MessageLoop::current()->PostTask(
-          FROM_HERE,
-          method_factory_.NewRunnableMethod(
-              &TestingTransportSocket::DoReadCallback,
-              final_read_callback_, 0));
+          base::Bind(&TestingTransportSocket::DoReadCallback,
+                     weak_factory_.GetWeakPtr(),
+                     final_read_callback_, 0));
     }
   }
 
   // Socket implementation.
   virtual int Read(net::IOBuffer* buf, int buf_len,
-                   net::OldCompletionCallback* callback) {
-    CHECK_GT(buf_len, 0);
-    int remaining = sample_->BytesRemaining();
-    if (remaining < 1) {
-      if (old_final_read_callback_ || !final_read_callback_.is_null())
-        return 0;
-      old_final_read_callback_ = callback;
-      return net::ERR_IO_PENDING;
-    }
-    int lot = GetRand(1, std::min(remaining, buf_len));
-    std::copy(sample_->data(), sample_->data() + lot, buf->data());
-    sample_->DidConsume(lot);
-    if (GetRand(0, 1)) {
-      return lot;
-    }
-    MessageLoop::current()->PostTask(FROM_HERE,
-        method_factory_.NewRunnableMethod(
-            &TestingTransportSocket::DoOldReadCallback, callback, lot));
-    return net::ERR_IO_PENDING;
-  }
-  virtual int Read(net::IOBuffer* buf, int buf_len,
                    const net::CompletionCallback& callback) {
     CHECK_GT(buf_len, 0);
     int remaining = sample_->BytesRemaining();
     if (remaining < 1) {
-      if (old_final_read_callback_ || !final_read_callback_.is_null())
+      if (!final_read_callback_.is_null())
         return 0;
       final_read_callback_ = callback;
       return net::ERR_IO_PENDING;
     }
     int lot = GetRand(1, std::min(remaining, buf_len));
     std::copy(sample_->data(), sample_->data() + lot, buf->data());
     sample_->DidConsume(lot);
     if (GetRand(0, 1)) {
       return lot;
     }
-    MessageLoop::current()->PostTask(FROM_HERE,
-        method_factory_.NewRunnableMethod(
-            &TestingTransportSocket::DoReadCallback, callback, lot));
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&TestingTransportSocket::DoReadCallback,
+                   weak_factory_.GetWeakPtr(), callback, lot));
     return net::ERR_IO_PENDING;
   }
 
   virtual int Write(net::IOBuffer* buf, int buf_len,
-                    net::OldCompletionCallback* callback) {
+                    const net::CompletionCallback& callback) {
     CHECK_GT(buf_len, 0);
     int remaining = answer_->BytesRemaining();
     CHECK_GE(remaining, buf_len);
     int lot = std::min(remaining, buf_len);
     if (GetRand(0, 1))
       lot = GetRand(1, lot);
     std::copy(buf->data(), buf->data() + lot, answer_->data());
     answer_->DidConsume(lot);
     if (GetRand(0, 1)) {
       return lot;
     }
-    MessageLoop::current()->PostTask(FROM_HERE,
-        method_factory_.NewRunnableMethod(
-            &TestingTransportSocket::DoWriteCallback, callback, lot));
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&TestingTransportSocket::DoWriteCallback,
+                   weak_factory_.GetWeakPtr(), callback, lot));
     return net::ERR_IO_PENDING;
   }
 
   virtual bool SetReceiveBufferSize(int32 size) {
     return true;
   }
 
   virtual bool SetSendBufferSize(int32 size) {
     return true;
   }
 
   net::DrainableIOBuffer* answer() { return answer_.get(); }
 
-  void DoOldReadCallback(net::OldCompletionCallback* callback, int result) {
-    if (result == 0 && !is_closed_) {
-      MessageLoop::current()->PostTask(FROM_HERE,
-          method_factory_.NewRunnableMethod(
-              &TestingTransportSocket::DoOldReadCallback, callback, 0));
-    } else {
-      if (callback)
-        callback->Run(result);
-    }
-  }
   void DoReadCallback(const net::CompletionCallback& callback, int result) {
     if (result == 0 && !is_closed_) {
-      MessageLoop::current()->PostTask(FROM_HERE,
-          method_factory_.NewRunnableMethod(
-              &TestingTransportSocket::DoReadCallback, callback, 0));
+      MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(
+              &TestingTransportSocket::DoReadCallback,
+              weak_factory_.GetWeakPtr(), callback, 0));
     } else {
       if (!callback.is_null())
         callback.Run(result);
     }
   }
 
-  void DoWriteCallback(net::OldCompletionCallback* callback, int result) {
-    if (callback)
-      callback->Run(result);
+  void DoWriteCallback(const net::CompletionCallback& callback, int result) {
+    if (!callback.is_null())
+      callback.Run(result);
   }
 
   bool is_closed_;
 
   // Data to return for Read requests.
   scoped_refptr<net::DrainableIOBuffer> sample_;
 
   // Data pushed to us by server socket (using Write calls).
   scoped_refptr<net::DrainableIOBuffer> answer_;
 
   // Final read callback to report zero (zero stands for EOF).
-  net::OldCompletionCallback* old_final_read_callback_;
   net::CompletionCallback final_read_callback_;
 
-  ScopedRunnableMethodFactory<TestingTransportSocket> method_factory_;
+  base::WeakPtrFactory<TestingTransportSocket> weak_factory_;
 };
 
 class Validator : public net::WebSocketServerSocket::Delegate {
  public:
   Validator(const std::string& resource,
             const std::string& origin,
             const std::string& host)
       : resource_(resource), origin_(origin), host_(host) {
   }
 
@@ skipping 26 matching lines @@
 char ReferenceSeq(unsigned n, unsigned salt) {
   return (salt * 2 + n * 3) % ('z' - 'a') + 'a';
 }
 
 class ReadWriteTracker {
  public:
   ReadWriteTracker(
       net::WebSocketServerSocket* ws, int bytes_to_read, int bytes_to_write)
       : ws_(ws),
         buf_size_(1 << 14),
-        accept_callback_(NewCallback(this, &ReadWriteTracker::OnAccept)),
-        read_callback_(NewCallback(this, &ReadWriteTracker::OnRead)),
-        write_callback_(NewCallback(this, &ReadWriteTracker::OnWrite)),
+        ALLOW_THIS_IN_INITIALIZER_LIST(
+            accept_callback_(this, &ReadWriteTracker::OnAccept)),
         read_buf_(new net::IOBuffer(buf_size_)),
         write_buf_(new net::IOBuffer(buf_size_)),
         bytes_remaining_to_read_(bytes_to_read),
         bytes_remaining_to_write_(bytes_to_write),
         read_initiated_(false),
         write_initiated_(false),
         got_final_zero_(false) {
-    int rv = ws_->Accept(accept_callback_.get());
+    int rv = ws_->Accept(&accept_callback_);
     if (rv != net::ERR_IO_PENDING)
       OnAccept(rv);
   }
 
   ~ReadWriteTracker() {
     CHECK_EQ(bytes_remaining_to_write_, 0);
     CHECK_EQ(bytes_remaining_to_read_, 0);
   }
 
   void OnAccept(int result) {
     ASSERT_EQ(result, 0);
     if (GetRand(0, 1)) {
       DoRead();
       DoWrite();
     } else {
       DoWrite();
       DoRead();
     }
   }
 
   void DoWrite() {
     if (bytes_remaining_to_write_ < 1)
       return;
     int lot = GetRand(1, bytes_remaining_to_write_);
     lot = std::min(lot, buf_size_);
     for (int i = 0; i < lot; ++i)
       write_buf_->data()[i] = ReferenceSeq(
           bytes_remaining_to_write_ - i - 1, kWriteSalt);
-    int rv = ws_->Write(write_buf_, lot, write_callback_.get());
+    int rv = ws_->Write(write_buf_, lot, base::Bind(&ReadWriteTracker::OnWrite,
+                                                    base::Unretained(this)));
     if (rv != net::ERR_IO_PENDING)
       OnWrite(rv);
   }
 
   void DoRead() {
     int lot = GetRand(1, buf_size_);
     if (bytes_remaining_to_read_ < 1) {
       if (got_final_zero_)
         return;
     } else {
       lot = GetRand(1, bytes_remaining_to_read_);
       lot = std::min(lot, buf_size_);
     }
-    int rv = ws_->Read(read_buf_, lot, read_callback_.get());
+    int rv = ws_->Read(read_buf_, lot, base::Bind(&ReadWriteTracker::OnRead,
+                                                  base::Unretained(this)));
     if (rv != net::ERR_IO_PENDING)
       OnRead(rv);
   }
 
   void OnWrite(int result) {
     ASSERT_GT(result, 0);
     ASSERT_LE(result, bytes_remaining_to_write_);
     bytes_remaining_to_write_ -= result;
     DoWrite();
   }
@@ skipping 10 matching lines @@
       ASSERT_EQ(read_buf_->data()[i], ReferenceSeq(
           bytes_remaining_to_read_ - i - 1, kReadSalt));
     }
     bytes_remaining_to_read_ -= result;
     DoRead();
   }
 
  private:
   net::WebSocketServerSocket* const ws_;
   int const buf_size_;
-  scoped_ptr<net::OldCompletionCallback> accept_callback_;
-  scoped_ptr<net::OldCompletionCallback> read_callback_;
-  scoped_ptr<net::OldCompletionCallback> write_callback_;
+  net::OldCompletionCallbackImpl<ReadWriteTracker> accept_callback_;
   scoped_refptr<net::IOBuffer> read_buf_;
   scoped_refptr<net::IOBuffer> write_buf_;
   int bytes_remaining_to_read_;
   int bytes_remaining_to_write_;
   bool read_initiated_;
   bool write_initiated_;
   bool got_final_zero_;
 };
 
 }  // namespace
@@ skipping 269 matching lines @@
   MessageLoop::current()->RunAllPending();
 
   for (size_t i = kill_list.size(); i--;)
     delete kill_list[i];
   for (size_t i = tracker_list.size(); i--;)
     delete tracker_list[i];
   MessageLoop::current()->RunAllPending();
 }
 
 }  // namespace net