base::Bind: Convert Socket::Write.

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 814 matching lines @@
 
   was_used_to_convey_data_ = true;
 
   if (write_result.async) {
     RunCallbackAsync(callback, write_result.result);
     return net::ERR_IO_PENDING;
   }
 
   return write_result.result;
 }
+int MockTCPClientSocket::Write(net::IOBuffer* buf, int buf_len,
+                               const net::CompletionCallback& callback) {
+  DCHECK(buf);
+  DCHECK_GT(buf_len, 0);
+
+  if (!connected_)
+    return net::ERR_UNEXPECTED;
+
+  std::string data(buf->data(), buf_len);
+  net::MockWriteResult write_result = data_->OnWrite(data);
+
+  was_used_to_convey_data_ = true;
+
+  if (write_result.async) {
+    RunCallbackAsync(callback, write_result.result);
+    return net::ERR_IO_PENDING;
+  }
+
+  return write_result.result;
+}
 
 int MockTCPClientSocket::Connect(net::OldCompletionCallback* callback) {
   if (connected_)
     return net::OK;
   connected_ = true;
   peer_closed_connection_ = false;
   if (data_->connect_data().async) {
     RunCallbackAsync(callback, data_->connect_data().result);
     return net::ERR_IO_PENDING;
   }
@@ skipping 120 matching lines @@
       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),
+      old_write_callback_(NULL),
       write_result_(0),
       read_data_(),
       read_buf_(NULL),
       read_buf_len_(0),
       read_pending_(false),
       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_);
+  if (old_write_callback_)
+    old_write_callback_->Run(write_result_);
+  else
+    write_callback_.Run(write_result_);
 }
 
 int DeterministicMockTCPClientSocket::CompleteRead() {
   DCHECK_GT(read_buf_len_, 0);
   DCHECK_LE(read_data_.data_len, read_buf_len_);
   DCHECK(read_buf_);
 
   was_used_to_convey_data_ = true;
 
   if (read_data_.result == ERR_IO_PENDING)
@@ skipping 13 matching lines @@
     read_pending_ = false;
     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);
-
-  if (!connected_)
-    return net::ERR_UNEXPECTED;
-
-  std::string data(buf->data(), buf_len);
-  net::MockWriteResult write_result = data_->OnWrite(data);
-
-  if (write_result.async) {
-    write_callback_ = callback;
-    write_result_ = write_result.result;
-    DCHECK(write_callback_ != NULL);
-    write_pending_ = true;
-    return net::ERR_IO_PENDING;
-  }
-
-  was_used_to_convey_data_ = true;
-  write_pending_ = false;
-  return write_result.result;
-}
-
 int DeterministicMockTCPClientSocket::Read(
     net::IOBuffer* buf, int buf_len, net::OldCompletionCallback* 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);
 
@@ skipping 27 matching lines @@
   if (read_data_.async || (read_data_.result == ERR_IO_PENDING)) {
     read_pending_ = true;
     DCHECK(!read_callback_.is_null());
     return ERR_IO_PENDING;
   }
 
   was_used_to_convey_data_ = true;
   return CompleteRead();
 }
 
+int DeterministicMockTCPClientSocket::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);
+  net::MockWriteResult write_result = data_->OnWrite(data);
+
+  if (write_result.async) {
+    old_write_callback_ = callback;
+    write_result_ = write_result.result;
+    DCHECK(old_write_callback_ != NULL);
+    write_pending_ = true;
+    return net::ERR_IO_PENDING;
+  }
+
+  was_used_to_convey_data_ = true;
+  write_pending_ = false;
+  return write_result.result;
+}
+int DeterministicMockTCPClientSocket::Write(
+    net::IOBuffer* buf, int buf_len, const net::CompletionCallback& callback) {
+  DCHECK(buf);
+  DCHECK_GT(buf_len, 0);
+
+  if (!connected_)
+    return net::ERR_UNEXPECTED;
+
+  std::string data(buf->data(), buf_len);
+  net::MockWriteResult write_result = data_->OnWrite(data);
+
+  if (write_result.async) {
+    write_callback_ = callback;
+    write_result_ = write_result.result;
+    DCHECK(!write_callback_.is_null());
+    write_pending_ = true;
+    return net::ERR_IO_PENDING;
+  }
+
+  was_used_to_convey_data_ = true;
+  write_pending_ = false;
+  return write_result.result;
+}
+
 // TODO(erikchen): Support connect sequencing.
 int DeterministicMockTCPClientSocket::Connect(
     net::OldCompletionCallback* callback) {
   if (connected_)
     return net::OK;
   connected_ = true;
   if (data_->connect_data().async) {
     RunCallbackAsync(callback, data_->connect_data().result);
     return net::ERR_IO_PENDING;
   }
@@ skipping 123 matching lines @@
 }
 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::Write(net::IOBuffer* buf, int buf_len,
+                               const net::CompletionCallback& 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);
   if (rv == net::OK) {
     delete connect_callback;
     if (data_->connect.result == net::OK)
       connected_ = true;
     if (data_->connect.async) {
@@ skipping 167 matching lines @@
 
   std::string data(buf->data(), buf_len);
   MockWriteResult write_result = data_->OnWrite(data);
 
   if (write_result.async) {
     RunCallbackAsync(callback, write_result.result);
     return ERR_IO_PENDING;
   }
   return write_result.result;
 }
+int MockUDPClientSocket::Write(net::IOBuffer* buf, int buf_len,
+                               const net::CompletionCallback& callback) {
+  DCHECK(buf);
+  DCHECK_GT(buf_len, 0);
+
+  if (!connected_)
+    return ERR_UNEXPECTED;
+
+  std::string data(buf->data(), buf_len);
+  MockWriteResult write_result = data_->OnWrite(data);
+
+  if (write_result.async) {
+    RunCallbackAsync(callback, write_result.result);
+    return ERR_IO_PENDING;
+  }
+  return write_result.result;
+}
 
 bool MockUDPClientSocket::SetReceiveBufferSize(int32 size) {
   return true;
 }
 
 bool MockUDPClientSocket::SetSendBufferSize(int32 size) {
   return true;
 }
 
 void MockUDPClientSocket::Close() {
@@ skipping 380 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