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:
-  scoped_refptr<AudioDecoder> audio_decoder_;
+struct Pipeline::PipelineInitState {
   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 606 matching lines @@
     // If this method returns false, then there's no audio stream.
     if (InitializeAudioDecoder(demuxer_))
       return;
   }
 
   // Assuming audio decoder was created, create audio renderer.
   if (state_ == kInitAudioDecoder) {
     SetState(kInitAudioRenderer);
 
     // Returns false if there's no audio stream.
-    if (InitializeAudioRenderer(pipeline_init_state_->audio_decoder_)) {
+    if (InitializeAudioRenderer(audio_decoder_)) {
       base::AutoLock auto_lock(lock_);
       has_audio_ = true;

[scherkus (not reviewing), 2012/02/03 23:31:29]

I wonder if we can replace has_audio_/has_video_ w/ ptr checks for decoders and
renderers... (maybe TODO-ify?)

[Ami GONE FROM CHROMIUM, 2012/02/04 00:10:21]

TODO'd.

       return;
     }
   }
 
   // Assuming audio renderer was created, create video decoder.
   if (state_ == kInitAudioRenderer) {
     // Then perform the stage of initialization, i.e. initialize video decoder.
     SetState(kInitVideoDecoder);
     if (InitializeVideoDecoder(demuxer_))
       return;
@@ skipping 323 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 41 matching lines @@
     // default: intentionally left out to force new states to cause compiler
     // errors.
   };
 }
 
 void Pipeline::FinishDestroyingFiltersTask() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineStopped());
 
   // Clear filter references.
+  audio_decoder_ = NULL;
   audio_renderer_ = NULL;
   video_renderer_ = NULL;
   demuxer_ = NULL;
 
   pipeline_filter_ = NULL;
 
   if (error_caused_teardown_ && !IsPipelineOk() && !error_callback_.is_null())
     error_callback_.Run(status_);
 
   if (stop_pending_) {
@@ skipping 60 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(&audio_decoder_);
 
-  if (!audio_decoder) {
+  if (!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(
+  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