Change ownership of PipelineImpl

media/filters/pipeline_controller.h

 // Copyright 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_FILTERS_PIPELINE_CONTROLLER_H_
 #define MEDIA_FILTERS_PIPELINE_CONTROLLER_H_
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "media/base/media_export.h"
 #include "media/base/pipeline.h"
 #include "media/base/renderer.h"
 
 namespace media {
-
 class Demuxer;
 
 // PipelineController wraps a Pipeline to expose the one-at-a-time operations
 // (Seek(), Suspend(), and Resume()) with a simpler API. Internally it tracks
 // pending operations and dispatches them when possible. Duplicate requests
 // (such as seeking twice to the same time) may be elided.
 //
-// TODO(sandersd):
-//   - Expose an operation that restarts via suspend+resume.
+// TODO(sandersd/tguilbert):
+//   - Expose an operation that cycles via suspend+resume.

[sandersd (OOO until July 31), 2017/02/23 23:11:46]

Nit: Reword these as:
  - Expose an operation that replaces the renderer.
  - Expose an operation that replaces the demuxer.

I'm not sure if replacing the demuxer implies replacing the renderer as well.
Clarify that if you can.

[tguilbert, 2017/02/24 02:13:59]

Done.

 //   - Block invalid calls after an error occurs.
+//   - Support restarting with a new demuxer.
 class MEDIA_EXPORT PipelineController {
  public:
   enum class State {
     CREATED,
     STARTING,
     PLAYING,
     SEEKING,
     SUSPENDING,
     SUSPENDED,
     RESUMING,
   };
 
   using RendererFactoryCB = base::Callback<std::unique_ptr<Renderer>(void)>;
   using SeekedCB = base::Callback<void(bool time_updated)>;
   using SuspendedCB = base::Callback<void()>;
   using BeforeResumeCB = base::Callback<void()>;
   using ResumedCB = base::Callback<void()>;
 
-  // Construct a PipelineController wrapping |pipeline_|. |pipeline_| must
-  // outlive the resulting PipelineController. The callbacks are:
+  // Construct a PipelineController wrapping |pipeline_|.
+  // The callbacks are:
   //   - |renderer_factory_cb| is called by PipelineController to create new
   //     renderers when starting and resuming.
   //   - |seeked_cb| is called upon reaching a stable state if a seek occured.
   //   - |suspended_cb| is called immediately after suspending.
   //   - |before_resume_cb| is called immediately before resuming.
   //   - |resumed_cb| is called immediately after resuming.
   //   - |error_cb| is called if any operation on |pipeline_| does not result
   //     in PIPELINE_OK or its error callback is called.
-  PipelineController(Pipeline* pipeline,
+  PipelineController(std::unique_ptr<Pipeline> pipeline,
                      const RendererFactoryCB& renderer_factory_cb,
                      const SeekedCB& seeked_cb,
                      const SuspendedCB& suspended_cb,
                      const BeforeResumeCB& before_resume_cb,
                      const ResumedCB& resumed_cb,
                      const PipelineStatusCB& error_cb);
   ~PipelineController();
 
   // Start |pipeline_|. |demuxer| will be retained and StartWaitingForSeek()/
   // CancelPendingSeek() will be issued to it as necessary.
@@ skipping 33 matching lines @@
   //   - Start() is processed immediately while in the CREATED state.
   //   - Resume() is processed immediately while in the SUSPENDED state.
   bool IsStable();
 
   // Returns true if the current target state is suspended.
   bool IsSuspended();
 
   // Returns true if |pipeline_| is suspended.
   bool IsPipelineSuspended();
 
+  // Subset of the Pipeline interface directly exposing |pipeline_|.
+  void Stop();
+  bool IsPipelineRunning() const;
+  double GetPlaybackRate() const;
+  void SetPlaybackRate(double playback_rate);
+  float GetVolume() const;
+  void SetVolume(float volume);
+  base::TimeDelta GetMediaTime() const;
+  Ranges<base::TimeDelta> GetBufferedTimeRanges() const;
+  base::TimeDelta GetMediaDuration() const;
+  bool DidLoadingProgress();
+  PipelineStatistics GetStatistics() const;
+  void SetCdm(CdmContext* cdm_context, const CdmAttachedCB& cdm_attached_cb);
+  void OnEnabledAudioTracksChanged(
+      const std::vector<MediaTrack::Id>& enabledTrackIds);
+  void OnSelectedVideoTrackChanged(
+      const std::vector<MediaTrack::Id>& selectedTrackId);
+
  private:
   // Attempts to make progress from the current state to the target state.
   void Dispatch();
 
   // PipelineStaus callback that also carries the target state.
   void OnPipelineStatus(State state, PipelineStatus pipeline_status);
 
   // The Pipeline we are managing state for.
-  Pipeline* pipeline_ = nullptr;
+  std::unique_ptr<Pipeline> pipeline_;
 
   // Factory for Renderers, used for Start() and Resume().
   RendererFactoryCB renderer_factory_cb_;
 
   // Called after seeks (which includes Start()) upon reaching a stable state.
   // Multiple seeks result in only one callback if no stable state occurs
   // between them.
   SeekedCB seeked_cb_;
 
   // Called immediately when |pipeline_| completes a suspend operation.
@@ skipping 42 matching lines @@
 
   base::ThreadChecker thread_checker_;
   base::WeakPtrFactory<PipelineController> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PipelineController);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_PIPELINE_CONTROLLER_H_