Stop audio streams in all codepaths that need it.

media/audio/audio_output_controller.cc

 // Copyright (c) 2011 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/audio/audio_output_controller.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 
@@ skipping 15 matching lines @@
       state_(kEmpty),
       buffer_(0, capacity),
       pending_request_(false),
       sync_reader_(sync_reader),
       message_loop_(NULL),
       number_polling_attempts_left_(0) {
 }
 
 AudioOutputController::~AudioOutputController() {
   DCHECK_EQ(kClosed, state_);
+  StopCloseAndClearStream();
 }
 
 // static
 scoped_refptr<AudioOutputController> AudioOutputController::Create(
     EventHandler* event_handler,
     const AudioParameters& params,
     uint32 buffer_capacity) {
 
   if (!params.IsValid())
     return NULL;
@@ skipping 85 matching lines @@
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   // Close() can be called before DoCreate() is executed.
   if (state_ == kClosed)
     return;
   DCHECK_EQ(kEmpty, state_);
 
   if (!AudioManager::GetAudioManager())
     return;
 
+  StopCloseAndClearStream();
   stream_ = AudioManager::GetAudioManager()->MakeAudioOutputStreamProxy(params);
   if (!stream_) {
     // TODO(hclam): Define error types.
     handler_->OnError(this, 0);
     return;
   }
 
   if (!stream_->Open()) {
-    stream_->Close();
-    stream_ = NULL;
+    StopCloseAndClearStream();
 
     // TODO(hclam): Define error types.
     handler_->OnError(this, 0);
     return;
   }
 
   // We have successfully opened the stream. Set the initial volume.
   stream_->SetVolume(volume_);
 
   // Finally set the state to kCreated.
@@ skipping 58 matching lines @@
   stream_->Start(this);
 
   // Tell the event handler that we are now playing.
   handler_->OnPlaying(this);
 }
 
 void AudioOutputController::DoPause() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   // We can pause from started state.
-  if (state_ != kPlaying)
+  if (state_ != kPlaying) {
+    if (stream_)
+      stream_->Stop();
     return;
+  }
   state_ = kPaused;
 
   // Then we stop the audio device. This is not the perfect solution because
   // it discards all the internal buffer in the audio device.
   // TODO(hclam): Actually pause the audio device.
   stream_->Stop();
 
   if (LowLatencyMode()) {
     // Send a special pause mark to the low-latency audio thread.
     sync_reader_->UpdatePendingBytes(kPauseMark);
@@ skipping 13 matching lines @@
       return;
     base::AutoLock auto_lock(lock_);
     buffer_.Clear();
   }
 }
 
 void AudioOutputController::DoClose(const base::Closure& closed_task) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   if (state_ != kClosed) {
-    // |stream_| can be null if creating the device failed in DoCreate().
-    if (stream_) {
-      stream_->Stop();
-      stream_->Close();
-      // After stream is closed it is destroyed, so don't keep a reference to
-      // it.
-      stream_ = NULL;
-    }
+    StopCloseAndClearStream();
 
     if (LowLatencyMode()) {
       sync_reader_->Close();
     }
 
     state_ = kClosed;
   }
 
   closed_task.Run();
 }
@@ skipping 73 matching lines @@
   AudioBuffersState buffers_state = buffers_state_;
   buffers_state.pending_bytes += buffer_.forward_bytes();
 
   // If we need more data then call the event handler to ask for more data.
   // It is okay that we don't lock in this block because the parameters are
   // correct and in the worst case we are just asking more data than needed.
   base::AutoUnlock auto_unlock(lock_);
   handler_->OnMoreData(this, buffers_state);
 }
 
+void AudioOutputController::StopCloseAndClearStream() {
+  // Allow calling unconditionally and bail if we don't have a stream_ to close.
+  if (!stream_)
+    return;
+  stream_->Stop();
+  stream_->Close();
+  stream_ = NULL;
+}
+
 }  // namespace media