base::Bind: Convert Socket::Read.

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),
-        final_read_callback_(NULL),
+        old_final_read_callback_(NULL),
         method_factory_(this) {
   }
 
   ~TestingTransportSocket() {
-    if (final_read_callback_) {
+    if (old_final_read_callback_) {
       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));
+              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 (final_read_callback_)
+      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())
         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;
     }
@@ skipping 25 matching lines @@
   virtual bool SetReceiveBufferSize(int32 size) {
     return true;
   }
 
   virtual bool SetSendBufferSize(int32 size) {
     return true;
   }
 
   net::DrainableIOBuffer* answer() { return answer_.get(); }
 
-  void DoReadCallback(net::OldCompletionCallback* callback, int result) {
+  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));
     } else {
-      if (callback)
-        callback->Run(result);
+      if (!callback.is_null())
+        callback.Run(result);
     }
   }
 
   void DoWriteCallback(net::OldCompletionCallback* callback, int result) {
     if (callback)
       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* final_read_callback_;
+  net::OldCompletionCallback* old_final_read_callback_;
+  net::CompletionCallback final_read_callback_;
 
   ScopedRunnableMethodFactory<TestingTransportSocket> method_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 404 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