Move AudioRenderer 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 AudioRenderer;
 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
@@ skipping 177 matching lines @@
   // 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 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 56 matching lines @@
   // 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;
-  virtual void DisableAudioRenderer() OVERRIDE;
 
   // 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);
 
   // Callback executed by filters when completing teardown operations.
   void OnTeardownStateTransition();
 
   // Callback executed by filters to update statistics.
   void OnUpdateStatistics(const PipelineStatistics& stats);
 
+  // Callback executed by audio renderer when it has been disabled.
+  void OnAudioDisabled();
+
   // Callback executed by audio renderer to update clock time.
   void OnAudioTimeUpdate(base::TimeDelta time, base::TimeDelta max_time);
 
   // Callback executed by video renderer to update clock time.
   void OnVideoTimeUpdate(base::TimeDelta max_time);
 
   // The following "task" methods correspond to the public methods, but these
   // methods are run as the result of posting a task to the PipelineInternal's
   // message loop.
   void StartTask(scoped_ptr<FilterCollection> filter_collection,
@@ skipping 21 matching lines @@
   // 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 disabling the audio renderer.
-  void DisableAudioRendererTask();
+  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();
 
   // Carries out stopping filter threads, deleting filters, running
   // appropriate callbacks, and setting the appropriate pipeline state
   // depending on whether we performing Stop() or SetError().
@@ skipping 30 matching lines @@
   // 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 a Stop() on |demuxer_| & |pipeline_filter_|. |callback|
-  // is called once both objects have been stopped.
-  void DoStop(const base::Closure& callback);
+  // 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);
 
-  // Called when |demuxer_| has stopped. This method calls Stop()
-  // on |pipeline_filter_|.
-  void OnDemuxerStopDone(const base::Closure& callback);
-
-  // Initiates a Seek() on the |demuxer_| & |pipeline_filter_|.
-  void DoSeek(base::TimeDelta seek_timestamp);
-
-  // Called when |demuxer_| finishes seeking. If seeking was successful,
-  // then Seek() is called on |pipeline_filter_|.
-  void OnDemuxerSeekDone(base::TimeDelta seek_timestamp,
-                         PipelineStatus status);
+  // Initiates an asynchronous Seek() and preroll call sequence executing
+  // |done_cb| with the final status when completed. If |skip_demuxer_seek| is
+  // true then only renderers will attempt to preroll.
+  //
+  // TODO(scherkus): Prerolling should be separate from seeking so we can report
+  // finer grained ready states (HAVE_CURRENT_DATA vs. HAVE_FUTURE_DATA)
+  // indepentent from seeking.
+  void DoSeek(base::TimeDelta seek_timestamp, bool skip_demuxer_seek,
+              const PipelineStatusCB& done_cb);
 
   void OnAudioUnderflow();
 
   void StartClockIfWaitingForTimeUpdate_Locked();
 
   // Report pipeline |status| through |cb| avoiding duplicate error reporting.
   void ReportStatus(const PipelineStatusCB& cb, PipelineStatus status);
 
   // Message loop used to execute pipeline tasks.
   scoped_refptr<base::MessageLoopProxy> message_loop_;
@@ skipping 88 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_;
 
@@ skipping 15 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_