Convert //remoting to use std::unique_ptr

remoting/protocol/pseudotcp_adapter_unittest.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 <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
+#include "base/memory/ptr_util.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "remoting/protocol/p2p_datagram_socket.h"
 #include "remoting/protocol/p2p_stream_socket.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace remoting {
@@ skipping 265 matching lines @@
  protected:
   void SetUp() override {
     jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
 
     host_socket_ = new FakeSocket();
     client_socket_ = new FakeSocket();
 
     host_socket_->Connect(client_socket_);
     client_socket_->Connect(host_socket_);
 
-    host_pseudotcp_.reset(new PseudoTcpAdapter(make_scoped_ptr(host_socket_)));
+    host_pseudotcp_.reset(new PseudoTcpAdapter(base::WrapUnique(host_socket_)));
     client_pseudotcp_.reset(
-        new PseudoTcpAdapter(make_scoped_ptr(client_socket_)));
+        new PseudoTcpAdapter(base::WrapUnique(client_socket_)));
   }
 
   FakeSocket* host_socket_;
   FakeSocket* client_socket_;
 
-  scoped_ptr<PseudoTcpAdapter> host_pseudotcp_;
-  scoped_ptr<PseudoTcpAdapter> client_pseudotcp_;
+  std::unique_ptr<PseudoTcpAdapter> host_pseudotcp_;
+  std::unique_ptr<PseudoTcpAdapter> client_pseudotcp_;
   base::MessageLoop message_loop_;
 };
 
 TEST_F(PseudoTcpAdapterTest, DataTransfer) {
   net::TestCompletionCallback host_connect_cb;
   net::TestCompletionCallback client_connect_cb;
 
   int rv1 = host_pseudotcp_->Connect(host_connect_cb.callback());
   int rv2 = client_pseudotcp_->Connect(client_connect_cb.callback());
 
@@ skipping 44 matching lines @@
                            client_pseudotcp_.get());
 
   tester->Start();
   message_loop_.Run();
   tester->CheckResults();
 }
 
 class DeleteOnConnected {
  public:
   DeleteOnConnected(base::MessageLoop* message_loop,
-                    scoped_ptr<PseudoTcpAdapter>* adapter)
+                    std::unique_ptr<PseudoTcpAdapter>* adapter)
       : message_loop_(message_loop), adapter_(adapter) {}
   void OnConnected(int error) {
     adapter_->reset();
     message_loop_->PostTask(FROM_HERE,
                             base::MessageLoop::QuitWhenIdleClosure());
   }
   base::MessageLoop* message_loop_;
-  scoped_ptr<PseudoTcpAdapter>* adapter_;
+  std::unique_ptr<PseudoTcpAdapter>* adapter_;
 };
 
 TEST_F(PseudoTcpAdapterTest, DeleteOnConnected) {
   // This test verifies that deleting the adapter mid-callback doesn't lead
   // to deleted structures being touched as the stack unrolls, so the failure
   // mode is a crash rather than a normal test failure.
   net::TestCompletionCallback client_connect_cb;
   DeleteOnConnected host_delete(&message_loop_, &host_pseudotcp_);
 
   host_pseudotcp_->Connect(base::Bind(&DeleteOnConnected::OnConnected,
@@ skipping 33 matching lines @@
 
   tester->Start();
   message_loop_.Run();
   tester->CheckResults();
 }
 
 }  // namespace
 
 }  // namespace protocol
 }  // namespace remoting