Add P2PDatagramSocket and P2PStreamSocket interfaces.

remoting/base/buffered_socket_writer_unittest.cc

 // Copyright 2015 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/base/buffered_socket_writer.h"
 
 #include <stdlib.h>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/socket/socket_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace remoting {
 
 namespace {
-const int kTestBufferSize = 10 * 1024; // 10k;
+
+const int kTestBufferSize = 10000;
 const size_t kWriteChunkSize = 1024U;
 
 class SocketDataProvider: public net::SocketDataProvider {
  public:
   SocketDataProvider()
       : write_limit_(-1), async_write_(false), next_write_error_(net::OK) {}
 
   net::MockRead OnRead() override {
     return net::MockRead(net::ASYNC, net::ERR_IO_PENDING);
   }
@@ skipping 54 matching lines @@
   }
 
  protected:
   void SetUp() override {
     socket_.reset(new net::MockTCPClientSocket(net::AddressList(), &net_log_,
                                                &socket_data_provider_));
     socket_data_provider_.set_connect_data(
         net::MockConnect(net::SYNCHRONOUS, net::OK));
     EXPECT_EQ(net::OK, socket_->Connect(net::CompletionCallback()));
 
-    writer_.reset(new BufferedSocketWriter());
-    writer_->Init(socket_.get(), base::Bind(
-        &BufferedSocketWriterTest::OnWriteFailed, base::Unretained(this)));
+    writer_ = BufferedSocketWriter::CreateForSocket(
+        socket_.get(), base::Bind(&BufferedSocketWriterTest::OnWriteFailed,
+                                  base::Unretained(this)));
     test_buffer_ = new net::IOBufferWithSize(kTestBufferSize);
     test_buffer_2_ = new net::IOBufferWithSize(kTestBufferSize);
     for (int i = 0; i< kTestBufferSize; ++i) {
       test_buffer_->data()[i] = rand() % 256;
       test_buffer_2_->data()[i] = rand() % 256;
     }
   }
 
   void OnWriteFailed(int error) {
     write_error_ = error;
@@ skipping 10 matching lines @@
                         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()));
   }
 
   void TestAppendInCallback() {
     writer_->Write(test_buffer_, base::Bind(
-        base::IgnoreResult(&BufferedSocketWriterBase::Write),
+        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(),
@@ skipping 85 matching lines @@
   writer_->Write(test_buffer_2_,
                  base::Bind(&BufferedSocketWriterTest::Unexpected,
                             base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(net::ERR_FAILED, write_error_);
   EXPECT_EQ(static_cast<size_t>(test_buffer_->size()),
             socket_data_provider_.written_data().size());
 }
 
 }  // namespace remoting