Big media::Pipeline cleanup.

media/base/pipeline_impl.h

-// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2008-2009 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.
 
 // Implementation of Pipeline.
 
 #ifndef MEDIA_BASE_PIPELINE_IMPL_H_
 #define MEDIA_BASE_PIPELINE_IMPL_H_
 
 #include <string>
 #include <vector>
@@ skipping 13 matching lines @@
 // Class which implements the Media::Pipeline contract.  The majority of the
 // actual code for this object lives in the PipelineThread class, which is
 // responsible for actually building and running the pipeline.  This object
 // is basically a simple container for state information, and is responsible
 // for creating and communicating with the PipelineThread object.
 class PipelineImpl : public Pipeline {
  public:
   PipelineImpl();
   virtual ~PipelineImpl();
 
-  // Implementation of PipelineStatus methods.
-  virtual bool IsInitialized() const;
-  virtual base::TimeDelta GetDuration() const;
-  virtual base::TimeDelta GetBufferedTime() const;
-  virtual int64 GetTotalBytes() const;
-  virtual int64 GetBufferedBytes()const;
-  virtual void GetVideoSize(size_t* width_out, size_t* height_out) const;
-  virtual float GetVolume() const;
-  virtual float GetPlaybackRate() const;
-  virtual base::TimeDelta GetTime() const;
-  virtual base::TimeDelta GetInterpolatedTime() const;
-  virtual PipelineError GetError() const;
-  virtual bool IsRendered(const std::string& major_mime_type) const;
-
-  // Implementation of Pipeline methods.
+  // Pipeline implementation.
   virtual bool Start(FilterFactory* filter_factory,
-                     const std::string& url,
+                     const std::string& uri,
                      PipelineCallback* start_callback);
   virtual void Stop();
-  virtual void SetPlaybackRate(float rate);
-  virtual void Seek(base::TimeDelta time,
-                    PipelineCallback* seek_callback);
+  virtual void Seek(base::TimeDelta time, PipelineCallback* seek_callback);
+  virtual bool IsInitialized() const;
+  virtual bool IsRendered(const std::string& major_mime_type) const;
+  virtual float GetPlaybackRate() const;
+  virtual void SetPlaybackRate(float playback_rate);
+  virtual float GetVolume() const;
   virtual void SetVolume(float volume);
+  virtual base::TimeDelta GetTime() const;
+  virtual base::TimeDelta GetBufferedTime() const;
+  virtual base::TimeDelta GetDuration() const;
+  virtual int64 GetBufferedBytes() const;
+  virtual int64 GetTotalBytes() const;
+  virtual void GetVideoSize(size_t* width_out, size_t* height_out) const;
+  virtual PipelineError GetError() const;
 
  private:
   friend class FilterHostImpl;
   friend class PipelineThread;
 
   // Reset the state of the pipeline object to the initial state.  This method
   // is used by the constructor, and the Stop method.
   void ResetState();
 
   // Used internally to make sure that the thread is in a state that is
@@ skipping 42 matching lines @@
 
   // Amount of available buffered data.  Set by a FilterHostImpl object
   // on behalf of a filter.
   int64 buffered_bytes_;
 
   // Total size of the media.  Set by a FilterHostImpl object on behalf
   // of a filter.
   int64 total_bytes_;
 
   // Lock used to serialize access for getter/setter methods.
-  Lock lock_;
+  mutable Lock lock_;
 
   // Video width and height.  Set by a FilterHostImpl object on behalf
   // of a filter.  The video_size_access_lock_ is used to make sure access
   // to the pair of width and height are modified or read in thread safe way.
   size_t video_width_;
   size_t video_height_;
 
   // Current volume level (from 0.0f to 1.0f).  The volume reflects the last
   // value the audio filter was called with SetVolume, so there will be a short
   // period of time between the client calling SetVolume on the pipeline and
   // this value being updated.  Set by the PipelineThread just prior to calling
   // the audio renderer.
   float volume_;
 
   // Current playback rate (>= 0.0f).  This member reflects the last value
   // that the filters in the pipeline were called with, so there will be a short
   // period of time between the client calling SetPlaybackRate and this value
   // being updated.  Set by the PipelineThread just prior to calling filters.
   float playback_rate_;
 
   // Current playback time.  Set by a FilterHostImpl object on behalf of the
   // audio renderer filter.
   base::TimeDelta time_;
 
-  // Internal system timer at last time the SetTime method was called.  Used to
-  // compute interpolated time.
-  base::TimeTicks ticks_at_last_set_time_;
-
   // Status of the pipeline.  Initialized to PIPELINE_OK which indicates that
   // the pipeline is operating correctly. Any other value indicates that the
   // pipeline is stopped or is stopping.  Clients can call the Stop method to
   // reset the pipeline state, and restore this to PIPELINE_OK.
   PipelineError error_;
 
   // Vector of major mime types that have been rendered by this pipeline.
   typedef std::set<std::string> RenderedMimeTypesSet;
   RenderedMimeTypesSet rendered_mime_types_;
 
@@ skipping 29 matching lines @@
   // pipeline thread.  For example, Seek posts a task to call SeekTask.
   explicit PipelineThread(PipelineImpl* pipeline);
 
   // After Start() is called, a task of StartTask() is posted on the pipeline
   // thread to perform initialization. See StartTask() to learn more about
   // initialization.
   bool Start(FilterFactory* filter_factory,
              const std::string& url_media_source,
              PipelineCallback* init_complete_callback);
   void Stop();
+  void Seek(base::TimeDelta time, PipelineCallback* seek_callback);
   void SetPlaybackRate(float rate);
-  void Seek(base::TimeDelta time, PipelineCallback* seek_callback);
   void SetVolume(float volume);
 
   // Methods called by a FilterHostImpl object.  These methods may be called
   // on any thread, either the pipeline's thread or any other.
 
   // When a filter calls it's FilterHost, the filter host calls back to the
   // pipeline thread.  If the pipeline thread is running a nested message loop
   // then it will be exited.
   void InitializationComplete(FilterHostImpl* host);
 
   // Sets the pipeline time and schedules a task to call back to any filters
   // that have registered a time update callback.
   void SetTime(base::TimeDelta time);
 
   // Called by a FilterHostImpl on behalf of a filter calling FilterHost::Error.
   // If the pipeline is running a nested message loop, it will be exited.
   void Error(PipelineError error);
 
-  // Called by a FilterHostImpl on behalf of a filter that calls the
-  // FilterHost::PostTask method.
-  void PostTask(Task* task);
-
   // Simple accessor used by the FilterHostImpl class to get access to the
   // pipeline object.
   PipelineImpl* pipeline() const { return pipeline_; }
 
   // Accessor used to post messages to thread's message loop.
   MessageLoop* message_loop() const { return thread_.message_loop(); }
 
   // Accessor used by PipelineImpl to check if we're executing on the pipeline
   // thread.
   PlatformThreadId thread_id() const { return thread_.thread_id(); }
 
  private:
+  // Only allow ourselves to be destroyed via ref-counting.
+  friend class base::RefCountedThreadSafe<PipelineThread>;
+  virtual ~PipelineThread();
+
   enum State {
     kCreated,
     kInitDataSource,
     kInitDemuxer,
     kInitAudioDecoder,
     kInitAudioRenderer,
     kInitVideoDecoder,
     kInitVideoRenderer,
     kStarted,
     kStopped,
     kError,
   };
 
-  // Implementation of MessageLoop::DestructionObserver.  StartTask registers
-  // this class as a destruction observer on the thread's message loop.
-  // It is used to destroy the list of FilterHosts
-  // (and thus destroy the associated filters) when all tasks have been
-  // processed and the message loop has been quit.
-  virtual void WillDestroyCurrentMessageLoop();
-
-  friend class base::RefCountedThreadSafe<PipelineThread>;
-  virtual ~PipelineThread();
-
   // Simple method used to make sure the pipeline is running normally.
   bool IsPipelineOk() { return PIPELINE_OK == pipeline_->error_; }
 
   // Helper method to tell whether we are in the state of initializing.
   bool IsPipelineInitializing() {
     return state_ == kInitDataSource ||
            state_ == kInitDemuxer ||
            state_ == kInitAudioDecoder ||
            state_ == kInitAudioRenderer ||
            state_ == kInitVideoDecoder ||
            state_ == kInitVideoRenderer;
   }
 
+  // Implementation of MessageLoop::DestructionObserver.  StartTask registers
+  // this class as a destruction observer on the thread's message loop.
+  // It is used to destroy the list of FilterHosts
+  // (and thus destroy the associated filters) when all tasks have been
+  // processed and the message loop has been quit.
+  virtual void WillDestroyCurrentMessageLoop();
+
   // The following "task" methods correspond to the public methods, but these
   // methods are run as the result of posting a task to the PipelineThread's
   // message loop.
 
   // StartTask() is a special task that performs initialization in multiple
   // passes. It is executed as a result of calling Start() or
   // InitializationComplete() that advances initialization to the next state. It
   // works as a hub of state transition for initialization.
   void StartTask();
   void StopTask();
   void SetPlaybackRateTask(float rate);
   void SeekTask(base::TimeDelta time, PipelineCallback* seek_callback);
   void SetVolumeTask(float volume);
-  void SetTimeTask();
 
   // Internal methods used in the implementation of the pipeline thread.  All
   // of these methods are only called on the pipeline thread.
 
-  // Calls the Stop method on every filter in the pipeline
-  void StopFilters();
-
   // The following template functions make use of the fact that media filter
   // derived interfaces are self-describing in the sense that they all contain
   // the static method filter_type() which returns a FilterType enum that
   // uniquely identifies the filter's interface.  In addition, filters that are
   // specific to audio or video also support a static method major_mime_type()
   // which returns a string of "audio/" or "video/".
   //
   // Uses the FilterFactory to create a new filter of the Filter class, and
   // initializes it using the Source object.  The source may be another filter
   // or it could be a string in the case of a DataSource.
@@ skipping 82 matching lines @@
 
   typedef std::vector<base::Thread*> FilterThreadVector;
   FilterThreadVector filter_threads_;
 
   DISALLOW_COPY_AND_ASSIGN(PipelineThread);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_PIPELINE_IMPL_H_