Replace scoped_ptr with unique_ptr in webrtc/modules/audio_coding/neteq/

webrtc/modules/audio_coding/neteq/audio_decoder_unittest.cc

 /*
  *  Copyright (c) 2012 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 "webrtc/modules/audio_coding/neteq/audio_decoder_impl.h"
 
 #include <assert.h>
 #include <stdlib.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
-#include "webrtc/base/scoped_ptr.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/g722/audio_decoder_g722.h"
 #include "webrtc/modules/audio_coding/codecs/g722/audio_encoder_g722.h"
 #include "webrtc/modules/audio_coding/codecs/ilbc/audio_decoder_ilbc.h"
 #include "webrtc/modules/audio_coding/codecs/ilbc/audio_encoder_ilbc.h"
 #include "webrtc/modules/audio_coding/codecs/isac/fix/include/audio_decoder_isacfix.h"
 #include "webrtc/modules/audio_coding/codecs/isac/fix/include/audio_encoder_isacfix.h"
 #include "webrtc/modules/audio_coding/codecs/isac/main/include/audio_decoder_isac.h"
 #include "webrtc/modules/audio_coding/codecs/isac/main/include/audio_encoder_isac.h"
@@ skipping 108 matching lines @@
 
   // TODO(henrik.lundin) Change return type to size_t once most/all overriding
   // implementations are gone.
   virtual int EncodeFrame(const int16_t* input,
                           size_t input_len_samples,
                           uint8_t* output) {
     encoded_info_.encoded_bytes = 0;
     const size_t samples_per_10ms = audio_encoder_->SampleRateHz() / 100;
     RTC_CHECK_EQ(samples_per_10ms * audio_encoder_->Num10MsFramesInNextPacket(),
                  input_len_samples);
-    rtc::scoped_ptr<int16_t[]> interleaved_input(
+    std::unique_ptr<int16_t[]> interleaved_input(
         new int16_t[channels_ * samples_per_10ms]);
     for (size_t i = 0; i < audio_encoder_->Num10MsFramesInNextPacket(); ++i) {
       EXPECT_EQ(0u, encoded_info_.encoded_bytes);
 
       // Duplicate the mono input signal to however many channels the test
       // wants.
       test::InputAudioFile::DuplicateInterleaved(input + i * samples_per_10ms,
                                                  samples_per_10ms, channels_,
                                                  interleaved_input.get());
 
@@ skipping 56 matching lines @@
           decoded, processed_samples, channels_, channel_diff_tolerance);
     EXPECT_LE(
         MseInputOutput(input, decoded, processed_samples, channels_, delay),
         mse);
   }
 
   // Encodes a payload and decodes it twice with decoder re-init before each
   // decode. Verifies that the decoded result is the same.
   void ReInitTest() {
     InitEncoder();
-    rtc::scoped_ptr<int16_t[]> input(new int16_t[frame_size_]);
+    std::unique_ptr<int16_t[]> input(new int16_t[frame_size_]);
     ASSERT_TRUE(
         input_audio_.Read(frame_size_, codec_input_rate_hz_, input.get()));
     size_t enc_len = EncodeFrame(input.get(), frame_size_, encoded_);
     size_t dec_len;
     AudioDecoder::SpeechType speech_type1, speech_type2;
     decoder_->Reset();
-    rtc::scoped_ptr<int16_t[]> output1(new int16_t[frame_size_ * channels_]);
+    std::unique_ptr<int16_t[]> output1(new int16_t[frame_size_ * channels_]);
     dec_len = decoder_->Decode(encoded_, enc_len, codec_input_rate_hz_,
                                frame_size_ * channels_ * sizeof(int16_t),
                                output1.get(), &speech_type1);
     ASSERT_LE(dec_len, frame_size_ * channels_);
     EXPECT_EQ(frame_size_ * channels_, dec_len);
     // Re-init decoder and decode again.
     decoder_->Reset();
-    rtc::scoped_ptr<int16_t[]> output2(new int16_t[frame_size_ * channels_]);
+    std::unique_ptr<int16_t[]> output2(new int16_t[frame_size_ * channels_]);
     dec_len = decoder_->Decode(encoded_, enc_len, codec_input_rate_hz_,
                                frame_size_ * channels_ * sizeof(int16_t),
                                output2.get(), &speech_type2);
     ASSERT_LE(dec_len, frame_size_ * channels_);
     EXPECT_EQ(frame_size_ * channels_, dec_len);
     for (unsigned int n = 0; n < frame_size_; ++n) {
       ASSERT_EQ(output1[n], output2[n]) << "Exit test on first diff; n = " << n;
     }
     EXPECT_EQ(speech_type1, speech_type2);
   }
 
   // Call DecodePlc and verify that the correct number of samples is produced.
   void DecodePlcTest() {
     InitEncoder();
-    rtc::scoped_ptr<int16_t[]> input(new int16_t[frame_size_]);
+    std::unique_ptr<int16_t[]> input(new int16_t[frame_size_]);
     ASSERT_TRUE(
         input_audio_.Read(frame_size_, codec_input_rate_hz_, input.get()));
     size_t enc_len = EncodeFrame(input.get(), frame_size_, encoded_);
     AudioDecoder::SpeechType speech_type;
     decoder_->Reset();
-    rtc::scoped_ptr<int16_t[]> output(new int16_t[frame_size_ * channels_]);
+    std::unique_ptr<int16_t[]> output(new int16_t[frame_size_ * channels_]);
     size_t dec_len = decoder_->Decode(encoded_, enc_len, codec_input_rate_hz_,
                                       frame_size_ * channels_ * sizeof(int16_t),
                                       output.get(), &speech_type);
     EXPECT_EQ(frame_size_ * channels_, dec_len);
     // Call DecodePlc and verify that we get one frame of data.
     // (Overwrite the output from the above Decode call, but that does not
     // matter.)
     dec_len = decoder_->DecodePlc(1, output.get());
     EXPECT_EQ(frame_size_ * channels_, dec_len);
   }
 
   test::ResampleInputAudioFile input_audio_;
   int codec_input_rate_hz_;
   uint8_t* encoded_;
   size_t frame_size_;
   size_t data_length_;
   size_t encoded_bytes_;
   size_t channels_;
   const int payload_type_;
   AudioEncoder::EncodedInfo encoded_info_;
   AudioDecoder* decoder_;
-  rtc::scoped_ptr<AudioEncoder> audio_encoder_;
+  std::unique_ptr<AudioEncoder> audio_encoder_;
 };
 
 class AudioDecoderPcmUTest : public AudioDecoderTest {
  protected:
   AudioDecoderPcmUTest() : AudioDecoderTest() {
     frame_size_ = 160;
     data_length_ = 10 * frame_size_;
     decoder_ = new AudioDecoderPcmU(1);
     AudioEncoderPcmU::Config config;
     config.frame_size_ms = static_cast<int>(frame_size_ / 8);
@@ skipping 43 matching lines @@
     AudioEncoderIlbc::Config config;
     config.frame_size_ms = 30;
     config.payload_type = payload_type_;
     audio_encoder_.reset(new AudioEncoderIlbc(config));
   }
 
   // Overload the default test since iLBC's function WebRtcIlbcfix_NetEqPlc does
   // not return any data. It simply resets a few states and returns 0.
   void DecodePlcTest() {
     InitEncoder();
-    rtc::scoped_ptr<int16_t[]> input(new int16_t[frame_size_]);
+    std::unique_ptr<int16_t[]> input(new int16_t[frame_size_]);
     ASSERT_TRUE(
         input_audio_.Read(frame_size_, codec_input_rate_hz_, input.get()));
     size_t enc_len = EncodeFrame(input.get(), frame_size_, encoded_);
     AudioDecoder::SpeechType speech_type;
     decoder_->Reset();
-    rtc::scoped_ptr<int16_t[]> output(new int16_t[frame_size_ * channels_]);
+    std::unique_ptr<int16_t[]> output(new int16_t[frame_size_ * channels_]);
     size_t dec_len = decoder_->Decode(encoded_, enc_len, codec_input_rate_hz_,
                                       frame_size_ * channels_ * sizeof(int16_t),
                                       output.get(), &speech_type);
     EXPECT_EQ(frame_size_, dec_len);
     // Simply call DecodePlc and verify that we get 0 as return value.
     EXPECT_EQ(0U, decoder_->DecodePlc(1, output.get()));
   }
 };
 
 class AudioDecoderIsacFloatTest : public AudioDecoderTest {
@@ skipping 377 matching lines @@
   EXPECT_TRUE(CodecSupported(NetEqDecoder::kDecoderCNGnb));
   EXPECT_TRUE(CodecSupported(NetEqDecoder::kDecoderCNGwb));
   EXPECT_TRUE(CodecSupported(NetEqDecoder::kDecoderCNGswb32kHz));
   EXPECT_TRUE(CodecSupported(NetEqDecoder::kDecoderCNGswb48kHz));
   EXPECT_TRUE(CodecSupported(NetEqDecoder::kDecoderArbitrary));
   EXPECT_EQ(has_opus, CodecSupported(NetEqDecoder::kDecoderOpus));
   EXPECT_EQ(has_opus, CodecSupported(NetEqDecoder::kDecoderOpus_2ch));
 }
 
 }  // namespace webrtc