base::Bind: Convert Socket::Read.

net/socket/socket_test_util.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/socket_test_util.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 720 matching lines @@
     : MockClientSocket(net_log),
       addresses_(addresses),
       data_(data),
       read_offset_(0),
       num_bytes_read_(0),
       read_data_(false, net::ERR_UNEXPECTED),
       need_read_data_(true),
       peer_closed_connection_(false),
       pending_buf_(NULL),
       pending_buf_len_(0),
-      pending_callback_(NULL),
+      old_pending_callback_(NULL),
       was_used_to_convey_data_(false) {
   DCHECK(data_);
   data_->Reset();
 }
 
 int MockTCPClientSocket::Read(net::IOBuffer* buf, int buf_len,
                               net::OldCompletionCallback* callback) {
   if (!connected_)
     return net::ERR_UNEXPECTED;
 
   // If the buffer is already in use, a read is already in progress!
   DCHECK(pending_buf_ == NULL);
 
   // Store our async IO data.
   pending_buf_ = buf;
   pending_buf_len_ = buf_len;
-  pending_callback_ = callback;
+  old_pending_callback_ = callback;
 
   if (need_read_data_) {
     read_data_ = data_->GetNextRead();
     if (read_data_.result == ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ) {
       // This MockRead is just a marker to instruct us to set
       // peer_closed_connection_.  Skip it and get the next one.
       read_data_ = data_->GetNextRead();
       peer_closed_connection_ = true;
     }
     // ERR_IO_PENDING means that the SocketDataProvider is taking responsibility
     // to complete the async IO manually later (via OnReadComplete).
     if (read_data_.result == ERR_IO_PENDING) {
       DCHECK(callback);  // We need to be using async IO in this case.
       return ERR_IO_PENDING;
     }
     need_read_data_ = false;
   }
 
   return CompleteRead();
 }
+int MockTCPClientSocket::Read(net::IOBuffer* buf, int buf_len,
+                              const net::CompletionCallback& callback) {
+  if (!connected_)
+    return net::ERR_UNEXPECTED;
+
+  // If the buffer is already in use, a read is already in progress!
+  DCHECK(pending_buf_ == NULL);
+
+  // Store our async IO data.
+  pending_buf_ = buf;
+  pending_buf_len_ = buf_len;
+  pending_callback_ = callback;
+
+  if (need_read_data_) {
+    read_data_ = data_->GetNextRead();
+    if (read_data_.result == ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ) {
+      // This MockRead is just a marker to instruct us to set
+      // peer_closed_connection_.  Skip it and get the next one.
+      read_data_ = data_->GetNextRead();
+      peer_closed_connection_ = true;
+    }
+    // ERR_IO_PENDING means that the SocketDataProvider is taking responsibility
+    // to complete the async IO manually later (via OnReadComplete).
+    if (read_data_.result == ERR_IO_PENDING) {
+      // We need to be using async IO in this case.
+      DCHECK(!callback.is_null());
+      return ERR_IO_PENDING;
+    }
+    need_read_data_ = false;
+  }
+
+  return CompleteRead();
+}
 
 int MockTCPClientSocket::Write(net::IOBuffer* buf, int buf_len,
                                net::OldCompletionCallback* callback) {
   DCHECK(buf);
   DCHECK_GT(buf_len, 0);
 
   if (!connected_)
     return net::ERR_UNEXPECTED;
 
   std::string data(buf->data(), buf_len);
@@ skipping 29 matching lines @@
   if (data_->connect_data().async) {
     RunCallbackAsync(callback, data_->connect_data().result);
     return net::ERR_IO_PENDING;
   }
 
   return data_->connect_data().result;
 }
 
 void MockTCPClientSocket::Disconnect() {
   MockClientSocket::Disconnect();
-  pending_callback_ = NULL;
+  old_pending_callback_ = NULL;
+  pending_callback_.Reset();
 }
 
 bool MockTCPClientSocket::IsConnected() const {
   return connected_ && !peer_closed_connection_;
 }
 
 bool MockTCPClientSocket::IsConnectedAndIdle() const {
   return IsConnected();
 }
 
@@ skipping 30 matching lines @@
   // Since we've been waiting for data, need_read_data_ should be true.
   DCHECK(need_read_data_);
 
   read_data_ = data;
   need_read_data_ = false;
 
   // The caller is simulating that this IO completes right now.  Don't
   // let CompleteRead() schedule a callback.
   read_data_.async = false;
 
-  net::OldCompletionCallback* callback = pending_callback_;
-  int rv = CompleteRead();
-  RunOldCallback(callback, rv);
+  if (old_pending_callback_) {
+    net::OldCompletionCallback* callback = old_pending_callback_;
+    int rv = CompleteRead();
+    RunOldCallback(callback, rv);
+  } else {
+    net::CompletionCallback callback = pending_callback_;
+    int rv = CompleteRead();
+    RunCallback(callback, rv);
+  }
 }
 
 int MockTCPClientSocket::CompleteRead() {
   DCHECK(pending_buf_);
   DCHECK(pending_buf_len_ > 0);
 
   was_used_to_convey_data_ = true;
 
   // Save the pending async IO data and reset our |pending_| state.
   net::IOBuffer* buf = pending_buf_;
   int buf_len = pending_buf_len_;
-  net::OldCompletionCallback* callback = pending_callback_;
+  net::OldCompletionCallback* old_callback = old_pending_callback_;
+  net::CompletionCallback callback = pending_callback_;
   pending_buf_ = NULL;
   pending_buf_len_ = 0;
-  pending_callback_ = NULL;
+  old_pending_callback_ = NULL;
+  pending_callback_.Reset();
 
   int result = read_data_.result;
   DCHECK(result != ERR_IO_PENDING);
 
   if (read_data_.data) {
     if (read_data_.data_len - read_offset_ > 0) {
       result = std::min(buf_len, read_data_.data_len - read_offset_);
       memcpy(buf->data(), read_data_.data + read_offset_, result);
       read_offset_ += result;
       num_bytes_read_ += result;
       if (read_offset_ == read_data_.data_len) {
         need_read_data_ = true;
         read_offset_ = 0;
       }
     } else {
       result = 0;  // EOF
     }
   }
 
   if (read_data_.async) {
-    DCHECK(callback);
-    RunCallbackAsync(callback, result);
+    DCHECK(old_callback || !callback.is_null());
+    if (old_callback)
+      RunCallbackAsync(old_callback, result);
+    else
+      RunCallbackAsync(callback, result);
     return net::ERR_IO_PENDING;
   }
   return result;
 }
 
 DeterministicMockTCPClientSocket::DeterministicMockTCPClientSocket(
     net::NetLog* net_log, net::DeterministicSocketData* data)
     : MockClientSocket(net_log),
       write_pending_(false),
       write_callback_(NULL),
       write_result_(0),
       read_data_(),
       read_buf_(NULL),
       read_buf_len_(0),
       read_pending_(false),
-      read_callback_(NULL),
+      old_read_callback_(NULL),
       data_(data),
       was_used_to_convey_data_(false) {}
 
 DeterministicMockTCPClientSocket::~DeterministicMockTCPClientSocket() {}
 
 void DeterministicMockTCPClientSocket::CompleteWrite() {
   was_used_to_convey_data_ = true;
   write_pending_ = false;
   write_callback_->Run(write_result_);
 }
@@ skipping 13 matching lines @@
   int result = read_data_.result;
 
   if (read_data_.data_len > 0) {
     DCHECK(read_data_.data);
     result = std::min(read_buf_len_, read_data_.data_len);
     memcpy(read_buf_->data(), read_data_.data, result);
   }
 
   if (read_pending_) {
     read_pending_ = false;
-    read_callback_->Run(result);
+    if (old_read_callback_)
+      old_read_callback_->Run(result);
+    else
+      read_callback_.Run(result);
   }
 
   return result;
 }
 
 int DeterministicMockTCPClientSocket::Write(
     net::IOBuffer* buf, int buf_len, net::OldCompletionCallback* callback) {
   DCHECK(buf);
   DCHECK_GT(buf_len, 0);
 
@@ skipping 21 matching lines @@
   if (!connected_)
     return net::ERR_UNEXPECTED;
 
   read_data_ = data_->GetNextRead();
   // The buffer should always be big enough to contain all the MockRead data. To
   // use small buffers, split the data into multiple MockReads.
   DCHECK_LE(read_data_.data_len, buf_len);
 
   read_buf_ = buf;
   read_buf_len_ = buf_len;
+  old_read_callback_ = callback;
+
+  if (read_data_.async || (read_data_.result == ERR_IO_PENDING)) {
+    read_pending_ = true;
+    DCHECK(old_read_callback_);
+    return ERR_IO_PENDING;
+  }
+
+  was_used_to_convey_data_ = true;
+  return CompleteRead();
+}
+int DeterministicMockTCPClientSocket::Read(
+    net::IOBuffer* buf, int buf_len, const net::CompletionCallback& callback) {
+  if (!connected_)
+    return net::ERR_UNEXPECTED;
+
+  read_data_ = data_->GetNextRead();
+  // The buffer should always be big enough to contain all the MockRead data. To
+  // use small buffers, split the data into multiple MockReads.
+  DCHECK_LE(read_data_.data_len, buf_len);
+
+  read_buf_ = buf;
+  read_buf_len_ = buf_len;
   read_callback_ = callback;
 
   if (read_data_.async || (read_data_.result == ERR_IO_PENDING)) {
     read_pending_ = true;
-    DCHECK(read_callback_);
+    DCHECK(!read_callback_.is_null());
     return ERR_IO_PENDING;
   }
 
   was_used_to_convey_data_ = true;
   return CompleteRead();
 }
 
 // TODO(erikchen): Support connect sequencing.
 int DeterministicMockTCPClientSocket::Connect(
     net::OldCompletionCallback* callback) {
@@ skipping 121 matching lines @@
 }
 
 MockSSLClientSocket::~MockSSLClientSocket() {
   Disconnect();
 }
 
 int MockSSLClientSocket::Read(net::IOBuffer* buf, int buf_len,
                               net::OldCompletionCallback* callback) {
   return transport_->socket()->Read(buf, buf_len, callback);
 }
+int MockSSLClientSocket::Read(net::IOBuffer* buf, int buf_len,
+                              const net::CompletionCallback& callback) {
+  return transport_->socket()->Read(buf, buf_len, callback);
+}
 
 int MockSSLClientSocket::Write(net::IOBuffer* buf, int buf_len,
                                net::OldCompletionCallback* callback) {
   return transport_->socket()->Write(buf, buf_len, callback);
 }
 
 int MockSSLClientSocket::Connect(net::OldCompletionCallback* callback) {
   OldConnectCallback* connect_callback = new OldConnectCallback(
       this, callback, data_->connect.result);
   int rv = transport_->socket()->Connect(connect_callback);
@@ skipping 92 matching lines @@
 
 MockUDPClientSocket::MockUDPClientSocket(SocketDataProvider* data,
                                          net::NetLog* net_log)
     : connected_(false),
       data_(data),
       read_offset_(0),
       read_data_(false, net::ERR_UNEXPECTED),
       need_read_data_(true),
       pending_buf_(NULL),
       pending_buf_len_(0),
-      pending_callback_(NULL),
+      old_pending_callback_(NULL),
       net_log_(NetLog::Source(), net_log),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   DCHECK(data_);
   data_->Reset();
 }
 
 MockUDPClientSocket::~MockUDPClientSocket() {}
 
 int MockUDPClientSocket::Read(net::IOBuffer* buf, int buf_len,
                               net::OldCompletionCallback* callback) {
   if (!connected_)
     return net::ERR_UNEXPECTED;
 
   // If the buffer is already in use, a read is already in progress!
   DCHECK(pending_buf_ == NULL);
 
   // Store our async IO data.
   pending_buf_ = buf;
   pending_buf_len_ = buf_len;
-  pending_callback_ = callback;
+  old_pending_callback_ = callback;
 
   if (need_read_data_) {
     read_data_ = data_->GetNextRead();
     // ERR_IO_PENDING means that the SocketDataProvider is taking responsibility
     // to complete the async IO manually later (via OnReadComplete).
     if (read_data_.result == ERR_IO_PENDING) {
       DCHECK(callback);  // We need to be using async IO in this case.
       return ERR_IO_PENDING;
     }
     need_read_data_ = false;
   }
 
   return CompleteRead();
 }
+int MockUDPClientSocket::Read(net::IOBuffer* buf, int buf_len,
+                              const net::CompletionCallback& callback) {
+  if (!connected_)
+    return net::ERR_UNEXPECTED;
+
+  // If the buffer is already in use, a read is already in progress!
+  DCHECK(pending_buf_ == NULL);
+
+  // Store our async IO data.
+  pending_buf_ = buf;
+  pending_buf_len_ = buf_len;
+  pending_callback_ = callback;
+
+  if (need_read_data_) {
+    read_data_ = data_->GetNextRead();
+    // ERR_IO_PENDING means that the SocketDataProvider is taking responsibility
+    // to complete the async IO manually later (via OnReadComplete).
+    if (read_data_.result == ERR_IO_PENDING) {
+      // We need to be using async IO in this case.
+      DCHECK(!callback.is_null());
+      return ERR_IO_PENDING;
+    }
+    need_read_data_ = false;
+  }
+
+  return CompleteRead();
+}
 
 int MockUDPClientSocket::Write(net::IOBuffer* buf, int buf_len,
                                net::OldCompletionCallback* callback) {
   DCHECK(buf);
   DCHECK_GT(buf_len, 0);
 
   if (!connected_)
     return ERR_UNEXPECTED;
 
   std::string data(buf->data(), buf_len);
@@ skipping 45 matching lines @@
   // Since we've been waiting for data, need_read_data_ should be true.
   DCHECK(need_read_data_);
 
   read_data_ = data;
   need_read_data_ = false;
 
   // The caller is simulating that this IO completes right now.  Don't
   // let CompleteRead() schedule a callback.
   read_data_.async = false;
 
-  net::OldCompletionCallback* callback = pending_callback_;
-  int rv = CompleteRead();
-  RunCallback(callback, rv);
+  if (old_pending_callback_) {
+    net::OldCompletionCallback* callback = old_pending_callback_;
+    int rv = CompleteRead();
+    RunOldCallback(callback, rv);
+  } else {
+    net::CompletionCallback callback = pending_callback_;
+    int rv = CompleteRead();
+    RunCallback(callback, rv);
+  }
 }
 
 int MockUDPClientSocket::CompleteRead() {
   DCHECK(pending_buf_);
   DCHECK(pending_buf_len_ > 0);
 
   // Save the pending async IO data and reset our |pending_| state.
   net::IOBuffer* buf = pending_buf_;
   int buf_len = pending_buf_len_;
-  net::OldCompletionCallback* callback = pending_callback_;
+  net::OldCompletionCallback* old_callback = old_pending_callback_;
+  net::CompletionCallback callback = pending_callback_;
   pending_buf_ = NULL;
   pending_buf_len_ = 0;
-  pending_callback_ = NULL;
+  old_pending_callback_ = NULL;
+  pending_callback_.Reset();
+  pending_callback_.Reset();
 
   int result = read_data_.result;
   DCHECK(result != ERR_IO_PENDING);
 
   if (read_data_.data) {
     if (read_data_.data_len - read_offset_ > 0) {
       result = std::min(buf_len, read_data_.data_len - read_offset_);
       memcpy(buf->data(), read_data_.data + read_offset_, result);
       read_offset_ += result;
       if (read_offset_ == read_data_.data_len) {
         need_read_data_ = true;
         read_offset_ = 0;
       }
     } else {
       result = 0;  // EOF
     }
   }
 
   if (read_data_.async) {
-    DCHECK(callback);
-    RunCallbackAsync(callback, result);
+    DCHECK(old_callback || !callback.is_null());
+    if (old_callback)
+      RunCallbackAsync(old_callback, result);
+    else
+      RunCallbackAsync(callback, result);
     return net::ERR_IO_PENDING;
   }
   return result;
 }
 
 void MockUDPClientSocket::RunCallbackAsync(net::OldCompletionCallback* callback,
                                            int result) {
   MessageLoop::current()->PostTask(FROM_HERE,
+      base::Bind(&MockUDPClientSocket::RunOldCallback,
+                 weak_factory_.GetWeakPtr(), callback, result));
+}
+void MockUDPClientSocket::RunCallbackAsync(
+    const net::CompletionCallback& callback, int result) {
+  MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&MockUDPClientSocket::RunCallback, weak_factory_.GetWeakPtr(),
                  callback, result));
 }
 
-void MockUDPClientSocket::RunCallback(net::OldCompletionCallback* callback,
+void MockUDPClientSocket::RunOldCallback(net::OldCompletionCallback* callback,
                                       int result) {
   if (callback)
     callback->Run(result);
 }
+void MockUDPClientSocket::RunCallback(const net::CompletionCallback& callback,
+                                      int result) {
+  if (!callback.is_null())
+    callback.Run(result);
+}
 
 TestSocketRequest::TestSocketRequest(
     std::vector<TestSocketRequest*>* request_order,
     size_t* completion_count)
     : request_order_(request_order),
       completion_count_(completion_count) {
   DCHECK(request_order);
   DCHECK(completion_count);
 }
 
@@ skipping 256 matching lines @@
 
 const char kSOCKS5OkRequest[] =
     { 0x05, 0x01, 0x00, 0x03, 0x04, 'h', 'o', 's', 't', 0x00, 0x50 };
 const int kSOCKS5OkRequestLength = arraysize(kSOCKS5OkRequest);
 
 const char kSOCKS5OkResponse[] =
     { 0x05, 0x00, 0x00, 0x01, 127, 0, 0, 1, 0x00, 0x50 };
 const int kSOCKS5OkResponseLength = arraysize(kSOCKS5OkResponse);
 
 }  // namespace net