Convert //chromecast from scoped_ptr to std::unique_ptr

chromecast/media/cma/pipeline/media_pipeline_impl.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 "chromecast/media/cma/pipeline/media_pipeline_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 98 matching lines @@
   video_pipeline_.reset();
   audio_pipeline_.reset();
   audio_decoder_.reset();
   media_pipeline_backend_.reset();
   if (!client_.pipeline_backend_destroyed_cb.is_null())
     client_.pipeline_backend_destroyed_cb.Run();
 }
 
 void MediaPipelineImpl::Initialize(
     LoadType load_type,
-    scoped_ptr<MediaPipelineBackend> media_pipeline_backend) {
+    std::unique_ptr<MediaPipelineBackend> media_pipeline_backend) {
   CMALOG(kLogControl) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
   audio_decoder_.reset();
   media_pipeline_backend_.reset(media_pipeline_backend.release());
   if (!client_.pipeline_backend_created_cb.is_null())
     client_.pipeline_backend_created_cb.Run();
 
   if (load_type == kLoadTypeURL || load_type == kLoadTypeMediaSource) {
     base::TimeDelta low_threshold(kLowBufferThresholdURL);
     base::TimeDelta high_threshold(kHighBufferThresholdURL);
@@ skipping 30 matching lines @@
   cdm_ = cdm;
   if (audio_pipeline_)
     audio_pipeline_->SetCdm(cdm);
   if (video_pipeline_)
     video_pipeline_->SetCdm(cdm);
 }
 
 ::media::PipelineStatus MediaPipelineImpl::InitializeAudio(
     const ::media::AudioDecoderConfig& config,
     const AvPipelineClient& client,
-    scoped_ptr<CodedFrameProvider> frame_provider) {
+    std::unique_ptr<CodedFrameProvider> frame_provider) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!audio_decoder_);
 
   MediaPipelineBackend::AudioDecoder* backend_audio_decoder =
       media_pipeline_backend_->CreateAudioDecoder();
   if (!backend_audio_decoder) {
     return ::media::PIPELINE_ERROR_ABORT;
   }
   audio_decoder_.reset(new AudioDecoderSoftwareWrapper(backend_audio_decoder));
   audio_pipeline_.reset(new AudioPipelineImpl(audio_decoder_.get(), client));
   if (cdm_)
     audio_pipeline_->SetCdm(cdm_);
   return audio_pipeline_->Initialize(config, std::move(frame_provider));
 }
 
 ::media::PipelineStatus MediaPipelineImpl::InitializeVideo(
     const std::vector<::media::VideoDecoderConfig>& configs,
     const VideoPipelineClient& client,
-    scoped_ptr<CodedFrameProvider> frame_provider) {
+    std::unique_ptr<CodedFrameProvider> frame_provider) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!video_decoder_);
 
   video_decoder_ = media_pipeline_backend_->CreateVideoDecoder();
   if (!video_decoder_) {
     return ::media::PIPELINE_ERROR_ABORT;
   }
   video_pipeline_.reset(new VideoPipelineImpl(video_decoder_, client));
   if (cdm_)
     video_pipeline_->SetCdm(cdm_);
@@ skipping 313 matching lines @@
 
 void MediaPipelineImpl::ResetBitrateState() {
   elapsed_time_delta_ = base::TimeDelta::FromSeconds(0);
   audio_bytes_for_bitrate_estimation_ = 0;
   video_bytes_for_bitrate_estimation_ = 0;
   last_sample_time_ = base::TimeTicks::Now();
 }
 
 }  // namespace media
 }  // namespace chromecast