Convert //chromecast from scoped_ptr to std::unique_ptr

chromecast/media/cma/backend/multizone_backend_unittest.cc

 // Copyright 2016 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 <stdint.h>
 #include <stdlib.h>
 
 #include <limits>
+#include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "chromecast/base/task_runner_impl.h"
 #include "chromecast/media/cma/base/decoder_buffer_adapter.h"
 #include "chromecast/media/cma/base/decoder_config_adapter.h"
 #include "chromecast/public/cast_media_shlib.h"
 #include "chromecast/public/media/cast_decoder_buffer.h"
 #include "chromecast/public/media/decoder_config.h"
@@ skipping 52 matching lines @@
     ASSERT_TRUE(false);
   }
   void OnVideoResolutionChanged(const Size& size) override {
     DCHECK(thread_checker_.CalledOnValidThread());
   }
 
   const AudioConfig config_;
   const bool effects_only_;
   const base::Closure eos_cb_;
   bool feeding_completed_;
-  scoped_ptr<TaskRunnerImpl> task_runner_;
-  scoped_ptr<MediaPipelineBackend> backend_;
+  std::unique_ptr<TaskRunnerImpl> task_runner_;
+  std::unique_ptr<MediaPipelineBackend> backend_;
   MediaPipelineBackend::AudioDecoder* decoder_;
   int64_t push_limit_us_;
   int64_t last_push_length_us_;
   int64_t pushed_us_;
   int64_t next_push_playback_timestamp_;
   scoped_refptr<DecoderBufferBase> pending_buffer_;
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(BufferFeeder);
 };
@@ skipping 17 matching lines @@
     CastMediaShlib::Finalize();
   }
 
   void AddEffectsStreams();
 
   void Initialize(int sample_rate);
   void Start();
   void OnEndOfStream();
 
  private:
-  std::vector<scoped_ptr<BufferFeeder>> effects_feeders_;
-  scoped_ptr<BufferFeeder> audio_feeder_;
+  std::vector<std::unique_ptr<BufferFeeder>> effects_feeders_;
+  std::unique_ptr<BufferFeeder> audio_feeder_;
 
   DISALLOW_COPY_AND_ASSIGN(MultizoneBackendTest);
 };
 
 namespace {
 
 BufferFeeder::BufferFeeder(const AudioConfig& config,
                            bool effects_only,
                            const base::Closure& eos_cb)
     : config_(config),
@@ skipping 125 matching lines @@
 
 void MultizoneBackendTest::AddEffectsStreams() {
   AudioConfig effects_config;
   effects_config.codec = kCodecPCM;
   effects_config.sample_format = kSampleFormatS16;
   effects_config.channel_number = 2;
   effects_config.bytes_per_channel = 2;
   effects_config.samples_per_second = 48000;
 
   for (int i = 0; i < kNumEffectsStreams; ++i) {
-    scoped_ptr<BufferFeeder> feeder(new BufferFeeder(
+    std::unique_ptr<BufferFeeder> feeder(new BufferFeeder(
         effects_config, true /* effects_only */, base::Bind(&IgnoreEos)));
     feeder->Initialize();
     effects_feeders_.push_back(std::move(feeder));
   }
 }
 
 void MultizoneBackendTest::Start() {
   for (auto& feeder : effects_feeders_)
     feeder->Start();
   CHECK(audio_feeder_);
   audio_feeder_->Start();
 }
 
 void MultizoneBackendTest::OnEndOfStream() {
   audio_feeder_->Stop();
   for (auto& feeder : effects_feeders_)
     feeder->Stop();
 
   base::MessageLoop::current()->QuitWhenIdle();
 }
 
 TEST_P(MultizoneBackendTest, RenderingDelay) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   Initialize(GetParam());
   AddEffectsStreams();
   Start();
   message_loop->Run();
 }
 
 INSTANTIATE_TEST_CASE_P(Required,
                         MultizoneBackendTest,
                         ::testing::Values(8000,
                                           11025,
                                           12000,
                                           16000,
                                           22050,
                                           24000,
                                           32000,
                                           44100,
                                           48000));
 
 INSTANTIATE_TEST_CASE_P(Optional,
                         MultizoneBackendTest,
                         ::testing::Values(64000, 88200, 96000));
 
 }  // namespace media
 }  // namespace chromecast