Convert //remoting to use std::unique_ptr

remoting/host/chromoting_host_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/chromoting_host.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/fake_desktop_environment.h"
 #include "remoting/host/fake_mouse_cursor_monitor.h"
 #include "remoting/host/host_mock_objects.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/errors.h"
 #include "remoting/protocol/fake_connection_to_client.h"
 #include "remoting/protocol/fake_desktop_capturer.h"
@@ skipping 35 matching lines @@
   ChromotingHostTest() {}
 
   void SetUp() override {
     task_runner_ = new AutoThreadTaskRunner(message_loop_.task_runner(),
                                             base::Bind(&base::DoNothing));
 
     desktop_environment_factory_.reset(new FakeDesktopEnvironmentFactory());
     session_manager_ = new protocol::MockSessionManager();
 
     host_.reset(new ChromotingHost(
-        desktop_environment_factory_.get(), make_scoped_ptr(session_manager_),
+        desktop_environment_factory_.get(), base::WrapUnique(session_manager_),
         protocol::TransportContext::ForTests(protocol::TransportRole::SERVER),
         task_runner_,    // Audio
         task_runner_));  // Video encode
     host_->AddStatusObserver(&host_status_observer_);
 
     xmpp_login_ = "host@domain";
     session1_ = new MockSession();
     session2_ = new MockSession();
     session_unowned1_.reset(new MockSession());
     session_unowned2_.reset(new MockSession());
@@ skipping 21 matching lines @@
     EXPECT_CALL(*session1_, config())
         .WillRepeatedly(ReturnRef(*session_config1_));
     EXPECT_CALL(*session2_, config())
         .WillRepeatedly(ReturnRef(*session_config2_));
     EXPECT_CALL(*session_unowned1_, config())
         .WillRepeatedly(ReturnRef(*session_config1_));
     EXPECT_CALL(*session_unowned2_, config())
         .WillRepeatedly(ReturnRef(*session_config2_));
 
     owned_connection1_.reset(
-        new protocol::FakeConnectionToClient(make_scoped_ptr(session1_)));
+        new protocol::FakeConnectionToClient(base::WrapUnique(session1_)));
     owned_connection1_->set_host_stub(&host_stub1_);
     connection1_ = owned_connection1_.get();
     connection1_->set_client_stub(&client_stub1_);
 
     owned_connection2_.reset(
-        new protocol::FakeConnectionToClient(make_scoped_ptr(session2_)));
+        new protocol::FakeConnectionToClient(base::WrapUnique(session2_)));
     owned_connection2_->set_host_stub(&host_stub2_);
     connection2_ = owned_connection2_.get();
     connection2_->set_client_stub(&client_stub2_);
   }
 
   // Helper method to pretend a client is connected to ChromotingHost.
   void SimulateClientConnection(int connection_index, bool authenticate,
                                 bool reject) {
-    scoped_ptr<protocol::ConnectionToClient> connection = std::move(
+    std::unique_ptr<protocol::ConnectionToClient> connection = std::move(
         (connection_index == 0) ? owned_connection1_ : owned_connection2_);
     protocol::ConnectionToClient* connection_ptr = connection.get();
-    scoped_ptr<ClientSession> client(new ClientSession(
+    std::unique_ptr<ClientSession> client(new ClientSession(
         host_.get(), task_runner_ /* audio_task_runner */,
         std::move(connection), desktop_environment_factory_.get(),
         base::TimeDelta(), nullptr, std::vector<HostExtension*>()));
     ClientSession* client_ptr = client.get();
 
     connection_ptr->set_host_stub(client.get());
     get_client(connection_index) = client_ptr;
 
     // |host| is responsible for deleting |client| from now on.
     host_->clients_.push_back(client.release());
@@ skipping 61 matching lines @@
   Expectation ExpectClientDisconnected(int connection_index) {
     return EXPECT_CALL(host_status_observer_,
                        OnClientDisconnected(get_session_jid(connection_index)))
         .RetiresOnSaturation();
   }
 
  protected:
   base::MessageLoop message_loop_;
   scoped_refptr<AutoThreadTaskRunner> task_runner_;
   MockConnectionToClientEventHandler handler_;
-  scoped_ptr<FakeDesktopEnvironmentFactory> desktop_environment_factory_;
+  std::unique_ptr<FakeDesktopEnvironmentFactory> desktop_environment_factory_;
   MockHostStatusObserver host_status_observer_;
-  scoped_ptr<ChromotingHost> host_;
+  std::unique_ptr<ChromotingHost> host_;
   protocol::MockSessionManager* session_manager_;
   std::string xmpp_login_;
   protocol::FakeConnectionToClient* connection1_;
-  scoped_ptr<protocol::FakeConnectionToClient> owned_connection1_;
+  std::unique_ptr<protocol::FakeConnectionToClient> owned_connection1_;
   ClientSession* client1_;
   std::string session_jid1_;
   MockSession* session1_;  // Owned by |connection_|.
-  scoped_ptr<SessionConfig> session_config1_;
+  std::unique_ptr<SessionConfig> session_config1_;
   MockClientStub client_stub1_;
   MockHostStub host_stub1_;
   protocol::FakeConnectionToClient* connection2_;
-  scoped_ptr<protocol::FakeConnectionToClient> owned_connection2_;
+  std::unique_ptr<protocol::FakeConnectionToClient> owned_connection2_;
   ClientSession* client2_;
   std::string session_jid2_;
   MockSession* session2_;  // Owned by |connection2_|.
-  scoped_ptr<SessionConfig> session_config2_;
+  std::unique_ptr<SessionConfig> session_config2_;
   MockClientStub client_stub2_;
   MockHostStub host_stub2_;
-  scoped_ptr<MockSession> session_unowned1_;  // Not owned by a connection.
+  std::unique_ptr<MockSession> session_unowned1_;  // Not owned by a connection.
   std::string session_unowned_jid1_;
-  scoped_ptr<MockSession> session_unowned2_;  // Not owned by a connection.
+  std::unique_ptr<MockSession> session_unowned2_;  // Not owned by a connection.
   std::string session_unowned_jid2_;
   protocol::Session::EventHandler* session_unowned1_event_handler_;
   protocol::Session::EventHandler* session_unowned2_event_handler_;
 
   protocol::FakeConnectionToClient*& get_connection(int connection_index) {
     return (connection_index == 0) ? connection1_ : connection2_;
   }
 
   // Returns the cached client pointers client1_ or client2_.
   ClientSession*& get_client(int connection_index) {
@@ skipping 146 matching lines @@
 
   ExpectClientConnected(0);
   SimulateClientConnection(0, true, false);
 
   ExpectClientDisconnected(0);
   DisconnectAllClients();
   testing::Mock::VerifyAndClearExpectations(&host_status_observer_);
 }
 
 }  // namespace remoting