Replace scoped_ptr with unique_ptr in webrtc/modules/audio_processing/

webrtc/modules/audio_processing/audio_processing_impl.h

 /*
  *  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.
  */
 
 #ifndef WEBRTC_MODULES_AUDIO_PROCESSING_AUDIO_PROCESSING_IMPL_H_
 #define WEBRTC_MODULES_AUDIO_PROCESSING_AUDIO_PROCESSING_IMPL_H_
 
 #include <list>
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "webrtc/base/criticalsection.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/modules/audio_processing/audio_buffer.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
 #include "webrtc/system_wrappers/include/file_wrapper.h"
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 // Files generated at build-time by the protobuf compiler.
 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD
 #include "external/webrtc/webrtc/modules/audio_processing/debug.pb.h"
 #else
@@ skipping 100 matching lines @@
       EXCLUSIVE_LOCKS_REQUIRED(crit_render_, crit_capture_);
 
  private:
   struct ApmPublicSubmodules;
   struct ApmPrivateSubmodules;
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   // State for the debug dump.
   struct ApmDebugDumpThreadState {
     ApmDebugDumpThreadState() : event_msg(new audioproc::Event()) {}
-    rtc::scoped_ptr<audioproc::Event> event_msg;  // Protobuf message.
+    std::unique_ptr<audioproc::Event> event_msg;  // Protobuf message.
     std::string event_str;  // Memory for protobuf serialization.
 
     // Serialized string of last saved APM configuration.
     std::string last_serialized_config;
   };
 
   struct ApmDebugDumpState {
     ApmDebugDumpState() : debug_file(FileWrapper::Create()) {}
     // Number of bytes that can still be written to the log before the maximum
     // size is reached. A value of <= 0 indicates that no limit is used.
     int64_t num_bytes_left_for_log_ = -1;
-    rtc::scoped_ptr<FileWrapper> debug_file;
+    std::unique_ptr<FileWrapper> debug_file;
     ApmDebugDumpThreadState render;
     ApmDebugDumpThreadState capture;
   };
 #endif
 
   // Method for modifying the formats struct that are called from both
   // the render and capture threads. The check for whether modifications
   // are needed is done while holding the render lock only, thereby avoiding
   // that the capture thread blocks the render thread.
   // The struct is modified in a single-threaded manner by holding both the
@@ skipping 80 matching lines @@
 
   // Debug dump state.
   ApmDebugDumpState debug_dump_;
 #endif
 
   // Critical sections.
   rtc::CriticalSection crit_render_ ACQUIRED_BEFORE(crit_capture_);
   rtc::CriticalSection crit_capture_;
 
   // Structs containing the pointers to the submodules.
-  rtc::scoped_ptr<ApmPublicSubmodules> public_submodules_;
-  rtc::scoped_ptr<ApmPrivateSubmodules> private_submodules_
+  std::unique_ptr<ApmPublicSubmodules> public_submodules_;
+  std::unique_ptr<ApmPrivateSubmodules> private_submodules_
       GUARDED_BY(crit_capture_);
 
   // State that is written to while holding both the render and capture locks
   // but can be read without any lock being held.
   // As this is only accessed internally of APM, and all internal methods in APM
   // either are holding the render or capture locks, this construct is safe as
   // it is not possible to read the variables while writing them.
   struct ApmFormatState {
     ApmFormatState()
         :  // Format of processing streams at input/output call sites.
@@ skipping 41 matching lines @@
     int delay_offset_ms;
     bool was_stream_delay_set;
     int last_stream_delay_ms;
     int last_aec_system_delay_ms;
     int stream_delay_jumps;
     bool output_will_be_muted;
     bool key_pressed;
     bool transient_suppressor_enabled;
     std::vector<Point> array_geometry;
     SphericalPointf target_direction;
-    rtc::scoped_ptr<AudioBuffer> capture_audio;
+    std::unique_ptr<AudioBuffer> capture_audio;
     // Only the rate and samples fields of fwd_proc_format_ are used because the
     // forward processing number of channels is mutable and is tracked by the
     // capture_audio_.
     StreamConfig fwd_proc_format;
     int split_rate;
   } capture_ GUARDED_BY(crit_capture_);
 
   struct ApmCaptureNonLockedState {
     ApmCaptureNonLockedState(bool beamformer_enabled)
         : fwd_proc_format(kSampleRate16kHz),
           split_rate(kSampleRate16kHz),
           stream_delay_ms(0),
           beamformer_enabled(beamformer_enabled) {}
     // Only the rate and samples fields of fwd_proc_format_ are used because the
     // forward processing number of channels is mutable and is tracked by the
     // capture_audio_.
     StreamConfig fwd_proc_format;
     int split_rate;
     int stream_delay_ms;
     bool beamformer_enabled;
   } capture_nonlocked_;
 
   struct ApmRenderState {
-    rtc::scoped_ptr<AudioConverter> render_converter;
-    rtc::scoped_ptr<AudioBuffer> render_audio;
+    std::unique_ptr<AudioConverter> render_converter;
+    std::unique_ptr<AudioBuffer> render_audio;
   } render_ GUARDED_BY(crit_render_);
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_AUDIO_PROCESSING_AUDIO_PROCESSING_IMPL_H_