Add P2PDatagramSocket and P2PStreamSocket interfaces.

remoting/protocol/pseudotcp_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/pseudotcp_adapter.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #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;
 
 namespace {
 const int kReadBufferSize = 65536;  // Maximum size of a packet.
 const uint16 kDefaultMtu = 1280;
 }  // namespace
 
 namespace remoting {
 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.
   void OnTcpOpen(cricket::PseudoTcp* tcp) override;
   void OnTcpReadable(cricket::PseudoTcp* tcp) override;
   void OnTcpWriteable(cricket::PseudoTcp* tcp) override;
   // This is triggered by NotifyClock or NotifyPacket.
   void OnTcpClosed(cricket::PseudoTcp* tcp, uint32 error) override;
   // This is triggered by NotifyClock, NotifyPacket, Recv and Send.
   WriteResult TcpWritePacket(cricket::PseudoTcp* tcp,
@@ skipping 28 matching lines @@
   void CheckWriteComplete();
 
   // This re-sets |timer| without triggering callbacks.
   void AdjustClock();
 
   net::CompletionCallback connect_callback_;
   net::CompletionCallback read_callback_;
   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_;
   scoped_refptr<net::IOBuffer> write_buffer_;
   int write_buffer_size_;
 
   // Whether we need to wait for data to be sent before completing write.
   bool write_waits_for_send_;
 
   // Set to true in the write-waits-for-send mode when we've
   // successfully writtend data to the send buffer and waiting for the
   // data to be sent to the remote end.
   bool waiting_write_position_;
 
   // Number of the bytes written by the last write stored while we wait
   // for the data to be sent (i.e. when waiting_write_position_ = true).
   int last_write_result_;
 
   bool socket_write_pending_;
   scoped_refptr<net::IOBuffer> socket_read_buffer_;
 
   base::OneShotTimer<Core> timer_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 
-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),
       waiting_write_position_(false),
       socket_write_pending_(false) {
   // Doesn't trigger callbacks.
   pseudo_tcp_.NotifyMTU(kDefaultMtu);
 }
 
 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());
 
   // Reference the Core in case a callback deletes the adapter.
   scoped_refptr<Core> core(this);
 
   int result = pseudo_tcp_.Recv(buffer->data(), buffer_size);
   if (result < 0) {
     result = net::MapSystemError(pseudo_tcp_.GetError());
     DCHECK(result < 0);
   }
 
   if (result == net::ERR_IO_PENDING) {
     read_buffer_ = buffer;
     read_buffer_size_ = buffer_size;
     read_callback_ = callback;
   }
 
   AdjustClock();
 
   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());
 
   // Reference the Core in case a callback deletes the adapter.
   scoped_refptr<Core> core(this);
 
   int result = pseudo_tcp_.Send(buffer->data(), buffer_size);
   if (result < 0) {
     result = net::MapSystemError(pseudo_tcp_.GetError());
     DCHECK(result < 0);
@@ skipping 38 matching lines @@
     return net::ERR_FAILED;
 
   AdjustClock();
 
   connect_callback_ = callback;
   DoReadFromSocket();
 
   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_);
 
   if (!connect_callback_.is_null()) {
     net::CompletionCallback callback = connect_callback_;
     connect_callback_.Reset();
     callback.Run(net::OK);
   }
 
   OnTcpReadable(tcp);
@@ skipping 90 matching lines @@
 
 void PseudoTcpAdapter::Core::SetSendBufferSize(int32 size) {
   pseudo_tcp_.SetOption(cricket::PseudoTcp::OPT_SNDBUF, size);
 }
 
 void PseudoTcpAdapter::Core::SetWriteWaitsForSend(bool write_waits_for_send) {
   write_waits_for_send_ = 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();
 }
 
 cricket::IPseudoTcpNotify::WriteResult PseudoTcpAdapter::Core::TcpWritePacket(
     PseudoTcp* tcp,
     const char* buffer,
     size_t len) {
   DCHECK_EQ(tcp, &pseudo_tcp_);
 
   // If we already have a write pending, we behave like a congested network,
   // returning success for the write, but dropping the packet.  PseudoTcp will
   // back-off and retransmit, adjusting for the perceived congestion.
   if (socket_write_pending_)
     return IPseudoTcpNotify::WR_SUCCESS;
 
   scoped_refptr<net::IOBuffer> write_buffer = new net::IOBuffer(len);
   memcpy(write_buffer->data(), buffer, len);
 
   // 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 {
     result = net::ERR_CONNECTION_CLOSED;
   }
   if (result == net::ERR_IO_PENDING) {
     socket_write_pending_ = true;
     return IPseudoTcpNotify::WR_SUCCESS;
   } else if (result == net::ERR_MSG_TOO_BIG) {
     return IPseudoTcpNotify::WR_TOO_LARGE;
   } else if (result < 0) {
     return IPseudoTcpNotify::WR_FAIL;
   } else {
     return IPseudoTcpNotify::WR_SUCCESS;
   }
 }
 
 void PseudoTcpAdapter::Core::DoReadFromSocket() {
   if (!socket_read_buffer_.get())
     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);
   }
 }
 
 void PseudoTcpAdapter::Core::HandleReadResults(int result) {
   if (result <= 0) {
     LOG(ERROR) << "Read returned " << result;
     return;
@@ skipping 51 matching lines @@
       waiting_write_position_ = false;
 
       net::CompletionCallback callback = write_callback_;
       write_callback_.Reset();
       write_buffer_ = NULL;
       callback.Run(last_write_result_);
     }
   }
 }
 
-// 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);
 }
 
 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);
 }
 
 void PseudoTcpAdapter::SetNoDelay(bool no_delay) {
   DCHECK(CalledOnValidThread());
   core_->SetNoDelay(no_delay);
 }
 
 void PseudoTcpAdapter::SetWriteWaitsForSend(bool write_waits_for_send) {
   DCHECK(CalledOnValidThread());
   core_->SetWriteWaitsForSend(write_waits_for_send);
 }
 
 }  // namespace protocol
 }  // namespace remoting