Move remoting-specific adapters from jingle/glue to remoting/protocol

remoting/protocol/pseudotcp_adapter.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// 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 "jingle/glue/pseudotcp_adapter.h"
+#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"
 
 using cricket::PseudoTcp;
 
 namespace {
 const int kReadBufferSize = 65536;  // Maximum size of a packet.
 const uint16 kDefaultMtu = 1280;
 }  // namespace
 
-namespace jingle_glue {
+namespace remoting {
+namespace protocol {
 
 class PseudoTcpAdapter::Core : public cricket::IPseudoTcpNotify,
                                public base::RefCounted<Core> {
  public:
-  explicit Core(net::Socket* socket);
+  explicit Core(scoped_ptr<net::Socket> socket);
 
   // Functions used to implement net::StreamSocket.
   int Read(net::IOBuffer* buffer, int buffer_size,
            const net::CompletionCallback& callback);
   int Write(net::IOBuffer* buffer, int buffer_size,
             const net::CompletionCallback& callback);
   int Connect(const net::CompletionCallback& callback);
   void Disconnect();
   bool IsConnected() const;
 
@@ skipping 65 matching lines @@
 
   bool socket_write_pending_;
   scoped_refptr<net::IOBuffer> socket_read_buffer_;
 
   base::OneShotTimer<Core> timer_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 
-PseudoTcpAdapter::Core::Core(net::Socket* socket)
+PseudoTcpAdapter::Core::Core(scoped_ptr<net::Socket> socket)
     : pseudo_tcp_(this, 0),
-      socket_(socket),
+      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() {
 }
 
@@ skipping 228 matching lines @@
     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(
-        write_buffer.get(),
-        len,
+        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) {
@@ skipping 78 matching lines @@
       net::CompletionCallback callback = write_callback_;
       write_callback_.Reset();
       write_buffer_ = NULL;
       callback.Run(last_write_result_);
     }
   }
 }
 
 // Public interface implemention.
 
-PseudoTcpAdapter::PseudoTcpAdapter(net::Socket* socket)
-    : core_(new Core(socket)) {
+PseudoTcpAdapter::PseudoTcpAdapter(scoped_ptr<net::Socket> 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,
@@ skipping 118 matching lines @@
 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 jingle_glue
+}  // namespace protocol
+}  // namespace remoting