Move VideoRenderer out of Filter heirarchy.

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 <string>
 
 #include "base/gtest_prod_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "media/base/audio_renderer.h"
 #include "media/base/demuxer.h"
-#include "media/base/filter_host.h"
 #include "media/base/media_export.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/ranges.h"
 #include "ui/gfx/size.h"
 
 class MessageLoop;
 
 namespace base {
 class MessageLoopProxy;
 class TimeDelta;
 }
 
 namespace media {
 
 class AudioDecoder;
 class Clock;
-class Filter;
 class FilterCollection;
 class MediaLog;
 class VideoDecoder;
 class VideoRenderer;
 
 // Adapter for using asynchronous Pipeline methods in code that wants to run
 // synchronously.  To use, construct an instance of this class and pass the
 // |Callback()| to the Pipeline method requiring a callback.  Then Wait() for
 // the callback to get fired and call status() to see what the callback's
 // argument was.  This object is for one-time use; call |Callback()| exactly
@@ skipping 32 matching lines @@
 //         |                                              ^
 //         V                                              | if Stop
 //   [ Seeking (for each filter) ] <--------[ Flushing (for each filter) ]
 //         |                         if Seek              ^
 //         V                                              |
 //   [ Starting (for each filter) ]                       |
 //         |                                              |
 //         V      Seek()/Stop()                           |
 //   [ Started ] -------------------------> [ Pausing (for each filter) ]
 //         |                                              ^
-//         |   NotifyEnded()             Seek()/Stop()    |
+//         |   OnRendererEnded()             Seek()/Stop()    |
 //         `-------------> [ Ended ] ---------------------'
 //                                                        ^  SetError()
 //                                                        |
 //                                         [ Any State Other Than InitXXX ]
 
 //
 // Initialization is a series of state transitions from "Created" through each
 // filter initialization state.  When all filter initialization states have
 // completed, we are implicitly in a "Paused" state.  At that point we simulate
 // a Seek() to the beginning of the media to give filters 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.
 class MEDIA_EXPORT Pipeline
     : public base::RefCountedThreadSafe<Pipeline>,
-      public FilterHost,
       public DemuxerHost {
  public:
   // Constructs a media pipeline that will execute on |message_loop|.
   Pipeline(MessageLoop* message_loop, MediaLog* media_log);
 
   // Build a pipeline to using the given filter collection to construct a filter
   // chain.
   //
   // Pipeline initialization is an inherently asynchronous process.  Clients can
   // either poll the IsInitialized() method (discouraged) or optionally pass in
@@ skipping 27 matching lines @@
   //
   // It is an error to call this method if the pipeline has not started.
   //
   // TODO(scherkus): ideally clients would destroy the pipeline after calling
   // Stop() and create a new pipeline as needed.
   void Stop(const base::Closure& stop_cb);
 
   // Attempt to seek to the position specified by time.  |seek_cb| will be
   // executed when the all filters in the pipeline have processed the seek.
   //
-  // Clients are expected to call GetCurrentTime() to check whether the seek
+  // Clients are expected to call GetMediaTime() to check whether the seek
   // succeeded.
   //
   // It is an error to call this method if the pipeline has not started.
   void Seek(base::TimeDelta time, const PipelineStatusCB& seek_cb);
 
   // Returns true if the pipeline has been started via Start().  If IsRunning()
   // returns true, it is expected that Stop() will be called before destroying
   // the pipeline.
   bool IsRunning() const;
 
@@ skipping 24 matching lines @@
   // Gets the current volume setting being used by the audio renderer.  When
   // the pipeline is started, this value will be 1.0f.  Valid values range
   // from 0.0f to 1.0f.
   float GetVolume() const;
 
   // Attempt to set the volume of the audio renderer.  Valid values for volume
   // range from 0.0f (muted) to 1.0f (full volume).  This value affects all
   // channels proportionately for multi-channel audio streams.
   void SetVolume(float volume);
 
-  // Gets the current pipeline time. For a pipeline "time" progresses from 0 to
-  // the end of the media.
-  base::TimeDelta GetCurrentTime() const;
+  // Returns the current media playback time, which progresses from 0 until
+  // GetMediaDuration().
+  base::TimeDelta GetMediaTime() const;
 
   // Get approximate time ranges of buffered media.
   Ranges<base::TimeDelta> GetBufferedTimeRanges();
 
   // Get the duration of the media in microseconds.  If the duration has not
   // been determined yet, then returns 0.
   base::TimeDelta GetMediaDuration() const;
 
   // Get the total size of the media file.  If the size has not yet been
   // determined or can not be determined, this value is 0.
   int64 GetTotalBytes() const;
 
   // Gets the natural size of the video output in pixel units.  If there is no
   // video or the video has not been rendered yet, the width and height will
   // be 0.
   void GetNaturalVideoSize(gfx::Size* out_size) const;
 
   // Return true if loading progress has been made since the last time this
   // method was called.
   bool DidLoadingProgress() const;
 
   // Gets the current pipeline statistics.
   PipelineStatistics GetStatistics() const;
 
   void SetClockForTesting(Clock* clock);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(PipelineTest, GetBufferedTimeRanges);
   FRIEND_TEST_ALL_PREFIXES(PipelineTest, DisableAudioRenderer);
+  FRIEND_TEST_ALL_PREFIXES(PipelineTest, DisableAudioRendererDuringInit);
+  FRIEND_TEST_ALL_PREFIXES(PipelineTest, EndedCallback);
+  FRIEND_TEST_ALL_PREFIXES(PipelineTest, AudioStreamShorterThanVideo);
   friend class MediaLog;
 
   // Only allow ourselves to be deleted by reference counting.
   friend class base::RefCountedThreadSafe<Pipeline>;
   virtual ~Pipeline();
 
   // Pipeline states, as described above.
   enum State {
     kCreated,
     kInitDemuxer,
@@ skipping 50 matching lines @@
   // DataSourceHost (by way of DemuxerHost) implementation.
   virtual void SetTotalBytes(int64 total_bytes) OVERRIDE;
   virtual void AddBufferedByteRange(int64 start, int64 end) OVERRIDE;
   virtual void AddBufferedTimeRange(base::TimeDelta start,
                                     base::TimeDelta end) OVERRIDE;
 
   // DemuxerHost implementaion.
   virtual void SetDuration(base::TimeDelta duration) OVERRIDE;
   virtual void OnDemuxerError(PipelineStatus error) OVERRIDE;
 
-  // FilterHost implementation.
-  virtual void SetError(PipelineStatus error) OVERRIDE;
-  virtual base::TimeDelta GetTime() const OVERRIDE;
-  virtual base::TimeDelta GetDuration() const OVERRIDE;
-  virtual void SetNaturalVideoSize(const gfx::Size& size) OVERRIDE;
-  virtual void NotifyEnded() OVERRIDE;
+  // Initiates teardown sequence in response to a runtime error.
+  //
+  // Safe to call from any thread.
+  void SetError(PipelineStatus error);
+
+  // Callback executed when the natural size of the video has changed.
+  void OnNaturalVideoSizeChanged(const gfx::Size& size);
+
+  // Callback executed when either of the renderers have ended.
+  void OnRendererEnded();
 
   // Callbacks executed by filters upon completing initialization.
   void OnFilterInitialize(PipelineStatus status);
 
   // Callback executed by filters upon completing Play(), Pause(), or Stop().
   void OnFilterStateTransition();
 
   // Callback executed by filters upon completing Seek().
   void OnFilterStateTransitionWithStatus(PipelineStatus status);
 
@@ skipping 36 matching lines @@
 
   // Carries out notifying filters that the playback rate has changed.
   void PlaybackRateChangedTask(float playback_rate);
 
   // Carries out notifying filters that the volume has changed.
   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);
 
-  // Carries out handling a notification from a filter that it has ended.
-  void NotifyEndedTask();
+  // Carries out handling a notification from a renderer that it has ended.
+  void OnRendererEndedTask();
 
   // Carries out disabling the audio renderer.
   void AudioDisabledTask();
 
   // Carries out advancing to the next filter during Play()/Pause()/Seek().
   void FilterStateTransitionTask();
 
   // Carries out advancing to the next teardown operation.
   void TeardownStateTransitionTask();
 
@@ skipping 26 matching lines @@
 
   // Kicks off destroying filters. Called by StopTask() and ErrorChangedTask().
   // When we start to tear down the pipeline, we will consider two cases:
   // 1. when pipeline has not been initialized, we will transit to stopping
   // state first.
   // 2. when pipeline has been initialized, we will first transit to pausing
   // => flushing => stopping => stopped state.
   // This will remove the race condition during stop between filters.
   void TearDownPipeline();
 
-  // Compute the current time. Assumes that the lock has been acquired by the
-  // caller.
-  base::TimeDelta GetCurrentTime_Locked() const;
-
   // Compute the time corresponding to a byte offset.
   base::TimeDelta TimeForByteOffset_Locked(int64 byte_offset) const;
 
   // Initiates an asynchronous Pause/Seek/Play/Stop() call sequence executing
   // |done_cb| when completed.
   void DoPause(const base::Closure& done_cb);
   void DoFlush(const base::Closure& done_cb);
   void DoPlay(const base::Closure& done_cb);
   void DoStop(const base::Closure& done_cb);
 
@@ skipping 106 matching lines @@
 
   // Filter collection as passed in by Start().
   scoped_ptr<FilterCollection> filter_collection_;
 
   // Callbacks for various pipeline operations.
   PipelineStatusCB seek_cb_;
   base::Closure stop_cb_;
   PipelineStatusCB ended_cb_;
   PipelineStatusCB error_cb_;
 
-  // Reference to the filter(s) that constitute the pipeline.
-  //
-  // TODO(scherkus): At this point in time this is a CompositeFilter that
-  // contains |video_renderer_|. Remove when CompositeFilter is gone, see
-  // http://crbug.com/126069
-  scoped_refptr<Filter> pipeline_filter_;
-
   // Decoder reference used for signalling imminent shutdown.
   // This is a HACK necessary because WebMediaPlayerImpl::Destroy() holds the
   // renderer thread loop hostage for until PipelineImpl::Stop() calls its
   // callback.
   // This reference should only be used for this hack and no other purposes.
   // http://crbug.com/110228 tracks removing this hack.
   scoped_refptr<VideoDecoder> video_decoder_;
 
   // Renderer references used for setting the volume and determining
   // when playback has finished.
@@ skipping 13 matching lines @@
   // Time of pipeline creation; is non-zero only until the pipeline first
   // reaches "kStarted", at which point it is used & zeroed out.
   base::Time creation_time_;
 
   DISALLOW_COPY_AND_ASSIGN(Pipeline);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_PIPELINE_H_