base::Bind: Convert Socket::Read.

net/socket/ssl_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.
 
 // This test suite uses SSLClientSocket to test the implementation of
 // SSLServerSocket. In order to establish connections between the sockets
 // we need two additional classes:
 // 1. FakeSocket
 //    Connects SSL socket to FakeDataChannel. This class is just a stub.
 //
@@ skipping 33 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace net {
 
 namespace {
 
 class FakeDataChannel {
  public:
   FakeDataChannel()
-      : read_callback_(NULL),
+      : old_read_callback_(NULL),
         read_buf_len_(0),
         ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)) {
   }
 
   virtual int Read(IOBuffer* buf, int buf_len,
                    OldCompletionCallback* callback) {
     if (data_.empty()) {
+      old_read_callback_ = callback;
+      read_buf_ = buf;
+      read_buf_len_ = buf_len;
+      return net::ERR_IO_PENDING;
+    }
+    return PropogateData(buf, buf_len);
+  }
+  virtual int Read(IOBuffer* buf, int buf_len,
+                   const CompletionCallback& callback) {
+    if (data_.empty()) {
       read_callback_ = callback;
       read_buf_ = buf;
       read_buf_len_ = buf_len;
       return net::ERR_IO_PENDING;
     }
     return PropogateData(buf, buf_len);
   }
 
   virtual int Write(IOBuffer* buf, int buf_len,
                     OldCompletionCallback* callback) {
     data_.push(new net::DrainableIOBuffer(buf, buf_len));
     MessageLoop::current()->PostTask(
         FROM_HERE, task_factory_.NewRunnableMethod(
             &FakeDataChannel::DoReadCallback));
     return buf_len;
   }
 
  private:
   void DoReadCallback() {
-    if (!read_callback_ || data_.empty())
+    if ((!old_read_callback_ && read_callback_.is_null()) || data_.empty())
       return;
 
     int copied = PropogateData(read_buf_, read_buf_len_);
-    net::OldCompletionCallback* callback = read_callback_;
-    read_callback_ = NULL;
-    read_buf_ = NULL;
-    read_buf_len_ = 0;
-    callback->Run(copied);
+    if (old_read_callback_) {
+      net::OldCompletionCallback* callback = old_read_callback_;
+      old_read_callback_ = NULL;
+      read_buf_ = NULL;
+      read_buf_len_ = 0;
+      callback->Run(copied);
+    } else {
+      net::CompletionCallback callback = read_callback_;
+      read_callback_.Reset();
+      read_buf_ = NULL;
+      read_buf_len_ = 0;
+      callback.Run(copied);
+    }
   }
 
   int PropogateData(scoped_refptr<net::IOBuffer> read_buf, int read_buf_len) {
     scoped_refptr<net::DrainableIOBuffer> buf = data_.front();
     int copied = std::min(buf->BytesRemaining(), read_buf_len);
     memcpy(read_buf->data(), buf->data(), copied);
     buf->DidConsume(copied);
 
     if (!buf->BytesRemaining())
       data_.pop();
     return copied;
   }
 
-  net::OldCompletionCallback* read_callback_;
+  net::OldCompletionCallback* old_read_callback_;
+  net::CompletionCallback read_callback_;
   scoped_refptr<net::IOBuffer> read_buf_;
   int read_buf_len_;
 
   std::queue<scoped_refptr<net::DrainableIOBuffer> > data_;
 
   ScopedRunnableMethodFactory<FakeDataChannel> task_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeDataChannel);
 };
 
 class FakeSocket : public StreamSocket {
  public:
   FakeSocket(FakeDataChannel* incoming_channel,
              FakeDataChannel* outgoing_channel)
       : incoming_(incoming_channel),
         outgoing_(outgoing_channel) {
   }
 
   virtual ~FakeSocket() {
   }
 
   virtual int Read(IOBuffer* buf, int buf_len,
                    OldCompletionCallback* callback) {
     // Read random number of bytes.
     buf_len = rand() % buf_len + 1;
     return incoming_->Read(buf, buf_len, callback);
   }
+  virtual int Read(IOBuffer* buf, int buf_len,
+                   const CompletionCallback& callback) {
+    // Read random number of bytes.
+    buf_len = rand() % buf_len + 1;
+    return incoming_->Read(buf, buf_len, callback);
+  }
 
   virtual int Write(IOBuffer* buf, int buf_len,
                     OldCompletionCallback* callback) {
     // Write random number of bytes.
     buf_len = rand() % buf_len + 1;
     return outgoing_->Write(buf, buf_len, callback);
   }
 
   virtual bool SetReceiveBufferSize(int32 size) {
     return true;
@@ skipping 330 matching lines @@
   const char* kKeyingLabelBad = "EXPERIMENTAL-server-socket-test-bad";
   unsigned char client_bad[kKeyingMaterialSize];
   rv = client_socket_->ExportKeyingMaterial(kKeyingLabelBad, kKeyingContext,
                                             client_bad, sizeof(client_bad));
   ASSERT_EQ(rv, net::OK);
   EXPECT_TRUE(memcmp(server_out, client_bad, sizeof(server_out)) != 0);
 }
 #endif
 
 }  // namespace net