Fix BufferedSocketWriter to buffer everything before it starts writing.

remoting/base/buffered_socket_writer_unittest.cc

Index: remoting/base/buffered_socket_writer_unittest.cc
diff --git a/remoting/base/buffered_socket_writer_unittest.cc b/remoting/base/buffered_socket_writer_unittest.cc
index 3bf5d49ceca7bd217f07cf115d2137abf3bc6772..d924ad0e77f69fe8ae111f04378b9384331c5acb 100644
--- a/remoting/base/buffered_socket_writer_unittest.cc
+++ b/remoting/base/buffered_socket_writer_unittest.cc
@@ -23,6 +23,13 @@ namespace {
 const int kTestBufferSize = 10000;
 const size_t kWriteChunkSize = 1024U;
 
+int WriteNetSocket(net::Socket* socket,
+                   const scoped_refptr<net::IOBuffer>& buf,
+                   int buf_len,
+                   const net::CompletionCallback& callback) {
+  return socket->Write(buf.get(), buf_len, callback);
+}
+
 class SocketDataProvider: public net::SocketDataProvider {
  public:
   SocketDataProvider()
@@ -95,25 +102,26 @@ class BufferedSocketWriterTest : public testing::Test {
         net::MockConnect(net::SYNCHRONOUS, net::OK));
     EXPECT_EQ(net::OK, socket_->Connect(net::CompletionCallback()));
 
-    writer_ = BufferedSocketWriter::CreateForSocket(
-        socket_.get(), base::Bind(&BufferedSocketWriterTest::OnWriteFailed,
-                                  base::Unretained(this)));
+    writer_.reset(new BufferedSocketWriter());
     test_buffer_ = new net::IOBufferWithSize(kTestBufferSize);
     test_buffer_2_ = new net::IOBufferWithSize(kTestBufferSize);
-    for (int i = 0; i< kTestBufferSize; ++i) {
+    for (int i = 0; i < kTestBufferSize; ++i) {
       test_buffer_->data()[i] = rand() % 256;
       test_buffer_2_->data()[i] = rand() % 256;
     }
   }
 
+  void StartWriter() {
+    writer_->Start(base::Bind(&WriteNetSocket, socket_.get()),
+                   base::Bind(&BufferedSocketWriterTest::OnWriteFailed,
+                              base::Unretained(this)));
+  };
+
   void OnWriteFailed(int error) {
     write_error_ = error;
   }
 
-  void TestWrite() {
-    writer_->Write(test_buffer_, base::Closure());
-    writer_->Write(test_buffer_2_, base::Closure());
-    base::RunLoop().RunUntilIdle();
+  void VerifyWrittenData() {
     ASSERT_EQ(static_cast<size_t>(test_buffer_->size() +
                                   test_buffer_2_->size()),
               socket_data_provider_.written_data().size());
@@ -126,22 +134,20 @@ class BufferedSocketWriterTest : public testing::Test {
                         test_buffer_2_->size()));
   }
 
+  void TestWrite() {
+    writer_->Write(test_buffer_, base::Closure());
+    writer_->Write(test_buffer_2_, base::Closure());
+    base::RunLoop().RunUntilIdle();
+    VerifyWrittenData();
+  }
+
   void TestAppendInCallback() {
     writer_->Write(test_buffer_, base::Bind(
         base::IgnoreResult(&BufferedSocketWriter::Write),
         base::Unretained(writer_.get()), test_buffer_2_,
         base::Closure()));
     base::RunLoop().RunUntilIdle();
-    ASSERT_EQ(static_cast<size_t>(test_buffer_->size() +
-                                  test_buffer_2_->size()),
-              socket_data_provider_.written_data().size());
-    EXPECT_EQ(0, memcmp(test_buffer_->data(),
-                        socket_data_provider_.written_data().data(),
-                        test_buffer_->size()));
-    EXPECT_EQ(0, memcmp(test_buffer_2_->data(),
-                        socket_data_provider_.written_data().data() +
-                            test_buffer_->size(),
-                        test_buffer_2_->size()));
+    VerifyWrittenData();
   }
 
   base::MessageLoop message_loop_;
@@ -156,17 +162,20 @@ class BufferedSocketWriterTest : public testing::Test {
 
 // Test synchronous write.
 TEST_F(BufferedSocketWriterTest, WriteFull) {
+  StartWriter();
   TestWrite();
 }
 
 // Test synchronous write in 1k chunks.
 TEST_F(BufferedSocketWriterTest, WriteChunks) {
+  StartWriter();
   socket_data_provider_.set_write_limit(kWriteChunkSize);
   TestWrite();
 }
 
 // Test asynchronous write.
 TEST_F(BufferedSocketWriterTest, WriteAsync) {
+  StartWriter();
   socket_data_provider_.set_async_write(true);
   socket_data_provider_.set_write_limit(kWriteChunkSize);
   TestWrite();
@@ -174,11 +183,13 @@ TEST_F(BufferedSocketWriterTest, WriteAsync) {
 
 // Make sure we can call Write() from the done callback.
 TEST_F(BufferedSocketWriterTest, AppendInCallbackSync) {
+  StartWriter();
   TestAppendInCallback();
 }
 
 // Make sure we can call Write() from the done callback.
 TEST_F(BufferedSocketWriterTest, AppendInCallbackAsync) {
+  StartWriter();
   socket_data_provider_.set_async_write(true);
   socket_data_provider_.set_write_limit(kWriteChunkSize);
   TestAppendInCallback();
@@ -186,6 +197,7 @@ TEST_F(BufferedSocketWriterTest, AppendInCallbackAsync) {
 
 // Test that the writer can be destroyed from callback.
 TEST_F(BufferedSocketWriterTest, DestroyFromCallback) {
+  StartWriter();
   socket_data_provider_.set_async_write(true);
   writer_->Write(test_buffer_, base::Bind(
       &BufferedSocketWriterTest::DestroyWriter,
@@ -204,6 +216,7 @@ TEST_F(BufferedSocketWriterTest, DestroyFromCallback) {
 
 // Verify that it stops writing after the first error.
 TEST_F(BufferedSocketWriterTest, TestWriteErrorSync) {
+  StartWriter();
   socket_data_provider_.set_write_limit(kWriteChunkSize);
   writer_->Write(test_buffer_, base::Closure());
   socket_data_provider_.set_async_write(true);
@@ -220,6 +233,7 @@ TEST_F(BufferedSocketWriterTest, TestWriteErrorSync) {
 
 // Verify that it stops writing after the first error.
 TEST_F(BufferedSocketWriterTest, TestWriteErrorAsync) {
+  StartWriter();
   socket_data_provider_.set_write_limit(kWriteChunkSize);
   writer_->Write(test_buffer_, base::Closure());
   socket_data_provider_.set_async_write(true);
@@ -233,4 +247,14 @@ TEST_F(BufferedSocketWriterTest, TestWriteErrorAsync) {
             socket_data_provider_.written_data().size());
 }
 
+TEST_F(BufferedSocketWriterTest, WriteBeforeStart) {
+  writer_->Write(test_buffer_, base::Closure());
+  writer_->Write(test_buffer_2_, base::Closure());
+
+  StartWriter();
+  base::RunLoop().RunUntilIdle();
+
+  VerifyWrittenData();
+}
+
 }  // namespace remoting