Convert //media/audio from scoped_ptr to std::unique_ptr

media/audio/audio_input_controller.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef MEDIA_AUDIO_AUDIO_INPUT_CONTROLLER_H_
 #define MEDIA_AUDIO_AUDIO_INPUT_CONTROLLER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 
 #include "base/atomicops.h"
 #include "base/callback.h"
 #include "base/files/file.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/timer/timer.h"
 #include "build/build_config.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_parameters.h"
 
@@ skipping 256 matching lines @@
                 const AudioParameters& params,
                 const std::string& device_id);
   void DoCreateForLowLatency(AudioManager* audio_manager,
                              const AudioParameters& params,
                              const std::string& device_id);
   void DoCreateForStream(AudioInputStream* stream_to_control);
   void DoRecord();
   void DoClose();
   void DoReportError();
   void DoSetVolume(double volume);
-  void DoOnData(scoped_ptr<AudioBus> data);
+  void DoOnData(std::unique_ptr<AudioBus> data);
   void DoLogAudioLevels(float level_dbfs, int microphone_volume_percent);
 
   // Method to check if we get recorded data after a stream was started,
   // and log the result to UMA.
   void FirstCheckForNoData();
 
   // Method which ensures that OnError() is triggered when data recording
   // times out. Called on the audio thread.
   void DoCheckForNoData();
 
@@ skipping 11 matching lines @@
   // Logs the silence state as UMA stat.
   void LogSilenceState(SilenceState value);
 #endif
 
   // Enable and disable debug recording of audio input. Called on the audio
   // thread.
   void DoEnableDebugRecording(AudioInputWriter* input_writer);
   void DoDisableDebugRecording();
 
   // Called on the audio thread.
-  void WriteInputDataForDebugging(scoped_ptr<AudioBus> data);
+  void WriteInputDataForDebugging(std::unique_ptr<AudioBus> data);
 
   // Gives access to the task runner of the creating thread.
   scoped_refptr<base::SingleThreadTaskRunner> creator_task_runner_;
 
   // The task runner of audio-manager thread that this object runs on.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   // Contains the AudioInputController::EventHandler which receives state
   // notifications from this class.
   EventHandler* handler_;
 
   // Pointer to the audio input stream object.
   AudioInputStream* stream_;
 
   // |no_data_timer_| is used to call OnError() when we stop receiving
   // OnData() calls. This can occur when an audio input device is unplugged
   // whilst recording on Windows.
   // See http://crbug.com/79936 for details.
   // This member is only touched by the audio thread.
-  scoped_ptr<base::Timer> no_data_timer_;
+  std::unique_ptr<base::Timer> no_data_timer_;
 
   // This flag is used to signal that we are receiving OnData() calls, i.e,
   // that data is active. It can be touched by the audio thread and by the
   // low-level audio thread which calls OnData(). E.g. on Windows, the
   // low-level audio thread is called wasapi_capture_thread.
   base::subtle::Atomic32 data_is_active_;
 
   // |state_| is written on the audio thread and is read on the hardware audio
   // thread. These operations need to be locked. But lock is not required for
   // reading on the audio input controller thread.
@@ skipping 33 matching lines @@
 
   // Used for audio debug recordings. Accessed on audio thread.
   AudioInputWriter* input_writer_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioInputController);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_AUDIO_AUDIO_INPUT_CONTROLLER_H_