Convert //remoting to use std::unique_ptr

remoting/protocol/jingle_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/protocol/jingle_session.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 99 matching lines @@
     host_signal_strategy_.reset(new FakeSignalStrategy(kHostJid));
     client_signal_strategy_.reset(new FakeSignalStrategy(kClientJid));
     FakeSignalStrategy::Connect(host_signal_strategy_.get(),
                                 client_signal_strategy_.get());
 
     host_server_.reset(new JingleSessionManager(host_signal_strategy_.get()));
     host_server_->AcceptIncoming(
         base::Bind(&MockSessionManagerListener::OnIncomingSession,
                    base::Unretained(&host_server_listener_)));
 
-    scoped_ptr<AuthenticatorFactory> factory(
-        new FakeHostAuthenticatorFactory(auth_round_trips,
-          messages_till_start, auth_action, true));
+    std::unique_ptr<AuthenticatorFactory> factory(
+        new FakeHostAuthenticatorFactory(auth_round_trips, messages_till_start,
+                                         auth_action, true));
     host_server_->set_authenticator_factory(std::move(factory));
 
     client_server_.reset(
         new JingleSessionManager(client_signal_strategy_.get()));
   }
 
   void CreateSessionManagers(int auth_round_trips,
                              FakeAuthenticator::Action auth_action) {
     CreateSessionManagers(auth_round_trips, 0, auth_action);
   }
@@ skipping 58 matching lines @@
                     OnSessionStateChange(Session::AUTHENTICATED))
             .Times(1);
 
         // Expect that the connection will be closed eventually.
         EXPECT_CALL(client_session_event_handler_,
                     OnSessionStateChange(Session::CLOSED))
             .Times(AtMost(1));
       }
     }
 
-    scoped_ptr<Authenticator> authenticator(new FakeAuthenticator(
+    std::unique_ptr<Authenticator> authenticator(new FakeAuthenticator(
         FakeAuthenticator::CLIENT, auth_round_trips, auth_action, true));
 
     client_session_ =
         client_server_->Connect(kHostJid, std::move(authenticator));
     client_session_->SetEventHandler(&client_session_event_handler_);
     client_session_->SetTransport(&client_transport_);
 
     base::RunLoop().RunUntilIdle();
   }
 
   void ExpectRouteChange(const std::string& channel_name) {
     EXPECT_CALL(host_session_event_handler_,
                 OnSessionRouteChange(channel_name, _))
         .Times(AtLeast(1));
     EXPECT_CALL(client_session_event_handler_,
                 OnSessionRouteChange(channel_name, _))
         .Times(AtLeast(1));
   }
 
-  scoped_ptr<base::MessageLoopForIO> message_loop_;
+  std::unique_ptr<base::MessageLoopForIO> message_loop_;
 
   NetworkSettings network_settings_;
 
-  scoped_ptr<FakeSignalStrategy> host_signal_strategy_;
-  scoped_ptr<FakeSignalStrategy> client_signal_strategy_;
+  std::unique_ptr<FakeSignalStrategy> host_signal_strategy_;
+  std::unique_ptr<FakeSignalStrategy> client_signal_strategy_;
 
-  scoped_ptr<JingleSessionManager> host_server_;
+  std::unique_ptr<JingleSessionManager> host_server_;
   MockSessionManagerListener host_server_listener_;
-  scoped_ptr<JingleSessionManager> client_server_;
+  std::unique_ptr<JingleSessionManager> client_server_;
 
-  scoped_ptr<Session> host_session_;
+  std::unique_ptr<Session> host_session_;
   MockSessionEventHandler host_session_event_handler_;
   MockTransport host_transport_;
-  scoped_ptr<Session> client_session_;
+  std::unique_ptr<Session> client_session_;
   MockSessionEventHandler client_session_event_handler_;
   MockTransport client_transport_;
 };
 
 
 // Verify that we can create and destroy session managers without a
 // connection.
 TEST_F(JingleSessionTest, CreateAndDestoy) {
   CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
 }
 
 // Verify that an incoming session can be rejected, and that the
 // status of the connection is set to FAILED in this case.
 TEST_F(JingleSessionTest, RejectConnection) {
   CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
 
   // Reject incoming session.
   EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _))
       .WillOnce(SetArgumentPointee<1>(protocol::SessionManager::DECLINE));
 
   {
     InSequence dummy;
     EXPECT_CALL(client_session_event_handler_,
                 OnSessionStateChange(Session::FAILED))
         .Times(1);
   }
 
-  scoped_ptr<Authenticator> authenticator(new FakeAuthenticator(
+  std::unique_ptr<Authenticator> authenticator(new FakeAuthenticator(
       FakeAuthenticator::CLIENT, 1, FakeAuthenticator::ACCEPT, true));
   client_session_ = client_server_->Connect(kHostJid, std::move(authenticator));
   client_session_->SetEventHandler(&client_session_event_handler_);
 
   base::RunLoop().RunUntilIdle();
 }
 
 // Verify that we can connect two endpoints with single-step authentication.
 TEST_F(JingleSessionTest, Connect) {
   CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
@@ skipping 31 matching lines @@
 // Verify that incompatible protocol configuration is handled properly.
 TEST_F(JingleSessionTest, TestIncompatibleProtocol) {
   CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
 
   EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _)).Times(0);
 
   EXPECT_CALL(client_session_event_handler_,
               OnSessionStateChange(Session::FAILED))
       .Times(1);
 
-  scoped_ptr<Authenticator> authenticator(new FakeAuthenticator(
+  std::unique_ptr<Authenticator> authenticator(new FakeAuthenticator(
       FakeAuthenticator::CLIENT, 1, FakeAuthenticator::ACCEPT, true));
 
-  scoped_ptr<CandidateSessionConfig> config =
+  std::unique_ptr<CandidateSessionConfig> config =
       CandidateSessionConfig::CreateDefault();
   // Disable all video codecs so the host will reject connection.
   config->mutable_video_configs()->clear();
   client_server_->set_protocol_config(std::move(config));
   client_session_ = client_server_->Connect(kHostJid, std::move(authenticator));
   client_session_->SetEventHandler(&client_session_event_handler_);
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(INCOMPATIBLE_PROTOCOL, client_session_->error());
   EXPECT_FALSE(host_session_);
 }
 
 // Verify that GICE-only client is rejected with an appropriate error code.
 TEST_F(JingleSessionTest, TestLegacyIceConnection) {
   CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
 
   EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _)).Times(0);
 
   EXPECT_CALL(client_session_event_handler_,
               OnSessionStateChange(Session::FAILED))
       .Times(1);
 
-  scoped_ptr<Authenticator> authenticator(new FakeAuthenticator(
+  std::unique_ptr<Authenticator> authenticator(new FakeAuthenticator(
       FakeAuthenticator::CLIENT, 1, FakeAuthenticator::ACCEPT, true));
 
-  scoped_ptr<CandidateSessionConfig> config =
+  std::unique_ptr<CandidateSessionConfig> config =
       CandidateSessionConfig::CreateDefault();
   config->set_ice_supported(false);
   client_server_->set_protocol_config(std::move(config));
   client_session_ = client_server_->Connect(kHostJid, std::move(authenticator));
   client_session_->SetEventHandler(&client_session_event_handler_);
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(INCOMPATIBLE_PROTOCOL, client_session_->error());
   EXPECT_FALSE(host_session_);
 }
 
 TEST_F(JingleSessionTest, DeleteSessionOnIncomingConnection) {
   CreateSessionManagers(3, FakeAuthenticator::ACCEPT);
 
   EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _))
       .WillOnce(DoAll(
           WithArg<0>(Invoke(this, &JingleSessionTest::SetHostSession)),
           SetArgumentPointee<1>(protocol::SessionManager::ACCEPT)));
 
   EXPECT_CALL(host_session_event_handler_,
       OnSessionStateChange(Session::ACCEPTED))
       .Times(AtMost(1));
 
   EXPECT_CALL(host_session_event_handler_,
       OnSessionStateChange(Session::AUTHENTICATING))
       .WillOnce(InvokeWithoutArgs(this, &JingleSessionTest::DeleteSession));
 
-  scoped_ptr<Authenticator> authenticator(new FakeAuthenticator(
+  std::unique_ptr<Authenticator> authenticator(new FakeAuthenticator(
       FakeAuthenticator::CLIENT, 3, FakeAuthenticator::ACCEPT, true));
 
   client_session_ = client_server_->Connect(kHostJid, std::move(authenticator));
 
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(JingleSessionTest, DeleteSessionOnAuth) {
   // Same as the previous test, but set messages_till_started to 2 in
   // CreateSessionManagers so that the session will goes into the
   // AUTHENTICATING state after two message exchanges.
   CreateSessionManagers(3, 2, FakeAuthenticator::ACCEPT);
 
   EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _))
       .WillOnce(DoAll(
           WithArg<0>(Invoke(this, &JingleSessionTest::SetHostSession)),
           SetArgumentPointee<1>(protocol::SessionManager::ACCEPT)));
 
   EXPECT_CALL(host_session_event_handler_,
       OnSessionStateChange(Session::ACCEPTED))
       .Times(AtMost(1));
 
   EXPECT_CALL(host_session_event_handler_,
       OnSessionStateChange(Session::AUTHENTICATING))
       .WillOnce(InvokeWithoutArgs(this, &JingleSessionTest::DeleteSession));
 
-  scoped_ptr<Authenticator> authenticator(new FakeAuthenticator(
+  std::unique_ptr<Authenticator> authenticator(new FakeAuthenticator(
       FakeAuthenticator::CLIENT, 3, FakeAuthenticator::ACCEPT, true));
 
   client_session_ = client_server_->Connect(kHostJid, std::move(authenticator));
   base::RunLoop().RunUntilIdle();
 }
 
 // Verify that we can connect with multistep authentication.
 TEST_F(JingleSessionTest, TestMultistepAuth) {
   CreateSessionManagers(3, FakeAuthenticator::ACCEPT);
   ASSERT_NO_FATAL_FAILURE(
       InitiateConnection(3, FakeAuthenticator::ACCEPT, false));
 }
 
 }  // namespace protocol
 }  // namespace remoting