Stop the AudioDeviceThread when the IO loop goes away.

content/renderer/media/audio_input_device.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 "content/renderer/media/audio_input_device.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time.h"
@@ skipping 128 matching lines @@
   // NOTE: |completion| may be NULL.
   // Make sure we don't call shutdown more than once.
   if (stream_id_) {
     filter_->RemoveDelegate(stream_id_);
     Send(new AudioInputHostMsg_CloseStream(stream_id_));
 
     stream_id_ = 0;
     session_id_ = 0;
     pending_device_ready_ = false;
   }
+
+  // We can run into an issue where ShutDownOnIOThread is called right after
+  // OnStreamCreated is called in cases where Start/Stop are called before we
+  // get the OnStreamCreated callback.  To handle that corner case, we call
+  // Stop(). In most cases, the thread will already be stopped.
+  audio_thread_.Stop(MessageLoop::current());
   audio_callback_.reset();
 }
 
 void AudioInputDevice::SetVolumeOnIOThread(double volume) {
   DCHECK(message_loop()->BelongsToCurrentThread());
   if (stream_id_)
     Send(new AudioInputHostMsg_SetVolume(stream_id_, volume));
 }
 
 void AudioInputDevice::OnStreamCreated(
@@ skipping 12 matching lines @@
   DVLOG(1) << "OnStreamCreated (stream_id=" << stream_id_ << ")";
 
   // Takes care of the case when Stop() is called before OnStreamCreated().
   if (!stream_id_) {
     base::SharedMemory::CloseHandle(handle);
     // Close the socket handler.
     base::SyncSocket socket(socket_handle);
     return;
   }
 
+  DCHECK(audio_thread_.IsStopped());
   audio_callback_.reset(
       new AudioInputDevice::AudioThreadCallback(audio_parameters_, handle,
                                                 length, callback_));
-  audio_thread_.Start(audio_callback_.get(), socket_handle,
-                       "AudioInputDevice");
+  audio_thread_.Start(audio_callback_.get(), socket_handle, "AudioInputDevice");
 
   MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&AudioInputDevice::StartOnIOThread, this));
 }
 
 void AudioInputDevice::OnVolume(double volume) {
   NOTIMPLEMENTED();
 }
 
 void AudioInputDevice::OnStateChanged(AudioStreamState state) {
@@ skipping 54 matching lines @@
   pending_device_ready_ = false;
   // Notify the client that the device has been started.
   if (event_handler_)
     event_handler_->OnDeviceStarted(device_id);
 }
 
 void AudioInputDevice::Send(IPC::Message* message) {
   filter_->Send(message);
 }
 
 void AudioInputDevice::WillDestroyCurrentMessageLoop() {

[scherkus (not reviewing), 2012/02/29 21:10:15]

ditto

+  LOG(ERROR) << "IO loop going away before the input device has been stopped";
+  audio_thread_.Stop(NULL);
   ShutDownOnIOThread();
 }
 
 // AudioInputDevice::AudioThreadCallback
 AudioInputDevice::AudioThreadCallback::AudioThreadCallback(
     const AudioParameters& audio_parameters,
     base::SharedMemoryHandle memory,
     int memory_length,
     CaptureCallback* capture_callback)
     : AudioDeviceThread::Callback(audio_parameters, memory, memory_length),
@@ skipping 23 matching lines @@
                                     channel_index,
                                     bytes_per_sample,
                                     number_of_frames);
   }
 
   // Deliver captured data to the client in floating point format
   // and update the audio-delay measurement.
   capture_callback_->Capture(audio_data_, number_of_frames,
                              audio_delay_milliseconds);
 }