Convert //chromecast from scoped_ptr to std::unique_ptr

chromecast/renderer/media/media_pipeline_proxy.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/renderer/media/media_pipeline_proxy.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "chromecast/common/media/cma_messages.h"
 #include "chromecast/media/cma/base/coded_frame_provider.h"
 #include "chromecast/renderer/media/audio_pipeline_proxy.h"
 #include "chromecast/renderer/media/media_channel_proxy.h"
 #include "chromecast/renderer/media/video_pipeline_proxy.h"
 
 namespace chromecast {
 namespace media {
 
 // MediaPipelineProxyInternal -
 // This class is not thread safe and should run on the same thread
 // as the media channel proxy.
 class MediaPipelineProxyInternal {
  public:
-  static void Release(scoped_ptr<MediaPipelineProxyInternal> proxy);
+  static void Release(std::unique_ptr<MediaPipelineProxyInternal> proxy);
 
   explicit MediaPipelineProxyInternal(
       scoped_refptr<MediaChannelProxy> media_channel_proxy);
   virtual ~MediaPipelineProxyInternal();
 
   void SetClient(const MediaPipelineClient& client);
   void SetCdm(int render_frame_id, int cdm_id);
   void StartPlayingFrom(const base::TimeDelta& time);
   void Flush(const base::Closure& flush_cb);
   void Stop();
@@ skipping 12 matching lines @@
   MediaPipelineClient client_;
 
   // Store the callback for a flush.
   base::Closure flush_cb_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaPipelineProxyInternal);
 };
 
 // static
 void MediaPipelineProxyInternal::Release(
-    scoped_ptr<MediaPipelineProxyInternal> proxy) {
+    std::unique_ptr<MediaPipelineProxyInternal> proxy) {
   proxy->Shutdown();
 }
 
 MediaPipelineProxyInternal::MediaPipelineProxyInternal(
     scoped_refptr<MediaChannelProxy> media_channel_proxy)
     : media_channel_proxy_(media_channel_proxy) {
   DCHECK(media_channel_proxy.get());
 
   // Creation can be done on a different thread.
   thread_checker_.DetachFromThread();
@@ skipping 19 matching lines @@
   CmaMessageFilterProxy::MediaDelegate delegate;
   delegate.flush_cb = base::Bind(&MediaPipelineProxyInternal::OnFlushDone,
                                  base::Unretained(this));
   delegate.client = client;
   bool success = media_channel_proxy_->SetMediaDelegate(delegate);
   CHECK(success);
 }
 
 void MediaPipelineProxyInternal::SetCdm(int render_frame_id, int cdm_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  bool success = media_channel_proxy_->Send(scoped_ptr<IPC::Message>(
-      new CmaHostMsg_SetCdm(media_channel_proxy_->GetId(),
-                            render_frame_id,
-                            cdm_id)));
+  bool success = media_channel_proxy_->Send(
+      std::unique_ptr<IPC::Message>(new CmaHostMsg_SetCdm(
+          media_channel_proxy_->GetId(), render_frame_id, cdm_id)));
   LOG_IF(ERROR, !success) << "Failed to send SetCdm=" << cdm_id;
 }
 
 void MediaPipelineProxyInternal::Flush(const base::Closure& flush_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  bool success = media_channel_proxy_->Send(scoped_ptr<IPC::Message>(
+  bool success = media_channel_proxy_->Send(std::unique_ptr<IPC::Message>(
       new CmaHostMsg_Flush(media_channel_proxy_->GetId())));
   if (!success) {
     LOG(ERROR) << "Failed to send Flush";
     return;
   }
   DCHECK(flush_cb_.is_null());
   flush_cb_ = flush_cb;
 }
 
 void MediaPipelineProxyInternal::Stop() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  bool success = media_channel_proxy_->Send(scoped_ptr<IPC::Message>(
+  bool success = media_channel_proxy_->Send(std::unique_ptr<IPC::Message>(
       new CmaHostMsg_Stop(media_channel_proxy_->GetId())));
   if (!success)
     client_.error_cb.Run(::media::PIPELINE_ERROR_ABORT);
 }
 
 void MediaPipelineProxyInternal::StartPlayingFrom(const base::TimeDelta& time) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  bool success = media_channel_proxy_->Send(scoped_ptr<IPC::Message>(
-      new CmaHostMsg_StartPlayingFrom(
-          media_channel_proxy_->GetId(), time)));
+  bool success = media_channel_proxy_->Send(std::unique_ptr<IPC::Message>(
+      new CmaHostMsg_StartPlayingFrom(media_channel_proxy_->GetId(), time)));
   if (!success)
     client_.error_cb.Run(::media::PIPELINE_ERROR_ABORT);
 }
 
 void MediaPipelineProxyInternal::SetPlaybackRate(double playback_rate) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  media_channel_proxy_->Send(scoped_ptr<IPC::Message>(
-      new CmaHostMsg_SetPlaybackRate(
+  media_channel_proxy_->Send(
+      std::unique_ptr<IPC::Message>(new CmaHostMsg_SetPlaybackRate(
           media_channel_proxy_->GetId(), playback_rate)));
 }
 
 void MediaPipelineProxyInternal::OnFlushDone() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!flush_cb_.is_null());
   base::ResetAndReturn(&flush_cb_).Run();
 }
 
 // A macro runs current member function on |io_task_runner_| thread.
@@ skipping 45 matching lines @@
 AudioPipelineProxy* MediaPipelineProxy::GetAudioPipeline() const {
   return audio_pipeline_.get();
 }
 
 VideoPipelineProxy* MediaPipelineProxy::GetVideoPipeline() const {
   return video_pipeline_.get();
 }
 
 void MediaPipelineProxy::InitializeAudio(
     const ::media::AudioDecoderConfig& config,
-    scoped_ptr<CodedFrameProvider> frame_provider,
+    std::unique_ptr<CodedFrameProvider> frame_provider,
     const ::media::PipelineStatusCB& status_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
   has_audio_ = true;
   audio_pipeline_->Initialize(config, std::move(frame_provider), status_cb);
 }
 
 void MediaPipelineProxy::InitializeVideo(
     const std::vector<::media::VideoDecoderConfig>& configs,
-    scoped_ptr<CodedFrameProvider> frame_provider,
+    std::unique_ptr<CodedFrameProvider> frame_provider,
     const ::media::PipelineStatusCB& status_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
   has_video_ = true;
   video_pipeline_->Initialize(configs, std::move(frame_provider), status_cb);
 }
 
 void MediaPipelineProxy::StartPlayingFrom(base::TimeDelta time) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (has_audio_)
     audio_pipeline_->StartFeeding();
@@ skipping 45 matching lines @@
   FORWARD_ON_IO_THREAD(Stop);
 }
 
 void MediaPipelineProxy::SetPlaybackRate(double playback_rate) {
   DCHECK(thread_checker_.CalledOnValidThread());
   FORWARD_ON_IO_THREAD(SetPlaybackRate, playback_rate);
 }
 
 }  // namespace cma
 }  // namespace chromecast