Convert //remoting to use std::unique_ptr

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 <stddef.h>
 
 #include <utility>
 
@@ skipping 14 matching lines @@
 const int kReadBufferSize = 65536;  // Maximum size of a packet.
 const uint16_t kDefaultMtu = 1280;
 }  // namespace
 
 namespace remoting {
 namespace protocol {
 
 class PseudoTcpAdapter::Core : public cricket::IPseudoTcpNotify,
                                public base::RefCounted<Core> {
  public:
-  explicit Core(scoped_ptr<P2PDatagramSocket> socket);
+  explicit Core(std::unique_ptr<P2PDatagramSocket> socket);
 
   // Functions used to implement net::StreamSocket.
   int Read(const scoped_refptr<net::IOBuffer>& buffer, int buffer_size,
            const net::CompletionCallback& callback);
   int Write(const scoped_refptr<net::IOBuffer>& buffer, int buffer_size,
             const net::CompletionCallback& callback);
   int Connect(const net::CompletionCallback& callback);
 
   // cricket::IPseudoTcpNotify interface.
   // These notifications are triggered from NotifyPacket.
@@ skipping 35 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<P2PDatagramSocket> socket_;
+  std::unique_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 timer_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
-
-PseudoTcpAdapter::Core::Core(scoped_ptr<P2PDatagramSocket> socket)
+PseudoTcpAdapter::Core::Core(std::unique_ptr<P2PDatagramSocket> socket)
     : pseudo_tcp_(this, 0),
       socket_(std::move(socket)),
       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 315 matching lines @@
       net::CompletionCallback callback = write_callback_;
       write_callback_.Reset();
       write_buffer_ = NULL;
       callback.Run(last_write_result_);
     }
   }
 }
 
 // Public interface implementation.
 
-PseudoTcpAdapter::PseudoTcpAdapter(scoped_ptr<P2PDatagramSocket> socket)
-    : core_(new Core(std::move(socket))) {
-}
+PseudoTcpAdapter::PseudoTcpAdapter(std::unique_ptr<P2PDatagramSocket> socket)
+    : core_(new Core(std::move(socket))) {}
 
 PseudoTcpAdapter::~PseudoTcpAdapter() {
   // Make sure that the underlying socket is destroyed before PseudoTcp.
   core_->DeleteSocket();
 }
 
 int PseudoTcpAdapter::Read(const scoped_refptr<net::IOBuffer>& buffer,
                            int buffer_size,
                            const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
@@ skipping 34 matching lines @@
   core_->SetNoDelay(no_delay);
 }
 
 void PseudoTcpAdapter::SetWriteWaitsForSend(bool write_waits_for_send) {
   DCHECK(CalledOnValidThread());
   core_->SetWriteWaitsForSend(write_waits_for_send);
 }
 
 }  // namespace protocol
 }  // namespace remoting