Add P2PDatagramSocket and P2PStreamSocket interfaces.

remoting/protocol/fake_datagram_socket.cc

 // Copyright 2014 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_datagram_socket.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 33 matching lines @@
 void FakeDatagramSocket::PairWith(FakeDatagramSocket* peer_socket) {
   EXPECT_TRUE(task_runner_->BelongsToCurrentThread());
   peer_socket_ = peer_socket->GetWeakPtr();
   peer_socket->peer_socket_ = GetWeakPtr();
 }
 
 base::WeakPtr<FakeDatagramSocket> FakeDatagramSocket::GetWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
-int FakeDatagramSocket::Read(net::IOBuffer* buf, int buf_len,
+int FakeDatagramSocket::Recv(const scoped_refptr<net::IOBuffer>& buf,
+                             int buf_len,
                              const net::CompletionCallback& callback) {
   EXPECT_TRUE(task_runner_->BelongsToCurrentThread());
   if (input_pos_ < static_cast<int>(input_packets_.size())) {
     return CopyReadData(buf, buf_len);
   } else {
     read_buffer_ = buf;
     read_buffer_size_ = buf_len;
     read_callback_ = callback;
     return net::ERR_IO_PENDING;
   }
 }
 
-int FakeDatagramSocket::Write(net::IOBuffer* buf, int buf_len,
-                         const net::CompletionCallback& callback) {
+int FakeDatagramSocket::Send(const scoped_refptr<net::IOBuffer>& buf,
+                             int buf_len,
+                             const net::CompletionCallback& callback) {
   EXPECT_TRUE(task_runner_->BelongsToCurrentThread());
   written_packets_.push_back(std::string());
   written_packets_.back().assign(buf->data(), buf->data() + buf_len);
 
   if (peer_socket_.get()) {
     task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&FakeDatagramSocket::AppendInputPacket,
-                   peer_socket_,
+        base::Bind(&FakeDatagramSocket::AppendInputPacket, peer_socket_,
                    std::string(buf->data(), buf->data() + buf_len)));
   }
 
   return buf_len;
 }
 
-int FakeDatagramSocket::SetReceiveBufferSize(int32 size) {
-  NOTIMPLEMENTED();
-  return net::ERR_NOT_IMPLEMENTED;
-}
-
-int FakeDatagramSocket::SetSendBufferSize(int32 size) {
-  NOTIMPLEMENTED();
-  return net::ERR_NOT_IMPLEMENTED;
-}
-
-int FakeDatagramSocket::CopyReadData(net::IOBuffer* buf, int buf_len) {
+int FakeDatagramSocket::CopyReadData(const scoped_refptr<net::IOBuffer>& buf,
+                                     int buf_len) {
   int size = std::min(
       buf_len, static_cast<int>(input_packets_[input_pos_].size()));
   memcpy(buf->data(), &(*input_packets_[input_pos_].begin()), size);
   ++input_pos_;
   return size;
 }
 
 FakeDatagramChannelFactory::FakeDatagramChannelFactory()
     : task_runner_(base::ThreadTaskRunnerHandle::Get()),
       asynchronous_create_(false),
@@ skipping 55 matching lines @@
     callback.Run(owned_socket.Pass());
 }
 
 void FakeDatagramChannelFactory::CancelChannelCreation(
     const std::string& name) {
   channels_.erase(name);
 }
 
 }  // namespace protocol
 }  // namespace remoting