Rename MediaFilter and MediaFilterCollection to Filter and FilterCollection, respectively.

media/base/pipeline_impl.h

 // Copyright (c) 2010 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 51 matching lines @@
 // from any state. If Stop() is ever called, this object will transition to
 // "Stopped" state.
 class PipelineImpl : public Pipeline, public FilterHost {
  public:
   explicit PipelineImpl(MessageLoop* message_loop);
 
   // Pipeline implementation.
   virtual void Init(PipelineCallback* ended_callback,
                     PipelineCallback* error_callback,
                     PipelineCallback* network_callback);
-  virtual bool Start(MediaFilterCollection* filter_collection,
+  virtual bool Start(FilterCollection* filter_collection,
                      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);
@@ skipping 95 matching lines @@
   // Callback executed by filters upon completing initialization.
   void OnFilterInitialize();
 
   // Callback executed by filters upon completing Play(), Pause(), Seek(),
   // or Stop().
   void OnFilterStateTransition();
 
   // 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(MediaFilterCollection* filter_collection,
+  void StartTask(FilterCollection* filter_collection,
                  const std::string& url,
                  PipelineCallback* start_callback);
 
   // 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.
   void InitializeTask();
 
   // Stops and destroys all filters, placing the pipeline in the kStopped state.
@@ skipping 28 matching lines @@
   // 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.
 
   // PrepareFilter() creates the filter's thread and injects a FilterHost and
   // MessageLoop.
-  bool PrepareFilter(scoped_refptr<MediaFilter> filter);
+  bool PrepareFilter(scoped_refptr<Filter> filter);
 
   // The following initialize methods are used to select a specific type of
-  // MediaFilter object from MediaFilterCollection and initialize it
-  // asynchronously.
+  // Filter object from FilterCollection and initialize it asynchronously.
   void InitializeDataSource();
   void InitializeDemuxer(const scoped_refptr<DataSource>& data_source);
 
   // 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
@@ skipping 118 matching lines @@
 
   // Set to true in DisableAudioRendererTask().
   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<MediaFilterCollection> filter_collection_;
+  scoped_ptr<FilterCollection> filter_collection_;
 
   // 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;
+  typedef std::vector<scoped_refptr<Filter> > FilterVector;
   FilterVector filters_;
 
   // Renderer references used for setting the volume and determining
   // when playback has finished.
   scoped_refptr<AudioRenderer> audio_renderer_;
   scoped_refptr<VideoRenderer> video_renderer_;
 
   // Vector of threads owned by the pipeline and being used by filters.
   typedef std::vector<base::Thread*> FilterThreadVector;
   FilterThreadVector filter_threads_;
@@ skipping 12 matching lines @@
 
   FRIEND_TEST_ALL_PREFIXES(PipelineImplTest, GetBufferedTime);
   FRIEND_TEST_ALL_PREFIXES(PipelineImplTest, AudioStreamShorterThanVideo);
 
   DISALLOW_COPY_AND_ASSIGN(PipelineImpl);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_PIPELINE_IMPL_H_