Monitor the IO message loop in the AudioDevice classes.

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"
 #include "content/common/child_process.h"
 #include "content/common/media/audio_messages.h"
 #include "content/common/view_messages.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/audio/audio_util.h"
 
 AudioInputDevice::AudioInputDevice(size_t buffer_size,
                                    int channels,
                                    double sample_rate,
                                    CaptureCallback* callback,
                                    CaptureEventHandler* event_handler)
-    : callback_(callback),
+    : ScopedLoopObserver(ChildProcess::current()->io_message_loop()),
+      callback_(callback),
       event_handler_(event_handler),
       audio_delay_milliseconds_(0),
       volume_(1.0),
       stream_id_(0),
       session_id_(0),
       pending_device_ready_(false),
       shared_memory_handle_(base::SharedMemory::NULLHandle()),
       memory_length_(0) {
   filter_ = RenderThreadImpl::current()->audio_input_message_filter();
   audio_data_.reserve(channels);
 #if defined(OS_MACOSX)
-  VLOG(1) << "Using AUDIO_PCM_LOW_LATENCY as input mode on Mac OS X.";
+  DVLOG(1) << "Using AUDIO_PCM_LOW_LATENCY as input mode on Mac OS X.";
   audio_parameters_.format = AudioParameters::AUDIO_PCM_LOW_LATENCY;
 #elif defined(OS_WIN)
-  VLOG(1) << "Using AUDIO_PCM_LOW_LATENCY as input mode on Windows.";
+  DVLOG(1) << "Using AUDIO_PCM_LOW_LATENCY as input mode on Windows.";
   audio_parameters_.format = AudioParameters::AUDIO_PCM_LOW_LATENCY;
 #else
   // TODO(henrika): add support for AUDIO_PCM_LOW_LATENCY on Linux as well.
   audio_parameters_.format = AudioParameters::AUDIO_PCM_LINEAR;
 #endif
   audio_parameters_.channels = channels;
   audio_parameters_.sample_rate = static_cast<int>(sample_rate);
   audio_parameters_.bits_per_sample = 16;
   audio_parameters_.samples_per_packet = buffer_size;
   for (int i = 0; i < channels; ++i) {
     float* channel_data = new float[buffer_size];
     audio_data_.push_back(channel_data);
   }
 }
 
 AudioInputDevice::~AudioInputDevice() {
   // TODO(henrika): The current design requires that the user calls
   // Stop before deleting this class.
   CHECK_EQ(0, stream_id_);
   for (int i = 0; i < audio_parameters_.channels; ++i)
     delete [] audio_data_[i];
 }
 
 void AudioInputDevice::Start() {
-  VLOG(1) << "Start()";
-  ChildProcess::current()->io_message_loop()->PostTask(
-      FROM_HERE,
+  DVLOG(1) << "Start()";
+  message_loop()->PostTask(FROM_HERE,
       base::Bind(&AudioInputDevice::InitializeOnIOThread, this));
 }
 
 void AudioInputDevice::SetDevice(int session_id) {
-  VLOG(1) << "SetDevice (session_id=" << session_id << ")";
-  ChildProcess::current()->io_message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&AudioInputDevice::SetSessionIdOnIOThread, this,
-                 session_id));
+  DVLOG(1) << "SetDevice (session_id=" << session_id << ")";
+  message_loop()->PostTask(FROM_HERE,
+      base::Bind(&AudioInputDevice::SetSessionIdOnIOThread, this, session_id));
 }
 
 void AudioInputDevice::Stop() {
-  DCHECK(MessageLoop::current() != ChildProcess::current()->io_message_loop());
-  VLOG(1) << "Stop()";
+  DCHECK(!message_loop()->BelongsToCurrentThread());
+  DVLOG(1) << "Stop()";
 
   base::WaitableEvent completion(false, false);
-  ChildProcess::current()->io_message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&AudioInputDevice::ShutDownOnIOThread, this,
-                 &completion));
-
-  // We wait here for the IO task to be completed to remove race conflicts
-  // with OnLowLatencyCreated() and to ensure that Stop() acts as a synchronous
-  // function call.
-  completion.Wait();
+  if (message_loop()->PostTask(FROM_HERE,
+          base::Bind(&AudioInputDevice::ShutDownOnIOThread, this,
+                     &completion))) {
+    // We wait here for the IO task to be completed to remove race conflicts
+    // with OnLowLatencyCreated() and to ensure that Stop() acts as a
+    // synchronous function call.
+    completion.Wait();
+  }
 }
 
 bool AudioInputDevice::SetVolume(double volume) {
   NOTIMPLEMENTED();
   return false;
 }
 
 bool AudioInputDevice::GetVolume(double* volume) {
   NOTIMPLEMENTED();
   return false;
 }
 
 void AudioInputDevice::InitializeOnIOThread() {
-  DCHECK(MessageLoop::current() == ChildProcess::current()->io_message_loop());
+  DCHECK(message_loop()->BelongsToCurrentThread());
   // Make sure we don't call Start() more than once.
   DCHECK_EQ(0, stream_id_);
   if (stream_id_)
     return;
 
   stream_id_ = filter_->AddDelegate(this);
   // If |session_id_| is not specified, it will directly create the stream;
   // otherwise it will send a AudioInputHostMsg_StartDevice msg to the browser
   // and create the stream when getting a OnDeviceReady() callback.
   if (!session_id_) {
     Send(new AudioInputHostMsg_CreateStream(
         stream_id_, audio_parameters_, true,
         AudioManagerBase::kDefaultDeviceId));
   } else {
     Send(new AudioInputHostMsg_StartDevice(stream_id_, session_id_));
     pending_device_ready_ = true;
   }
 }
 
 void AudioInputDevice::SetSessionIdOnIOThread(int session_id) {
-  DCHECK(MessageLoop::current() == ChildProcess::current()->io_message_loop());
+  DCHECK(message_loop()->BelongsToCurrentThread());
   session_id_ = session_id;
 }
 
 void AudioInputDevice::StartOnIOThread() {
-  DCHECK(MessageLoop::current() == ChildProcess::current()->io_message_loop());
+  DCHECK(message_loop()->BelongsToCurrentThread());
   if (stream_id_)
     Send(new AudioInputHostMsg_RecordStream(stream_id_));
 }
 
 void AudioInputDevice::ShutDownOnIOThread(base::WaitableEvent* completion) {
-  DCHECK(MessageLoop::current() == ChildProcess::current()->io_message_loop());
+  DCHECK(message_loop()->BelongsToCurrentThread());
+  // NOTE: |completion| may be NULL.
   // Make sure we don't call shutdown more than once.
-  if (!stream_id_) {
-    completion->Signal();
-    return;
+  if (stream_id_) {
+    filter_->RemoveDelegate(stream_id_);
+    Send(new AudioInputHostMsg_CloseStream(stream_id_));
+
+    ShutDownAudioThread();
+
+    stream_id_ = 0;
+    session_id_ = 0;
+    pending_device_ready_ = false;
   }
 
-  filter_->RemoveDelegate(stream_id_);
-  Send(new AudioInputHostMsg_CloseStream(stream_id_));
-
-  ShutDownAudioThread();
-
-  stream_id_ = 0;
-  session_id_ = 0;
-  pending_device_ready_ = false;
-
-  completion->Signal();
+  if (completion)
+    completion->Signal();
 }
 
 void AudioInputDevice::SetVolumeOnIOThread(double volume) {
-  DCHECK(MessageLoop::current() == ChildProcess::current()->io_message_loop());
+  DCHECK(message_loop()->BelongsToCurrentThread());
   if (stream_id_)
     Send(new AudioInputHostMsg_SetVolume(stream_id_, volume));
 }
 
 void AudioInputDevice::OnLowLatencyCreated(
     base::SharedMemoryHandle handle,
     base::SyncSocket::Handle socket_handle,
     uint32 length) {
-  DCHECK(MessageLoop::current() == ChildProcess::current()->io_message_loop());
+  DCHECK(message_loop()->BelongsToCurrentThread());
 #if defined(OS_WIN)
   DCHECK(handle);
   DCHECK(socket_handle);
 #else
   DCHECK_GE(handle.fd, 0);
   DCHECK_GE(socket_handle, 0);
 #endif
   DCHECK(length);
   DCHECK(!audio_thread_.get());
 
-  VLOG(1) << "OnLowLatencyCreated (stream_id=" << stream_id_ << ")";
+  DVLOG(1) << "OnLowLatencyCreated (stream_id=" << stream_id_ << ")";
   // Takes care of the case when Stop() is called before OnLowLatencyCreated().
   if (!stream_id_) {
     base::SharedMemory::CloseHandle(handle);
     // Close the socket handler.
     base::SyncSocket socket(socket_handle);
     return;
   }
 
   shared_memory_handle_ = handle;
   memory_length_ = length;
   audio_socket_.reset(new base::CancelableSyncSocket(socket_handle));
 
   audio_thread_.reset(
       new base::DelegateSimpleThread(this, "RendererAudioInputThread"));
   audio_thread_->Start();
 
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&AudioInputDevice::StartOnIOThread, this));
 }
 
 void AudioInputDevice::OnVolume(double volume) {
   NOTIMPLEMENTED();
 }
 
 void AudioInputDevice::OnStateChanged(AudioStreamState state) {
-  DCHECK(MessageLoop::current() == ChildProcess::current()->io_message_loop());
+  DCHECK(message_loop()->BelongsToCurrentThread());
   switch (state) {
     case kAudioStreamPaused:
       // TODO(xians): Should we just call ShutDownOnIOThread here instead?
 
       // Do nothing if the stream has been closed.
       if (!stream_id_)
         return;
 
       filter_->RemoveDelegate(stream_id_);
 
@@ skipping 11 matching lines @@
     case kAudioStreamError:
       DLOG(WARNING) << "AudioInputDevice::OnStateChanged(kError)";
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 void AudioInputDevice::OnDeviceReady(const std::string& device_id) {
-  DCHECK(MessageLoop::current() == ChildProcess::current()->io_message_loop());
-  VLOG(1) << "OnDeviceReady (device_id=" << device_id << ")";
+  DCHECK(message_loop()->BelongsToCurrentThread());
+  DVLOG(1) << "OnDeviceReady (device_id=" << device_id << ")";
 
   // Takes care of the case when Stop() is called before OnDeviceReady().
   if (!pending_device_ready_)
     return;
 
   // If AudioInputDeviceManager returns an empty string, it means no device
   // is ready for start.
   if (device_id.empty()) {
     filter_->RemoveDelegate(stream_id_);
     stream_id_ = 0;
@@ skipping 83 matching lines @@
     // Close the socket to terminate the main thread function in the
     // audio thread.
     audio_socket_->Shutdown();  // Stops blocking Receive calls.
     // TODO(tommi): We must not do this from the IO thread.  Fix.
     base::ThreadRestrictions::ScopedAllowIO allow_wait;
     audio_thread_->Join();
     audio_thread_.reset(NULL);
     audio_socket_.reset();
   }
 }
+
+void AudioInputDevice::WillDestroyCurrentMessageLoop() {
+  ShutDownOnIOThread(NULL);
+}