Convert //remoting to use std::unique_ptr

remoting/protocol/ice_transport_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/ice_transport.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "remoting/base/url_request.h"
 #include "remoting/protocol/chromium_port_allocator_factory.h"
 #include "remoting/protocol/connection_tester.h"
 #include "remoting/protocol/fake_authenticator.h"
@@ skipping 68 matching lines @@
   }
 
   void TearDown() override {
     client_message_pipe_.reset();
     host_message_pipe_.reset();
     client_transport_.reset();
     host_transport_.reset();
     message_loop_.RunUntilIdle();
   }
 
-  void ProcessTransportInfo(scoped_ptr<IceTransport>* target_transport,
-                            scoped_ptr<buzz::XmlElement> transport_info) {
+  void ProcessTransportInfo(std::unique_ptr<IceTransport>* target_transport,
+                            std::unique_ptr<buzz::XmlElement> transport_info) {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::Bind(&IceTransportTest::DeliverTransportInfo,
                               base::Unretained(this), target_transport,
                               base::Passed(&transport_info)),
         transport_info_delay_);
   }
 
-  void DeliverTransportInfo(scoped_ptr<IceTransport>* target_transport,
-                            scoped_ptr<buzz::XmlElement> transport_info) {
+  void DeliverTransportInfo(std::unique_ptr<IceTransport>* target_transport,
+                            std::unique_ptr<buzz::XmlElement> transport_info) {
     ASSERT_TRUE(target_transport);
     EXPECT_TRUE(
         (*target_transport)->ProcessTransportInfo(transport_info.get()));
   }
 
   void InitializeConnection() {
     jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
 
     host_transport_.reset(new IceTransport(
         new TransportContext(
-            nullptr, make_scoped_ptr(new ChromiumPortAllocatorFactory()),
+            nullptr, base::WrapUnique(new ChromiumPortAllocatorFactory()),
             nullptr, network_settings_, TransportRole::SERVER),
         &host_event_handler_));
     if (!host_authenticator_) {
       host_authenticator_.reset(new FakeAuthenticator(
           FakeAuthenticator::HOST, 0, FakeAuthenticator::ACCEPT, true));
     }
 
     client_transport_.reset(new IceTransport(
         new TransportContext(
-            nullptr, make_scoped_ptr(new ChromiumPortAllocatorFactory()),
+            nullptr, base::WrapUnique(new ChromiumPortAllocatorFactory()),
             nullptr, network_settings_, TransportRole::CLIENT),
         &client_event_handler_));
     if (!client_authenticator_) {
       client_authenticator_.reset(new FakeAuthenticator(
           FakeAuthenticator::CLIENT, 0, FakeAuthenticator::ACCEPT, true));
     }
 
     host_event_handler_.set_error_callback(base::Bind(
         &IceTransportTest::OnTransportError, base::Unretained(this)));
     client_event_handler_.set_error_callback(base::Bind(
@@ skipping 18 matching lines @@
         .WillOnce(QuitRunLoopOnCounter(run_loop_.get(), &counter));
     EXPECT_CALL(host_channel_callback_, OnDone(_))
         .WillOnce(QuitRunLoopOnCounter(run_loop_.get(), &counter));
 
     run_loop_->Run();
 
     EXPECT_TRUE(client_message_pipe_.get());
     EXPECT_TRUE(host_message_pipe_.get());
   }
 
-  void OnClientChannelCreated(scoped_ptr<MessagePipe> message_pipe) {
+  void OnClientChannelCreated(std::unique_ptr<MessagePipe> message_pipe) {
     client_message_pipe_ = std::move(message_pipe);
     client_channel_callback_.OnDone(client_message_pipe_.get());
   }
 
-  void OnHostChannelCreated(scoped_ptr<MessagePipe> message_pipe) {
+  void OnHostChannelCreated(std::unique_ptr<MessagePipe> message_pipe) {
     host_message_pipe_ = std::move(message_pipe);
     host_channel_callback_.OnDone(host_message_pipe_.get());
   }
 
   void OnTransportError(ErrorCode error) {
     LOG(ERROR) << "Transport Error";
     error_ = error;
     run_loop_->Quit();
   }
 
  protected:
   base::MessageLoopForIO message_loop_;
-  scoped_ptr<base::RunLoop> run_loop_;
+  std::unique_ptr<base::RunLoop> run_loop_;
 
   NetworkSettings network_settings_;
 
   base::TimeDelta transport_info_delay_;
 
-  scoped_ptr<IceTransport> host_transport_;
+  std::unique_ptr<IceTransport> host_transport_;
   TestTransportEventHandler host_event_handler_;
-  scoped_ptr<FakeAuthenticator> host_authenticator_;
+  std::unique_ptr<FakeAuthenticator> host_authenticator_;
 
-  scoped_ptr<IceTransport> client_transport_;
+  std::unique_ptr<IceTransport> client_transport_;
   TestTransportEventHandler client_event_handler_;
-  scoped_ptr<FakeAuthenticator> client_authenticator_;
+  std::unique_ptr<FakeAuthenticator> client_authenticator_;
 
   MockChannelCreatedCallback client_channel_callback_;
   MockChannelCreatedCallback host_channel_callback_;
 
-  scoped_ptr<MessagePipe> client_message_pipe_;
-  scoped_ptr<MessagePipe> host_message_pipe_;
+  std::unique_ptr<MessagePipe> client_message_pipe_;
+  std::unique_ptr<MessagePipe> host_message_pipe_;
 
   ErrorCode error_ = OK;
 };
 
 TEST_F(IceTransportTest, DataStream) {
   InitializeConnection();
 
   client_transport_->GetChannelFactory()->CreateChannel(
       kChannelName, base::Bind(&IceTransportTest::OnClientChannelCreated,
                                base::Unretained(this)));
@@ skipping 119 matching lines @@
 
   MessagePipeConnectionTester tester(host_message_pipe_.get(),
                                      client_message_pipe_.get(), kMessageSize,
                                      kMessages);
   tester.RunAndCheckResults();
 }
 
 
 }  // namespace protocol
 }  // namespace remoting