Report stalled event correctly for <video>

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 54 matching lines @@
   explicit PipelineImpl(MessageLoop* message_loop);
 
   // Pipeline implementation.
   virtual bool Start(FilterFactory* filter_factory,
                      const std::string& uri,
                      PipelineCallback* start_callback);
   virtual void Stop(PipelineCallback* stop_callback);
   virtual void Seek(base::TimeDelta time, PipelineCallback* seek_callback);
   virtual bool IsRunning() const;
   virtual bool IsInitialized() const;
+  virtual bool IsNetworkActive() 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 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 bool IsLoaded() 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 ownership
   // of |error_callback|.
   virtual void SetPipelineErrorCallback(PipelineCallback* error_callback);
 
+  // |network_callback_| will be executed when there's a network event.
+  virtual void SetNetworkEventCallback(PipelineCallback* network_callback);
+
  private:
   // Pipeline states, as described above.
   enum State {
     kCreated,
     kInitDataSource,
     kInitDemuxer,
     kInitAudioDecoder,
     kInitAudioRenderer,
     kInitVideoDecoder,
     kInitVideoRenderer,
@@ skipping 29 matching lines @@
   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 SetLoaded(bool loaded);
+  virtual void SetNetworkActivity(bool network_activity);
   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;
 
@@ skipping 29 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, PipelineCallback* seek_callback);
 
   // Carries out handling a notification from a filter that it has ended.
   void NotifyEndedTask();
 
+  // Carries out handling a notification of network event.
+  void NotifyNetworkEventTask();
+
   // 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 85 matching lines @@
   size_t video_height_;
 
   // Sets by the filters to indicate whether the data source is a streaming
   // source.
   bool streaming_;
 
   // Sets by the filters to indicate whether the data source is a fully
   // loaded source.
   bool loaded_;
 
+  // Sets by the filters to indicate whether network is active.
+  bool network_activity_;
+
   // Current volume level (from 0.0f to 1.0f).  This value is set immediately
   // via SetVolume() and a task is dispatched on the message loop to notify the
   // filters.
   float volume_;
 
   // Current playback rate (>= 0.0f).  This value is set immediately via
   // SetPlaybackRate() and a task is dispatched on the message loop to notify
   // the filters.
   float playback_rate_;
 
@@ skipping 37 matching lines @@
   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_;
+  scoped_ptr<PipelineCallback> network_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_