Move AudioRenderer out of Filter heirarchy.

media/filters/audio_renderer_impl.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/filters/audio_renderer_impl.h"
 
 #include <math.h>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "media/base/filter_host.h"
 #include "media/audio/audio_util.h"
 
 namespace media {
 
 AudioRendererImpl::AudioRendererImpl(media::AudioRendererSink* sink)
-    : host_(NULL),
-      state_(kUninitialized),
+    : state_(kUninitialized),
       pending_read_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       audio_time_buffered_(kNoTimestamp()),
       current_time_(kNoTimestamp()),
       bytes_per_frame_(0),
       bytes_per_second_(0),
       stopped_(false),
       sink_(sink),
       is_initialized_(false),
       underflow_disabled_(false),
       read_cb_(base::Bind(&AudioRendererImpl::DecodedAudioReady,
                           base::Unretained(this))) {
 }
 
-void AudioRendererImpl::SetHost(FilterHost* host) {
-  DCHECK(host);
-  DCHECK(!host_);
-  host_ = host;
-}
-
 void AudioRendererImpl::Play(const base::Closure& callback) {
   {
     base::AutoLock auto_lock(lock_);
     DCHECK_EQ(kPaused, state_);
     state_ = kPlaying;
     callback.Run();
   }
 
   if (stopped_)
     return;
@@ skipping 86 matching lines @@
 void AudioRendererImpl::DoSeek() {
   earliest_end_time_ = base::Time::Now();
 
   // Pause and flush the stream when we seek to a new location.
   sink_->Pause(true);
 }
 
 void AudioRendererImpl::Initialize(const scoped_refptr<AudioDecoder>& decoder,
                                    const PipelineStatusCB& init_cb,
                                    const base::Closure& underflow_cb,
-                                   const TimeCB& time_cb) {
+                                   const TimeCB& time_cb,
+                                   const base::Closure& ended_cb,
+                                   const base::Closure& disabled_cb,
+                                   const PipelineStatusCB& error_cb) {
   DCHECK(decoder);
   DCHECK(!init_cb.is_null());
   DCHECK(!underflow_cb.is_null());
   DCHECK(!time_cb.is_null());
+  DCHECK(!ended_cb.is_null());
+  DCHECK(!disabled_cb.is_null());
+  DCHECK(!error_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
   decoder_ = decoder;
   underflow_cb_ = underflow_cb;
   time_cb_ = time_cb;
+  ended_cb_ = ended_cb;
+  disabled_cb_ = disabled_cb;
+  error_cb_ = error_cb;
 
   // Create a callback so our algorithm can request more reads.
   base::Closure cb = base::Bind(&AudioRendererImpl::ScheduleRead_Locked, this);
 
   // Construct the algorithm.
   algorithm_.reset(new AudioRendererAlgorithm());
 
   // Initialize our algorithm with media properties, initial playback rate,
   // and a callback to request more reads from the data source.
   ChannelLayout channel_layout = decoder_->channel_layout();
@@ skipping 262 matching lines @@
     //
     // We use the following conditions to determine underflow:
     //   1) Algorithm can not fill the audio callback buffer
     //   2) We have NOT received an end of stream buffer
     //   3) We are in the kPlaying state
     //
     // Otherwise fill the buffer with whatever data we can send to the device.
     if (!algorithm_->CanFillBuffer() && received_end_of_stream_ &&
         !rendered_end_of_stream_ && base::Time::Now() >= earliest_end_time_) {
       rendered_end_of_stream_ = true;
-      host_->NotifyEnded();
+      ended_cb_.Run();
     } else if (!algorithm_->CanFillBuffer() && !received_end_of_stream_ &&
                state_ == kPlaying && !underflow_disabled_) {
       state_ = kUnderflow;
       underflow_cb = underflow_cb_;
     } else if (algorithm_->CanFillBuffer()) {
       frames_written = algorithm_->FillBuffer(dest, requested_frames);
       DCHECK_GT(frames_written, 0u);
     } else {
       // We can't write any data this cycle. For example, we may have
       // sent all available data to the audio device while not reaching
@@ skipping 62 matching lines @@
 
 base::TimeDelta AudioRendererImpl::ConvertToDuration(int bytes) {
   if (bytes_per_second_) {
     return base::TimeDelta::FromMicroseconds(
         base::Time::kMicrosecondsPerSecond * bytes / bytes_per_second_);
   }
   return base::TimeDelta();
 }
 
 void AudioRendererImpl::OnRenderError() {
-  host_->DisableAudioRenderer();
+  disabled_cb_.Run();
 }
 
 void AudioRendererImpl::DisableUnderflowForTesting() {
   DCHECK(!is_initialized_);
   underflow_disabled_ = true;
 }
 
 void AudioRendererImpl::HandleAbortedReadOrDecodeError(bool is_decode_error) {
   PipelineStatus status = is_decode_error ? PIPELINE_ERROR_DECODE : PIPELINE_OK;
   switch (state_) {
     case kUninitialized:
       NOTREACHED();
       return;
     case kPaused:
       if (status != PIPELINE_OK)
-        host_->SetError(status);
+        error_cb_.Run(status);
       base::ResetAndReturn(&pause_cb_).Run();
       return;
     case kSeeking:
       state_ = kPaused;
       base::ResetAndReturn(&seek_cb_).Run(status);
       return;
     case kPlaying:
     case kUnderflow:
     case kRebuffering:
     case kStopped:
       if (status != PIPELINE_OK)
-        host_->SetError(status);
+        error_cb_.Run(status);
       return;
   }
 }
 
 }  // namespace media