Convert //chromecast from scoped_ptr to std::unique_ptr

chromecast/media/cma/backend/alsa/stream_mixer_alsa.h

 // Copyright 2015 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 CHROMECAST_MEDIA_CMA_BACKEND_ALSA_STREAM_MIXER_ALSA_H_
 #define CHROMECAST_MEDIA_CMA_BACKEND_ALSA_STREAM_MIXER_ALSA_H_
 
 #include <alsa/asoundlib.h>
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/threading/thread.h"
 #include "base/timer/timer.h"
 #include "chromecast/media/cma/backend/alsa/media_pipeline_backend_alsa.h"
 #include "chromecast/public/cast_media_shlib.h"
 
 namespace media {
 class AudioBus;
 }  // namespace media
 
@@ skipping 94 matching lines @@
   bool empty() const { return inputs_.empty(); }
   State state() const { return state_; }
   int num_output_channels() const { return num_output_channels_; }
 
   const scoped_refptr<base::SingleThreadTaskRunner>& task_runner() const {
     return mixer_task_runner_;
   }
 
   // Adds an input to the mixer. The input will live at least until
   // RemoveInput(input) is called. Can be called on any thread.
-  void AddInput(scoped_ptr<InputQueue> input);
+  void AddInput(std::unique_ptr<InputQueue> input);
   // Instructs the mixer to remove an input. The input should not be referenced
   // after this is called. Can be called on any thread.
   void RemoveInput(InputQueue* input);
 
   // Attempts to write some frames of audio to ALSA. Must only be called on the
   // mixer thread.
   void OnFramesQueued();
 
-  void SetAlsaWrapperForTest(scoped_ptr<AlsaWrapper> alsa_wrapper);
+  void SetAlsaWrapperForTest(std::unique_ptr<AlsaWrapper> alsa_wrapper);
   void WriteFramesForTest();  // Can be called on any thread.
   void ClearInputsForTest();  // Removes all inputs.
 
   void AddLoopbackAudioObserver(
       CastMediaShlib::LoopbackAudioObserver* observer);
 
   void RemoveLoopbackAudioObserver(
       CastMediaShlib::LoopbackAudioObserver* observer);
 
  protected:
@@ skipping 33 matching lines @@
   void CheckClose();
 
   void WriteFrames();
   bool TryWriteFrames();
   void WriteMixedPcm(const ::media::AudioBus& mixed, int frames);
   void UpdateRenderingDelay(int newly_pushed_frames);
   ssize_t BytesPerOutputFormatSample();
 
   static bool single_threaded_for_test_;
 
-  scoped_ptr<AlsaWrapper> alsa_;
-  scoped_ptr<base::Thread> mixer_thread_;
+  std::unique_ptr<AlsaWrapper> alsa_;
+  std::unique_ptr<base::Thread> mixer_thread_;
   scoped_refptr<base::SingleThreadTaskRunner> mixer_task_runner_;
 
   unsigned int fixed_output_samples_per_second_;
   int requested_output_samples_per_second_;
   int output_samples_per_second_;
   snd_pcm_t* pcm_;
   snd_pcm_hw_params_t* pcm_hw_params_;
   snd_pcm_status_t* pcm_status_;
   snd_pcm_format_t pcm_format_;
 
@@ skipping 11 matching lines @@
 
   ScopedVector<InputQueue> inputs_;
   ScopedVector<InputQueue> ignored_inputs_;
   MediaPipelineBackendAlsa::RenderingDelay rendering_delay_;
   // Buffer to write final interleaved data before sending to snd_pcm_writei().
   std::vector<uint8_t> interleaved_;
 
   // Buffers that hold audio data while it is mixed, before it is passed to the
   // ALSA layer. These are kept as members of this class to minimize copies and
   // allocations.
-  scoped_ptr<::media::AudioBus> temp_;
-  scoped_ptr<::media::AudioBus> mixed_;
+  std::unique_ptr<::media::AudioBus> temp_;
+  std::unique_ptr<::media::AudioBus> mixed_;
 
-  scoped_ptr<base::Timer> retry_write_frames_timer_;
+  std::unique_ptr<base::Timer> retry_write_frames_timer_;
 
   int check_close_timeout_;
-  scoped_ptr<base::Timer> check_close_timer_;
+  std::unique_ptr<base::Timer> check_close_timer_;
 
   std::vector<CastMediaShlib::LoopbackAudioObserver*> loopback_observers_;
 
   DISALLOW_COPY_AND_ASSIGN(StreamMixerAlsa);
 };
 
 }  // namespace media
 }  // namespace chromecast
 
 #endif  // CHROMECAST_MEDIA_CMA_BACKEND_ALSA_STREAM_MIXER_ALSA_H_