Stop the AudioDeviceThread when the IO loop goes away.

content/renderer/media/audio_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_device.h"
 
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time.h"
@@ skipping 160 matching lines @@
 
   // Make sure we don't call shutdown more than once.
   if (stream_id_) {
     is_started_ = false;
 
     filter_->RemoveDelegate(stream_id_);
     Send(new AudioHostMsg_CloseStream(stream_id_));
     stream_id_ = 0;
   }
 
+  // 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.
+  // Another situation is when the IO thread goes away before Stop() is called
+  // in which case, we cannot use the message loop to close the thread handle
+  // and can't not rely on the main thread existing either.
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
+  audio_thread_.Stop(NULL);
   audio_callback_.reset();
 }
 
 void AudioDevice::SetVolumeOnIOThread(double volume) {
   DCHECK(message_loop()->BelongsToCurrentThread());
   if (stream_id_)
     Send(new AudioHostMsg_SetVolume(stream_id_, volume));
 }
 
 void AudioDevice::OnStateChanged(AudioStreamState state) {
@@ skipping 20 matching lines @@
 #endif
 
   // 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 AudioDevice::AudioThreadCallback(audio_parameters_,
       handle, length, callback_));
   audio_thread_.Start(audio_callback_.get(), socket_handle, "AudioDevice");
 
   // We handle the case where Play() and/or Pause() may have been called
   // multiple times before OnStreamCreated() gets called.
   is_started_ = true;
   if (play_on_start_)
     PlayOnIOThread();
 }
 
 void AudioDevice::Send(IPC::Message* message) {
   filter_->Send(message);
 }
 
 void AudioDevice::WillDestroyCurrentMessageLoop() {
+  LOG(ERROR) << "IO loop going away before the audio device has been stopped";
   ShutDownOnIOThread();
 }
 
 // AudioDevice::AudioThreadCallback
 
 AudioDevice::AudioThreadCallback::AudioThreadCallback(
     const AudioParameters& audio_parameters,
     base::SharedMemoryHandle memory,
     int memory_length,
     media::AudioRendererSink::RenderCallback* render_callback)
@@ skipping 31 matching lines @@
   // to the browser process as float, so we don't lose precision for
   // audio hardware which has better than 16bit precision.
   int16* data = reinterpret_cast<int16*>(shared_memory_.memory());
   media::InterleaveFloatToInt16(audio_data_, data,
       audio_parameters_.samples_per_packet);
 
   // Let the host know we are done.
   media::SetActualDataSizeInBytes(&shared_memory_, memory_length_,
       num_frames * audio_parameters_.channels * sizeof(data[0]));
 }