media: Remove FilterCollection.

media/base/pipeline.h

 // 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.
 
 #ifndef MEDIA_BASE_PIPELINE_H_
 #define MEDIA_BASE_PIPELINE_H_
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/default_tick_clock.h"
 #include "media/base/buffering_state.h"
 #include "media/base/demuxer.h"
 #include "media/base/media_export.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/ranges.h"
 #include "media/base/serial_runner.h"
+#include "media/base/text_track.h"
 #include "media/base/video_rotation.h"
 #include "ui/gfx/size.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 class TimeDelta;
 }
 
 namespace media {
 
-class FilterCollection;
 class MediaLog;
 class Renderer;
 class TextRenderer;
 class TextTrackConfig;
 class TimeDeltaInterpolator;
 
 // Metadata describing a pipeline once it has been initialized.
 struct PipelineMetadata {
   PipelineMetadata()
       : has_audio(false), has_video(false), video_rotation(VIDEO_ROTATION_0) {}
@@ skipping 34 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.
 class MEDIA_EXPORT Pipeline : public DemuxerHost {
  public:
   // Constructs a media pipeline that will execute on |task_runner|.
   Pipeline(const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
            MediaLog* media_log);
   virtual ~Pipeline();
 
-  // Build a pipeline to using the given filter collection to construct a filter
-  // chain, executing |seek_cb| when the initial seek has completed.
-  //
-  // |filter_collection| must be a complete collection containing a demuxer,
-  // audio/video decoders, and audio/video renderers. Failing to do so will
-  // result in a crash.
+  // Build a pipeline to using the given |demuxer| and |renderer| to construct
+  // a filter chain, executing |seek_cb| when the initial seek has completed.
   //
   // The following permanent callbacks will be executed as follows up until
   // Stop() has completed:
   //   |ended_cb| will be executed whenever the media reaches the end.
   //   |error_cb| will be executed whenever an error occurs but hasn't been
   //              reported already through another callback.
   //   |metadata_cb| will be executed when the content duration, container video
   //                 size, start time, and whether the content has audio and/or
   //                 video in supported formats are known.
   //   |buffering_state_cb| will be executed whenever there are changes in the
   //                        overall buffering state of the pipeline.
   //   |duration_change_cb| optional callback that will be executed whenever the
   //                        presentation duration changes.
+  //   |add_text_track_cb| will be executed whenever a text track is added.
   // It is an error to call this method after the pipeline has already started.
-  void Start(scoped_ptr<FilterCollection> filter_collection,
+  void Start(Demuxer* demuxer,
+             scoped_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 base::Closure& duration_change_cb,
+             const AddTextTrackCB& add_text_track_cb);
 
   // Asynchronously stops the pipeline, executing |stop_cb| when the pipeline
   // teardown has completed.
   //
   // Stop() must complete before destroying the pipeline. It it permissible to
   // call Stop() at any point during the lifetime of the pipeline.
   //
   // It is safe to delete the pipeline during the execution of |stop_cb|.
   void Stop(const base::Closure& stop_cb);
 
@@ skipping 117 matching lines @@
   void VolumeChangedTask(float volume);
 
   // Carries out notifying filters that we are seeking to a new timestamp.
   void SeekTask(base::TimeDelta time, const PipelineStatusCB& seek_cb);
 
   // Callbacks executed when a renderer has ended.
   void OnRendererEnded();
   void OnTextRendererEnded();
   void RunEndedCallbackIfNeeded();
 
+  scoped_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,
+                      const AddTextTrackDoneCB& done_cb);
+
   // Kicks off initialization for each media object, executing |done_cb| with
   // the result when completed.
   void InitializeDemuxer(const PipelineStatusCB& done_cb);
   void InitializeRenderer(const PipelineStatusCB& done_cb);
 
   void OnStateTransition(PipelineStatus status);
   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);
 
+  void ReportMetaData();

[scherkus (not reviewing), 2014/08/28 18:48:22]

nit: Metadata

[xhwang, 2014/08/28 19:52:05]

Done.

+
   void BufferingStateChanged(BufferingState new_buffering_state);
 
   // Task runner used to execute pipeline tasks.
   scoped_refptr<base::SingleThreadTaskRunner> 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_;
@@ skipping 47 matching lines @@
 
   // Temporary callback used for Stop().
   base::Closure stop_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_;
-
-  // Contains the demuxer and renderers to use when initializing.
-  scoped_ptr<FilterCollection> filter_collection_;
+  AddTextTrackCB add_text_track_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_;
 
   PipelineStatistics statistics_;
 
   scoped_ptr<SerialRunner> pending_callbacks_;
 
   base::ThreadChecker thread_checker_;
 
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<Pipeline> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Pipeline);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_PIPELINE_H_