Move Renderer permanent callbacks into RendererClient 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"
 #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"
 #include "media/base/media_export.h"
 #include "media/base/pipeline.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/ranges.h"
+#include "media/base/renderer_client.h"
 #include "media/base/serial_runner.h"
 #include "media/base/text_track.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 }
 
 namespace media {
 
 class MediaLog;
@@ skipping 33 matching lines @@
 // a chance to preroll. From then on the normal Seek() transitions are carried
 // out and we start playing the media.
 //
 // 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 {
+class MEDIA_EXPORT PipelineImpl : public Pipeline,
+                                  public DemuxerHost,
+                                  public RendererClient {
  public:
   // 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;
@@ skipping 52 matching lines @@
 
   // DemuxerHost implementaion.
   void OnBufferedTimeRangesChanged(
       const Ranges<base::TimeDelta>& ranges) override;
   void SetDuration(base::TimeDelta duration) override;
   void OnDemuxerError(PipelineStatus error) override;
   void AddTextStream(DemuxerStream* text_stream,
                      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();
+  // RendererClient implementation.
+  void OnError(PipelineStatus error) override;
+  void OnEnded() override;
+  void OnStatisticsUpdate(const PipelineStatistics& stats) override;
+  void OnBufferingStateChange(BufferingState state) override;
+  void OnWaitingForDecryptionKey() override;
 
   // 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.
@@ skipping 21 matching lines @@
   // |cdm_attached_cb| with the result. If |renderer_| is null,
   // |cdm_attached_cb| will be fired immediately with true, and |cdm_context|
   // will be set in |renderer_| later when |renderer_| is created.
   void SetCdmTask(CdmContext* cdm_context,
                   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();

[xhwang, 2016/05/09 18:13:22]

remove?

[alokp, 2016/05/09 21:31:43]

Done.

   void OnTextRendererEnded();
   void RunEndedCallbackIfNeeded();
 
   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.
@@ skipping 12 matching lines @@
 
   // 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);
 
   // 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.
   const scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
 
   // MediaLog to which to log events.
   scoped_refptr<MediaLog> media_log_;
 
@@ skipping 93 matching lines @@
   // 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_