Add unittests for BufferedSocketWriter and fix some bugs in that code.

remoting/protocol/fake_session.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/message_loop.h"
 #include "net/base/address_list.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace remoting {
 namespace protocol {
 
 const char kTestJid[] = "host1@gmail.com/chromoting123";
 
 FakeSocket::FakeSocket()
-    : next_read_error_(net::OK),
+    : async_write_(false),
+      write_pending_(false),
+      write_limit_(0),
+      next_write_error_(net::OK),
+      next_read_error_(net::OK),
       read_pending_(false),
       read_buffer_size_(0),
       input_pos_(0),
       message_loop_(MessageLoop::current()),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
 }
 
 FakeSocket::~FakeSocket() {
   EXPECT_EQ(message_loop_, MessageLoop::current());
 }
@@ skipping 42 matching lines @@
     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,
                       const net::CompletionCallback& callback) {
   EXPECT_EQ(message_loop_, MessageLoop::current());
+  EXPECT_FALSE(write_pending_);
+
+  if (write_limit_ > 0)
+    buf_len = std::min(write_limit_, buf_len);
+
+  if (async_write_) {
+    message_loop_->PostTask(FROM_HERE, base::Bind(
+        &FakeSocket::DoAsyncWrite, weak_factory_.GetWeakPtr(),
+        scoped_refptr<net::IOBuffer>(buf), buf_len, callback));
+    write_pending_ = true;
+    return net::ERR_IO_PENDING;
+  } else {
+    if (next_write_error_ != net::OK) {
+      int r = next_write_error_;
+      next_write_error_ = net::OK;
+      return r;
+    }
+
+    DoWrite(buf, buf_len);
+    return buf_len;
+  }
+}
+
+void FakeSocket::DoAsyncWrite(scoped_refptr<net::IOBuffer> buf, int buf_len,
+                              const net::CompletionCallback& callback) {
+  write_pending_ = false;
+
+  if (next_write_error_ != net::OK) {
+    int r = next_write_error_;
+    next_write_error_ = net::OK;
+    callback.Run(r);
+    return;
+  }
+
+  DoWrite(buf, buf_len);
+  callback.Run(buf_len);
+}
+
+void FakeSocket::DoWrite(net::IOBuffer* buf, int buf_len) {
   written_data_.insert(written_data_.end(),
                        buf->data(), buf->data() + buf_len);
 
   if (peer_socket_) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
         &FakeSocket::AppendInputData, peer_socket_,
         std::vector<char>(buf->data(), buf->data() + buf_len)));
   }
-
-  return buf_len;
 }
 
 bool FakeSocket::SetReceiveBufferSize(int32 size) {
   NOTIMPLEMENTED();
   return false;
 }
 bool FakeSocket::SetSendBufferSize(int32 size) {
   NOTIMPLEMENTED();
   return false;
 }
@@ skipping 195 matching lines @@
 void FakeSession::set_config(const SessionConfig& config) {
   config_ = config;
 }
 
 void FakeSession::Close() {
   closed_ = true;
 }
 
 }  // namespace protocol
 }  // namespace remoting