Replace scoped_ptr with std::unique_ptr in //media.

media/test/pipeline_integration_test_base.cc

 // 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.
 
 #include "media/test/pipeline_integration_test_base.h"
 
 #include <utility>
 
 #include "base/bind.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "media/base/cdm_context.h"
 #include "media/base/media_log.h"
 #include "media/base/media_tracks.h"
 #include "media/base/test_data_util.h"
 #include "media/filters/chunk_demuxer.h"
 #if !defined(MEDIA_DISABLE_FFMPEG)
 #include "media/filters/ffmpeg_audio_decoder.h"
 #include "media/filters/ffmpeg_demuxer.h"
 #include "media/filters/ffmpeg_video_decoder.h"
@@ skipping 54 matching lines @@
 
 void PipelineIntegrationTestBase::DemuxerEncryptedMediaInitDataCB(
     EmeInitDataType type,
     const std::vector<uint8_t>& init_data) {
   DCHECK(!init_data.empty());
   CHECK(!encrypted_media_init_data_cb_.is_null());
   encrypted_media_init_data_cb_.Run(type, init_data);
 }
 
 void PipelineIntegrationTestBase::DemuxerMediaTracksUpdatedCB(
-    scoped_ptr<MediaTracks> tracks) {
+    std::unique_ptr<MediaTracks> tracks) {
   CHECK(tracks);
 }
 
 void PipelineIntegrationTestBase::OnEnded() {
   DCHECK(!ended_);
   ended_ = true;
   pipeline_status_ = PIPELINE_OK;
   message_loop_.PostTask(FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
@@ skipping 12 matching lines @@
   return pipeline_status_;
 }
 
 void PipelineIntegrationTestBase::OnError(PipelineStatus status) {
   DCHECK_NE(status, PIPELINE_OK);
   pipeline_status_ = status;
   message_loop_.PostTask(FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
 PipelineStatus PipelineIntegrationTestBase::StartInternal(
-    scoped_ptr<DataSource> data_source,
+    std::unique_ptr<DataSource> data_source,
     CdmContext* cdm_context,
     uint8_t test_type) {
   hashing_enabled_ = test_type & kHashed;
   clockless_playback_ = test_type & kClockless;
 
   EXPECT_CALL(*this, OnMetadata(_))
       .Times(AtMost(1))
       .WillRepeatedly(SaveArg<0>(&metadata_));
   EXPECT_CALL(*this, OnBufferingStateChanged(BUFFERING_HAVE_ENOUGH))
       .Times(AnyNumber());
@@ skipping 27 matching lines @@
       base::Bind(&PipelineIntegrationTestBase::OnWaitingForDecryptionKey,
                  base::Unretained(this)));
   message_loop_.Run();
   return pipeline_status_;
 }
 
 PipelineStatus PipelineIntegrationTestBase::StartWithFile(
     const std::string& filename,
     CdmContext* cdm_context,
     uint8_t test_type) {
-  scoped_ptr<FileDataSource> file_data_source(new FileDataSource());
+  std::unique_ptr<FileDataSource> file_data_source(new FileDataSource());
   base::FilePath file_path(GetTestDataFilePath(filename));
   CHECK(file_data_source->Initialize(file_path)) << "Is " << file_path.value()
                                                  << " missing?";
   return StartInternal(std::move(file_data_source), cdm_context, test_type);
 }
 
 PipelineStatus PipelineIntegrationTestBase::Start(const std::string& filename) {
   return StartWithFile(filename, nullptr, kNormal);
 }
 
 PipelineStatus PipelineIntegrationTestBase::Start(const std::string& filename,
                                                   CdmContext* cdm_context) {
   return StartWithFile(filename, cdm_context, kNormal);
 }
 
 PipelineStatus PipelineIntegrationTestBase::Start(const std::string& filename,
                                                   uint8_t test_type) {
   return StartWithFile(filename, nullptr, test_type);
 }
 
 PipelineStatus PipelineIntegrationTestBase::Start(const uint8_t* data,
                                                   size_t size,
                                                   uint8_t test_type) {
-  return StartInternal(make_scoped_ptr(new MemoryDataSource(data, size)),
+  return StartInternal(base::WrapUnique(new MemoryDataSource(data, size)),
                        nullptr, test_type);
 }
 
 void PipelineIntegrationTestBase::Play() {
   pipeline_->SetPlaybackRate(1);
 }
 
 void PipelineIntegrationTestBase::Pause() {
   pipeline_->SetPlaybackRate(0);
 }
@@ skipping 63 matching lines @@
   message_loop_.PostDelayedTask(
       FROM_HERE,
       base::Bind(&PipelineIntegrationTestBase::QuitAfterCurrentTimeTask,
                  base::Unretained(this), wait_time),
       base::TimeDelta::FromMilliseconds(10));
   message_loop_.Run();
   return (pipeline_status_ == PIPELINE_OK);
 }
 
 void PipelineIntegrationTestBase::CreateDemuxer(
-    scoped_ptr<DataSource> data_source) {
+    std::unique_ptr<DataSource> data_source) {
   data_source_ = std::move(data_source);
 
   Demuxer::MediaTracksUpdatedCB tracks_updated_cb =
       base::Bind(&PipelineIntegrationTestBase::DemuxerMediaTracksUpdatedCB,
                  base::Unretained(this));
 
 #if !defined(MEDIA_DISABLE_FFMPEG)
-  demuxer_ = scoped_ptr<Demuxer>(new FFmpegDemuxer(
+  demuxer_ = std::unique_ptr<Demuxer>(new FFmpegDemuxer(
       message_loop_.task_runner(), data_source_.get(),
       base::Bind(&PipelineIntegrationTestBase::DemuxerEncryptedMediaInitDataCB,
                  base::Unretained(this)),
       tracks_updated_cb, new MediaLog()));
 #endif
 }
 
-scoped_ptr<Renderer> PipelineIntegrationTestBase::CreateRenderer() {
+std::unique_ptr<Renderer> PipelineIntegrationTestBase::CreateRenderer() {
   ScopedVector<VideoDecoder> video_decoders;
 #if !defined(MEDIA_DISABLE_LIBVPX)
   video_decoders.push_back(new VpxVideoDecoder());
 #endif  // !defined(MEDIA_DISABLE_LIBVPX)
 
 #if !defined(MEDIA_DISABLE_FFMPEG)
   video_decoders.push_back(new FFmpegVideoDecoder());
 #endif
 
   // Simulate a 60Hz rendering sink.
   video_sink_.reset(new NullVideoSink(
       clockless_playback_, base::TimeDelta::FromSecondsD(1.0 / 60),
       base::Bind(&PipelineIntegrationTestBase::OnVideoFramePaint,
                  base::Unretained(this)),
       message_loop_.task_runner()));
 
   // Disable frame dropping if hashing is enabled.
-  scoped_ptr<VideoRenderer> video_renderer(new VideoRendererImpl(
+  std::unique_ptr<VideoRenderer> video_renderer(new VideoRendererImpl(
       message_loop_.task_runner(), message_loop_.task_runner().get(),
       video_sink_.get(), std::move(video_decoders), false, nullptr,
       new MediaLog()));
 
   if (!clockless_playback_) {
     audio_sink_ = new NullAudioSink(message_loop_.task_runner());
   } else {
     clockless_audio_sink_ = new ClocklessAudioSink();
   }
 
   ScopedVector<AudioDecoder> audio_decoders;
 
 #if !defined(MEDIA_DISABLE_FFMPEG)
   audio_decoders.push_back(
       new FFmpegAudioDecoder(message_loop_.task_runner(), new MediaLog()));
 #endif
 
   audio_decoders.push_back(new OpusAudioDecoder(message_loop_.task_runner()));
 
   // Don't allow the audio renderer to resample buffers if hashing is enabled.
   if (!hashing_enabled_) {
     AudioParameters out_params(AudioParameters::AUDIO_PCM_LOW_LATENCY,
                                CHANNEL_LAYOUT_STEREO, 44100, 16, 512);
     hardware_config_.UpdateOutputConfig(out_params);
   }
 
-  scoped_ptr<AudioRenderer> audio_renderer(new AudioRendererImpl(
+  std::unique_ptr<AudioRenderer> audio_renderer(new AudioRendererImpl(
       message_loop_.task_runner(),
       (clockless_playback_)
           ? static_cast<AudioRendererSink*>(clockless_audio_sink_.get())
           : audio_sink_.get(),
       std::move(audio_decoders), hardware_config_, new MediaLog()));
   if (hashing_enabled_) {
     if (clockless_playback_)
       clockless_audio_sink_->StartAudioHashForTesting();
     else
       audio_sink_->StartAudioHashForTesting();
   }
 
-  scoped_ptr<RendererImpl> renderer_impl(
+  std::unique_ptr<RendererImpl> renderer_impl(
       new RendererImpl(message_loop_.task_runner(), std::move(audio_renderer),
                        std::move(video_renderer)));
 
   // Prevent non-deterministic buffering state callbacks from firing (e.g., slow
   // machine, valgrind).
   renderer_impl->DisableUnderflowForTesting();
 
   if (clockless_playback_)
     renderer_impl->EnableClocklessVideoPlaybackForTesting();
 
@@ skipping 30 matching lines @@
   DCHECK(clockless_playback_);
   return clockless_audio_sink_->render_time();
 }
 
 base::TimeTicks DummyTickClock::NowTicks() {
   now_ += base::TimeDelta::FromSeconds(60);
   return now_;
 }
 
 }  // namespace media