Convert //remoting to use std::unique_ptr

remoting/host/client_session_unittest.cc

 // Copyright (c) 2012 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/host/client_session.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 114 matching lines @@
 
   // Used to run |message_loop_| after each test, until no objects remain that
   // require it.
   base::RunLoop run_loop_;
 
   // HostExtensions to pass when creating the ClientSession. Caller retains
   // ownership of the HostExtensions themselves.
   std::vector<HostExtension*> extensions_;
 
   // ClientSession instance under test.
-  scoped_ptr<ClientSession> client_session_;
+  std::unique_ptr<ClientSession> client_session_;
 
   // ClientSession::EventHandler mock for use in tests.
   MockClientSessionEventHandler session_event_handler_;
 
   // Storage for values to be returned by the protocol::Session mock.
-  scoped_ptr<SessionConfig> session_config_;
+  std::unique_ptr<SessionConfig> session_config_;
   const std::string client_jid_;
 
   // Stubs returned to |client_session_| components by |connection_|.
   MockClientStub client_stub_;
 
   // ClientSession owns |connection_| but tests need it to inject fake events.
   protocol::FakeConnectionToClient* connection_;
 
-  scoped_ptr<FakeDesktopEnvironmentFactory> desktop_environment_factory_;
+  std::unique_ptr<FakeDesktopEnvironmentFactory> desktop_environment_factory_;
 };
 
 void ClientSessionTest::SetUp() {
   // Arrange to run |message_loop_| until no components depend on it.
   task_runner_ = new AutoThreadTaskRunner(
       message_loop_.task_runner(), run_loop_.QuitClosure());
 
   desktop_environment_factory_.reset(new FakeDesktopEnvironmentFactory());
   session_config_ = SessionConfig::ForTest();
 }
 
 void ClientSessionTest::TearDown() {
   if (client_session_) {
     client_session_->DisconnectSession(protocol::OK);
     client_session_.reset();
     desktop_environment_factory_.reset();
   }
 
   // Clear out |task_runner_| reference so the loop can quit, and run it until
   // it does.
   task_runner_ = nullptr;
   run_loop_.Run();
 }
 
 void ClientSessionTest::CreateClientSession() {
   // Mock protocol::Session APIs called directly by ClientSession.
-  scoped_ptr<protocol::MockSession> session(new MockSession());
+  std::unique_ptr<protocol::MockSession> session(new MockSession());
   EXPECT_CALL(*session, config()).WillRepeatedly(ReturnRef(*session_config_));
   EXPECT_CALL(*session, jid()).WillRepeatedly(ReturnRef(client_jid_));
 
   // Mock protocol::ConnectionToClient APIs called directly by ClientSession.
   // HostStub is not touched by ClientSession, so we can safely pass nullptr.
-  scoped_ptr<protocol::FakeConnectionToClient> connection(
+  std::unique_ptr<protocol::FakeConnectionToClient> connection(
       new protocol::FakeConnectionToClient(std::move(session)));
   connection->set_client_stub(&client_stub_);
   connection_ = connection.get();
 
   client_session_.reset(new ClientSession(
       &session_event_handler_,
       task_runner_,  // Audio thread.
       std::move(connection), desktop_environment_factory_.get(),
       base::TimeDelta(), nullptr, extensions_));
 }
@@ skipping 228 matching lines @@
 
   // ext2 was instantiated but not sent a message, and wrapped video encoder.
   EXPECT_TRUE(extension2.was_instantiated());
   EXPECT_FALSE(extension2.has_handled_message());
 
   // ext3 was sent a message but not instantiated.
   EXPECT_FALSE(extension3.was_instantiated());
 }
 
 }  // namespace remoting