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

media/base/pipeline_impl.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/base/pipeline_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/base/renderer.h"
 #include "media/base/text_renderer.h"
@@ skipping 28 matching lines @@
 
 PipelineImpl::~PipelineImpl() {
   DCHECK(thread_checker_.CalledOnValidThread())
       << "Pipeline must be destroyed on same thread that created it";
   DCHECK(!running_) << "Stop() must complete before destroying object";
   DCHECK(stop_cb_.is_null());
   DCHECK(seek_cb_.is_null());
 }
 
 void PipelineImpl::Start(Demuxer* demuxer,
-                         scoped_ptr<Renderer> renderer,
+                         std::unique_ptr<Renderer> renderer,
                          const base::Closure& ended_cb,
                          const PipelineStatusCB& error_cb,
                          const PipelineStatusCB& seek_cb,
                          const PipelineMetadataCB& metadata_cb,
                          const BufferingStateCB& buffering_state_cb,
                          const base::Closure& duration_change_cb,
                          const AddTextTrackCB& add_text_track_cb,
                          const base::Closure& waiting_for_decryption_key_cb) {
   DCHECK(!ended_cb.is_null());
   DCHECK(!error_cb.is_null());
@@ skipping 58 matching lines @@
                            base::Bind(&PipelineImpl::PlaybackRateChangedTask,
                                       weak_this_, playback_rate));
   }
 }
 
 void PipelineImpl::Suspend(const PipelineStatusCB& suspend_cb) {
   task_runner_->PostTask(FROM_HERE, base::Bind(&PipelineImpl::SuspendTask,
                                                weak_this_, suspend_cb));
 }
 
-void PipelineImpl::Resume(scoped_ptr<Renderer> renderer,
+void PipelineImpl::Resume(std::unique_ptr<Renderer> renderer,
                           base::TimeDelta timestamp,
                           const PipelineStatusCB& seek_cb) {
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&PipelineImpl::ResumeTask, weak_this_,
                             base::Passed(&renderer), timestamp, seek_cb));
 }
 
 float PipelineImpl::GetVolume() const {
   base::AutoLock auto_lock(lock_);
   return volume_;
@@ skipping 276 matching lines @@
   pending_callbacks_ = SerialRunner::Run(bound_fns, done_cb);
 }
 
 void PipelineImpl::DoStop(const PipelineStatusCB& done_cb) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!pending_callbacks_.get());
 
   // TODO(scherkus): Enforce that Renderer is only called on a single thread,
   // even for accessing media time http://crbug.com/370634
-  scoped_ptr<Renderer> renderer;
+  std::unique_ptr<Renderer> renderer;
   {
     base::AutoLock auto_lock(lock_);
     renderer.swap(renderer_);
   }
   renderer.reset();
   text_renderer_.reset();
 
   if (demuxer_) {
     demuxer_->Stop();
     demuxer_ = NULL;
@@ skipping 224 matching lines @@
 
   if (text_renderer_) {
     fns.Push(base::Bind(&TextRenderer::Flush,
                         base::Unretained(text_renderer_.get())));
   }
 
   pending_callbacks_ = SerialRunner::Run(
       fns, base::Bind(&PipelineImpl::StateTransitionTask, weak_this_));
 }
 
-void PipelineImpl::ResumeTask(scoped_ptr<Renderer> renderer,
+void PipelineImpl::ResumeTask(std::unique_ptr<Renderer> renderer,
                               base::TimeDelta timestamp,
                               const PipelineStatusCB& seek_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Suppress resuming if we're not suspended.
   if (state_ != kSuspended) {
     DCHECK(state_ == kStopping || state_ == kStopped)
         << "Receive resume in unexpected state: " << state_;
     seek_cb.Run(PIPELINE_ERROR_INVALID_STATE);
     return;
@@ skipping 81 matching lines @@
   if (renderer_ && !renderer_ended_)
     return;
 
   if (text_renderer_ && text_renderer_->HasTracks() && !text_renderer_ended_)
     return;
 
   DCHECK_EQ(status_, PIPELINE_OK);
   ended_cb_.Run();
 }
 
-scoped_ptr<TextRenderer> PipelineImpl::CreateTextRenderer() {
+std::unique_ptr<TextRenderer> PipelineImpl::CreateTextRenderer() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   if (!cmd_line->HasSwitch(switches::kEnableInbandTextTracks))
-    return scoped_ptr<media::TextRenderer>();
+    return nullptr;
 
-  return scoped_ptr<media::TextRenderer>(new media::TextRenderer(
+  return base::WrapUnique(new media::TextRenderer(
       task_runner_, base::Bind(&PipelineImpl::OnAddTextTrack, weak_this_)));
 }
 
 void PipelineImpl::AddTextStreamTask(DemuxerStream* text_stream,
                                      const TextTrackConfig& config) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   // TODO(matthewjheaney): fix up text_ended_ when text stream
   // is added (http://crbug.com/321446).
   if (text_renderer_)
     text_renderer_->AddTextStream(text_stream, config);
@@ skipping 57 matching lines @@
   metadata_cb_.Run(metadata);
 }
 
 void PipelineImpl::BufferingStateChanged(BufferingState new_buffering_state) {
   DVLOG(1) << __FUNCTION__ << "(" << new_buffering_state << ") ";
   DCHECK(task_runner_->BelongsToCurrentThread());
   buffering_state_cb_.Run(new_buffering_state);
 }
 
 }  // namespace media