Convert //remoting to use std::unique_ptr

remoting/test/test_chromoting_client.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/test/test_chromoting_client.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "net/base/request_priority.h"
 #include "net/socket/client_socket_factory.h"
 #include "remoting/base/chromium_url_request.h"
 #include "remoting/base/url_request_context_getter.h"
 #include "remoting/client/audio_player.h"
 #include "remoting/client/chromoting_client.h"
 #include "remoting/client/client_context.h"
 #include "remoting/protocol/chromium_port_allocator_factory.h"
@@ skipping 34 matching lines @@
     const protocol::SecretFetchedCallback& secret_fetched_callback) {
   secret_fetched_callback.Run(client_secret);
 }
 
 }  // namespace
 
 TestChromotingClient::TestChromotingClient()
     : TestChromotingClient(nullptr) {}
 
 TestChromotingClient::TestChromotingClient(
-    scoped_ptr<protocol::VideoRenderer> video_renderer)
+    std::unique_ptr<protocol::VideoRenderer> video_renderer)
     : connection_to_host_state_(protocol::ConnectionToHost::INITIALIZING),
       connection_error_code_(protocol::OK),
       video_renderer_(std::move(video_renderer)) {}
 
 TestChromotingClient::~TestChromotingClient() {
   // Ensure any connections are closed and the members are destroyed in the
   // appropriate order.
   EndConnection();
 }
 
@@ skipping 37 matching lines @@
         new XmppSignalStrategy(net::ClientSocketFactory::GetDefaultFactory(),
                                request_context_getter, xmpp_server_config));
   }
 
   protocol::NetworkSettings network_settings(
       protocol::NetworkSettings::NAT_TRAVERSAL_FULL);
 
   scoped_refptr<protocol::TransportContext> transport_context(
       new protocol::TransportContext(
           signal_strategy_.get(),
-          make_scoped_ptr(new protocol::ChromiumPortAllocatorFactory()),
-          make_scoped_ptr(
+          base::WrapUnique(new protocol::ChromiumPortAllocatorFactory()),
+          base::WrapUnique(
               new ChromiumUrlRequestFactory(request_context_getter)),
           network_settings, protocol::TransportRole::CLIENT));
 
   protocol::ClientAuthenticationConfig client_auth_config;
   client_auth_config.host_id = connection_setup_info.host_id;
   client_auth_config.pairing_client_id = connection_setup_info.pairing_id;
   client_auth_config.pairing_secret = connection_setup_info.shared_secret;
 
   if (!connection_setup_info.pin.empty()) {
     client_auth_config.fetch_secret_callback =
@@ skipping 34 matching lines @@
 }
 
 void TestChromotingClient::RemoveRemoteConnectionObserver(
     RemoteConnectionObserver* observer) {
   DCHECK(observer);
 
   connection_observers_.RemoveObserver(observer);
 }
 
 void TestChromotingClient::SetSignalStrategyForTests(
-    scoped_ptr<SignalStrategy> signal_strategy) {
+    std::unique_ptr<SignalStrategy> signal_strategy) {
   signal_strategy_ = std::move(signal_strategy);
 }
 
 void TestChromotingClient::SetConnectionToHostForTests(
-    scoped_ptr<protocol::ConnectionToHost> connection_to_host) {
+    std::unique_ptr<protocol::ConnectionToHost> connection_to_host) {
   test_connection_to_host_ = std::move(connection_to_host);
 }
 
 void TestChromotingClient::OnConnectionState(
     protocol::ConnectionToHost::State state,
     protocol::ErrorCode error_code) {
   VLOG(1) << "TestChromotingClient::OnConnectionState("
           << "state: " << protocol::ConnectionToHost::StateToString(state)
           << ", error_code: " << protocol::ErrorCodeToString(error_code)
           << ") Called";
@@ skipping 74 matching lines @@
   VLOG(1) << "TestChromotingClient::InjectClipboardEvent() Called";
 }
 
 void TestChromotingClient::SetCursorShape(
     const protocol::CursorShapeInfo& cursor_shape) {
   VLOG(1) << "TestChromotingClient::SetCursorShape() Called";
 }
 
 }  // namespace test
 }  // namespace remoting