Rename MediaFilter and MediaFilterCollection to Filter and FilterCollection, respectively.

BUG=none
TEST=compiles

Review URL: http://codereview.chromium.org/5527003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@68115 0039d316-1c4b-4281-b951-d872f2087c98

11 files changed, 106 insertions, 108 deletions

diff --git a/media/base/media_filter_collection.cc b/media/base/filter_collection.cc
index a1380c4..bf74b43 100644
--- a/media/base/media_filter_collection.cc
+++ b/media/base/filter_collection.cc
@@ -2,89 +2,89 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "media/base/media_filter_collection.h"
+#include "media/base/filter_collection.h"
 
 namespace media {
 
-MediaFilterCollection::MediaFilterCollection() {
+FilterCollection::FilterCollection() {
 }
 
-void MediaFilterCollection::AddDataSource(DataSource* filter) {
+void FilterCollection::AddDataSource(DataSource* filter) {
   AddFilter(DATA_SOURCE, filter);
 }
 
-void MediaFilterCollection::AddDemuxer(Demuxer* filter) {
+void FilterCollection::AddDemuxer(Demuxer* filter) {
   AddFilter(DEMUXER, filter);
 }
 
-void MediaFilterCollection::AddVideoDecoder(VideoDecoder* filter) {
+void FilterCollection::AddVideoDecoder(VideoDecoder* filter) {
   AddFilter(VIDEO_DECODER, filter);
 }
 
-void MediaFilterCollection::AddAudioDecoder(AudioDecoder* filter) {
+void FilterCollection::AddAudioDecoder(AudioDecoder* filter) {
   AddFilter(AUDIO_DECODER, filter);
 }
 
-void MediaFilterCollection::AddVideoRenderer(VideoRenderer* filter) {
+void FilterCollection::AddVideoRenderer(VideoRenderer* filter) {
   AddFilter(VIDEO_RENDERER, filter);
 }
 
-void MediaFilterCollection::AddAudioRenderer(AudioRenderer* filter) {
+void FilterCollection::AddAudioRenderer(AudioRenderer* filter) {
   AddFilter(AUDIO_RENDERER, filter);
 }
 
-bool MediaFilterCollection::IsEmpty() const {
+bool FilterCollection::IsEmpty() const {
   return filters_.empty();
 }
 
-void MediaFilterCollection::Clear() {
+void FilterCollection::Clear() {
   filters_.clear();
 }
 
-void MediaFilterCollection::SelectDataSource(
+void FilterCollection::SelectDataSource(
     scoped_refptr<DataSource>* filter_out) {
   SelectFilter<DATA_SOURCE>(filter_out);
 }
 
-void MediaFilterCollection::SelectDemuxer(scoped_refptr<Demuxer>* filter_out) {
+void FilterCollection::SelectDemuxer(scoped_refptr<Demuxer>* filter_out) {
   SelectFilter<DEMUXER>(filter_out);
 }
 
-void MediaFilterCollection::SelectVideoDecoder(
+void FilterCollection::SelectVideoDecoder(
     scoped_refptr<VideoDecoder>* filter_out) {
   SelectFilter<VIDEO_DECODER>(filter_out);
 }
 
-void MediaFilterCollection::SelectAudioDecoder(
+void FilterCollection::SelectAudioDecoder(
     scoped_refptr<AudioDecoder>* filter_out) {
   SelectFilter<AUDIO_DECODER>(filter_out);
 }
 
-void MediaFilterCollection::SelectVideoRenderer(
+void FilterCollection::SelectVideoRenderer(
     scoped_refptr<VideoRenderer>* filter_out) {
   SelectFilter<VIDEO_RENDERER>(filter_out);
 }
 
-void MediaFilterCollection::SelectAudioRenderer(
+void FilterCollection::SelectAudioRenderer(
     scoped_refptr<AudioRenderer>* filter_out) {
   SelectFilter<AUDIO_RENDERER>(filter_out);
 }
 
-void MediaFilterCollection::AddFilter(FilterType filter_type,
-                                      MediaFilter* filter) {
+void FilterCollection::AddFilter(FilterType filter_type,
+                                 Filter* filter) {
   filters_.push_back(FilterListElement(filter_type, filter));
 }
 
-template<MediaFilterCollection::FilterType filter_type, class Filter>
-void MediaFilterCollection::SelectFilter(scoped_refptr<Filter>* filter_out) {
-  scoped_refptr<MediaFilter> filter;
+template<FilterCollection::FilterType filter_type, typename F>
+void FilterCollection::SelectFilter(scoped_refptr<F>* filter_out) {
+  scoped_refptr<Filter> filter;
   SelectFilter(filter_type, &filter);
-  *filter_out = reinterpret_cast<Filter*>(filter.get());
+  *filter_out = reinterpret_cast<F*>(filter.get());
 }
 
-void MediaFilterCollection::SelectFilter(
+void FilterCollection::SelectFilter(
     FilterType filter_type,
-    scoped_refptr<MediaFilter>* filter_out)  {
+    scoped_refptr<Filter>* filter_out)  {
 
   FilterList::iterator it = filters_.begin();
   while (it != filters_.end()) {
diff --git a/media/base/media_filter_collection.h b/media/base/filter_collection.h
index c4a403a..8a396e1 100644
--- a/media/base/media_filter_collection.h
+++ b/media/base/filter_collection.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef MEDIA_BASE_MEDIA_FILTER_COLLECTION_H_
-#define MEDIA_BASE_MEDIA_FILTER_COLLECTION_H_
+#ifndef MEDIA_BASE_FILTER_COLLECTION_H_
+#define MEDIA_BASE_FILTER_COLLECTION_H_
 
 #include <list>
 
@@ -12,11 +12,11 @@
 
 namespace media {
 
-// This is a collection of MediaFilter objects used to form a media playback
+// This is a collection of Filter objects used to form a media playback
 // pipeline. See src/media/base/pipeline.h for more information.
-class MediaFilterCollection {
+class FilterCollection {
  public:
-  MediaFilterCollection();
+  FilterCollection();
 
   // Adds a filter to the collection.
   void AddDataSource(DataSource* filter);
@@ -52,30 +52,28 @@ class MediaFilterCollection {
     AUDIO_DECODER,
     VIDEO_DECODER,
     AUDIO_RENDERER,
-    VIDEO_RENDERER
+    VIDEO_RENDERER,
   };
 
   // List of filters managed by this collection.
-  typedef std::pair<FilterType, scoped_refptr<MediaFilter> > FilterListElement;
+  typedef std::pair<FilterType, scoped_refptr<Filter> > FilterListElement;
   typedef std::list<FilterListElement> FilterList;
   FilterList filters_;
 
   // Helper function that adds a filter to the filter list.
-  void AddFilter(FilterType filter_type, MediaFilter* filter);
+  void AddFilter(FilterType filter_type, Filter* filter);
 
   // Helper function for SelectXXX() methods. It manages the
   // downcasting and mapping between FilterType and Filter class.
-  template<FilterType filter_type, class Filter>
-  void SelectFilter(scoped_refptr<Filter>* filter_out);
+  template<FilterType filter_type, typename F>
+  void SelectFilter(scoped_refptr<F>* filter_out);
 
-  // Helper function that searches the filters list for a specific
-  // filter type.
-  void SelectFilter(FilterType filter_type,
-                    scoped_refptr<MediaFilter>* filter_out);
+  // Helper function that searches the filters list for a specific filter type.
+  void SelectFilter(FilterType filter_type, scoped_refptr<Filter>* filter_out);
 
-  DISALLOW_COPY_AND_ASSIGN(MediaFilterCollection);
+  DISALLOW_COPY_AND_ASSIGN(FilterCollection);
 };
 
 }  // namespace media
 
-#endif  // MEDIA_BASE_MEDIA_FILTER_COLLECTION_H_
+#endif  // MEDIA_BASE_FILTER_COLLECTION_H_
diff --git a/media/base/media_filter_collection_unittest.cc b/media/base/filter_collection_unittest.cc
index 523123b..fef7e7f7 100644
--- a/media/base/media_filter_collection_unittest.cc
+++ b/media/base/filter_collection_unittest.cc
@@ -2,25 +2,25 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "media/base/media_filter_collection.h"
+#include "media/base/filter_collection.h"
 #include "media/base/mock_filters.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
-class MediaFilterCollectionTest : public ::testing::Test {
+class FilterCollectionTest : public ::testing::Test {
  public:
-  MediaFilterCollectionTest() {}
-  virtual ~MediaFilterCollectionTest() {}
+  FilterCollectionTest() {}
+  virtual ~FilterCollectionTest() {}
 
  protected:
-  MediaFilterCollection collection_;
+  FilterCollection collection_;
   MockFilterCollection mock_filters_;
 
-  DISALLOW_COPY_AND_ASSIGN(MediaFilterCollectionTest);
+  DISALLOW_COPY_AND_ASSIGN(FilterCollectionTest);
 };
 
-TEST_F(MediaFilterCollectionTest, TestIsEmptyAndClear) {
+TEST_F(FilterCollectionTest, TestIsEmptyAndClear) {
   EXPECT_TRUE(collection_.IsEmpty());
 
   collection_.AddDataSource(mock_filters_.data_source());
@@ -32,7 +32,7 @@ TEST_F(MediaFilterCollectionTest, TestIsEmptyAndClear) {
   EXPECT_TRUE(collection_.IsEmpty());
 }
 
-TEST_F(MediaFilterCollectionTest, SelectXXXMethods) {
+TEST_F(FilterCollectionTest, SelectXXXMethods) {
   scoped_refptr<AudioDecoder> audio_decoder;
   scoped_refptr<DataSource> data_source;
 
@@ -70,7 +70,7 @@ TEST_F(MediaFilterCollectionTest, SelectXXXMethods) {
   EXPECT_TRUE(collection_.IsEmpty());
 }
 
-TEST_F(MediaFilterCollectionTest, MultipleFiltersOfSameType) {
+TEST_F(FilterCollectionTest, MultipleFiltersOfSameType) {
   scoped_refptr<DataSource> data_source_a(new MockDataSource());
   scoped_refptr<DataSource> data_source_b(new MockDataSource());
 
diff --git a/media/base/filters.cc b/media/base/filters.cc
index 100af78..923329b 100644
--- a/media/base/filters.cc
+++ b/media/base/filters.cc
@@ -9,41 +9,43 @@
 
 namespace media {
 
-MediaFilter::MediaFilter() : host_(NULL), message_loop_(NULL) {}
+Filter::Filter() : host_(NULL), message_loop_(NULL) {}
 
-const char* MediaFilter::major_mime_type() const {
+Filter::~Filter() {}
+
+const char* Filter::major_mime_type() const {
   return "";
 }
 
-void MediaFilter::set_host(FilterHost* host) {
+void Filter::set_host(FilterHost* host) {
   DCHECK(host);
   DCHECK(!host_);
   host_ = host;
 }
 
-FilterHost* MediaFilter::host() {
+FilterHost* Filter::host() {
   return host_;
 }
 
-bool MediaFilter::requires_message_loop() const {
+bool Filter::requires_message_loop() const {
   return false;
 }
 
-const char* MediaFilter::message_loop_name() const {
+const char* Filter::message_loop_name() const {
   return "FilterThread";
 }
 
-void MediaFilter::set_message_loop(MessageLoop* message_loop) {
+void Filter::set_message_loop(MessageLoop* message_loop) {
   DCHECK(message_loop);
   DCHECK(!message_loop_);
   message_loop_ = message_loop;
 }
 
-MessageLoop* MediaFilter::message_loop() {
+MessageLoop* Filter::message_loop() {
   return message_loop_;
 }
 
-void MediaFilter::Play(FilterCallback* callback) {
+void Filter::Play(FilterCallback* callback) {
   DCHECK(callback);
   if (callback) {
     callback->Run();
@@ -51,7 +53,7 @@ void MediaFilter::Play(FilterCallback* callback) {
   }
 }
 
-void MediaFilter::Pause(FilterCallback* callback) {
+void Filter::Pause(FilterCallback* callback) {
   DCHECK(callback);
   if (callback) {
     callback->Run();
@@ -59,7 +61,7 @@ void MediaFilter::Pause(FilterCallback* callback) {
   }
 }
 
-void MediaFilter::Flush(FilterCallback* callback) {
+void Filter::Flush(FilterCallback* callback) {
   DCHECK(callback);
   if (callback) {
     callback->Run();
@@ -67,7 +69,7 @@ void MediaFilter::Flush(FilterCallback* callback) {
   }
 }
 
-void MediaFilter::Stop(FilterCallback* callback) {
+void Filter::Stop(FilterCallback* callback) {
   DCHECK(callback);
   if (callback) {
     callback->Run();
@@ -75,20 +77,18 @@ void MediaFilter::Stop(FilterCallback* callback) {
   }
 }
 
-void MediaFilter::SetPlaybackRate(float playback_rate) {}
+void Filter::SetPlaybackRate(float playback_rate) {}
 
-void MediaFilter::Seek(base::TimeDelta time, FilterCallback* callback) {
+void Filter::Seek(base::TimeDelta time, FilterCallback* callback) {
   scoped_ptr<FilterCallback> seek_callback(callback);
   if (seek_callback.get()) {
     seek_callback->Run();
   }
 }
 
-void MediaFilter::OnAudioRendererDisabled() {
+void Filter::OnAudioRendererDisabled() {
 }
 
-MediaFilter::~MediaFilter() {}
-
 bool DataSource::IsUrlSupported(const std::string& url) {
   return true;
 }
diff --git a/media/base/filters.h b/media/base/filters.h
index 8c3d757..4fd52e2 100644
--- a/media/base/filters.h
+++ b/media/base/filters.h
@@ -40,15 +40,15 @@ namespace media {
 class Buffer;
 class Decoder;
 class DemuxerStream;
+class Filter;
 class FilterHost;
-class MediaFilter;
 
 // Used for completing asynchronous methods.
 typedef Callback0::Type FilterCallback;
 
-class MediaFilter : public base::RefCountedThreadSafe<MediaFilter> {
+class Filter : public base::RefCountedThreadSafe<Filter> {
  public:
-  MediaFilter();
+  Filter();
 
   // Return the major mime type for this filter.
   virtual const char* major_mime_type() const;
@@ -110,8 +110,8 @@ class MediaFilter : public base::RefCountedThreadSafe<MediaFilter> {
 
  protected:
   // Only allow scoped_refptr<> to delete filters.
-  friend class base::RefCountedThreadSafe<MediaFilter>;
-  virtual ~MediaFilter();
+  friend class base::RefCountedThreadSafe<Filter>;
+  virtual ~Filter();
 
   FilterHost* host() const { return host_; }
   MessageLoop* message_loop() const { return message_loop_; }
@@ -120,10 +120,10 @@ class MediaFilter : public base::RefCountedThreadSafe<MediaFilter> {
   FilterHost* host_;
   MessageLoop* message_loop_;
 
-  DISALLOW_COPY_AND_ASSIGN(MediaFilter);
+  DISALLOW_COPY_AND_ASSIGN(Filter);
 };
 
-class DataSource : public MediaFilter {
+class DataSource : public Filter {
  public:
   typedef Callback1<size_t>::Type ReadCallback;
   static const size_t kReadError = static_cast<size_t>(-1);
@@ -152,7 +152,7 @@ class DataSource : public MediaFilter {
 };
 
 
-class Demuxer : public MediaFilter {
+class Demuxer : public Filter {
  public:
   virtual bool requires_message_loop() const;
   virtual const char* message_loop_name() const;
@@ -208,7 +208,7 @@ class DemuxerStream : public base::RefCountedThreadSafe<DemuxerStream> {
 };
 
 
-class VideoDecoder : public MediaFilter {
+class VideoDecoder : public Filter {
  public:
   virtual const char* major_mime_type() const;
   virtual bool requires_message_loop() const;
@@ -253,7 +253,7 @@ class VideoDecoder : public MediaFilter {
 };
 
 
-class AudioDecoder : public MediaFilter {
+class AudioDecoder : public Filter {
  public:
   virtual const char* major_mime_type() const;
   virtual bool requires_message_loop() const;
@@ -292,7 +292,7 @@ class AudioDecoder : public MediaFilter {
 };
 
 
-class VideoRenderer : public MediaFilter {
+class VideoRenderer : public Filter {
  public:
   virtual const char* major_mime_type() const;
 
@@ -306,7 +306,7 @@ class VideoRenderer : public MediaFilter {
 };
 
 
-class AudioRenderer : public MediaFilter {
+class AudioRenderer : public Filter {
  public:
   virtual const char* major_mime_type() const;
 
diff --git a/media/base/media_format.h b/media/base/media_format.h
index 8b9cdb0..7b53d63 100644
--- a/media/base/media_format.h
+++ b/media/base/media_format.h
@@ -26,10 +26,10 @@ extern const char kMajorTypeAudio[];
 extern const char kMajorTypeVideo[];
 }  // namespace mime_type
 
-// MediaFormat is used to describe the output of a MediaFilterInterface to
-// determine whether a downstream filter can accept the output from an upstream
-// filter.  In general, every MediaFormat contains a MIME type describing
-// its output as well as additional key-values describing additional details.
+// MediaFormat is used to describe the output of a Filter to determine whether
+// a downstream filter can accept the output from an upstream filter.
+// In general, every MediaFormat contains a MIME type describing its output as
+// well as additional key-values describing additional details.
 //
 // For example, an audio decoder could output audio/x-uncompressed and include
 // additional key-values such as the number of channels and the sample rate.
diff --git a/media/base/mock_filters.h b/media/base/mock_filters.h
index af7c0c5..3b1deb3 100644
--- a/media/base/mock_filters.h
+++ b/media/base/mock_filters.h
@@ -17,7 +17,7 @@
 
 #include "base/callback.h"
 #include "media/base/filters.h"
-#include "media/base/media_filter_collection.h"
+#include "media/base/filter_collection.h"
 #include "media/base/video_frame.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
@@ -94,7 +94,7 @@ class MockDataSource : public DataSource {
  public:
   MockDataSource() {}
 
-  // MediaFilter implementation.
+  // Filter implementation.
   MOCK_METHOD1(Stop, void(FilterCallback* callback));
   MOCK_METHOD1(SetPlaybackRate, void(float playback_rate));
   MOCK_METHOD2(Seek, void(base::TimeDelta time, FilterCallback* callback));
@@ -121,7 +121,7 @@ class MockDemuxer : public Demuxer {
  public:
   MockDemuxer() {}
 
-  // MediaFilter implementation.
+  // Filter implementation.
   MOCK_METHOD1(Stop, void(FilterCallback* callback));
   MOCK_METHOD1(SetPlaybackRate, void(float playback_rate));
   MOCK_METHOD2(Seek, void(base::TimeDelta time, FilterCallback* callback));
@@ -163,7 +163,7 @@ class MockVideoDecoder : public VideoDecoder {
  public:
   MockVideoDecoder() {}
 
-  // MediaFilter implementation.
+  // Filter implementation.
   MOCK_METHOD1(Stop, void(FilterCallback* callback));
   MOCK_METHOD1(SetPlaybackRate, void(float playback_rate));
   MOCK_METHOD2(Seek, void(base::TimeDelta time, FilterCallback* callback));
@@ -192,7 +192,7 @@ class MockAudioDecoder : public AudioDecoder {
  public:
   MockAudioDecoder() {}
 
-  // MediaFilter implementation.
+  // Filter implementation.
   MOCK_METHOD1(Stop, void(FilterCallback* callback));
   MOCK_METHOD1(SetPlaybackRate, void(float playback_rate));
   MOCK_METHOD2(Seek, void(base::TimeDelta time, FilterCallback* callback));
@@ -220,7 +220,7 @@ class MockVideoRenderer : public VideoRenderer {
  public:
   MockVideoRenderer() {}
 
-  // MediaFilter implementation.
+  // Filter implementation.
   MOCK_METHOD1(Stop, void(FilterCallback* callback));
   MOCK_METHOD1(SetPlaybackRate, void(float playback_rate));
   MOCK_METHOD2(Seek, void(base::TimeDelta time, FilterCallback* callback));
@@ -243,7 +243,7 @@ class MockAudioRenderer : public AudioRenderer {
  public:
   MockAudioRenderer() {}
 
-  // MediaFilter implementation.
+  // Filter implementation.
   MOCK_METHOD1(Stop, void(FilterCallback* callback));
   MOCK_METHOD1(SetPlaybackRate, void(float playback_rate));
   MOCK_METHOD2(Seek, void(base::TimeDelta time, FilterCallback* callback));
@@ -285,12 +285,12 @@ class MockFilterCollection {
   MockVideoRenderer* video_renderer() const { return video_renderer_; }
   MockAudioRenderer* audio_renderer() const { return audio_renderer_; }
 
-  MediaFilterCollection* filter_collection() const {
+  FilterCollection* filter_collection() const {
     return filter_collection(true);
   }
 
-  MediaFilterCollection* filter_collection(bool include_data_source) const {
-    MediaFilterCollection* collection = new MediaFilterCollection();
+  FilterCollection* filter_collection(bool include_data_source) const {
+    FilterCollection* collection = new FilterCollection();
 
     if (include_data_source) {
       collection->AddDataSource(data_source_);
diff --git a/media/base/pipeline.h b/media/base/pipeline.h
index 5b234af..50158d2 100644
--- a/media/base/pipeline.h
+++ b/media/base/pipeline.h
@@ -12,8 +12,6 @@
 #include <string>
 
 #include "base/callback.h"
-#include "media/base/filters.h"
-#include "media/base/media_filter_collection.h"
 
 namespace base {
 class TimeDelta;
@@ -42,6 +40,8 @@ enum PipelineError {
   DEMUXER_ERROR_COULD_NOT_CREATE_THREAD,
 };
 
+class FilterCollection;
+
 // Client-provided callbacks for various pipeline operations.  Clients should
 // inspect the Pipeline for errors.
 typedef Callback0::Type PipelineCallback;
@@ -69,7 +69,7 @@ class Pipeline : public base::RefCountedThreadSafe<Pipeline> {
   // If the caller provides a |start_callback|, it will be called when the
   // pipeline initialization completes.  Clients are expected to call GetError()
   // to check whether initialization succeeded.
-  virtual bool Start(MediaFilterCollection* filter_collection,
+  virtual bool Start(FilterCollection* filter_collection,
                      const std::string& url,
                      PipelineCallback* start_callback) = 0;
 
diff --git a/media/base/pipeline_impl.cc b/media/base/pipeline_impl.cc
index 049ab00..f73d14a 100644
--- a/media/base/pipeline_impl.cc
+++ b/media/base/pipeline_impl.cc
@@ -10,6 +10,7 @@
 #include "base/condition_variable.h"
 #include "base/stl_util-inl.h"
 #include "media/base/clock_impl.h"
+#include "media/base/filter_collection.h"
 #include "media/base/media_format.h"
 #include "media/base/pipeline_impl.h"
 
@@ -43,12 +44,12 @@ void PipelineImpl::Init(PipelineCallback* ended_callback,
 }
 
 // Creates the PipelineInternal and calls it's start method.
-bool PipelineImpl::Start(MediaFilterCollection* collection,
+bool PipelineImpl::Start(FilterCollection* collection,
                          const std::string& url,
                          PipelineCallback* start_callback) {
   AutoLock auto_lock(lock_);
   scoped_ptr<PipelineCallback> callback(start_callback);
-  scoped_ptr<MediaFilterCollection> filter_collection(collection);
+  scoped_ptr<FilterCollection> filter_collection(collection);
 
   if (running_) {
     VLOG(1) << "Media pipeline is already running";
@@ -519,7 +520,7 @@ void PipelineImpl::OnFilterStateTransition() {
       NewRunnableMethod(this, &PipelineImpl::FilterStateTransitionTask));
 }
 
-void PipelineImpl::StartTask(MediaFilterCollection* filter_collection,
+void PipelineImpl::StartTask(FilterCollection* filter_collection,
                              const std::string& url,
                              PipelineCallback* start_callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
@@ -844,7 +845,7 @@ void PipelineImpl::FilterStateTransitionTask() {
 
   // Carry out the action for the current state.
   if (TransientState(state_)) {
-    MediaFilter* filter = filters_[filters_.size() - remaining_transitions_];
+    Filter* filter = filters_[filters_.size() - remaining_transitions_];
     if (state_ == kPausing) {
       filter->Pause(NewCallback(this, &PipelineImpl::OnFilterStateTransition));
     } else if (state_ == kFlushing) {
@@ -937,7 +938,7 @@ void PipelineImpl::FinishDestroyingFiltersTask() {
   }
 }
 
-bool PipelineImpl::PrepareFilter(scoped_refptr<MediaFilter> filter) {
+bool PipelineImpl::PrepareFilter(scoped_refptr<Filter> filter) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
diff --git a/media/base/pipeline_impl.h b/media/base/pipeline_impl.h
index 603194a..32c1052 100644
--- a/media/base/pipeline_impl.h
+++ b/media/base/pipeline_impl.h
@@ -69,7 +69,7 @@ class PipelineImpl : public Pipeline, public FilterHost {
   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);
@@ -185,7 +185,7 @@ class PipelineImpl : public Pipeline, public FilterHost {
   // 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);
 
@@ -234,11 +234,10 @@ class PipelineImpl : public Pipeline, public FilterHost {
 
   // 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);
 
@@ -377,7 +376,7 @@ class PipelineImpl : public Pipeline, public FilterHost {
   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_;
@@ -391,7 +390,7 @@ class PipelineImpl : public Pipeline, public FilterHost {
 
   // 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
diff --git a/media/base/pipeline_impl_unittest.cc b/media/base/pipeline_impl_unittest.cc
index f465e52..1116582 100644
--- a/media/base/pipeline_impl_unittest.cc
+++ b/media/base/pipeline_impl_unittest.cc
@@ -356,7 +356,7 @@ TEST_F(PipelineImplTest, RequiredFilterMissing) {
   EXPECT_CALL(callbacks_, OnStart());
 
   // Create a filter collection with missing filter.
-  MediaFilterCollection* collection = mocks_->filter_collection(false);
+  FilterCollection* collection = mocks_->filter_collection(false);
   pipeline_->Start(collection, "",
                    NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
                                &CallbackHelper::OnStart));