Move FilterType into MediaFilterCollection

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"
@@ skipping 936 matching lines @@
   filter->set_host(this);
   filters_.push_back(make_scoped_refptr(filter.get()));
 }
 
 void PipelineImpl::InitializeDataSource() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   scoped_refptr<DataSource> data_source;
   while (true) {
-    filter_collection_->SelectFilter(&data_source);
+    filter_collection_->SelectDataSource(&data_source);
     if (!data_source || data_source->IsUrlSupported(url_))
       break;
   }
 
   if (!data_source) {
     SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     return;
   }
 
   PrepareFilter(data_source);
   pipeline_init_state_->data_source_ = data_source;
   data_source->Initialize(
       url_, NewCallback(this, &PipelineImpl::OnFilterInitialize));
 }
 
 void PipelineImpl::InitializeDemuxer(
     const scoped_refptr<DataSource>& data_source) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   scoped_refptr<Demuxer> demuxer;
 
   CHECK(data_source);
 
-  filter_collection_->SelectFilter(&demuxer);
+  filter_collection_->SelectDemuxer(&demuxer);
   if (!demuxer) {
     SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     return;
   }
 
   PrepareFilter(demuxer);
   pipeline_init_state_->demuxer_ = demuxer;
   demuxer->Initialize(data_source,
                       NewCallback(this, &PipelineImpl::OnFilterInitialize));
 }
 
 bool PipelineImpl::InitializeAudioDecoder(
     const scoped_refptr<Demuxer>& demuxer) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   scoped_refptr<DemuxerStream> stream =
       FindDemuxerStream(demuxer, mime_type::kMajorTypeAudio);
 
   if (stream) {
     scoped_refptr<AudioDecoder> audio_decoder;
-    filter_collection_->SelectFilter(&audio_decoder);
+    filter_collection_->SelectAudioDecoder(&audio_decoder);
 
     if (audio_decoder) {
       PrepareFilter(audio_decoder);
       pipeline_init_state_->audio_decoder_ = audio_decoder;
       audio_decoder->Initialize(
           stream,
           NewCallback(this, &PipelineImpl::OnFilterInitialize));
       return true;
     } else {
       SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     }
   }
 
   return false;
 }
 
 bool PipelineImpl::InitializeVideoDecoder(
     const scoped_refptr<Demuxer>& demuxer) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   scoped_refptr<DemuxerStream> stream =
       FindDemuxerStream(demuxer, mime_type::kMajorTypeVideo);
 
   if (stream) {
     scoped_refptr<VideoDecoder> video_decoder;
-    filter_collection_->SelectFilter(&video_decoder);
+    filter_collection_->SelectVideoDecoder(&video_decoder);
 
     if (video_decoder) {
       PrepareFilter(video_decoder);
       pipeline_init_state_->video_decoder_ = video_decoder;
       video_decoder->Initialize(
           stream,
           NewCallback(this, &PipelineImpl::OnFilterInitialize));
       return true;
     } else {
       SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     }
   }
   return false;
 }
 
 bool PipelineImpl::InitializeAudioRenderer(
     const scoped_refptr<AudioDecoder>& decoder) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   if (decoder) {
-    filter_collection_->SelectFilter(&audio_renderer_);
+    filter_collection_->SelectAudioRenderer(&audio_renderer_);
 
     if (audio_renderer_) {
       PrepareFilter(audio_renderer_);
       audio_renderer_->Initialize(
           decoder, NewCallback(this, &PipelineImpl::OnFilterInitialize));
       return true;
     } else {
       SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     }
   }
   return false;
 }
 
 bool PipelineImpl::InitializeVideoRenderer(
     const scoped_refptr<VideoDecoder>& decoder) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   if (decoder) {
-    filter_collection_->SelectFilter(&video_renderer_);
+    filter_collection_->SelectVideoRenderer(&video_renderer_);
 
     if (video_renderer_) {
       PrepareFilter(video_renderer_);
       video_renderer_->Initialize(
           decoder, NewCallback(this, &PipelineImpl::OnFilterInitialize));
       return true;
     } else {
       SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     }
   }
@@ skipping 41 matching lines @@
           this, &PipelineImpl::OnFilterStateTransition));
     }
   } else {
     state_ = kStopped;
     message_loop_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &PipelineImpl::FinishDestroyingFiltersTask));
   }
 }
 
 }  // namespace media