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

media/base/pipeline_impl.h

 // Copyright (c) 2016 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.
 
 #ifndef MEDIA_BASE_PIPELINE_IMPL_H_
 #define MEDIA_BASE_PIPELINE_IMPL_H_
 
+#include <memory>
+
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "media/base/buffering_state.h"
 #include "media/base/cdm_context.h"
 #include "media/base/demuxer.h"
@@ skipping 59 matching lines @@
   // Constructs a media pipeline that will execute on |task_runner|.
   PipelineImpl(const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
                MediaLog* media_log);
   ~PipelineImpl() override;
 
   void SetErrorForTesting(PipelineStatus status);
   bool HasWeakPtrsForTesting() const;
 
   // Pipeline implementation.
   void 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) override;
   void Stop(const base::Closure& stop_cb) override;
   void Seek(base::TimeDelta time, const PipelineStatusCB& seek_cb) override;
   bool IsRunning() const override;
   double GetPlaybackRate() const override;
   void SetPlaybackRate(double playback_rate) override;
   void Suspend(const PipelineStatusCB& suspend_cb) override;
-  void Resume(scoped_ptr<Renderer> renderer,
+  void Resume(std::unique_ptr<Renderer> renderer,
               base::TimeDelta timestamp,
               const PipelineStatusCB& seek_cb) override;
   float GetVolume() const override;
   void SetVolume(float volume) override;
   base::TimeDelta GetMediaTime() const override;
   Ranges<base::TimeDelta> GetBufferedTimeRanges() const override;
   base::TimeDelta GetMediaDuration() const override;
   bool DidLoadingProgress() override;
   PipelineStatistics GetStatistics() const override;
   void SetCdm(CdmContext* cdm_context,
@@ skipping 45 matching lines @@
 
   // The following "task" methods correspond to the public methods, but these
   // methods are run as the result of posting a task to the Pipeline's
   // task runner.
   void StartTask();
 
   // Suspends the pipeline, discarding the current renderer.
   void SuspendTask(const PipelineStatusCB& suspend_cb);
 
   // Resumes the pipeline with a new renderer, and initializes it with a seek.
-  void ResumeTask(scoped_ptr<Renderer> renderer,
+  void ResumeTask(std::unique_ptr<Renderer> renderer,
                   base::TimeDelta timestamp,
                   const PipelineStatusCB& seek_sb);
 
   // Stops and destroys all filters, placing the pipeline in the kStopped state.
   void StopTask(const base::Closure& stop_cb);
 
   // Carries out stopping and destroying all filters, placing the pipeline in
   // the kStopped state.
   void ErrorChangedTask(PipelineStatus error);
 
@@ skipping 14 matching lines @@
                   const CdmAttachedCB& cdm_attached_cb);
   void OnCdmAttached(const CdmAttachedCB& cdm_attached_cb,
                      CdmContext* cdm_context,
                      bool success);
 
   // Callbacks executed when a renderer has ended.
   void OnRendererEnded();
   void OnTextRendererEnded();
   void RunEndedCallbackIfNeeded();
 
-  scoped_ptr<TextRenderer> CreateTextRenderer();
+  std::unique_ptr<TextRenderer> CreateTextRenderer();
 
   // Carries out adding a new text stream to the text renderer.
   void AddTextStreamTask(DemuxerStream* text_stream,
                          const TextTrackConfig& config);
 
   // Carries out removing a text stream from the text renderer.
   void RemoveTextStreamTask(DemuxerStream* text_stream);
 
   // Callbacks executed when a text track is added.
   void OnAddTextTrack(const TextTrackConfig& config,
@@ skipping 91 matching lines @@
   BufferingStateCB buffering_state_cb_;
   base::Closure duration_change_cb_;
   AddTextTrackCB add_text_track_cb_;
   base::Closure waiting_for_decryption_key_cb_;
 
   // Holds the initialized demuxer. Used for seeking. Owned by client.
   Demuxer* demuxer_;
 
   // Holds the initialized renderers. Used for setting the volume,
   // playback rate, and determining when playback has finished.
-  scoped_ptr<Renderer> renderer_;
-  scoped_ptr<TextRenderer> text_renderer_;
+  std::unique_ptr<Renderer> renderer_;
+  std::unique_ptr<TextRenderer> text_renderer_;
 
   PipelineStatistics statistics_;
 
-  scoped_ptr<SerialRunner> pending_callbacks_;
+  std::unique_ptr<SerialRunner> pending_callbacks_;
 
   // The CdmContext to be used to decrypt (and decode) encrypted stream in this
   // pipeline. It is set when SetCdm() succeeds on the renderer (or when
   // SetCdm() is called before Start()), after which it is guaranteed to outlive
   // this pipeline. The saved value will be used to configure new renderers,
   // when starting or resuming.
   CdmContext* cdm_context_;
 
   base::ThreadChecker thread_checker_;
 
   // A weak pointer that can be safely copied on the media thread.
   base::WeakPtr<PipelineImpl> weak_this_;
 
   // Weak pointers must be created on the main thread, and must be dereferenced
   // on the media thread.
   //
   // Declared last so that weak pointers will be invalidated before all other
   // member variables.
   base::WeakPtrFactory<PipelineImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PipelineImpl);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_PIPELINE_IMPL_H_