base::Bind: Convert Socket::Read.

remoting/protocol/fake_session.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 "remoting/protocol/fake_session.h"
 
 #include "base/message_loop.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 18 matching lines @@
   input_data_.insert(input_data_.end(), data, data + data_size);
   // Complete pending read if any.
   if (read_pending_) {
     read_pending_ = false;
     int result = std::min(read_buffer_size_,
                           static_cast<int>(input_data_.size() - input_pos_));
     CHECK(result > 0);
     memcpy(read_buffer_->data(),
            &(*input_data_.begin()) + input_pos_, result);
     input_pos_ += result;
-    read_callback_->Run(result);
+    if (old_read_callback_)
+      old_read_callback_->Run(result);
+    else
+      read_callback_.Run(result);
     read_buffer_ = NULL;
   }
 }
 
 int FakeSocket::Read(net::IOBuffer* buf, int buf_len,
                      net::OldCompletionCallback* callback) {
   EXPECT_EQ(message_loop_, MessageLoop::current());
   if (input_pos_ < static_cast<int>(input_data_.size())) {
     int result = std::min(buf_len,
                           static_cast<int>(input_data_.size()) - input_pos_);
     memcpy(buf->data(), &(*input_data_.begin()) + input_pos_, result);
     input_pos_ += result;
     return result;
   } else {
     read_pending_ = true;
     read_buffer_ = buf;
     read_buffer_size_ = buf_len;
+    old_read_callback_ = callback;
+    return net::ERR_IO_PENDING;
+  }
+}
+int FakeSocket::Read(net::IOBuffer* buf, int buf_len,
+                     const net::CompletionCallback& callback) {
+  EXPECT_EQ(message_loop_, MessageLoop::current());
+  if (input_pos_ < static_cast<int>(input_data_.size())) {
+    int result = std::min(buf_len,
+                          static_cast<int>(input_data_.size()) - input_pos_);
+    memcpy(buf->data(), &(*input_data_.begin()) + input_pos_, result);
+    input_pos_ += result;
+    return result;
+  } else {
+    read_pending_ = true;
+    read_buffer_ = buf;
+    read_buffer_size_ = buf_len;
     read_callback_ = callback;
     return net::ERR_IO_PENDING;
   }
 }
 
 int FakeSocket::Write(net::IOBuffer* buf, int buf_len,
                       net::OldCompletionCallback* callback) {
   EXPECT_EQ(message_loop_, MessageLoop::current());
   written_data_.insert(written_data_.end(),
                        buf->data(), buf->data() + buf_len);
@@ skipping 72 matching lines @@
   return 0;
 }
 
 base::TimeDelta FakeSocket::GetConnectTimeMicros() const {
   NOTIMPLEMENTED();
   return base::TimeDelta();
 }
 
 FakeUdpSocket::FakeUdpSocket()
     : read_pending_(false),
+      old_read_callback_(NULL),
       input_pos_(0),
       message_loop_(MessageLoop::current()) {
 }
 
 FakeUdpSocket::~FakeUdpSocket() {
   EXPECT_EQ(message_loop_, MessageLoop::current());
 }
 
 void FakeUdpSocket::AppendInputPacket(const char* data, int data_size) {
   EXPECT_EQ(message_loop_, MessageLoop::current());
   input_packets_.push_back(std::string());
   input_packets_.back().assign(data, data + data_size);
 
   // Complete pending read if any.
   if (read_pending_) {
     read_pending_ = false;
     int result = std::min(data_size, read_buffer_size_);
     memcpy(read_buffer_->data(), data, result);
     input_pos_ = input_packets_.size();
-    read_callback_->Run(result);
+    if (old_read_callback_)
+      old_read_callback_->Run(result);
+    else
+      old_read_callback_->Run(result);
     read_buffer_ = NULL;
   }
 }
 
 int FakeUdpSocket::Read(net::IOBuffer* buf, int buf_len,
                         net::OldCompletionCallback* callback) {
   EXPECT_EQ(message_loop_, MessageLoop::current());
   if (input_pos_ < static_cast<int>(input_packets_.size())) {
     int result = std::min(
         buf_len, static_cast<int>(input_packets_[input_pos_].size()));
     memcpy(buf->data(), &(*input_packets_[input_pos_].begin()), result);
     ++input_pos_;
     return result;
   } else {
     read_pending_ = true;
     read_buffer_ = buf;
     read_buffer_size_ = buf_len;
+    old_read_callback_ = callback;
+    return net::ERR_IO_PENDING;
+  }
+}
+int FakeUdpSocket::Read(net::IOBuffer* buf, int buf_len,
+                        const net::CompletionCallback& callback) {
+  EXPECT_EQ(message_loop_, MessageLoop::current());
+  if (input_pos_ < static_cast<int>(input_packets_.size())) {
+    int result = std::min(
+        buf_len, static_cast<int>(input_packets_[input_pos_].size()));
+    memcpy(buf->data(), &(*input_packets_[input_pos_].begin()), result);
+    ++input_pos_;
+    return result;
+  } else {
+    read_pending_ = true;
+    read_buffer_ = buf;
+    read_buffer_size_ = buf_len;
     read_callback_ = callback;
     return net::ERR_IO_PENDING;
   }
 }
 
 int FakeUdpSocket::Write(net::IOBuffer* buf, int buf_len,
                          net::OldCompletionCallback* callback) {
   EXPECT_EQ(message_loop_, MessageLoop::current());
   written_packets_.push_back(std::string());
   written_packets_.back().assign(buf->data(), buf->data() + buf_len);
@@ skipping 68 matching lines @@
 void FakeSession::set_config(const SessionConfig& config) {
   config_ = config;
 }
 
 void FakeSession::Close() {
   closed_ = true;
 }
 
 }  // namespace protocol
 }  // namespace remoting