Rename MediaFilter and MediaFilterCollection to Filter and FilterCollection, respectively.

media/base/pipeline_impl.cc

 // 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.
 //
 // TODO(scherkus): clean up PipelineImpl... too many crazy function names,
 // potential deadlocks, etc...
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #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"
 
 namespace media {
 
 PipelineImpl::PipelineImpl(MessageLoop* message_loop)
     : message_loop_(message_loop),
       clock_(new ClockImpl(&base::Time::Now)),
       waiting_for_clock_update_(false),
       state_(kCreated),
@@ skipping 13 matching lines @@
                         PipelineCallback* error_callback,
                         PipelineCallback* network_callback) {
   DCHECK(!IsRunning())
       << "Init() should be called before the pipeline has started";
   ended_callback_.reset(ended_callback);
   error_callback_.reset(error_callback);
   network_callback_.reset(network_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";
     return false;
   }
 
   if (collection->IsEmpty()) {
     return false;
   }
 
@@ skipping 450 matching lines @@
       NewRunnableMethod(this, &PipelineImpl::InitializeTask));
 }
 
 // Called from any thread.
 void PipelineImpl::OnFilterStateTransition() {
   // Continue walking down the filters.
   message_loop_->PostTask(FROM_HERE,
       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_);
   DCHECK_EQ(kCreated, state_);
   filter_collection_.reset(filter_collection);
   url_ = url;
   seek_callback_.reset(start_callback);
 
   // Kick off initialization.
   InitializeTask();
@@ skipping 304 matching lines @@
       clock_->SetTime(seek_timestamp_);
     }
 
     if (TransientState(state_)) {
       remaining_transitions_ = filters_.size();
     }
   }
 
   // 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) {
       // We had to use parallel flushing all filters.
       if (remaining_transitions_ == filters_.size()) {
         for (size_t i = 0; i < filters_.size(); i++) {
           filters_[i]->Flush(
               NewCallback(this, &PipelineImpl::OnFilterStateTransition));
         }
       }
@@ skipping 72 matching lines @@
   } else {
     // Destroying filters due to SetError().
     state_ = kError;
     // If our owner has requested to be notified of an error.
     if (error_callback_.get()) {
       error_callback_->Run();
     }
   }
 }
 
-bool PipelineImpl::PrepareFilter(scoped_refptr<MediaFilter> filter) {
+bool PipelineImpl::PrepareFilter(scoped_refptr<Filter> filter) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   // Create a dedicated thread for this filter if applicable.
   if (filter->requires_message_loop()) {
     scoped_ptr<base::Thread> thread(
         new base::Thread(filter->message_loop_name()));
     if (!thread.get() || !thread->Start()) {
       NOTREACHED() << "Could not start filter thread";
       SetError(PIPELINE_ERROR_INITIALIZATION_FAILED);
@@ skipping 201 matching lines @@
           this, &PipelineImpl::OnFilterStateTransition));
     }
   } else {
     state_ = kStopped;
     message_loop_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &PipelineImpl::FinishDestroyingFiltersTask));
   }
 }
 
 }  // namespace media