Replace Pipeline::SetNetworkActivity() with BufferedDataSource -> WebMediaPlayerImpl callback.

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"
@@ skipping 17 matching lines @@
 
 class AudioDecoder;
 class AudioRenderer;
 class Clock;
 class Filter;
 class FilterCollection;
 class MediaLog;
 class VideoDecoder;
 class VideoRenderer;
 
-enum NetworkEvent {
-  DOWNLOAD_CONTINUED,
-  DOWNLOAD_PAUSED,
-  CAN_PLAY_THROUGH
-};
-
-// Callback that executes when a network event occurs.
-// The parameter specifies the type of event that is being signalled.
-typedef base::Callback<void(NetworkEvent)> NetworkEventCB;
-
 // 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
 // once.
 class MEDIA_EXPORT PipelineStatusNotification {
  public:
   PipelineStatusNotification();
   ~PipelineStatusNotification();
@@ skipping 61 matching lines @@
 
   // 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
   // |start_cb|, which will be executed when initialization completes.
   //
   // The following permanent callbacks will be executed as follows:
   //   |start_cb_| will be executed when Start is done (successfully or not).
-  //   |network_cb_| will be executed whenever there's a network activity.
   //   |ended_cb| will be executed whenever the media reaches the end.
   //   |error_cb_| will be executed whenever an error occurs but hasn't
   //               been reported already through another callback.
   //
   // These callbacks are only executed after Start() has been called and until
   // Stop() has completed.
   //
   // It is an error to call this method after the pipeline has already started.
   //
   // TODO(scherkus): remove IsInitialized() and force clients to use callbacks.
   void Start(scoped_ptr<FilterCollection> filter_collection,
              const PipelineStatusCB& ended_cb,
              const PipelineStatusCB& error_cb,
-             const NetworkEventCB& network_cb,
              const PipelineStatusCB& start_cb);
 
   // Asynchronously stops the pipeline and resets it to an uninitialized state.
   //
   // If provided, |stop_cb| will be executed when the pipeline has been
   // completely torn down and reset to an uninitialized state.  It is acceptable
   // to call Start() again once the callback has finished executing.
   //
   // Stop() must be called before destroying the pipeline.  Clients can
   // determine whether Stop() must be called by checking IsRunning().
@@ skipping 139 matching lines @@
   // Returns true if the given state is one that transitions to a new state
   // after iterating through each filter.
   static bool TransientState(State state);
 
   // Given the current state, returns the next state.
   State FindNextState(State current);
 
   // DataSourceHost (by way of DemuxerHost) implementation.
   virtual void SetTotalBytes(int64 total_bytes) OVERRIDE;
   virtual void AddBufferedByteRange(int64 start, int64 end) OVERRIDE;
-  virtual void SetNetworkActivity(bool is_downloading_data) 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;
@@ skipping 20 matching lines @@
 
   // 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,
                  const PipelineStatusCB& ended_cb,
                  const PipelineStatusCB& error_cb,
-                 const NetworkEventCB& network_cb,
                  const PipelineStatusCB& start_cb);
 
   // InitializeTask() 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.  One stage communicates its status to the next through
   // |last_stage_status|.
   void InitializeTask(PipelineStatus last_stage_status);
 
   // Stops and destroys all filters, placing the pipeline in the kStopped state.
   void StopTask(const base::Closure& stop_cb);
 
   // Carries out stopping and destroying all filters, placing the pipeline in
   // the kError state.
   void ErrorChangedTask(PipelineStatus error);
 
   // 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 of network event.
-  void NotifyNetworkEventTask(NetworkEvent type);
-
   // Carries out disabling the audio renderer.
   void DisableAudioRendererTask();
 
   // 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
@@ skipping 152 matching lines @@
   bool audio_disabled_;
 
   // 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_;
-  NetworkEventCB network_cb_;
 
   // Reference to the filter(s) that constitute the pipeline.
   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.
@@ skipping 17 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_