Move Pipeline permanent callbacks into Pipeline::Client interface.

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"
@@ skipping 58 matching lines @@
 //
 // If any error ever happens, this object will transition to the "Error" state
 // from any state. If Stop() is ever called, this object will transition to
 // "Stopped" state.
 //
 // TODO(sandersd): It should be possible to pass through Suspended when going
 // from InitDemuxer to InitRenderer, thereby eliminating the Resuming state.
 // Some annoying differences between the two paths need to be removed first.
 class MEDIA_EXPORT PipelineImpl : public Pipeline, public DemuxerHost {
  public:
-  // Constructs a media pipeline that will execute on |task_runner|.
-  PipelineImpl(const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-               MediaLog* media_log);
+  // Constructs a media pipeline that will execute media tasks on
+  // |media_task_runner|.
+  PipelineImpl(
+      const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
+      MediaLog* media_log);
   ~PipelineImpl() override;
 
   void SetErrorForTesting(PipelineStatus status);
   bool HasWeakPtrsForTesting() const;
 
   // Pipeline implementation.
   void Start(Demuxer* demuxer,
              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;
+             Client* client,
+             const PipelineStatusCB& seek_cb) override;
+  void Stop() 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(std::unique_ptr<Renderer> renderer,
               base::TimeDelta timestamp,
               const PipelineStatusCB& seek_cb) override;
   float GetVolume() const override;
   void SetVolume(float volume) override;
@@ skipping 42 matching lines @@
                      const TextTrackConfig& config) override;
   void RemoveTextStream(DemuxerStream* text_stream) override;
 
   // Callback executed when a rendering error happened, initiating the teardown
   // sequence.
   void OnError(PipelineStatus error);
 
   // Callback executed by filters to update statistics.
   void OnUpdateStatistics(const PipelineStatistics& stats_delta);
 
+  // Callback executed by renderer when waiting for decryption key.
+  void OnWaitingForDecryptionKey();
+
   // 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(std::unique_ptr<Renderer> renderer,
@@ skipping 48 matching lines @@
   // the result when completed.
   void InitializeDemuxer(const PipelineStatusCB& done_cb);
   void InitializeRenderer(const PipelineStatusCB& done_cb);
 
   void StateTransitionTask(PipelineStatus status);
 
   // Initiates an asynchronous pause-flush-seek-preroll call sequence
   // executing |done_cb| with the final status when completed.
   void DoSeek(base::TimeDelta seek_timestamp, const PipelineStatusCB& done_cb);
 
-  // Initiates an asynchronous pause-flush-stop call sequence executing
-  // |done_cb| when completed.
-  void DoStop(const PipelineStatusCB& done_cb);
-  void OnStopCompleted(PipelineStatus status);
+  // Stops media rendering and executes |stop_cb_| when done.
+  void DoStop();
 
   void ReportMetadata();
 
   void BufferingStateChanged(BufferingState new_buffering_state);
 
+  // Task runner of the thread on which this class is constructed.
+  // Also used to post notifications on Pipeline::Client object.
+  const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
+
   // Task runner used to execute pipeline tasks.
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  const scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
 
   // MediaLog to which to log events.
   scoped_refptr<MediaLog> media_log_;
 
   // Lock used to serialize access for the following data members.
   mutable base::Lock lock_;
 
   // Whether or not the pipeline is running.
   bool running_;
 
@@ skipping 37 matching lines @@
   // set to kNoTimestamp().
   base::TimeDelta suspend_timestamp_;
 
   // Whether we've received the audio/video/text ended events.
   bool renderer_ended_;
   bool text_renderer_ended_;
 
   // Temporary callback used for Start(), Seek(), and Resume().
   PipelineStatusCB seek_cb_;
 
   // Temporary callback used for Stop().

[xhwang, 2016/05/04 06:32:22]

This is really for StopTask() now. 

Actually it seems we can just pass the |stop_cb| to DoStop(), in which case we
don't need to store this as a class member, which seems cleaner to me.

[alokp, 2016/05/04 17:40:01]

In StopTask, we skip calling DoStop if the pipeline is already in the kStopping
state. In that case we simply store the stop_cb as a member variable for DoStop
to call later. I think this is from the days when we used to post tasks for
DoStop and OnStopCompleted. We no longer need the kStopping state. I have
already combined OnStopCompleted into DoStop. We can further combine StopTask
and DoStop and get rid of kStopping state. I would prefer to make this change in
a follow-up patch - perhaps when we split this class along threads.

   base::Closure stop_cb_;
 
   // Temporary callback used for Suspend().
   PipelineStatusCB suspend_cb_;
 
-  // Permanent callbacks passed in via Start().
-  base::Closure ended_cb_;
-  PipelineStatusCB error_cb_;
-  PipelineMetadataCB metadata_cb_;
-  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.
   std::unique_ptr<Renderer> renderer_;
   std::unique_ptr<TextRenderer> text_renderer_;
 
+  // Holds the client passed on Start().
+  std::unique_ptr<base::WeakPtrFactory<Client>> client_weak_factory_;

[xhwang, 2016/05/04 06:32:22]

Can you add comments about the threading expectation on this factory?

[alokp, 2016/05/04 17:40:01]

Added comments and also created weak_client_ as suggested by wez@

+
   PipelineStatistics statistics_;
 
   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_