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

webrtc/modules/audio_processing/test/process_test.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 <string.h>
 #ifdef WEBRTC_ANDROID
 #include <sys/stat.h>
 #endif
 
 #include <algorithm>
+#include <memory>
 
 #include "webrtc/base/format_macros.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/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"
 #include "webrtc/system_wrappers/include/cpu_features_wrapper.h"
 #include "webrtc/system_wrappers/include/tick_util.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/test/testsupport/perf_test.h"
 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD
@@ skipping 107 matching lines @@
   if (argc > 1 && strcmp(argv[1], "--help") == 0) {
     usage();
     return;
   }
 
   if (argc < 2) {
     printf("Did you mean to run without arguments?\n");
     printf("Try `process_test --help' for more information.\n\n");
   }
 
-  rtc::scoped_ptr<AudioProcessing> apm(AudioProcessing::Create());
+  std::unique_ptr<AudioProcessing> apm(AudioProcessing::Create());
   ASSERT_TRUE(apm.get() != NULL);
 
   const char* pb_filename = NULL;
   const char* far_filename = NULL;
   const char* near_filename = NULL;
   std::string out_filename;
   const char* vad_out_filename = NULL;
   const char* ns_prob_filename = NULL;
   const char* aecm_echo_path_in_filename = NULL;
   const char* aecm_echo_path_out_filename = NULL;
@@ skipping 324 matching lines @@
   FILE* far_file = NULL;
   FILE* near_file = NULL;
   FILE* event_file = NULL;
   FILE* delay_file = NULL;
   FILE* drift_file = NULL;
   FILE* vad_out_file = NULL;
   FILE* ns_prob_file = NULL;
   FILE* aecm_echo_path_in_file = NULL;
   FILE* aecm_echo_path_out_file = NULL;
 
-  rtc::scoped_ptr<WavWriter> output_wav_file;
-  rtc::scoped_ptr<RawFile> output_raw_file;
+  std::unique_ptr<WavWriter> output_wav_file;
+  std::unique_ptr<RawFile> output_raw_file;
 
   if (pb_filename) {
     pb_file = OpenFile(pb_filename, "rb");
   } else {
     if (far_filename) {
       far_file = OpenFile(far_filename, "rb");
     }
 
     near_file = OpenFile(near_filename, "rb");
     if (!simulating) {
@@ skipping 21 matching lines @@
 
   if (apm->noise_suppression()->is_enabled()) {
     ns_prob_file = OpenFile(ns_prob_filename, "wb");
   }
 
   if (aecm_echo_path_in_filename != NULL) {
     aecm_echo_path_in_file = OpenFile(aecm_echo_path_in_filename, "rb");
 
     const size_t path_size =
         apm->echo_control_mobile()->echo_path_size_bytes();
-    rtc::scoped_ptr<char[]> echo_path(new char[path_size]);
+    std::unique_ptr<char[]> echo_path(new char[path_size]);
     ASSERT_EQ(path_size, fread(echo_path.get(),
                                sizeof(char),
                                path_size,
                                aecm_echo_path_in_file));
     EXPECT_EQ(apm->kNoError,
               apm->echo_control_mobile()->SetEchoPath(echo_path.get(),
                                                       path_size));
     fclose(aecm_echo_path_in_file);
     aecm_echo_path_in_file = NULL;
   }
@@ skipping 21 matching lines @@
   TickTime t1 = t0;
   int64_t max_time_us = 0;
   int64_t max_time_reverse_us = 0;
   int64_t min_time_us = 1e6;
   int64_t min_time_reverse_us = 1e6;
 
   // TODO(ajm): Ideally we would refactor this block into separate functions,
   //            but for now we want to share the variables.
   if (pb_file) {
     Event event_msg;
-    rtc::scoped_ptr<ChannelBuffer<float> > reverse_cb;
-    rtc::scoped_ptr<ChannelBuffer<float> > primary_cb;
+    std::unique_ptr<ChannelBuffer<float> > reverse_cb;
+    std::unique_ptr<ChannelBuffer<float> > primary_cb;
     int output_sample_rate = 32000;
     AudioProcessing::ChannelLayout output_layout = AudioProcessing::kMono;
     while (ReadMessageFromFile(pb_file, &event_msg)) {
       std::ostringstream trace_stream;
       trace_stream << "Processed frames: " << reverse_count << " (reverse), "
                    << primary_count << " (primary)";
       SCOPED_TRACE(trace_stream.str());
 
       if (event_msg.type() == Event::INIT) {
         ASSERT_TRUE(event_msg.has_init());
@@ skipping 463 matching lines @@
       }
     }
   }
   if (progress) {
     printf("100%% complete\r");
   }
 
   if (aecm_echo_path_out_file != NULL) {
     const size_t path_size =
         apm->echo_control_mobile()->echo_path_size_bytes();
-    rtc::scoped_ptr<char[]> echo_path(new char[path_size]);
+    std::unique_ptr<char[]> echo_path(new char[path_size]);
     apm->echo_control_mobile()->GetEchoPath(echo_path.get(), path_size);
     ASSERT_EQ(path_size, fwrite(echo_path.get(),
                                 sizeof(char),
                                 path_size,
                                 aecm_echo_path_out_file));
     fclose(aecm_echo_path_out_file);
     aecm_echo_path_out_file = NULL;
   }
 
   if (verbose) {
@@ skipping 71 matching lines @@
 }  // namespace
 }  // namespace webrtc
 
 int main(int argc, char* argv[]) {
   webrtc::void_main(argc, argv);
 
   // Optional, but removes memory leak noise from Valgrind.
   google::protobuf::ShutdownProtobufLibrary();
   return 0;
 }