Remove DemuxerFactory and URL parameter from Pipeline.

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/demuxer.h"
 #include "media/base/download_rate_monitor.h"
 #include "media/base/filter_host.h"
 #include "media/base/media_export.h"
 #include "media/base/pipeline_status.h"
-#include "media/base/preload.h"
 #include "ui/gfx/size.h"
 
 class MessageLoop;
 
 namespace base {
 class TimeDelta;
 }
 
 namespace media {
 
@@ skipping 81 matching lines @@
 // from any state. If Stop() is ever called, this object will transition to
 // "Stopped" state.
 class MEDIA_EXPORT Pipeline
     : public base::RefCountedThreadSafe<Pipeline>,
       public FilterHost,
       public DemuxerHost {
  public:
   // Constructs a media pipeline that will execute on |message_loop|.
   Pipeline(MessageLoop* message_loop, MediaLog* media_log);
 
-  // Build a pipeline to render the given URL using the given filter collection
-  // to construct a filter chain.
+  // 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 std::string& url,
              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.
@@ skipping 48 matching lines @@
   // Gets the current volume setting being used by the audio renderer.  When
   // the pipeline is started, this value will be 1.0f.  Valid values range
   // from 0.0f to 1.0f.
   float GetVolume() const;
 
   // Attempt to set the volume of the audio renderer.  Valid values for volume
   // range from 0.0f (muted) to 1.0f (full volume).  This value affects all
   // channels proportionately for multi-channel audio streams.
   void SetVolume(float volume);
 
-  // Set the preload value for the pipeline.
-  void SetPreload(Preload preload);
-
   // Gets the current pipeline time. For a pipeline "time" progresses from 0 to
   // the end of the media.
   base::TimeDelta GetCurrentTime() const;
 
   // Get the approximate amount of playable data buffered so far in micro-
   // seconds.
   base::TimeDelta GetBufferedTime();
 
   // Get the duration of the media in microseconds.  If the duration has not
   // been determined yet, then returns 0.
@@ skipping 124 matching lines @@
   // 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,
-                 const std::string& url,
                  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);
 
-  // Returns media preload value.
-  virtual Preload GetPreload() const;
-
-  // Carries out notifying filters that the preload value has changed.
-  void PreloadChangedTask(Preload preload);
-
   // 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
   // appropriate callbacks, and setting the appropriate pipeline state
   // depending on whether we performing Stop() or SetError().
   // Called after all filters have been stopped.
   void FinishDestroyingFiltersTask();
 
   // Internal methods used in the implementation of the pipeline thread.  All
   // of these methods are only called on the pipeline thread.
 
   // The following initialize methods are used to select a specific type of
-  // Filter object from FilterCollection and initialize it asynchronously.
+  // object from FilterCollection and initialize it asynchronously.
   void InitializeDemuxer();
-  void OnDemuxerBuilt(PipelineStatus status, Demuxer* demuxer);
+  void OnDemuxerInitialized(PipelineStatus status);
 
   // Returns true if the asynchronous action of creating decoder has started.
   // Returns false if this method did nothing because the corresponding
   // audio/video stream does not exist.
   bool InitializeAudioDecoder(const scoped_refptr<Demuxer>& demuxer);
   bool InitializeVideoDecoder(const scoped_refptr<Demuxer>& demuxer);
 
   // Initializes a renderer and connects it with decoder. Returns true if the
   // asynchronous action of creating renderer has started. Returns
   // false if this method did nothing because the corresponding audio/video
@@ skipping 90 matching lines @@
 
   // Indicates whether the data source is local, such as a local media file
   // from disk or a local webcam stream.
   bool local_source_;
 
   // 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 value of preload attribute. This value is set immediately via
-  // SetPreload() and a task is dispatched on the message loop to notify the
-  // filters.
-  Preload preload_;
-
   // 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_;
 
   // Playback rate to set when the current seek has finished.
   float pending_playback_rate_;
 
   // Reference clock.  Keeps track of current playback time.  Uses system
   // clock and linear interpolation, but can have its time manually set
@@ skipping 36 matching lines @@
   bool audio_disabled_;
 
   // Keep track of the maximum buffered position so the buffering appears
   // smooth.
   // TODO(vrk): This is a hack.
   base::TimeDelta max_buffered_time_;
 
   // Filter collection as passed in by Start().
   scoped_ptr<FilterCollection> filter_collection_;
 
-  // URL for the data source as passed in by Start().
-  std::string url_;
-
   // 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_;
 
@@ skipping 29 matching lines @@
 
   // True if the pipeline is actively downloading bytes, false otherwise.
   bool is_downloading_data_;
 
   DISALLOW_COPY_AND_ASSIGN(Pipeline);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_PIPELINE_H_