Merge 23255 - Implemented endofstream callback for media::PipelineImpl....

media/base/pipeline_impl.h

 // 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 <set>
@@ skipping 23 matching lines @@
 //   [ InitXXX (for each filter) ]
 //         |
 //         V
 //   [ Seeking (for each filter) ] <----------------------.
 //         |                                              |
 //         V                                              |
 //   [ Starting (for each filter) ]                       |
 //         |                                              |
 //         V      Seek()                                  |
 //   [ Started ] --------> [ Pausing (for each filter) ] -'
-//
+//         |                                              |
+//         |   NotifyEnded()                Seek()        |
+//         `-------------> [ Ended ] ---------------------'
 //
 //                  SetError()
 //   [ Any State ] -------------> [ Error ]
 //         |          Stop()
 //         '--------------------> [ Stopped ]
 //
 // 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.
@@ skipping 22 matching lines @@
   virtual void SetVolume(float volume);
   virtual base::TimeDelta GetCurrentTime() 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 bool IsStreaming() const;
   virtual PipelineError GetError() const;
 
+  // Sets a permanent callback owned by the pipeline that will be executed when
+  // the media reaches the end.
+  virtual void SetPipelineEndedCallback(PipelineCallback* ended_callback);
+
   // |error_callback_| will be executed upon an error in the pipeline. If
-  // |error_callback_| is NULL, it is ignored. The pipeline takes ownernship
+  // |error_callback_| is NULL, it is ignored. The pipeline takes ownership
   // of |error_callback|.
   virtual void SetPipelineErrorCallback(PipelineCallback* error_callback);
 
  private:
   // Pipeline states, as described above.
   enum State {
     kCreated,
     kInitDataSource,
     kInitDemuxer,
     kInitAudioDecoder,
     kInitAudioRenderer,
     kInitVideoDecoder,
     kInitVideoRenderer,
     kPausing,
     kSeeking,
     kStarting,
     kStarted,
+    kEnded,
     kStopped,
     kError,
   };
 
   virtual ~PipelineImpl();
 
   // Reset the state of the pipeline object to the initial state.  This method
   // is used by the constructor, and the Stop() method.
   void ResetState();
 
@@ skipping 13 matching lines @@
   // FilterHost implementation.
   virtual void SetError(PipelineError error);
   virtual base::TimeDelta GetTime() const;
   virtual void SetTime(base::TimeDelta time);
   virtual void SetDuration(base::TimeDelta duration);
   virtual void SetBufferedTime(base::TimeDelta buffered_time);
   virtual void SetTotalBytes(int64 total_bytes);
   virtual void SetBufferedBytes(int64 buffered_bytes);
   virtual void SetVideoSize(size_t width, size_t height);
   virtual void SetStreaming(bool streamed);
+  virtual void NotifyEnded();
   virtual void BroadcastMessage(FilterMessage message);
 
   // Method called during initialization to insert a mime type into the
   // |rendered_mime_types_| set.
   void InsertRenderedMimeType(const std::string& major_mime_type);
 
   // Method called during initialization to determine if we rendered anything.
   bool HasRenderedMimeTypes() const;
 
   // Callback executed by filters upon completing initialization.
@@ skipping 25 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, PipelineCallback* seek_callback);
 
+  // Carries out handling a notification from a filter that it has ended.
+  void NotifyEndedTask();
+
   // Carries out message broadcasting on the message loop.
   void BroadcastMessageTask(FilterMessage message);
 
   // Carries out advancing to the next filter during Play()/Pause()/Seek().
   void FilterStateTransitionTask();
 
   // Internal methods used in the implementation of the pipeline thread.  All
   // of these methods are only called on the pipeline thread.
 
   // The following template functions make use of the fact that media filter
@@ skipping 131 matching lines @@
 
   // Filter factory as passed in by Start().
   scoped_refptr<FilterFactory> filter_factory_;
 
   // URL for the data source as passed in by Start().
   std::string url_;
 
   // Callbacks for various pipeline operations.
   scoped_ptr<PipelineCallback> seek_callback_;
   scoped_ptr<PipelineCallback> stop_callback_;
+  scoped_ptr<PipelineCallback> ended_callback_;
   scoped_ptr<PipelineCallback> error_callback_;
 
   // Vector of our filters and map maintaining the relationship between the
   // FilterType and the filter itself.
   typedef std::vector<scoped_refptr<MediaFilter> > FilterVector;
   FilterVector filters_;
 
   typedef std::map<FilterType, scoped_refptr<MediaFilter> > FilterTypeMap;
   FilterTypeMap filter_types_;
 
   // Vector of threads owned by the pipeline and being used by filters.
   typedef std::vector<base::Thread*> FilterThreadVector;
   FilterThreadVector filter_threads_;
 
   DISALLOW_COPY_AND_ASSIGN(PipelineImpl);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_PIPELINE_IMPL_H_