Remove AudioDecoder from the Filter heirarchy.

media/base/pipeline.cc

 // 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.
 
 #include "media/base/pipeline.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 36 matching lines @@
   while (!notified_)
     cv_.Wait();
 }
 
 media::PipelineStatus PipelineStatusNotification::status() {
   base::AutoLock auto_lock(lock_);
   DCHECK(notified_);
   return status_;
 }
 
-class Pipeline::PipelineInitState {
- public:
+struct Pipeline::PipelineInitState {
   scoped_refptr<AudioDecoder> audio_decoder_;

[scherkus (not reviewing), 2012/02/06 21:04:04]

nit: drop trailing _ for structs

[Ami GONE FROM CHROMIUM, 2012/02/06 21:38:48]

Done.

   scoped_refptr<VideoDecoder> video_decoder_;
   scoped_refptr<CompositeFilter> composite_;
 };
 
 Pipeline::Pipeline(MessageLoop* message_loop, MediaLog* media_log)
     : message_loop_(message_loop),
       media_log_(media_log),
       clock_(new Clock(&base::Time::Now)),
       waiting_for_clock_update_(false),
       state_(kCreated),
@@ skipping 952 matching lines @@
     // We use audio stream to update the clock. So if there is such a stream,
     // we pause the clock until we receive a valid timestamp.
     waiting_for_clock_update_ = true;
     if (!has_audio_) {
       clock_->SetMaxTime(clock_->Duration());
       StartClockIfWaitingForTimeUpdate_Locked();
     }
 
     // Start monitoring rate of downloading.
     int bitrate = 0;
-    if (demuxer_.get()) {
+    if (demuxer_) {
       bitrate = demuxer_->GetBitrate();
       local_source_ = demuxer_->IsLocalSource();
       streaming_ = !demuxer_->IsSeekable();
     }
     // Needs to be locked because most other calls to |download_rate_monitor_|
     // occur on the renderer thread.
     download_rate_monitor_.Start(
         base::Bind(&Pipeline::OnCanPlayThrough, this),
         bitrate, streaming_, local_source_);
     download_rate_monitor_.SetBufferedBytes(buffered_bytes_, base::Time::Now());
@@ skipping 121 matching lines @@
     const scoped_refptr<Demuxer>& demuxer) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   scoped_refptr<DemuxerStream> stream =
       demuxer->GetStream(DemuxerStream::AUDIO);
 
   if (!stream)
     return false;
 
-  scoped_refptr<AudioDecoder> audio_decoder;
-  filter_collection_->SelectAudioDecoder(&audio_decoder);
+  filter_collection_->SelectAudioDecoder(&pipeline_init_state_->audio_decoder_);
 
-  if (!audio_decoder) {
+  if (!pipeline_init_state_->audio_decoder_) {
     SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     return false;
   }
 
-  if (!PrepareFilter(audio_decoder))
-    return false;
-
-  pipeline_init_state_->audio_decoder_ = audio_decoder;
-  audio_decoder->Initialize(
+  pipeline_init_state_->audio_decoder_->Initialize(
       stream,
       base::Bind(&Pipeline::OnFilterInitialize, this),
       base::Bind(&Pipeline::OnUpdateStatistics, this));
   return true;
 }
 
 bool Pipeline::InitializeVideoDecoder(
     const scoped_refptr<Demuxer>& demuxer) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
@@ skipping 228 matching lines @@
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (!waiting_for_clock_update_)
     return;
 
   waiting_for_clock_update_ = false;
   clock_->Play();
 }
 
 }  // namespace media