Convert //chromecast from scoped_ptr to std::unique_ptr

chromecast/media/audio/cast_audio_output_stream_unittest.cc

 // 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.
 
 #include "chromecast/media/audio/cast_audio_output_stream.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
@@ skipping 171 matching lines @@
   bool error_;
 };
 
 class FakeAudioManager : public CastAudioManager {
  public:
   FakeAudioManager()
       : CastAudioManager(nullptr, nullptr), media_pipeline_backend_(nullptr) {}
   ~FakeAudioManager() override {}
 
   // CastAudioManager overrides.
-  scoped_ptr<MediaPipelineBackend> CreateMediaPipelineBackend(
+  std::unique_ptr<MediaPipelineBackend> CreateMediaPipelineBackend(
       const MediaPipelineDeviceParams& params) override {
     DCHECK(media::MediaMessageLoop::GetTaskRunner()->BelongsToCurrentThread());
     DCHECK(!media_pipeline_backend_);
 
-    scoped_ptr<FakeMediaPipelineBackend> backend(
+    std::unique_ptr<FakeMediaPipelineBackend> backend(
         new FakeMediaPipelineBackend());
     // Cache the backend locally to be used by tests.
     media_pipeline_backend_ = backend.get();
     return std::move(backend);
   }
   void ReleaseOutputStream(::media::AudioOutputStream* stream) override {
     DCHECK(media_pipeline_backend_);
     media_pipeline_backend_ = nullptr;
     CastAudioManager::ReleaseOutputStream(stream);
   }
@@ skipping 142 matching lines @@
     completion_event->Signal();
   }
   void OpenStreamOnAudioThread(::media::AudioOutputStream* stream,
                                bool* success,
                                base::WaitableEvent* completion_event) {
     DCHECK(audio_task_runner_->BelongsToCurrentThread());
     *success = stream->Open();
     completion_event->Signal();
   }
 
-  scoped_ptr<FakeAudioManager> audio_manager_;
+  std::unique_ptr<FakeAudioManager> audio_manager_;
   scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> backend_task_runner_;
 
   // AudioParameters used to create AudioOutputStream.
   // Tests can modify these parameters before calling CreateStream.
   ::media::AudioParameters::Format format_;
   ::media::ChannelLayout channel_layout_;
   int sample_rate_;
   int bits_per_sample_;
   int frames_per_buffer_;
@@ skipping 72 matching lines @@
   ASSERT_TRUE(stream);
   EXPECT_FALSE(GetAudio());
 
   EXPECT_TRUE(OpenStream(stream));
   FakeAudioDecoder* audio_decoder = GetAudio();
   ASSERT_TRUE(audio_decoder);
   FakeMediaPipelineBackend* backend = GetBackend();
   ASSERT_TRUE(backend);
   EXPECT_EQ(FakeMediaPipelineBackend::kStateStopped, backend->state());
 
-  scoped_ptr<FakeAudioSourceCallback> source_callback(
+  std::unique_ptr<FakeAudioSourceCallback> source_callback(
       new FakeAudioSourceCallback);
   StartStream(stream, source_callback.get());
   EXPECT_EQ(FakeMediaPipelineBackend::kStateRunning, backend->state());
 
   StopStream(stream);
   EXPECT_EQ(FakeMediaPipelineBackend::kStatePaused, backend->state());
 
   CloseStream(stream);
   EXPECT_FALSE(GetAudio());
 }
 
 TEST_F(CastAudioOutputStreamTest, PushFrame) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
   EXPECT_TRUE(OpenStream(stream));
 
   FakeAudioDecoder* audio_decoder = GetAudio();
   ASSERT_TRUE(audio_decoder);
   // Verify initial state.
   EXPECT_EQ(0u, audio_decoder->pushed_buffer_count());
   EXPECT_FALSE(audio_decoder->last_buffer());
 
-  scoped_ptr<FakeAudioSourceCallback> source_callback(
+  std::unique_ptr<FakeAudioSourceCallback> source_callback(
       new FakeAudioSourceCallback);
   StartStream(stream, source_callback.get());
   StopStream(stream);
 
   // Verify that the stream pushed frames to the backend.
   EXPECT_LT(0u, audio_decoder->pushed_buffer_count());
   EXPECT_TRUE(audio_decoder->last_buffer());
 
   // Verify decoder buffer.
   ::media::AudioParameters audio_params = GetAudioParams();
@@ skipping 13 matching lines @@
 
 TEST_F(CastAudioOutputStreamTest, DeviceBusy) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
   EXPECT_TRUE(OpenStream(stream));
 
   FakeAudioDecoder* audio_decoder = GetAudio();
   ASSERT_TRUE(audio_decoder);
   audio_decoder->set_pipeline_status(FakeAudioDecoder::PIPELINE_STATUS_BUSY);
 
-  scoped_ptr<FakeAudioSourceCallback> source_callback(
+  std::unique_ptr<FakeAudioSourceCallback> source_callback(
       new FakeAudioSourceCallback);
   StartStream(stream, source_callback.get());
 
   // Make sure that one frame was pushed.
   EXPECT_EQ(1u, audio_decoder->pushed_buffer_count());
   // No error must be reported to source callback.
   EXPECT_FALSE(source_callback->error());
 
   // Sleep for a few frames and verify that more frames were not pushed
   // because the backend device was busy.
@@ skipping 24 matching lines @@
 
 TEST_F(CastAudioOutputStreamTest, DeviceError) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
   EXPECT_TRUE(OpenStream(stream));
 
   FakeAudioDecoder* audio_decoder = GetAudio();
   ASSERT_TRUE(audio_decoder);
   audio_decoder->set_pipeline_status(FakeAudioDecoder::PIPELINE_STATUS_ERROR);
 
-  scoped_ptr<FakeAudioSourceCallback> source_callback(
+  std::unique_ptr<FakeAudioSourceCallback> source_callback(
       new FakeAudioSourceCallback);
   StartStream(stream, source_callback.get());
 
   // Make sure that AudioOutputStream attempted to push the initial frame.
   EXPECT_LT(0u, audio_decoder->pushed_buffer_count());
   // AudioOutputStream must report error to source callback.
   EXPECT_TRUE(source_callback->error());
 
   StopStream(stream);
   CloseStream(stream);
 }
 
 TEST_F(CastAudioOutputStreamTest, DeviceAsyncError) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
   EXPECT_TRUE(OpenStream(stream));
 
   FakeAudioDecoder* audio_decoder = GetAudio();
   ASSERT_TRUE(audio_decoder);
   audio_decoder->set_pipeline_status(
       FakeAudioDecoder::PIPELINE_STATUS_ASYNC_ERROR);
 
-  scoped_ptr<FakeAudioSourceCallback> source_callback(
+  std::unique_ptr<FakeAudioSourceCallback> source_callback(
       new FakeAudioSourceCallback);
   StartStream(stream, source_callback.get());
 
   // Make sure that one frame was pushed.
   EXPECT_EQ(1u, audio_decoder->pushed_buffer_count());
 
   // Unblock the pipeline and verify that PushFrame resumes.
   // (have to post because this directly calls buffer complete)
   backend_task_runner_->PostTask(
       FROM_HERE,
@@ skipping 27 matching lines @@
   EXPECT_EQ(0.5f, audio_decoder->volume());
 
   CloseStream(stream);
 }
 
 TEST_F(CastAudioOutputStreamTest, StartStopStart) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
   ASSERT_TRUE(OpenStream(stream));
 
-  scoped_ptr<FakeAudioSourceCallback> source_callback(
+  std::unique_ptr<FakeAudioSourceCallback> source_callback(
       new FakeAudioSourceCallback);
   audio_task_runner_->PostTask(
       FROM_HERE, base::Bind(&::media::AudioOutputStream::Start,
                             base::Unretained(stream), source_callback.get()));
   audio_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&::media::AudioOutputStream::Stop, base::Unretained(stream)));
   audio_task_runner_->PostTask(
       FROM_HERE, base::Bind(&::media::AudioOutputStream::Start,
                             base::Unretained(stream), source_callback.get()));
@@ skipping 10 matching lines @@
 TEST_F(CastAudioOutputStreamTest, CloseWithoutStart) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
   ASSERT_TRUE(OpenStream(stream));
   CloseStream(stream);
 }
 
 }  // namespace
 }  // namespace media
 }  // namespace chromecast