Miscellaneous AudioRendererImpl cleanup salvaged from http://codereview.chromium.org/10918022/.

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 <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "media/audio/audio_util.h"
 #include "media/base/demuxer_stream.h"
 
 namespace media {
 
 AudioRendererImpl::AudioRendererImpl(media::AudioRendererSink* sink)
     : 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),
       preroll_aborted_(false) {
 }
 
 void AudioRendererImpl::Play(const base::Closure& callback) {
   {
     base::AutoLock auto_lock(lock_);
     DCHECK_EQ(kPaused, state_);
     state_ = kPlaying;
     callback.Run();
   }
 
   if (stopped_)
     return;
 
   if (GetPlaybackRate() != 0.0f) {
     DoPlay();
   } else {
     DoPause();
   }
 }
 
 void AudioRendererImpl::DoPlay() {
   earliest_end_time_ = base::Time::Now();
-  DCHECK(sink_.get());
   sink_->Play();
 }
 
 void AudioRendererImpl::Pause(const base::Closure& callback) {
   {
     base::AutoLock auto_lock(lock_);
     DCHECK(state_ == kPlaying || state_ == kUnderflow ||
            state_ == kRebuffering);
     pause_cb_ = callback;
     state_ = kPaused;
 
     // Pause only when we've completed our pending read.
     if (!pending_read_)
       base::ResetAndReturn(&pause_cb_).Run();
   }
 
   if (stopped_)
     return;
 
   DoPause();
 }
 
 void AudioRendererImpl::DoPause() {
-  DCHECK(sink_.get());
   sink_->Pause(false);
 }
 
 void AudioRendererImpl::Flush(const base::Closure& callback) {
   decoder_->Reset(callback);
 }
 
 void AudioRendererImpl::Stop(const base::Closure& callback) {
   DCHECK(!callback.is_null());
 
   if (!stopped_) {
-    DCHECK(sink_.get());
     sink_->Stop();
-
     stopped_ = true;
   }
   {
     base::AutoLock auto_lock(lock_);
     state_ = kStopped;
     algorithm_.reset(NULL);
     init_cb_.Reset();
     underflow_cb_.Reset();
     time_cb_.Reset();
   }
@@ skipping 37 matching lines @@
                                    const base::Closure& underflow_cb,
                                    const TimeCB& time_cb,
                                    const base::Closure& ended_cb,
                                    const base::Closure& disabled_cb,
                                    const PipelineStatusCB& error_cb) {
   base::AutoLock auto_lock(lock_);
   DCHECK(stream);
   DCHECK(!decoders.empty());
   DCHECK_EQ(stream->type(), DemuxerStream::AUDIO);
   DCHECK(!init_cb.is_null());
+  DCHECK(!statistics_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_);
 
   init_cb_ = init_cb;
   statistics_cb_ = statistics_cb;
   underflow_cb_ = underflow_cb;
@@ skipping 39 matching lines @@
   if (!decoders->empty() && status == DECODER_ERROR_NOT_SUPPORTED) {
     InitializeNextDecoder(demuxer_stream, decoders.Pass());
     return;
   }
 
   if (status != PIPELINE_OK) {
     base::ResetAndReturn(&init_cb_).Run(status);
     return;
   }
 
-  // Create a callback so our algorithm can request more reads.
-  base::Closure cb = base::Bind(&AudioRendererImpl::ScheduleRead_Locked, this);
+  // We're all good! Continue initializing the rest of the audio renderer based
+  // on the decoder format.
 
-  // 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();
   int channels = ChannelLayoutToChannelCount(channel_layout);
   int bits_per_channel = decoder_->bits_per_channel();
   int sample_rate = decoder_->samples_per_second();
   // TODO(vrk): Add method to AudioDecoder to compute bytes per frame.
   bytes_per_frame_ = channels * bits_per_channel / 8;
 
-  bool config_ok = algorithm_->ValidateConfig(channels, sample_rate,
-                                              bits_per_channel);
-  if (!config_ok || is_initialized_) {
+  algorithm_.reset(new AudioRendererAlgorithm());
+  if (!algorithm_->ValidateConfig(channels, sample_rate, bits_per_channel)) {
     base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
     return;
   }
 
-  if (config_ok)
-    algorithm_->Initialize(channels, sample_rate, bits_per_channel, 0.0f, cb);
+  algorithm_->Initialize(
+      channels, sample_rate, bits_per_channel, 0.0f,
+      base::Bind(&AudioRendererImpl::ScheduleRead_Locked, this));
 
   // We use the AUDIO_PCM_LINEAR flag because AUDIO_PCM_LOW_LATENCY
   // does not currently support all the sample-rates that we require.
   // Please see: http://code.google.com/p/chromium/issues/detail?id=103627
   // for more details.
   audio_parameters_ = AudioParameters(
       AudioParameters::AUDIO_PCM_LINEAR, channel_layout, sample_rate,
       bits_per_channel, GetHighLatencyOutputBufferSize(sample_rate));
 
-  bytes_per_second_ = audio_parameters_.GetBytesPerSecond();
+  sink_->Initialize(audio_parameters_, this);
+  sink_->Start();
 
-  DCHECK(sink_.get());
-  DCHECK(!is_initialized_);
-
-  sink_->Initialize(audio_parameters_, this);
-
-  sink_->Start();
-  is_initialized_ = true;
-
-  // Finally, execute the start callback.
   state_ = kPaused;
   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
 }
 
 void AudioRendererImpl::ResumeAfterUnderflow(bool buffer_more_audio) {
   base::AutoLock auto_lock(lock_);
   if (state_ == kUnderflow) {
     // The "&& preroll_aborted_" is a hack. If preroll is aborted, then we
     // shouldn't even reach the kUnderflow state to begin with. But for now
     // we're just making sure that the audio buffer capacity (i.e. the
@@ skipping 273 matching lines @@
           static_cast<int64>(ceil(predicted_play_time.InMicroseconds() *
                                   playback_rate)));
     }
     earliest_end_time_ =
         std::max(earliest_end_time_,
                  time_now + request_delay + predicted_play_time);
   }
 }
 
 base::TimeDelta AudioRendererImpl::ConvertToDuration(int bytes) {
-  if (bytes_per_second_) {
-    return base::TimeDelta::FromMicroseconds(
-        base::Time::kMicrosecondsPerSecond * bytes / bytes_per_second_);
-  }
-  return base::TimeDelta();
+  int bytes_per_second = audio_parameters_.GetBytesPerSecond();
+  CHECK(bytes_per_second);
+  return base::TimeDelta::FromMicroseconds(
+      base::Time::kMicrosecondsPerSecond * bytes / bytes_per_second);
 }
 
 void AudioRendererImpl::OnRenderError() {
   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:
@@ skipping 11 matching lines @@
     case kUnderflow:
     case kRebuffering:
     case kStopped:
       if (status != PIPELINE_OK)
         error_cb_.Run(status);
       return;
   }
 }
 
 }  // namespace media