Fold AudioRenderer::Stop() into the dtor.

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>
 
@@ skipping 49 matching lines @@
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       weak_factory_(this) {
   audio_buffer_stream_->set_splice_observer(base::Bind(
       &AudioRendererImpl::OnNewSpliceBuffer, weak_factory_.GetWeakPtr()));
   audio_buffer_stream_->set_config_change_observer(base::Bind(
       &AudioRendererImpl::OnConfigChange, weak_factory_.GetWeakPtr()));
 }
 
 AudioRendererImpl::~AudioRendererImpl() {
-  // Stop() should have been called and |algorithm_| should have been destroyed.
-  DCHECK(state_ == kUninitialized || state_ == kStopped);
-  DCHECK(!algorithm_.get());
+  DVLOG(1) << __FUNCTION__;
+  DCHECK(task_runner_->BelongsToCurrentThread());
+
+  // If Render() is in progress, this call will wait for Render() to finish.
+  // After this call, the |sink_| will not call back into |this| anymore.
+  sink_->Stop();

[DaleCurtis, 2014/07/22 00:15:48]

Correct, once this returns no further calls to the render callback should
happen.

+
+  if (!init_cb_.is_null())
+    base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_ABORT);
 }
 
 void AudioRendererImpl::StartRendering() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!rendering_);
   rendering_ = true;
 
   base::AutoLock auto_lock(lock_);
   // Wait for an eventual call to SetPlaybackRate() to start rendering.
@@ skipping 84 matching lines @@
   DCHECK_EQ(state_, kFlushed);
 
   audio_buffer_stream_->Reset(base::Bind(&AudioRendererImpl::ResetDecoderDone,
                                          weak_factory_.GetWeakPtr()));
 }
 
 void AudioRendererImpl::ResetDecoderDone() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   {
     base::AutoLock auto_lock(lock_);
-    if (state_ == kStopped)
-      return;
 
     DCHECK_EQ(state_, kFlushed);
     DCHECK(!flush_cb_.is_null());
 
     audio_clock_.reset(new AudioClock(audio_parameters_.sample_rate()));
     received_end_of_stream_ = false;
     rendered_end_of_stream_ = false;
 
     // Flush() may have been called while underflowed/not fully buffered.
     if (buffering_state_ != BUFFERING_HAVE_NOTHING)
       SetBufferingState_Locked(BUFFERING_HAVE_NOTHING);
 
     splicer_->Reset();
     if (buffer_converter_)
       buffer_converter_->Reset();
     algorithm_->FlushBuffers();
   }
 
   // Changes in buffering state are always posted. Flush callback must only be
   // run after buffering state has been set back to nothing.
   task_runner_->PostTask(FROM_HERE, base::ResetAndReturn(&flush_cb_));
 }
 
-void AudioRendererImpl::Stop(const base::Closure& callback) {
-  DVLOG(1) << __FUNCTION__;
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  DCHECK(!callback.is_null());
-
-  // TODO(scherkus): Consider invalidating |weak_factory_| and replacing
-  // task-running guards that check |state_| with DCHECK().
-
-  {
-    base::AutoLock auto_lock(lock_);
-
-    if (state_ == kStopped) {
-      task_runner_->PostTask(FROM_HERE, callback);
-      return;
-    }
-
-    ChangeState_Locked(kStopped);
-    algorithm_.reset();
-    time_cb_.Reset();
-    flush_cb_.Reset();
-  }
-
-  if (sink_) {
-    sink_->Stop();
-    sink_ = NULL;
-  }
-
-  audio_buffer_stream_.reset();
-  task_runner_->PostTask(FROM_HERE, callback);
-}
-
 void AudioRendererImpl::StartPlaying() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   DCHECK(!sink_playing_);
   DCHECK_EQ(state_, kFlushed);
   DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
   DCHECK(!pending_read_) << "Pending read must complete before seeking";
 
@@ skipping 69 matching lines @@
       statistics_cb,
       base::Bind(&AudioRendererImpl::OnAudioBufferStreamInitialized,
                  weak_factory_.GetWeakPtr()));
 }
 
 void AudioRendererImpl::OnAudioBufferStreamInitialized(bool success) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
 
-  if (state_ == kStopped) {
-    base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_ABORT);
-    return;
-  }
-
   if (!success) {
     state_ = kUninitialized;
     base::ResetAndReturn(&init_cb_).Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
   if (!audio_parameters_.IsValid()) {
     ChangeState_Locked(kUninitialized);
     base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
     return;
@@ skipping 110 matching lines @@
       if (trim_time > base::TimeDelta()) {
         buffer->TrimStart(buffer->frame_count() *
                           (static_cast<double>(trim_time.InMicroseconds()) /
                            buffer->duration().InMicroseconds()));
       }
       // If the entire buffer was trimmed, request a new one.
       if (!buffer->frame_count())
         return true;
     }
 
-    if (state_ != kUninitialized && state_ != kStopped)
+    if (state_ != kUninitialized)
       algorithm_->EnqueueBuffer(buffer);
   }
 
   switch (state_) {
     case kUninitialized:
     case kInitializing:
     case kFlushing:
       NOTREACHED();
       return false;
 
     case kFlushed:
       DCHECK(!pending_read_);
       return false;
 
     case kPlaying:
       if (buffer->end_of_stream() || algorithm_->IsQueueFull()) {
         if (buffering_state_ == BUFFERING_HAVE_NOTHING)
           SetBufferingState_Locked(BUFFERING_HAVE_ENOUGH);
         return false;
       }
       return true;
-
-    case kStopped:
-      return false;
   }
   return false;
 }
 
 void AudioRendererImpl::AttemptRead() {
   base::AutoLock auto_lock(lock_);
   AttemptRead_Locked();
 }
 
 void AudioRendererImpl::AttemptRead_Locked() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   lock_.AssertAcquired();
 
   if (!CanRead_Locked())
     return;
 
   pending_read_ = true;
   audio_buffer_stream_->Read(base::Bind(&AudioRendererImpl::DecodedAudioReady,
                                         weak_factory_.GetWeakPtr()));
 }
 
 bool AudioRendererImpl::CanRead_Locked() {
   lock_.AssertAcquired();
 
   switch (state_) {
     case kUninitialized:
     case kInitializing:
     case kFlushing:
     case kFlushed:
-    case kStopped:
       return false;
 
     case kPlaying:
       break;
   }
 
   return !pending_read_ && !received_end_of_stream_ &&
       !algorithm_->IsQueueFull();
 }
 
@@ skipping 146 matching lines @@
         DoFlush_Locked();
         return;
       }
 
       error_cb_.Run(status);
       base::ResetAndReturn(&flush_cb_).Run();
       return;
 
     case kFlushed:
     case kPlaying:
-    case kStopped:
       if (status != PIPELINE_OK)
         error_cb_.Run(status);
       return;
   }
 }
 
 void AudioRendererImpl::ChangeState_Locked(State new_state) {
   DVLOG(1) << __FUNCTION__ << " : " << state_ << " -> " << new_state;
   lock_.AssertAcquired();
   state_ = new_state;
@@ skipping 21 matching lines @@
            << buffering_state;
   DCHECK_NE(buffering_state_, buffering_state);
   lock_.AssertAcquired();
   buffering_state_ = buffering_state;
 
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(buffering_state_cb_, buffering_state_));
 }
 
 }  // namespace media