Monitor the IO message loop in the AudioDevice classes.

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/bind.h"
 #include "base/debug/trace_event.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_output_controller.h"
 #include "media/audio/audio_util.h"
@@ skipping 75 matching lines @@
 }
 
 void AudioDevice::Start() {
   AudioParameters params;
   params.format = latency_format_;
   params.channels = channels_;
   params.sample_rate = static_cast<int>(sample_rate_);
   params.bits_per_sample = bits_per_sample_;
   params.samples_per_packet = buffer_size_;
 
-  ChildProcess::current()->io_message_loop()->PostTask(
-      FROM_HERE,
+  loop()->PostTask(FROM_HERE,
       base::Bind(&AudioDevice::InitializeOnIOThread, this, params));
 }
 
 void AudioDevice::Stop() {
-  DCHECK(MessageLoop::current() != ChildProcess::current()->io_message_loop());
+  DCHECK(!loop()->BelongsToCurrentThread());
 
   // Stop and shutdown the audio thread from the IO thread.
   // This operation must be synchronous for now since the |callback_| pointer
   // isn't ref counted and the object might go out of scope after Stop()
   // returns (and FireRenderCallback might dereference a bogus pointer).
   // TODO(tommi): Add an Uninitialize() method to AudioRendererSink?
   base::WaitableEvent done(true, false);
-  ChildProcess::current()->io_message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&AudioDevice::ShutDownOnIOThread, this, &done));
-  done.Wait();
+  if (loop()->PostTask(FROM_HERE,
+          base::Bind(&AudioDevice::ShutDownOnIOThread, this, &done))) {
+    done.Wait();
+  }
 }
 
 void AudioDevice::Play() {
-  ChildProcess::current()->io_message_loop()->PostTask(
-      FROM_HERE,
+  loop()->PostTask(FROM_HERE,
       base::Bind(&AudioDevice::PlayOnIOThread, this));
 }
 
 void AudioDevice::Pause(bool flush) {
-  ChildProcess::current()->io_message_loop()->PostTask(
-      FROM_HERE,
+  loop()->PostTask(FROM_HERE,
       base::Bind(&AudioDevice::PauseOnIOThread, this, flush));
 }
 
 bool AudioDevice::SetVolume(double volume) {
   if (volume < 0 || volume > 1.0)
     return false;
 
-  ChildProcess::current()->io_message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&AudioDevice::SetVolumeOnIOThread, this, volume));
+  if (!loop()->PostTask(FROM_HERE,
+          base::Bind(&AudioDevice::SetVolumeOnIOThread, this, volume))) {
+    return false;
+  }
 
   volume_ = volume;
 
   return true;
 }
 
 void AudioDevice::GetVolume(double* volume) {
   // Return a locally cached version of the current scaling factor.
   *volume = volume_;
 }
 
 void AudioDevice::InitializeOnIOThread(const AudioParameters& params) {
-  DCHECK_EQ(MessageLoop::current(), ChildProcess::current()->io_message_loop());
+  DCHECK(loop()->BelongsToCurrentThread());
   // Make sure we don't create the stream more than once.
   DCHECK_EQ(0, stream_id_);
   if (stream_id_)
     return;
 
   stream_id_ = filter_->AddDelegate(this);
   Send(new AudioHostMsg_CreateStream(stream_id_, params, true));
 }
 
 void AudioDevice::PlayOnIOThread() {
-  DCHECK_EQ(MessageLoop::current(), ChildProcess::current()->io_message_loop());
+  DCHECK(loop()->BelongsToCurrentThread());
   if (stream_id_ && is_started_)
     Send(new AudioHostMsg_PlayStream(stream_id_));
   else
     play_on_start_ = true;
 }
 
 void AudioDevice::PauseOnIOThread(bool flush) {
-  DCHECK_EQ(MessageLoop::current(), ChildProcess::current()->io_message_loop());
+  DCHECK(loop()->BelongsToCurrentThread());
   if (stream_id_ && is_started_) {
     Send(new AudioHostMsg_PauseStream(stream_id_));
     if (flush)
       Send(new AudioHostMsg_FlushStream(stream_id_));
   } else {
     // Note that |flush| isn't relevant here since this is the case where
     // the stream is first starting.
     play_on_start_ = false;
   }
 }
 
 void AudioDevice::ShutDownOnIOThread(base::WaitableEvent* signal) {
-  DCHECK_EQ(MessageLoop::current(), ChildProcess::current()->io_message_loop());
+  DCHECK(loop()->BelongsToCurrentThread());
 
   // 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;
 
     ShutDownAudioThread();
   }
 
-  signal->Signal();
+  if (signal)
+    signal->Signal();
 }
 
 void AudioDevice::SetVolumeOnIOThread(double volume) {
-  DCHECK_EQ(MessageLoop::current(), ChildProcess::current()->io_message_loop());
+  DCHECK(loop()->BelongsToCurrentThread());
   if (stream_id_)
     Send(new AudioHostMsg_SetVolume(stream_id_, volume));
 }
 
 void AudioDevice::OnRequestPacket(AudioBuffersState buffers_state) {
   // This method does not apply to the low-latency system.
 }
 
 void AudioDevice::OnStateChanged(AudioStreamState state) {
   if (state == kAudioStreamError) {
     DLOG(WARNING) << "AudioDevice::OnStateChanged(kError)";
     callback_->OnError();
   }
 }
 
-void AudioDevice::OnCreated(
-    base::SharedMemoryHandle handle, uint32 length) {
+void AudioDevice::OnCreated(base::SharedMemoryHandle handle, uint32 length) {
   // Not needed in this simple implementation.
 }
 
 void AudioDevice::OnLowLatencyCreated(
     base::SharedMemoryHandle handle,
     base::SyncSocket::Handle socket_handle,
     uint32 length) {
-  DCHECK_EQ(MessageLoop::current(), ChildProcess::current()->io_message_loop());
+  DCHECK(loop()->BelongsToCurrentThread());
   DCHECK_GE(length, buffer_size_ * sizeof(int16) * channels_);
 #if defined(OS_WIN)
   DCHECK(handle);
   DCHECK(socket_handle);
 #else
   DCHECK_GE(handle.fd, 0);
   DCHECK_GE(socket_handle, 0);
 #endif
 
   // Takes care of the case when Stop() is called before OnLowLatencyCreated().
@@ skipping 82 matching lines @@
     // to the browser process as float, so we don't lose precision for
     // audio hardware which has better than 16bit precision.
     media::InterleaveFloatToInt16(audio_data_,
                                   data,
                                   buffer_size_);
   }
   return num_frames;
 }
 
 void AudioDevice::ShutDownAudioThread() {
-  DCHECK_EQ(MessageLoop::current(), ChildProcess::current()->io_message_loop());
+  DCHECK(loop()->BelongsToCurrentThread());
 
   if (audio_thread_.get()) {
     // 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();
   }
 }