Convert //remoting to use std::unique_ptr

remoting/protocol/session_config_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/session_config.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace remoting {
 namespace protocol {
 
-void TestGetFinalConfig(scoped_ptr<SessionConfig> config) {
-  scoped_ptr<CandidateSessionConfig> candidate_config =
+void TestGetFinalConfig(std::unique_ptr<SessionConfig> config) {
+  std::unique_ptr<CandidateSessionConfig> candidate_config =
       CandidateSessionConfig::CreateFrom(*config);
   ASSERT_TRUE(candidate_config);
-  scoped_ptr<SessionConfig> config2 =
+  std::unique_ptr<SessionConfig> config2 =
       SessionConfig::GetFinalConfig(candidate_config.get());
   ASSERT_TRUE(config2);
   EXPECT_EQ(config->protocol(), config2->protocol());
 
   if (config->protocol() == SessionConfig::Protocol::ICE) {
     EXPECT_EQ(config->control_config(), config2->control_config());
     EXPECT_EQ(config->event_config(), config2->event_config());
     EXPECT_EQ(config->video_config(), config2->video_config());
     EXPECT_EQ(config->audio_config(), config2->audio_config());
   }
 }
 
 TEST(SessionConfig, SelectCommon) {
-  scoped_ptr<CandidateSessionConfig> default_candidate_config =
+  std::unique_ptr<CandidateSessionConfig> default_candidate_config =
       CandidateSessionConfig::CreateDefault();
 
-  scoped_ptr<CandidateSessionConfig> candidate_config_with_webrtc =
+  std::unique_ptr<CandidateSessionConfig> candidate_config_with_webrtc =
       CandidateSessionConfig::CreateEmpty();
   candidate_config_with_webrtc->set_webrtc_supported(true);
 
-  scoped_ptr<CandidateSessionConfig> hybrid_candidate_config =
+  std::unique_ptr<CandidateSessionConfig> hybrid_candidate_config =
       CandidateSessionConfig::CreateDefault();
   hybrid_candidate_config->set_webrtc_supported(true);
 
-  scoped_ptr<SessionConfig> selected;
+  std::unique_ptr<SessionConfig> selected;
 
   // ICE is selected by default.
   selected = SessionConfig::SelectCommon(default_candidate_config.get(),
                                          default_candidate_config.get());
   ASSERT_TRUE(selected);
   EXPECT_EQ(SessionConfig::Protocol::ICE, selected->protocol());
 
   // WebRTC protocol is not supported by default.
   selected = SessionConfig::SelectCommon(default_candidate_config.get(),
                                          candidate_config_with_webrtc.get());
@@ skipping 23 matching lines @@
   ASSERT_TRUE(selected);
   EXPECT_EQ(SessionConfig::Protocol::WEBRTC, selected->protocol());
 }
 
 TEST(SessionConfig, GetFinalConfig) {
   TestGetFinalConfig(SessionConfig::ForTest());
   TestGetFinalConfig(SessionConfig::ForTestWithWebrtc());
 }
 
 TEST(SessionConfig, IsSupported) {
-  scoped_ptr<CandidateSessionConfig> default_candidate_config =
+  std::unique_ptr<CandidateSessionConfig> default_candidate_config =
       CandidateSessionConfig::CreateDefault();
 
-  scoped_ptr<CandidateSessionConfig> candidate_config_with_webrtc =
+  std::unique_ptr<CandidateSessionConfig> candidate_config_with_webrtc =
       CandidateSessionConfig::CreateEmpty();
   candidate_config_with_webrtc->set_webrtc_supported(true);
 
-  scoped_ptr<CandidateSessionConfig> hybrid_candidate_config =
+  std::unique_ptr<CandidateSessionConfig> hybrid_candidate_config =
       CandidateSessionConfig::CreateDefault();
   hybrid_candidate_config->set_webrtc_supported(true);
 
-  scoped_ptr<SessionConfig> ice_config = SessionConfig::ForTest();
-  scoped_ptr<SessionConfig> webrtc_config = SessionConfig::ForTestWithWebrtc();
+  std::unique_ptr<SessionConfig> ice_config = SessionConfig::ForTest();
+  std::unique_ptr<SessionConfig> webrtc_config =
+      SessionConfig::ForTestWithWebrtc();
 
   EXPECT_TRUE(default_candidate_config->IsSupported(*ice_config));
   EXPECT_FALSE(default_candidate_config->IsSupported(*webrtc_config));
 
   EXPECT_FALSE(candidate_config_with_webrtc->IsSupported(*ice_config));
   EXPECT_TRUE(candidate_config_with_webrtc->IsSupported(*webrtc_config));
 
   EXPECT_TRUE(hybrid_candidate_config->IsSupported(*ice_config));
   EXPECT_TRUE(hybrid_candidate_config->IsSupported(*webrtc_config));
 }
 
 }  // namespace protocol
 }  // namespace remoting