Replace scoped_ptr with unique_ptr in webrtc/modules/audio_coding/

webrtc/modules/audio_coding/acm2/audio_coding_module_unittest_oldapi.cc

 /*
  *  Copyright (c) 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.
  */
 
 #include <stdio.h>
 #include <string.h>
+#include <memory>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/md5digest.h"
 #include "webrtc/base/platform_thread.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/modules/audio_coding/acm2/acm_receive_test_oldapi.h"
 #include "webrtc/modules/audio_coding/acm2/acm_send_test_oldapi.h"
 #include "webrtc/modules/audio_coding/codecs/audio_encoder.h"
 #include "webrtc/modules/audio_coding/codecs/g711/audio_decoder_pcm.h"
 #include "webrtc/modules/audio_coding/codecs/g711/audio_encoder_pcm.h"
 #include "webrtc/modules/audio_coding/codecs/isac/main/include/audio_encoder_isac.h"
 #include "webrtc/modules/audio_coding/codecs/mock/mock_audio_encoder.h"
 #include "webrtc/modules/audio_coding/include/audio_coding_module.h"
 #include "webrtc/modules/audio_coding/include/audio_coding_module_typedefs.h"
@@ skipping 188 matching lines @@
     EXPECT_TRUE(last_length == 2 * codec_.pacsize || last_length == 0)
         << "Last encoded packet was " << last_length << " bytes.";
   }
 
   virtual void InsertAudioAndVerifyEncoding() {
     InsertAudio();
     VerifyEncoding();
   }
 
   const int id_;
-  rtc::scoped_ptr<RtpUtility> rtp_utility_;
-  rtc::scoped_ptr<AudioCodingModule> acm_;
+  std::unique_ptr<RtpUtility> rtp_utility_;
+  std::unique_ptr<AudioCodingModule> acm_;
   PacketizationCallbackStubOldApi packet_cb_;
   WebRtcRTPHeader rtp_header_;
   AudioFrame input_frame_;
   CodecInst codec_;
   Clock* clock_;
 };
 
 // Check if the statistics are initialized correctly. Before any call to ACM
 // all fields have to be zero.
 #if defined(WEBRTC_ANDROID)
@@ skipping 328 matching lines @@
     }
     // Now we're not holding the crit sect when calling ACM.
     PullAudio();
     fake_clock_->AdvanceTimeMilliseconds(10);
     return true;
   }
 
   rtc::PlatformThread send_thread_;
   rtc::PlatformThread insert_packet_thread_;
   rtc::PlatformThread pull_audio_thread_;
-  const rtc::scoped_ptr<EventWrapper> test_complete_;
+  const std::unique_ptr<EventWrapper> test_complete_;
   int send_count_;
   int insert_packet_count_;
   int pull_audio_count_ GUARDED_BY(crit_sect_);
   rtc::CriticalSection crit_sect_;
   int64_t next_insert_packet_time_ms_ GUARDED_BY(crit_sect_);
-  rtc::scoped_ptr<SimulatedClock> fake_clock_;
+  std::unique_ptr<SimulatedClock> fake_clock_;
 };
 
 #if defined(WEBRTC_IOS)
 #define MAYBE_DoTest DISABLED_DoTest
 #else
 #define MAYBE_DoTest DoTest
 #endif
 TEST_F(AudioCodingModuleMtTestOldApi, MAYBE_DoTest) {
   EXPECT_EQ(kEventSignaled, RunTest());
 }
@@ skipping 173 matching lines @@
   }
 
   static bool CbReceiveThread(void* context) {
     return reinterpret_cast<AcmReRegisterIsacMtTestOldApi*>(context)
         ->CbReceiveImpl();
   }
 
   bool CbReceiveImpl() {
     SleepMs(1);
     const size_t max_encoded_bytes = isac_encoder_->MaxEncodedBytes();
-    rtc::scoped_ptr<uint8_t[]> encoded(new uint8_t[max_encoded_bytes]);
+    std::unique_ptr<uint8_t[]> encoded(new uint8_t[max_encoded_bytes]);
     AudioEncoder::EncodedInfo info;
     {
       rtc::CritScope lock(&crit_sect_);
       if (clock_->TimeInMilliseconds() < next_insert_packet_time_ms_) {
         return true;
       }
       next_insert_packet_time_ms_ += kPacketSizeMs;
       ++receive_packet_count_;
 
       // Encode new frame.
@@ skipping 45 matching lines @@
       codec_registered_ = true;
     }
     if (codec_registered_ && receive_packet_count_ > kNumPackets) {
       test_complete_->Set();
     }
     return true;
   }
 
   rtc::PlatformThread receive_thread_;
   rtc::PlatformThread codec_registration_thread_;
-  const rtc::scoped_ptr<EventWrapper> test_complete_;
+  const std::unique_ptr<EventWrapper> test_complete_;
   rtc::CriticalSection crit_sect_;
   bool codec_registered_ GUARDED_BY(crit_sect_);
   int receive_packet_count_ GUARDED_BY(crit_sect_);
   int64_t next_insert_packet_time_ms_ GUARDED_BY(crit_sect_);
-  rtc::scoped_ptr<AudioEncoderIsac> isac_encoder_;
-  rtc::scoped_ptr<SimulatedClock> fake_clock_;
+  std::unique_ptr<AudioEncoderIsac> isac_encoder_;
+  std::unique_ptr<SimulatedClock> fake_clock_;
   test::AudioLoop audio_loop_;
 };
 
 #if defined(WEBRTC_IOS)
 #define MAYBE_DoTest DISABLED_DoTest
 #else
 #define MAYBE_DoTest DoTest
 #endif
 #if defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)
 TEST_F(AcmReRegisterIsacMtTestOldApi, MAYBE_DoTest) {
@@ skipping 29 matching lines @@
     int sample_rate_hz;
     int num_channels;
     std::string name;
   };
 
   void Run(int output_freq_hz,
            const std::string& checksum_ref,
            const std::vector<ExternalDecoder>& external_decoders) {
     const std::string input_file_name =
         webrtc::test::ResourcePath("audio_coding/neteq_universal_new", "rtp");
-    rtc::scoped_ptr<test::RtpFileSource> packet_source(
+    std::unique_ptr<test::RtpFileSource> packet_source(
         test::RtpFileSource::Create(input_file_name));
 #ifdef WEBRTC_ANDROID
     // Filter out iLBC and iSAC-swb since they are not supported on Android.
     packet_source->FilterOutPayloadType(102);  // iLBC.
     packet_source->FilterOutPayloadType(104);  // iSAC-swb.
 #endif
 
     test::AudioChecksum checksum;
     const std::string output_file_name =
         webrtc::test::OutputPath() +
@@ skipping 281 matching lines @@
                                   codec_frame_size_rtp_timestamps));
   }
 
   void SetUpTestExternalEncoder(AudioEncoder* external_speech_encoder,
                                 int payload_type) {
     ASSERT_TRUE(SetUpSender());
     ASSERT_TRUE(
         RegisterExternalSendCodec(external_speech_encoder, payload_type));
   }
 
-  rtc::scoped_ptr<test::AcmSendTestOldApi> send_test_;
-  rtc::scoped_ptr<test::InputAudioFile> audio_source_;
+  std::unique_ptr<test::AcmSendTestOldApi> send_test_;
+  std::unique_ptr<test::InputAudioFile> audio_source_;
   uint32_t frame_size_rtp_timestamps_;
   int packet_count_;
   uint8_t payload_type_;
   uint16_t last_sequence_number_;
   uint32_t last_timestamp_;
   rtc::Md5Digest payload_checksum_;
 };
 
 #if defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)
 TEST_F(AcmSenderBitExactnessOldApi, IsacWb30ms) {
@@ skipping 269 matching lines @@
                  int channels,
                  int payload_type,
                  int codec_frame_size_samples,
                  int codec_frame_size_rtp_timestamps) {
     ASSERT_TRUE(SetUpSender());
     ASSERT_TRUE(RegisterSendCodec(codec_name, codec_sample_rate_hz, channels,
                                   payload_type, codec_frame_size_samples,
                                   codec_frame_size_rtp_timestamps));
   }
 
-  rtc::scoped_ptr<test::AcmSendTestOldApi> send_test_;
-  rtc::scoped_ptr<test::InputAudioFile> audio_source_;
+  std::unique_ptr<test::AcmSendTestOldApi> send_test_;
+  std::unique_ptr<test::InputAudioFile> audio_source_;
 };
 
 TEST_F(AcmSetBitRateOldApi, Opus_48khz_20ms_10kbps) {
   ASSERT_NO_FATAL_FAILURE(SetUpTest("opus", 48000, 1, 107, 960, 960));
 #if defined(WEBRTC_ANDROID)
   Run(10000, 9288);
 #else
   Run(10000, 9024);
 #endif // WEBRTC_ANDROID
 
@@ skipping 272 matching lines @@
   Run(16000, 8000, 1000);
 }
 
 TEST_F(AcmSwitchingOutputFrequencyOldApi, Toggle8KhzTo16Khz) {
   Run(8000, 16000, 1000);
 }
 
 #endif
 
 }  // namespace webrtc