Add P2PDatagramSocket and P2PStreamSocket interfaces.

remoting/protocol/pseudotcp_adapter.cc

Index: remoting/protocol/pseudotcp_adapter.cc
diff --git a/remoting/protocol/pseudotcp_adapter.cc b/remoting/protocol/pseudotcp_adapter.cc
index 796db24299f8185d9958f4acb8922d851036719b..11f01fd552ec38ee42a237162893145e204b89fb 100644
--- a/remoting/protocol/pseudotcp_adapter.cc
+++ b/remoting/protocol/pseudotcp_adapter.cc
@@ -13,6 +13,7 @@
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
+#include "remoting/protocol/p2p_datagram_socket.h"
 
 using cricket::PseudoTcp;
 
@@ -27,16 +28,14 @@ namespace protocol {
 class PseudoTcpAdapter::Core : public cricket::IPseudoTcpNotify,
                                public base::RefCounted<Core> {
  public:
-  explicit Core(scoped_ptr<net::Socket> socket);
+  explicit Core(scoped_ptr<P2PDatagramSocket> socket);
 
   // Functions used to implement net::StreamSocket.
-  int Read(net::IOBuffer* buffer, int buffer_size,
+  int Read(const scoped_refptr<net::IOBuffer>& buffer, int buffer_size,
            const net::CompletionCallback& callback);
-  int Write(net::IOBuffer* buffer, int buffer_size,
+  int Write(const scoped_refptr<net::IOBuffer>& buffer, int buffer_size,
             const net::CompletionCallback& callback);
   int Connect(const net::CompletionCallback& callback);
-  void Disconnect();
-  bool IsConnected() const;
 
   // cricket::IPseudoTcpNotify interface.
   // These notifications are triggered from NotifyPacket.
@@ -85,7 +84,7 @@ class PseudoTcpAdapter::Core : public cricket::IPseudoTcpNotify,
   net::CompletionCallback write_callback_;
 
   cricket::PseudoTcp pseudo_tcp_;
-  scoped_ptr<net::Socket> socket_;
+  scoped_ptr<P2PDatagramSocket> socket_;
 
   scoped_refptr<net::IOBuffer> read_buffer_;
   int read_buffer_size_;
@@ -113,7 +112,7 @@ class PseudoTcpAdapter::Core : public cricket::IPseudoTcpNotify,
 };
 
 
-PseudoTcpAdapter::Core::Core(scoped_ptr<net::Socket> socket)
+PseudoTcpAdapter::Core::Core(scoped_ptr<P2PDatagramSocket> socket)
     : pseudo_tcp_(this, 0),
       socket_(socket.Pass()),
       write_waits_for_send_(false),
@@ -126,7 +125,8 @@ PseudoTcpAdapter::Core::Core(scoped_ptr<net::Socket> socket)
 PseudoTcpAdapter::Core::~Core() {
 }
 
-int PseudoTcpAdapter::Core::Read(net::IOBuffer* buffer, int buffer_size,
+int PseudoTcpAdapter::Core::Read(const scoped_refptr<net::IOBuffer>& buffer,
+                                 int buffer_size,
                                  const net::CompletionCallback& callback) {
   DCHECK(read_callback_.is_null());
 
@@ -150,7 +150,8 @@ int PseudoTcpAdapter::Core::Read(net::IOBuffer* buffer, int buffer_size,
   return result;
 }
 
-int PseudoTcpAdapter::Core::Write(net::IOBuffer* buffer, int buffer_size,
+int PseudoTcpAdapter::Core::Write(const scoped_refptr<net::IOBuffer>& buffer,
+                                  int buffer_size,
                                   const net::CompletionCallback& callback) {
   DCHECK(write_callback_.is_null());
 
@@ -209,28 +210,6 @@ int PseudoTcpAdapter::Core::Connect(const net::CompletionCallback& callback) {
   return net::ERR_IO_PENDING;
 }
 
-void PseudoTcpAdapter::Core::Disconnect() {
-  // Don't dispatch outstanding callbacks, as mandated by net::StreamSocket.
-  read_callback_.Reset();
-  read_buffer_ = NULL;
-  write_callback_.Reset();
-  write_buffer_ = NULL;
-  connect_callback_.Reset();
-
-  // TODO(wez): Connect should succeed if called after Disconnect, which
-  // PseudoTcp doesn't support, so we need to teardown the internal PseudoTcp
-  // and create a new one in Connect.
-  // TODO(wez): Close sets a shutdown flag inside PseudoTcp but has no other
-  // effect.  This should be addressed in PseudoTcp, really.
-  // In the meantime we can fake OnTcpClosed notification and tear down the
-  // PseudoTcp.
-  pseudo_tcp_.Close(true);
-}
-
-bool PseudoTcpAdapter::Core::IsConnected() const {
-  return pseudo_tcp_.State() == PseudoTcp::TCP_ESTABLISHED;
-}
-
 void PseudoTcpAdapter::Core::OnTcpOpen(PseudoTcp* tcp) {
   DCHECK(tcp == &pseudo_tcp_);
 
@@ -341,6 +320,13 @@ void PseudoTcpAdapter::Core::SetWriteWaitsForSend(bool write_waits_for_send) {
 }
 
 void PseudoTcpAdapter::Core::DeleteSocket() {
+  // Don't dispatch outstanding callbacks when the socket is deleted.
+  read_callback_.Reset();
+  read_buffer_ = NULL;
+  write_callback_.Reset();
+  write_buffer_ = NULL;
+  connect_callback_.Reset();
+
   socket_.reset();
 }
 
@@ -362,8 +348,8 @@ cricket::IPseudoTcpNotify::WriteResult PseudoTcpAdapter::Core::TcpWritePacket(
   // Our underlying socket is datagram-oriented, which means it should either
   // send exactly as many bytes as we requested, or fail.
   int result;
-  if (socket_.get()) {
-    result = socket_->Write(
+  if (socket_) {
+    result = socket_->Send(
         write_buffer.get(), len,
         base::Bind(&PseudoTcpAdapter::Core::OnWritten, base::Unretained(this)));
   } else {
@@ -386,10 +372,9 @@ void PseudoTcpAdapter::Core::DoReadFromSocket() {
     socket_read_buffer_ = new net::IOBuffer(kReadBufferSize);
 
   int result = 1;
-  while (socket_.get() && result > 0) {
-    result = socket_->Read(
-        socket_read_buffer_.get(),
-        kReadBufferSize,
+  while (socket_ && result > 0) {
+    result = socket_->Recv(
+        socket_read_buffer_.get(), kReadBufferSize,
         base::Bind(&PseudoTcpAdapter::Core::OnRead, base::Unretained(this)));
     if (result != net::ERR_IO_PENDING)
       HandleReadResults(result);
@@ -461,26 +446,26 @@ void PseudoTcpAdapter::Core::CheckWriteComplete() {
   }
 }
 
-// Public interface implemention.
+// Public interface implementation.
 
-PseudoTcpAdapter::PseudoTcpAdapter(scoped_ptr<net::Socket> socket)
+PseudoTcpAdapter::PseudoTcpAdapter(scoped_ptr<P2PDatagramSocket> socket)
     : core_(new Core(socket.Pass())) {
 }
 
 PseudoTcpAdapter::~PseudoTcpAdapter() {
-  Disconnect();
-
   // Make sure that the underlying socket is destroyed before PseudoTcp.
   core_->DeleteSocket();
 }
 
-int PseudoTcpAdapter::Read(net::IOBuffer* buffer, int buffer_size,
+int PseudoTcpAdapter::Read(const scoped_refptr<net::IOBuffer>& buffer,
+                           int buffer_size,
                            const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   return core_->Read(buffer, buffer_size, callback);
 }
 
-int PseudoTcpAdapter::Write(net::IOBuffer* buffer, int buffer_size,
+int PseudoTcpAdapter::Write(const scoped_refptr<net::IOBuffer>& buffer,
+                            int buffer_size,
                             const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   return core_->Write(buffer, buffer_size, callback);
@@ -488,106 +473,21 @@ int PseudoTcpAdapter::Write(net::IOBuffer* buffer, int buffer_size,
 
 int PseudoTcpAdapter::SetReceiveBufferSize(int32 size) {
   DCHECK(CalledOnValidThread());
-
   core_->SetReceiveBufferSize(size);
   return net::OK;
 }
 
 int PseudoTcpAdapter::SetSendBufferSize(int32 size) {
   DCHECK(CalledOnValidThread());
-
   core_->SetSendBufferSize(size);
   return net::OK;
 }
 
 int PseudoTcpAdapter::Connect(const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
-
-  // net::StreamSocket requires that Connect return OK if already connected.
-  if (IsConnected())
-    return net::OK;
-
   return core_->Connect(callback);
 }
 
-void PseudoTcpAdapter::Disconnect() {
-  DCHECK(CalledOnValidThread());
-  core_->Disconnect();
-}
-
-bool PseudoTcpAdapter::IsConnected() const {
-  return core_->IsConnected();
-}
-
-bool PseudoTcpAdapter::IsConnectedAndIdle() const {
-  DCHECK(CalledOnValidThread());
-  NOTIMPLEMENTED();
-  return false;
-}
-
-int PseudoTcpAdapter::GetPeerAddress(net::IPEndPoint* address) const {
-  DCHECK(CalledOnValidThread());
-
-  // We don't have a meaningful peer address, but we can't return an
-  // error, so we return a INADDR_ANY instead.
-  net::IPAddressNumber ip_address(net::kIPv4AddressSize);
-  *address = net::IPEndPoint(ip_address, 0);
-  return net::OK;
-}
-
-int PseudoTcpAdapter::GetLocalAddress(net::IPEndPoint* address) const {
-  DCHECK(CalledOnValidThread());
-  NOTIMPLEMENTED();
-  return net::ERR_FAILED;
-}
-
-const net::BoundNetLog& PseudoTcpAdapter::NetLog() const {
-  DCHECK(CalledOnValidThread());
-  return net_log_;
-}
-
-void PseudoTcpAdapter::SetSubresourceSpeculation() {
-  DCHECK(CalledOnValidThread());
-  NOTIMPLEMENTED();
-}
-
-void PseudoTcpAdapter::SetOmniboxSpeculation() {
-  DCHECK(CalledOnValidThread());
-  NOTIMPLEMENTED();
-}
-
-bool PseudoTcpAdapter::WasEverUsed() const {
-  DCHECK(CalledOnValidThread());
-  NOTIMPLEMENTED();
-  return true;
-}
-
-bool PseudoTcpAdapter::UsingTCPFastOpen() const {
-  DCHECK(CalledOnValidThread());
-  return false;
-}
-
-bool PseudoTcpAdapter::WasNpnNegotiated() const {
-  DCHECK(CalledOnValidThread());
-  return false;
-}
-
-net::NextProto PseudoTcpAdapter::GetNegotiatedProtocol() const {
-  DCHECK(CalledOnValidThread());
-  return net::kProtoUnknown;
-}
-
-bool PseudoTcpAdapter::GetSSLInfo(net::SSLInfo* ssl_info) {
-  DCHECK(CalledOnValidThread());
-  return false;
-}
-
-void PseudoTcpAdapter::GetConnectionAttempts(
-    net::ConnectionAttempts* out) const {
-  DCHECK(CalledOnValidThread());
-  out->clear();
-}
-
 void PseudoTcpAdapter::SetAckDelay(int delay_ms) {
   DCHECK(CalledOnValidThread());
   core_->SetAckDelay(delay_ms);