Convert //chromecast from scoped_ptr to std::unique_ptr

chromecast/media/cma/backend/audio_video_pipeline_device_unittest.cc

 // Copyright 2014 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 <limits>
+#include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.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"
@@ skipping 55 matching lines @@
       .Append(FILE_PATH_LITERAL("test")).Append(FILE_PATH_LITERAL("data"))
       .AppendASCII(name);
   return file_path;
 }
 
 class BufferFeeder : public MediaPipelineBackend::Decoder::Delegate {
  public:
   explicit BufferFeeder(const base::Closure& eos_cb);
   ~BufferFeeder() override {}
 
-  static scoped_ptr<BufferFeeder> LoadAudio(MediaPipelineBackend* backend,
-                                            const std::string& filename,
-                                            const base::Closure& eos_cb);
-  static scoped_ptr<BufferFeeder> LoadVideo(MediaPipelineBackend* backend,
-                                            const std::string& filename,
-                                            bool raw_h264,
-                                            const base::Closure& eos_cb);
+  static std::unique_ptr<BufferFeeder> LoadAudio(MediaPipelineBackend* backend,
+                                                 const std::string& filename,
+                                                 const base::Closure& eos_cb);
+  static std::unique_ptr<BufferFeeder> LoadVideo(MediaPipelineBackend* backend,
+                                                 const std::string& filename,
+                                                 bool raw_h264,
+                                                 const base::Closure& eos_cb);
 
   bool eos() const { return eos_; }
   MediaPipelineBackend::Decoder* decoder() const { return decoder_; }
   int64_t last_pushed_pts() const { return last_pushed_pts_; }
 
   void SetAudioConfig(const AudioConfig& config) { audio_config_ = config; }
   void SetVideoConfig(const VideoConfig& config) { video_config_ = config; }
 
   void FeedContinuousPcm();
   void PauseBeforeEos();
@@ skipping 33 matching lines @@
   bool feed_continuous_pcm_;
   MediaPipelineBackend* backend_;
   MediaPipelineBackend::Decoder* decoder_;
   BufferList buffers_;
   BufferList buffers_copy_;
   scoped_refptr<DecoderBufferBase> pending_buffer_;
   base::ThreadChecker thread_checker_;
   AudioConfig audio_config_;
   VideoConfig video_config_;
   int64_t last_pushed_pts_;
-  scoped_ptr<::media::AudioTimestampHelper> timestamp_helper_;
+  std::unique_ptr<::media::AudioTimestampHelper> timestamp_helper_;
 
   DISALLOW_COPY_AND_ASSIGN(BufferFeeder);
 };
 
 }  // namespace
 
 class AudioVideoPipelineDeviceTest : public testing::Test {
  public:
   struct PauseInfo {
     PauseInfo() {}
@@ skipping 37 matching lines @@
 
   // Adds a pause to the end of pause pattern
   void AddPause(base::TimeDelta delay, base::TimeDelta length);
   void PauseBeforeEos();
   void AddEffectsStreams();
 
   void Initialize();
   void Start();
   void OnEndOfStream();
 
-  void SetAudioFeeder(scoped_ptr<BufferFeeder> audio_feeder) {
+  void SetAudioFeeder(std::unique_ptr<BufferFeeder> audio_feeder) {
     audio_feeder_ = std::move(audio_feeder);
   }
-  void SetVideoFeeder(scoped_ptr<BufferFeeder> video_feeder) {
+  void SetVideoFeeder(std::unique_ptr<BufferFeeder> video_feeder) {
     video_feeder_ = std::move(video_feeder);
   }
 
   void RunStoppedChecks();
   void RunPlaybackChecks();
   void TestBackendStates();
   void StartImmediateEosTest();
   void EndImmediateEosTest();
 
  private:
   void MonitorLoop();
 
   void OnPauseCompleted();
 
   MediaPipelineDeviceParams::MediaSyncType sync_type_;
   MediaPipelineDeviceParams::AudioStreamType audio_type_;
-  scoped_ptr<TaskRunnerImpl> task_runner_;
-  scoped_ptr<MediaPipelineBackend> backend_;
-  std::vector<scoped_ptr<MediaPipelineBackend>> effects_backends_;
-  std::vector<scoped_ptr<BufferFeeder>> effects_feeders_;
-  scoped_ptr<BufferFeeder> audio_feeder_;
-  scoped_ptr<BufferFeeder> video_feeder_;
+  std::unique_ptr<TaskRunnerImpl> task_runner_;
+  std::unique_ptr<MediaPipelineBackend> backend_;
+  std::vector<std::unique_ptr<MediaPipelineBackend>> effects_backends_;
+  std::vector<std::unique_ptr<BufferFeeder>> effects_feeders_;
+  std::unique_ptr<BufferFeeder> audio_feeder_;
+  std::unique_ptr<BufferFeeder> video_feeder_;
   bool stopped_;
   bool ran_playing_playback_checks_;
   bool backwards_pts_change_;
   int64_t last_pts_;
 
   // Current media time.
   base::TimeDelta pause_time_;
 
   // Pause settings
   std::vector<PauseInfo> pause_pattern_;
@@ skipping 272 matching lines @@
       static_cast<MediaPipelineBackend::VideoDecoder*>(decoder_);
   VideoConfig config;
   config.codec = kVideoCodecUnknown;
   // Set invalid config first, to test that the decoder still accepts valid
   // config after an invalid config.
   video_decoder->SetConfig(config);
   EXPECT_TRUE(video_decoder->SetConfig(video_config_));
 }
 
 // static
-scoped_ptr<BufferFeeder> BufferFeeder::LoadAudio(MediaPipelineBackend* backend,
-                                                 const std::string& filename,
-                                                 const base::Closure& eos_cb) {
+std::unique_ptr<BufferFeeder> BufferFeeder::LoadAudio(
+    MediaPipelineBackend* backend,
+    const std::string& filename,
+    const base::Closure& eos_cb) {
   CHECK(backend);
   base::FilePath file_path = GetTestDataFilePath(filename);
   DemuxResult demux_result = FFmpegDemuxForTest(file_path, true /* audio */);
 
   MediaPipelineBackend::AudioDecoder* decoder = backend->CreateAudioDecoder();
   CHECK(decoder);
   AudioConfig config = DecoderConfigAdapter::ToCastAudioConfig(
       kPrimary, demux_result.audio_config);
   bool success = decoder->SetConfig(config);
   CHECK(success);
 
   VLOG(2) << "Got " << demux_result.frames.size() << " audio input frames";
-  scoped_ptr<BufferFeeder> feeder(new BufferFeeder(eos_cb));
+  std::unique_ptr<BufferFeeder> feeder(new BufferFeeder(eos_cb));
   feeder->audio_config_ = config;
   feeder->Initialize(backend, decoder, demux_result.frames);
   return feeder;
 }
 
 // static
-scoped_ptr<BufferFeeder> BufferFeeder::LoadVideo(MediaPipelineBackend* backend,
-                                                 const std::string& filename,
-                                                 bool raw_h264,
-                                                 const base::Closure& eos_cb) {
+std::unique_ptr<BufferFeeder> BufferFeeder::LoadVideo(
+    MediaPipelineBackend* backend,
+    const std::string& filename,
+    bool raw_h264,
+    const base::Closure& eos_cb) {
   CHECK(backend);
 
   VideoConfig video_config;
   BufferList buffers;
   if (raw_h264) {
     base::FilePath file_path = GetTestDataFilePath(filename);
     base::MemoryMappedFile video_stream;
     CHECK(video_stream.Initialize(file_path)) << "Couldn't open stream file: "
                                               << file_path.MaybeAsASCII();
     buffers = H264SegmenterForTest(video_stream.data(), video_stream.length());
@@ skipping 11 matching lines @@
         kPrimary, demux_result.video_config);
   }
 
   MediaPipelineBackend::VideoDecoder* decoder = backend->CreateVideoDecoder();
   CHECK(decoder);
 
   bool success = decoder->SetConfig(video_config);
   CHECK(success);
 
   VLOG(2) << "Got " << buffers.size() << " video input frames";
-  scoped_ptr<BufferFeeder> feeder(new BufferFeeder(eos_cb));
+  std::unique_ptr<BufferFeeder> feeder(new BufferFeeder(eos_cb));
   feeder->video_config_ = video_config;
   feeder->Initialize(backend, decoder, buffers);
   return feeder;
 }
 
 }  // namespace
 
 AudioVideoPipelineDeviceTest::AudioVideoPipelineDeviceTest()
     : sync_type_(MediaPipelineDeviceParams::kModeSyncPts),
       audio_type_(MediaPipelineDeviceParams::kAudioStreamNormal),
@@ skipping 28 matching lines @@
 void AudioVideoPipelineDeviceTest::AddEffectsStreams() {
   const int kNumEffectsStreams = 3;
   for (int i = 0; i < kNumEffectsStreams; ++i) {
     MediaPipelineDeviceParams params(
         MediaPipelineDeviceParams::kModeIgnorePts,
         MediaPipelineDeviceParams::kAudioStreamSoundEffects,
         task_runner_.get());
     MediaPipelineBackend* effects_backend =
         CastMediaShlib::CreateMediaPipelineBackend(params);
     CHECK(effects_backend);
-    effects_backends_.push_back(make_scoped_ptr(effects_backend));
+    effects_backends_.push_back(base::WrapUnique(effects_backend));
 
     MediaPipelineBackend::AudioDecoder* audio_decoder =
         effects_backend->CreateAudioDecoder();
     audio_decoder->SetConfig(DefaultAudioConfig());
 
-    scoped_ptr<BufferFeeder> feeder(new BufferFeeder(base::Bind(&IgnoreEos)));
+    std::unique_ptr<BufferFeeder> feeder(
+        new BufferFeeder(base::Bind(&IgnoreEos)));
     feeder->FeedContinuousPcm();
     feeder->Initialize(effects_backend, audio_decoder, BufferList());
     feeder->SetAudioConfig(DefaultAudioConfig());
     effects_feeders_.push_back(std::move(feeder));
     ASSERT_TRUE(effects_backend->Initialize());
   }
 }
 
 void AudioVideoPipelineDeviceTest::SetPausePattern(
     const std::vector<PauseInfo> pattern) {
@@ skipping 235 matching lines @@
 
   ASSERT_TRUE(backend_->Stop());
   base::MessageLoop::current()->RunUntilIdle();
 
   RunStoppedChecks();
 
   base::MessageLoop::current()->QuitWhenIdle();
 }
 
 TEST_F(AudioVideoPipelineDeviceTest, Mp3Playback) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   set_sync_type(MediaPipelineDeviceParams::kModeSyncPts);
   ConfigureForAudioOnly("sfx.mp3");
   PauseBeforeEos();
   Start();
   message_loop->Run();
 }
 
 TEST_F(AudioVideoPipelineDeviceTest, AacPlayback) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   set_sync_type(MediaPipelineDeviceParams::kModeSyncPts);
   ConfigureForAudioOnly("sfx.m4a");
   PauseBeforeEos();
   Start();
   message_loop->Run();
 }
 
 TEST_F(AudioVideoPipelineDeviceTest, VorbisPlayback) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   set_sync_type(MediaPipelineDeviceParams::kModeIgnorePts);
   ConfigureForAudioOnly("sfx.ogg");
   Start();
   message_loop->Run();
 }
 
 // TODO(kmackay) FFmpegDemuxForTest can't handle AC3 or EAC3.
 
 TEST_F(AudioVideoPipelineDeviceTest, OpusPlayback_Optional) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   set_sync_type(MediaPipelineDeviceParams::kModeSyncPts);
   ConfigureForAudioOnly("bear-opus.ogg");
   PauseBeforeEos();
   Start();
   message_loop->Run();
 }
 
 TEST_F(AudioVideoPipelineDeviceTest, FlacPlayback_Optional) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   set_sync_type(MediaPipelineDeviceParams::kModeSyncPts);
   ConfigureForAudioOnly("bear.flac");
   PauseBeforeEos();
   Start();
   message_loop->Run();
 }
 
 TEST_F(AudioVideoPipelineDeviceTest, H264Playback) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   set_sync_type(MediaPipelineDeviceParams::kModeIgnorePtsAndVSync);
   ConfigureForVideoOnly("bear.h264", true /* raw_h264 */);
   PauseBeforeEos();
   Start();
   message_loop->Run();
 }
 
 TEST_F(AudioVideoPipelineDeviceTest, WebmPlaybackWithPause) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   set_sync_type(MediaPipelineDeviceParams::kModeSyncPts);
   // Setup to pause for 100ms every 500ms
   AddPause(base::TimeDelta::FromMilliseconds(500),
            base::TimeDelta::FromMilliseconds(100));
 
   ConfigureForVideoOnly("bear-640x360.webm", false /* raw_h264 */);
   Start();
   message_loop->Run();
 }
 
 TEST_F(AudioVideoPipelineDeviceTest, Vp8Playback) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   set_sync_type(MediaPipelineDeviceParams::kModeSyncPts);
   ConfigureForVideoOnly("bear-vp8a.webm", false /* raw_h264 */);
   Start();
   message_loop->Run();
 }
 
 TEST_F(AudioVideoPipelineDeviceTest, WebmPlayback) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   set_sync_type(MediaPipelineDeviceParams::kModeIgnorePtsAndVSync);
   ConfigureForFile("bear-640x360.webm");
   PauseBeforeEos();
   Start();
   message_loop->Run();
 }
 
 // TODO(kmackay) FFmpegDemuxForTest can't handle HEVC or VP9.
 
 TEST_F(AudioVideoPipelineDeviceTest, AudioBackendStates) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
   Initialize();
   MediaPipelineBackend::AudioDecoder* audio_decoder =
       backend()->CreateAudioDecoder();
 
   // Test setting config before Initialize().
-  scoped_ptr<BufferFeeder> feeder(new BufferFeeder(base::Bind(&IgnoreEos)));
+  std::unique_ptr<BufferFeeder> feeder(
+      new BufferFeeder(base::Bind(&IgnoreEos)));
   feeder->Initialize(backend(), audio_decoder, BufferList());
   feeder->SetAudioConfig(DefaultAudioConfig());
   feeder->TestAudioConfigs();
 
   SetAudioFeeder(std::move(feeder));
   TestBackendStates();
 }
 
 TEST_F(AudioVideoPipelineDeviceTest, AudioEffectsBackendStates) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
   set_audio_type(MediaPipelineDeviceParams::kAudioStreamSoundEffects);
   set_sync_type(MediaPipelineDeviceParams::kModeIgnorePts);
   Initialize();
   MediaPipelineBackend::AudioDecoder* audio_decoder =
       backend()->CreateAudioDecoder();
 
-  scoped_ptr<BufferFeeder> feeder(new BufferFeeder(base::Bind(&IgnoreEos)));
+  std::unique_ptr<BufferFeeder> feeder(
+      new BufferFeeder(base::Bind(&IgnoreEos)));
   feeder->Initialize(backend(), audio_decoder, BufferList());
   feeder->SetAudioConfig(DefaultAudioConfig());
   ASSERT_TRUE(audio_decoder->SetConfig(DefaultAudioConfig()));
 
   SetAudioFeeder(std::move(feeder));
   TestBackendStates();
 }
 
 TEST_F(AudioVideoPipelineDeviceTest, VideoBackendStates) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
   Initialize();
   MediaPipelineBackend::VideoDecoder* video_decoder =
       backend()->CreateVideoDecoder();
 
   // Test setting config before Initialize().
-  scoped_ptr<BufferFeeder> feeder(new BufferFeeder(base::Bind(&IgnoreEos)));
+  std::unique_ptr<BufferFeeder> feeder(
+      new BufferFeeder(base::Bind(&IgnoreEos)));
   feeder->Initialize(backend(), video_decoder, BufferList());
   feeder->SetVideoConfig(DefaultVideoConfig());
   feeder->TestVideoConfigs();
 
   SetVideoFeeder(std::move(feeder));
   TestBackendStates();
 }
 
 TEST_F(AudioVideoPipelineDeviceTest, AudioImmediateEos) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
   Initialize();
   MediaPipelineBackend::AudioDecoder* audio_decoder =
       backend()->CreateAudioDecoder();
 
-  scoped_ptr<BufferFeeder> feeder(new BufferFeeder(
+  std::unique_ptr<BufferFeeder> feeder(new BufferFeeder(
       base::Bind(&AudioVideoPipelineDeviceTest::EndImmediateEosTest,
                  base::Unretained(this))));
   feeder->Initialize(backend(), audio_decoder, BufferList());
   feeder->SetAudioConfig(DefaultAudioConfig());
   SetAudioFeeder(std::move(feeder));
 
   StartImmediateEosTest();
 }
 
 TEST_F(AudioVideoPipelineDeviceTest, VideoImmediateEos) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
   Initialize();
   MediaPipelineBackend::VideoDecoder* video_decoder =
       backend()->CreateVideoDecoder();
 
-  scoped_ptr<BufferFeeder> feeder(new BufferFeeder(
+  std::unique_ptr<BufferFeeder> feeder(new BufferFeeder(
       base::Bind(&AudioVideoPipelineDeviceTest::EndImmediateEosTest,
                  base::Unretained(this))));
   feeder->Initialize(backend(), video_decoder, BufferList());
   feeder->SetVideoConfig(DefaultVideoConfig());
   SetVideoFeeder(std::move(feeder));
 
   StartImmediateEosTest();
 }
 
 TEST_F(AudioVideoPipelineDeviceTest, Mp3Playback_WithEffectsStreams) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   set_sync_type(MediaPipelineDeviceParams::kModeSyncPts);
   ConfigureForAudioOnly("sfx.mp3");
   PauseBeforeEos();
   AddEffectsStreams();
   Start();
   message_loop->Run();
 }
 
 TEST_F(AudioVideoPipelineDeviceTest, AacPlayback_WithEffectsStreams) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   set_sync_type(MediaPipelineDeviceParams::kModeSyncPts);
   ConfigureForAudioOnly("sfx.m4a");
   PauseBeforeEos();
   AddEffectsStreams();
   Start();
   message_loop->Run();
 }
 
 TEST_F(AudioVideoPipelineDeviceTest, VorbisPlayback_WithEffectsStreams) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   set_sync_type(MediaPipelineDeviceParams::kModeIgnorePts);
   ConfigureForAudioOnly("sfx.ogg");
   AddEffectsStreams();
   Start();
   message_loop->Run();
 }
 
 // TODO(kmackay) FFmpegDemuxForTest can't handle AC3 or EAC3.
 
 TEST_F(AudioVideoPipelineDeviceTest, OpusPlayback_WithEffectsStreams_Optional) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   set_sync_type(MediaPipelineDeviceParams::kModeSyncPts);
   ConfigureForAudioOnly("bear-opus.ogg");
   PauseBeforeEos();
   AddEffectsStreams();
   Start();
   message_loop->Run();
 }
 
 TEST_F(AudioVideoPipelineDeviceTest, FlacPlayback_WithEffectsStreams_Optional) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   set_sync_type(MediaPipelineDeviceParams::kModeSyncPts);
   ConfigureForAudioOnly("bear.flac");
   PauseBeforeEos();
   AddEffectsStreams();
   Start();
   message_loop->Run();
 }
 
 TEST_F(AudioVideoPipelineDeviceTest, H264Playback_WithEffectsStreams) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   set_sync_type(MediaPipelineDeviceParams::kModeIgnorePtsAndVSync);
   ConfigureForVideoOnly("bear.h264", true /* raw_h264 */);
   PauseBeforeEos();
   AddEffectsStreams();
   Start();
   message_loop->Run();
 }
 
 TEST_F(AudioVideoPipelineDeviceTest, WebmPlaybackWithPause_WithEffectsStreams) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   set_sync_type(MediaPipelineDeviceParams::kModeSyncPts);
   // Setup to pause for 100ms every 500ms
   AddPause(base::TimeDelta::FromMilliseconds(500),
            base::TimeDelta::FromMilliseconds(100));
 
   ConfigureForVideoOnly("bear-640x360.webm", false /* raw_h264 */);
   AddEffectsStreams();
   Start();
   message_loop->Run();
 }
 
 TEST_F(AudioVideoPipelineDeviceTest, Vp8Playback_WithEffectsStreams) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   set_sync_type(MediaPipelineDeviceParams::kModeSyncPts);
   ConfigureForVideoOnly("bear-vp8a.webm", false /* raw_h264 */);
   AddEffectsStreams();
   Start();
   message_loop->Run();
 }
 
 TEST_F(AudioVideoPipelineDeviceTest, WebmPlayback_WithEffectsStreams) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   set_sync_type(MediaPipelineDeviceParams::kModeIgnorePtsAndVSync);
   ConfigureForFile("bear-640x360.webm");
   PauseBeforeEos();
   AddEffectsStreams();
   Start();
   message_loop->Run();
 }
 
 }  // namespace media
 }  // namespace chromecast