Replace scoped_ptr with unique_ptr in webrtc/api/

webrtc/api/statscollector_unittest.cc

 /*
  *  Copyright 2014 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.
  */
 
@@ skipping 15 matching lines @@
 #include "webrtc/api/test/fakevideotracksource.h"
 #include "webrtc/api/videotrack.h"
 #include "webrtc/base/base64.h"
 #include "webrtc/base/fakesslidentity.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/network.h"
 #include "webrtc/media/base/fakemediaengine.h"
 #include "webrtc/p2p/base/faketransportcontroller.h"
 #include "webrtc/pc/channelmanager.h"
 
-using rtc::scoped_ptr;
 using testing::_;
 using testing::DoAll;
 using testing::Field;
 using testing::Return;
 using testing::ReturnNull;
 using testing::ReturnRef;
 using testing::SetArgPointee;
 using webrtc::PeerConnectionInterface;
 using webrtc::StatsReport;
 using webrtc::StatsReports;
@@ skipping 618 matching lines @@
     EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);
     if (voice_sender_info)
       VerifyVoiceSenderInfoReport(track_report, *voice_sender_info);
     if (voice_receiver_info)
     VerifyVoiceReceiverInfoReport(track_report, *voice_receiver_info);
   }
 
   void TestCertificateReports(
       const rtc::FakeSSLCertificate& local_cert,
       const std::vector<std::string>& local_ders,
-      rtc::scoped_ptr<rtc::FakeSSLCertificate> remote_cert,
+      std::unique_ptr<rtc::FakeSSLCertificate> remote_cert,
       const std::vector<std::string>& remote_ders) {
     StatsCollectorForTest stats(&pc_);
 
     StatsReports reports;  // returned values.
 
     // Fake stats to process.
     cricket::TransportChannelStats channel_stats;
     channel_stats.component = 1;
     channel_stats.srtp_crypto_suite = rtc::SRTP_AES128_CM_SHA1_80;
     channel_stats.ssl_cipher_suite =
@@ skipping 65 matching lines @@
                   internal::TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA),
               dtls_cipher_suite);
     std::string srtp_crypto_suite =
         ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
                           StatsReport::kStatsValueNameSrtpCipher);
     EXPECT_EQ(rtc::SrtpCryptoSuiteToName(rtc::SRTP_AES128_CM_SHA1_80),
               srtp_crypto_suite);
   }
 
   cricket::FakeMediaEngine* media_engine_;
-  rtc::scoped_ptr<cricket::ChannelManager> channel_manager_;
-  rtc::scoped_ptr<webrtc::MediaControllerInterface> media_controller_;
+  std::unique_ptr<cricket::ChannelManager> channel_manager_;
+  std::unique_ptr<webrtc::MediaControllerInterface> media_controller_;
   MockWebRtcSession session_;
   MockPeerConnection pc_;
   FakeDataChannelProvider data_channel_provider_;
   SessionStats session_stats_;
   rtc::scoped_refptr<webrtc::MediaStream> stream_;
   rtc::scoped_refptr<webrtc::VideoTrack> track_;
   rtc::scoped_refptr<FakeAudioTrack> audio_track_;
   std::vector<rtc::scoped_refptr<DataChannel>> data_channels_;
 };
 
@@ skipping 560 matching lines @@
   local_ders[3] = "der";
   local_ders[4] = "values";
   rtc::FakeSSLCertificate local_cert(DersToPems(local_ders));
 
   // Build remote certificate chain
   std::vector<std::string> remote_ders(4);
   remote_ders[0] = "A";
   remote_ders[1] = "non-";
   remote_ders[2] = "intersecting";
   remote_ders[3] = "set";
-  rtc::scoped_ptr<rtc::FakeSSLCertificate> remote_cert(
+  std::unique_ptr<rtc::FakeSSLCertificate> remote_cert(
       new rtc::FakeSSLCertificate(DersToPems(remote_ders)));
 
   TestCertificateReports(local_cert, local_ders, std::move(remote_cert),
                          remote_ders);
 }
 
 // This test verifies that all certificates without chains are correctly
 // reported.
 TEST_F(StatsCollectorTest, ChainlessCertificateReportsCreated) {
   // Build local certificate.
   std::string local_der = "This is the local der.";
   rtc::FakeSSLCertificate local_cert(DerToPem(local_der));
 
   // Build remote certificate.
   std::string remote_der = "This is somebody else's der.";
-  rtc::scoped_ptr<rtc::FakeSSLCertificate> remote_cert(
+  std::unique_ptr<rtc::FakeSSLCertificate> remote_cert(
       new rtc::FakeSSLCertificate(DerToPem(remote_der)));
 
   TestCertificateReports(local_cert, std::vector<std::string>(1, local_der),
                          std::move(remote_cert),
                          std::vector<std::string>(1, remote_der));
 }
 
 // This test verifies that the stats are generated correctly when no
 // transport is present.
 TEST_F(StatsCollectorTest, NoTransport) {
@@ skipping 69 matching lines @@
 
   cricket::TransportStats transport_stats;
   transport_stats.transport_name = "audio";
   transport_stats.channel_stats.push_back(channel_stats);
 
   SessionStats session_stats;
   session_stats.transport_stats[transport_stats.transport_name] =
       transport_stats;
 
   // Fake transport object.
-  rtc::scoped_ptr<cricket::FakeTransport> transport(
+  std::unique_ptr<cricket::FakeTransport> transport(
       new cricket::FakeTransport(transport_stats.transport_name));
 
   // Configure MockWebRtcSession
   EXPECT_CALL(session_, GetTransportStats(_))
     .WillOnce(DoAll(SetArgPointee<0>(session_stats),
                     Return(true)));
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
   stats.GetStats(NULL, &reports);
 
   // Check that the local certificate is absent.
@@ skipping 13 matching lines @@
 
 // This test verifies that a remote certificate with an unsupported digest
 // algorithm is correctly ignored.
 TEST_F(StatsCollectorTest, UnsupportedDigestIgnored) {
   // Build a local certificate.
   std::string local_der = "This is the local der.";
   rtc::FakeSSLCertificate local_cert(DerToPem(local_der));
 
   // Build a remote certificate with an unsupported digest algorithm.
   std::string remote_der = "This is somebody else's der.";
-  rtc::scoped_ptr<rtc::FakeSSLCertificate> remote_cert(
+  std::unique_ptr<rtc::FakeSSLCertificate> remote_cert(
       new rtc::FakeSSLCertificate(DerToPem(remote_der)));
   remote_cert->set_digest_algorithm("foobar");
 
   TestCertificateReports(local_cert, std::vector<std::string>(1, local_der),
                          std::move(remote_cert), std::vector<std::string>());
 }
 
 // This test verifies that a local stats object can get statistics via
 // AudioTrackInterface::GetStats() method.
 TEST_F(StatsCollectorTest, GetStatsFromLocalAudioTrack) {
@@ skipping 253 matching lines @@
   cricket::VoiceSenderInfo new_voice_sender_info;
   InitVoiceSenderInfo(&new_voice_sender_info);
   cricket::VoiceMediaInfo new_stats_read;
   reports.clear();
   SetupAndVerifyAudioTrackStats(
       new_audio_track.get(), stream_.get(), &stats, &voice_channel, kVcName,
       media_channel, &new_voice_sender_info, NULL, &new_stats_read, &reports);
 }
 
 }  // namespace webrtc