Replace scoped_ptr with unique_ptr in webrtc/base/

webrtc/p2p/base/transportcontroller_unittest.cc

 /*
  *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <map>
+#include <memory>
 
 #include "webrtc/base/fakesslidentity.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/helpers.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/sslidentity.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/p2p/base/dtlstransportchannel.h"
 #include "webrtc/p2p/base/faketransportcontroller.h"
 #include "webrtc/p2p/base/p2ptransportchannel.h"
 #include "webrtc/p2p/base/portallocator.h"
 #include "webrtc/p2p/base/transportcontroller.h"
 #include "webrtc/p2p/client/fakeportallocator.h"
 
 static const int kTimeout = 100;
@@ skipping 143 matching lines @@
   void OnCandidatesGathered(const std::string& transport_name,
                             const Candidates& candidates) {
     if (!signaling_thread_->IsCurrent()) {
       signaled_on_non_signaling_thread_ = true;
     }
     candidates_[transport_name].insert(candidates_[transport_name].end(),
                                        candidates.begin(), candidates.end());
     ++candidates_signal_count_;
   }
 
-  rtc::scoped_ptr<rtc::Thread> worker_thread_;  // Not used for most tests.
-  rtc::scoped_ptr<TransportControllerForTest> transport_controller_;
+  std::unique_ptr<rtc::Thread> worker_thread_;  // Not used for most tests.
+  std::unique_ptr<TransportControllerForTest> transport_controller_;
 
   // Information received from signals from transport controller.
   IceConnectionState connection_state_ = cricket::kIceConnectionConnecting;
   bool receiving_ = false;
   IceGatheringState gathering_state_ = cricket::kIceGatheringNew;
   // transport_name => candidates
   std::map<std::string, Candidates> candidates_;
   // Counts of each signal emitted.
   int connection_state_signal_count_ = 0;
   int receiving_signal_count_ = 0;
@@ skipping 70 matching lines @@
   ASSERT_NE(nullptr, channel);
   ASSERT_TRUE(channel->SetSslRole(rtc::SSL_CLIENT));
   rtc::SSLRole role;
   EXPECT_FALSE(transport_controller_->GetSslRole("video", &role));
   EXPECT_TRUE(transport_controller_->GetSslRole("audio", &role));
   EXPECT_EQ(rtc::SSL_CLIENT, role);
 }
 
 TEST_F(TransportControllerTest, TestSetAndGetLocalCertificate) {
   rtc::scoped_refptr<rtc::RTCCertificate> certificate1 =
-      rtc::RTCCertificate::Create(rtc::scoped_ptr<rtc::SSLIdentity>(
+      rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
           rtc::SSLIdentity::Generate("session1", rtc::KT_DEFAULT)));
   rtc::scoped_refptr<rtc::RTCCertificate> certificate2 =
-      rtc::RTCCertificate::Create(rtc::scoped_ptr<rtc::SSLIdentity>(
+      rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
           rtc::SSLIdentity::Generate("session2", rtc::KT_DEFAULT)));
   rtc::scoped_refptr<rtc::RTCCertificate> returned_certificate;
 
   FakeTransportChannel* channel1 = CreateChannel("audio", 1);
   ASSERT_NE(nullptr, channel1);
 
   EXPECT_TRUE(transport_controller_->SetLocalCertificate(certificate1));
   EXPECT_TRUE(transport_controller_->GetLocalCertificate(
       "audio", &returned_certificate));
   EXPECT_EQ(certificate1->identity()->certificate().ToPEMString(),
@@ skipping 15 matching lines @@
   EXPECT_FALSE(transport_controller_->SetLocalCertificate(certificate2));
 }
 
 TEST_F(TransportControllerTest, TestGetRemoteSSLCertificate) {
   rtc::FakeSSLCertificate fake_certificate("fake_data");
 
   FakeTransportChannel* channel = CreateChannel("audio", 1);
   ASSERT_NE(nullptr, channel);
 
   channel->SetRemoteSSLCertificate(&fake_certificate);
-  rtc::scoped_ptr<rtc::SSLCertificate> returned_certificate =
+  std::unique_ptr<rtc::SSLCertificate> returned_certificate =
       transport_controller_->GetRemoteSSLCertificate("audio");
   EXPECT_TRUE(returned_certificate);
   EXPECT_EQ(fake_certificate.ToPEMString(),
             returned_certificate->ToPEMString());
 
   // Should fail if called for a nonexistant transport.
   EXPECT_FALSE(transport_controller_->GetRemoteSSLCertificate("video"));
 }
 
 TEST_F(TransportControllerTest, TestSetLocalTransportDescription) {
@@ skipping 354 matching lines @@
   // new --> gathering --> complete
   EXPECT_EQ_WAIT(cricket::kIceGatheringComplete, gathering_state_, kTimeout);
   EXPECT_EQ(2, gathering_state_signal_count_);
 
   EXPECT_EQ_WAIT(1U, candidates_["audio"].size(), kTimeout);
   EXPECT_EQ_WAIT(1U, candidates_["video"].size(), kTimeout);
   EXPECT_EQ(2, candidates_signal_count_);
 
   EXPECT_TRUE(!signaled_on_non_signaling_thread_);
 }