Replace scoped_ptr with unique_ptr in webrtc/modules/audio_processing/test/

webrtc/modules/audio_processing/test/audio_processing_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 <math.h>
 #include <stdio.h>
+
 #include <algorithm>
 #include <limits>
+#include <memory>
 #include <queue>
 
 #include "webrtc/base/arraysize.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/common_audio/include/audio_util.h"
 #include "webrtc/common_audio/resampler/include/push_resampler.h"
 #include "webrtc/common_audio/resampler/push_sinc_resampler.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/modules/audio_processing/beamformer/mock_nonlinear_beamformer.h"
 #include "webrtc/modules/audio_processing/common.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
 #include "webrtc/modules/audio_processing/test/protobuf_utils.h"
 #include "webrtc/modules/audio_processing/test/test_utils.h"
 #include "webrtc/modules/include/module_common_types.h"
@@ skipping 190 matching lines @@
 #endif
 
 void OpenFileAndWriteMessage(const std::string filename,
                              const ::google::protobuf::MessageLite& msg) {
 #if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
   FILE* file = fopen(filename.c_str(), "wb");
   ASSERT_TRUE(file != NULL);
 
   int32_t size = msg.ByteSize();
   ASSERT_GT(size, 0);
-  rtc::scoped_ptr<uint8_t[]> array(new uint8_t[size]);
+  std::unique_ptr<uint8_t[]> array(new uint8_t[size]);
   ASSERT_TRUE(msg.SerializeToArray(array.get(), size));
 
   ASSERT_EQ(1u, fwrite(&size, sizeof(size), 1, file));
   ASSERT_EQ(static_cast<size_t>(size),
       fwrite(array.get(), sizeof(array[0]), size, file));
   fclose(file);
 #else
   std::cout << "Warning: Writing new reference is only allowed on Linux!"
       << std::endl;
 #endif
@@ skipping 143 matching lines @@
   int AnalyzeReverseStreamChooser(Format format);
   void ProcessDebugDump(const std::string& in_filename,
                         const std::string& out_filename,
                         Format format,
                         int max_size_bytes);
   void VerifyDebugDumpTest(Format format);
 
   const std::string output_path_;
   const std::string ref_path_;
   const std::string ref_filename_;
-  rtc::scoped_ptr<AudioProcessing> apm_;
+  std::unique_ptr<AudioProcessing> apm_;
   AudioFrame* frame_;
   AudioFrame* revframe_;
-  rtc::scoped_ptr<ChannelBuffer<float> > float_cb_;
-  rtc::scoped_ptr<ChannelBuffer<float> > revfloat_cb_;
+  std::unique_ptr<ChannelBuffer<float> > float_cb_;
+  std::unique_ptr<ChannelBuffer<float> > revfloat_cb_;
   int output_sample_rate_hz_;
   size_t num_output_channels_;
   FILE* far_file_;
   FILE* near_file_;
   FILE* out_file_;
 };
 
 ApmTest::ApmTest()
     : output_path_(test::OutputPath()),
       ref_path_(test::ProjectRootPath() + "data/audio_processing/"),
@@ skipping 664 matching lines @@
   // Turn comfort noise off/on
   EXPECT_EQ(apm_->kNoError,
       apm_->echo_control_mobile()->enable_comfort_noise(false));
   EXPECT_FALSE(apm_->echo_control_mobile()->is_comfort_noise_enabled());
   EXPECT_EQ(apm_->kNoError,
       apm_->echo_control_mobile()->enable_comfort_noise(true));
   EXPECT_TRUE(apm_->echo_control_mobile()->is_comfort_noise_enabled());
   // Set and get echo path
   const size_t echo_path_size =
       apm_->echo_control_mobile()->echo_path_size_bytes();
-  rtc::scoped_ptr<char[]> echo_path_in(new char[echo_path_size]);
-  rtc::scoped_ptr<char[]> echo_path_out(new char[echo_path_size]);
+  std::unique_ptr<char[]> echo_path_in(new char[echo_path_size]);
+  std::unique_ptr<char[]> echo_path_out(new char[echo_path_size]);
   EXPECT_EQ(apm_->kNullPointerError,
             apm_->echo_control_mobile()->SetEchoPath(NULL, echo_path_size));
   EXPECT_EQ(apm_->kNullPointerError,
             apm_->echo_control_mobile()->GetEchoPath(NULL, echo_path_size));
   EXPECT_EQ(apm_->kBadParameterError,
             apm_->echo_control_mobile()->GetEchoPath(echo_path_out.get(), 1));
   EXPECT_EQ(apm_->kNoError,
             apm_->echo_control_mobile()->GetEchoPath(echo_path_out.get(),
                                                      echo_path_size));
   for (size_t i = 0; i < echo_path_size; i++) {
@@ skipping 204 matching lines @@
   const size_t kNumOutputChannels = 1;
   const size_t kNumChunks = 700;
   const float kScaleFactor = 0.25f;
   Config config;
   std::vector<webrtc::Point> geometry;
   geometry.push_back(webrtc::Point(0.f, 0.f, 0.f));
   geometry.push_back(webrtc::Point(0.05f, 0.f, 0.f));
   config.Set<Beamforming>(new Beamforming(true, geometry));
   testing::NiceMock<MockNonlinearBeamformer>* beamformer =
       new testing::NiceMock<MockNonlinearBeamformer>(geometry);
-  rtc::scoped_ptr<AudioProcessing> apm(
+  std::unique_ptr<AudioProcessing> apm(
       AudioProcessing::Create(config, beamformer));
   EXPECT_EQ(kNoErr, apm->gain_control()->Enable(true));
   ChannelBuffer<float> src_buf(kSamplesPerChannel, kNumInputChannels);
   ChannelBuffer<float> dest_buf(kSamplesPerChannel, kNumOutputChannels);
   const size_t max_length = kSamplesPerChannel * std::max(kNumInputChannels,
                                                           kNumOutputChannels);
-  rtc::scoped_ptr<int16_t[]> int_data(new int16_t[max_length]);
-  rtc::scoped_ptr<float[]> float_data(new float[max_length]);
+  std::unique_ptr<int16_t[]> int_data(new int16_t[max_length]);
+  std::unique_ptr<float[]> float_data(new float[max_length]);
   std::string filename = ResourceFilePath("far", kSampleRateHz);
   FILE* far_file = fopen(filename.c_str(), "rb");
   ASSERT_TRUE(far_file != NULL) << "Could not open file " << filename << "\n";
   const int kDefaultVolume = apm->gain_control()->stream_analog_level();
   const int kDefaultCompressionGain =
       apm->gain_control()->compression_gain_db();
   bool is_target = false;
   EXPECT_CALL(*beamformer, is_target_present())
       .WillRepeatedly(testing::ReturnPointee(&is_target));
   for (size_t i = 0; i < kNumChunks; ++i) {
@@ skipping 494 matching lines @@
   ProcessDebugDump(in_filename, ref_filename, format, -1);
   ProcessDebugDump(ref_filename, out_filename, format, -1);
   ProcessDebugDump(ref_filename, limited_filename, format, logging_limit_bytes);
 
   FILE* ref_file = fopen(ref_filename.c_str(), "rb");
   FILE* out_file = fopen(out_filename.c_str(), "rb");
   FILE* limited_file = fopen(limited_filename.c_str(), "rb");
   ASSERT_TRUE(ref_file != NULL);
   ASSERT_TRUE(out_file != NULL);
   ASSERT_TRUE(limited_file != NULL);
-  rtc::scoped_ptr<uint8_t[]> ref_bytes;
-  rtc::scoped_ptr<uint8_t[]> out_bytes;
-  rtc::scoped_ptr<uint8_t[]> limited_bytes;
+  std::unique_ptr<uint8_t[]> ref_bytes;
+  std::unique_ptr<uint8_t[]> out_bytes;
+  std::unique_ptr<uint8_t[]> limited_bytes;
 
   size_t ref_size = ReadMessageBytesFromFile(ref_file, &ref_bytes);
   size_t out_size = ReadMessageBytesFromFile(out_file, &out_bytes);
   size_t limited_size = ReadMessageBytesFromFile(limited_file, &limited_bytes);
   size_t bytes_read = 0;
   size_t bytes_read_limited = 0;
   while (ref_size > 0 && out_size > 0) {
     bytes_read += ref_size;
     bytes_read_limited += limited_size;
     EXPECT_EQ(ref_size, out_size);
@@ skipping 93 matching lines @@
   ASSERT_EQ(0, fclose(fid));
 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 }
 
 TEST_F(ApmTest, FloatAndIntInterfacesGiveSimilarResults) {
   audioproc::OutputData ref_data;
   OpenFileAndReadMessage(ref_filename_, &ref_data);
 
   Config config;
   config.Set<ExperimentalAgc>(new ExperimentalAgc(false));
-  rtc::scoped_ptr<AudioProcessing> fapm(AudioProcessing::Create(config));
+  std::unique_ptr<AudioProcessing> fapm(AudioProcessing::Create(config));
   EnableAllComponents();
   EnableAllAPComponents(fapm.get());
   for (int i = 0; i < ref_data.test_size(); i++) {
     printf("Running test %d of %d...\n", i + 1, ref_data.test_size());
 
     audioproc::Test* test = ref_data.mutable_test(i);
     // TODO(ajm): Restore downmixing test cases.
     if (test->num_input_channels() != test->num_output_channels())
       continue;
 
@@ skipping 320 matching lines @@
   struct ChannelFormat {
     AudioProcessing::ChannelLayout in_layout;
     AudioProcessing::ChannelLayout out_layout;
   };
   ChannelFormat cf[] = {
     {AudioProcessing::kMonoAndKeyboard, AudioProcessing::kMono},
     {AudioProcessing::kStereoAndKeyboard, AudioProcessing::kMono},
     {AudioProcessing::kStereoAndKeyboard, AudioProcessing::kStereo},
   };
 
-  rtc::scoped_ptr<AudioProcessing> ap(AudioProcessing::Create());
+  std::unique_ptr<AudioProcessing> ap(AudioProcessing::Create());
   // Enable one component just to ensure some processing takes place.
   ap->noise_suppression()->Enable(true);
   for (size_t i = 0; i < arraysize(cf); ++i) {
     const int in_rate = 44100;
     const int out_rate = 48000;
     ChannelBuffer<float> in_cb(SamplesFromRate(in_rate),
                                TotalChannelsFromLayout(cf[i].in_layout));
     ChannelBuffer<float> out_cb(SamplesFromRate(out_rate),
                                 ChannelsFromLayout(cf[i].out_layout));
 
@@ skipping 104 matching lines @@
                             int output_rate,
                             int reverse_input_rate,
                             int reverse_output_rate,
                             size_t num_input_channels,
                             size_t num_output_channels,
                             size_t num_reverse_input_channels,
                             size_t num_reverse_output_channels,
                             std::string output_file_prefix) {
     Config config;
     config.Set<ExperimentalAgc>(new ExperimentalAgc(false));
-    rtc::scoped_ptr<AudioProcessing> ap(AudioProcessing::Create(config));
+    std::unique_ptr<AudioProcessing> ap(AudioProcessing::Create(config));
     EnableAllAPComponents(ap.get());
 
     ProcessingConfig processing_config = {
         {{input_rate, num_input_channels},
          {output_rate, num_output_channels},
          {reverse_input_rate, num_reverse_input_channels},
          {reverse_output_rate, num_reverse_output_channels}}};
     ap->Initialize(processing_config);
 
     FILE* far_file =
@@ skipping 24 matching lines @@
                                 num_reverse_input_channels);
     ChannelBuffer<float> out_cb(SamplesFromRate(output_rate),
                                 num_output_channels);
     ChannelBuffer<float> rev_out_cb(SamplesFromRate(reverse_output_rate),
                                     num_reverse_output_channels);
 
     // Temporary buffers.
     const int max_length =
         2 * std::max(std::max(out_cb.num_frames(), rev_out_cb.num_frames()),
                      std::max(fwd_cb.num_frames(), rev_cb.num_frames()));
-    rtc::scoped_ptr<float[]> float_data(new float[max_length]);
-    rtc::scoped_ptr<int16_t[]> int_data(new int16_t[max_length]);
+    std::unique_ptr<float[]> float_data(new float[max_length]);
+    std::unique_ptr<int16_t[]> int_data(new int16_t[max_length]);
 
     int analog_level = 127;
     while (ReadChunk(far_file, int_data.get(), float_data.get(), &rev_cb) &&
            ReadChunk(near_file, int_data.get(), float_data.get(), &fwd_cb)) {
       EXPECT_NOERR(ap->ProcessReverseStream(
           rev_cb.channels(), processing_config.reverse_input_stream(),
           processing_config.reverse_output_stream(), rev_out_cb.channels()));
 
       EXPECT_NOERR(ap->set_stream_delay_ms(0));
       ap->echo_cancellation()->set_stream_drift_samples(0);
@@ skipping 106 matching lines @@
                          cf[i].num_output, cf[i].num_output,
                          cf[i].num_reverse_output, cf[i].num_reverse_output,
                          file_direction).c_str(),
           "rb");
       ASSERT_TRUE(out_file != NULL);
       ASSERT_TRUE(ref_file != NULL);
 
       const size_t ref_length = SamplesFromRate(ref_rate) * out_num;
       const size_t out_length = SamplesFromRate(out_rate) * out_num;
       // Data from the reference file.
-      rtc::scoped_ptr<float[]> ref_data(new float[ref_length]);
+      std::unique_ptr<float[]> ref_data(new float[ref_length]);
       // Data from the output file.
-      rtc::scoped_ptr<float[]> out_data(new float[out_length]);
+      std::unique_ptr<float[]> out_data(new float[out_length]);
       // Data from the resampled output, in case the reference and output rates
       // don't match.
-      rtc::scoped_ptr<float[]> cmp_data(new float[ref_length]);
+      std::unique_ptr<float[]> cmp_data(new float[ref_length]);
 
       PushResampler<float> resampler;
       resampler.InitializeIfNeeded(out_rate, ref_rate, out_num);
 
       // Compute the resampling delay of the output relative to the reference,
       // to find the region over which we should search for the best SNR.
       float expected_delay_sec = 0;
       if (in_rate != ref_rate) {
         // Input resampling delay.
         expected_delay_sec +=
@@ skipping 161 matching lines @@
                     std::tr1::make_tuple(16000, 32000, 48000, 32000, 25, 35),
                     std::tr1::make_tuple(16000, 32000, 32000, 32000, 25, 0),
                     std::tr1::make_tuple(16000, 32000, 16000, 32000, 25, 20),
                     std::tr1::make_tuple(16000, 16000, 48000, 16000, 35, 20),
                     std::tr1::make_tuple(16000, 16000, 32000, 16000, 40, 20),
                     std::tr1::make_tuple(16000, 16000, 16000, 16000, 0, 0)));
 #endif
 
 }  // namespace
 }  // namespace webrtc