Add P2PDatagramSocket and P2PStreamSocket interfaces.

remoting/protocol/channel_socket_adapter.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/protocol/channel_socket_adapter.h"
 
 #include <limits>
 
 #include "base/callback.h"
 #include "base/logging.h"
@@ skipping 21 matching lines @@
 TransportChannelSocketAdapter::~TransportChannelSocketAdapter() {
   if (!destruction_callback_.is_null())
     destruction_callback_.Run();
 }
 
 void TransportChannelSocketAdapter::SetOnDestroyedCallback(
     const base::Closure& callback) {
   destruction_callback_ = callback;
 }
 
-int TransportChannelSocketAdapter::Read(
-    net::IOBuffer* buf,
-    int buffer_size,
+int TransportChannelSocketAdapter::Recv(
+    const scoped_refptr<net::IOBuffer>& buf, int buffer_size,
     const net::CompletionCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(buf);
   DCHECK(!callback.is_null());
   CHECK(read_callback_.is_null());
 
   if (!channel_) {
     DCHECK(closed_error_code_ != net::OK);
     return closed_error_code_;
   }
 
   read_callback_ = callback;
   read_buffer_ = buf;
   read_buffer_size_ = buffer_size;
 
   return net::ERR_IO_PENDING;
 }
 
-int TransportChannelSocketAdapter::Write(
-    net::IOBuffer* buffer,
-    int buffer_size,
+int TransportChannelSocketAdapter::Send(
+    const scoped_refptr<net::IOBuffer>& buffer, int buffer_size,
     const net::CompletionCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(buffer);
   DCHECK(!callback.is_null());
   CHECK(write_callback_.is_null());
 
   if (!channel_) {
     DCHECK(closed_error_code_ != net::OK);
     return closed_error_code_;
   }
@@ skipping 15 matching lines @@
     // Channel is not writable yet.
     result = net::ERR_IO_PENDING;
     write_callback_ = callback;
     write_buffer_ = buffer;
     write_buffer_size_ = buffer_size;
   }
 
   return result;
 }
 
-int TransportChannelSocketAdapter::SetReceiveBufferSize(int32 size) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  return (channel_->SetOption(rtc::Socket::OPT_RCVBUF, size) == 0) ?
-      net::OK : net::ERR_SOCKET_SET_RECEIVE_BUFFER_SIZE_ERROR;
-}
-
-int TransportChannelSocketAdapter::SetSendBufferSize(int32 size) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  return (channel_->SetOption(rtc::Socket::OPT_SNDBUF, size) == 0) ?
-      net::OK : net::ERR_SOCKET_SET_SEND_BUFFER_SIZE_ERROR;
-}
-
 void TransportChannelSocketAdapter::Close(int error_code) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!channel_)  // Already closed.
     return;
 
   DCHECK(error_code != net::OK);
   closed_error_code_ = error_code;
   channel_->SignalReadPacket.disconnect(this);
   channel_->SignalDestroyed.disconnect(this);
@@ skipping 68 matching lines @@
 
 void TransportChannelSocketAdapter::OnChannelDestroyed(
     cricket::TransportChannel* channel) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(channel, channel_);
   Close(net::ERR_CONNECTION_ABORTED);
 }
 
 }  // namespace protocol
 }  // namespace remoting