Sixth patch in getting rid of caching MessageLoop pointers. Audio and automa...

chrome/browser/renderer_host/audio_renderer_host.cc

 // Copyright (c) 2009 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.
 //
 // TODO(hclam): Several changes need to be made to this code:
 // 1. We should host AudioRendererHost on a dedicated audio thread. Doing
 //    so we don't have to worry about blocking method calls such as
 //    play / stop an audio stream.
 // 2. Move locked data structures into a separate structure that sanity
 //    checks access by different threads that use it.
 //
 // SEMANTICS OF |state_|
 // Note that |state_| of IPCAudioSource is accessed on two thread. Namely
 // the IO thread and the audio thread. IO thread is the thread on which
 // IPAudioSource::Play(), IPCAudioSource::Pause() are called. Audio thread
 // is a thread operated by the audio hardware for requesting data.
 // It is important that |state_| is only written on the IO thread because
 // reading of such state in Play() and Pause() is not protected. However,
 // since OnMoreData() is called on the audio thread and reads |state_|
 // variable. Writing to this variable needs to be protected in Play()
 // and Pause().
 
 #include "base/histogram.h"
 #include "base/lock.h"
-#include "base/message_loop.h"
 #include "base/process.h"
 #include "base/shared_memory.h"
 #include "base/waitable_event.h"
+#include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/renderer_host/audio_renderer_host.h"
 #include "chrome/common/render_messages.h"
 #include "ipc/ipc_logging.h"
 
 namespace {
 
 // This constant governs the hardware audio buffer size, this value should be
 // choosen carefully and is platform specific.
 const int kSamplesPerHardwarePacket = 8192;
 
@@ skipping 285 matching lines @@
  }
 }
 
 void AudioRendererHost::IPCAudioSource::StartBuffering() {
   SubmitPacketRequest(NULL);
 }
 
 //-----------------------------------------------------------------------------
 // AudioRendererHost implementations.
 
-AudioRendererHost::AudioRendererHost(MessageLoop* message_loop)
+AudioRendererHost::AudioRendererHost()
     : process_id_(0),
       process_handle_(0),
-      ipc_sender_(NULL),
-      io_loop_(message_loop) {
+      ipc_sender_(NULL) {
   // Make sure we perform actual initialization operations in the thread where
   // this object should live.
-  io_loop_->PostTask(FROM_HERE,
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
       NewRunnableMethod(this, &AudioRendererHost::OnInitialized));
 }
 
 AudioRendererHost::~AudioRendererHost() {
   DCHECK(sources_.empty());
 }
 
 void AudioRendererHost::Destroy() {
   // Post a message to the thread where this object should live and do the
   // actual operations there.
-  io_loop_->PostTask(
-      FROM_HERE, NewRunnableMethod(this, &AudioRendererHost::OnDestroyed));
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      NewRunnableMethod(this, &AudioRendererHost::OnDestroyed));
 }
 
 // Event received when IPC channel is connected to the renderer process.
 void AudioRendererHost::IPCChannelConnected(int process_id,
                                             base::ProcessHandle process_handle,
                                             IPC::Message::Sender* ipc_sender) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   process_id_ = process_id;
   process_handle_ = process_handle;
   ipc_sender_ = ipc_sender;
 }
 
 // Event received when IPC channel is closing.
 void AudioRendererHost::IPCChannelClosing() {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   ipc_sender_ = NULL;
   process_handle_ = 0;
   process_id_ = 0;
   DestroyAllSources();
 }
 
 bool AudioRendererHost::OnMessageReceived(const IPC::Message& message,
                                           bool* message_was_ok) {
   if (!IsAudioRendererHostMessage(message))
     return false;
@@ skipping 25 matching lines @@
       return true;
     default:
       break;
     }
     return false;
 }
 
 void AudioRendererHost::OnCreateStream(
     const IPC::Message& msg, int stream_id,
     const ViewHostMsg_Audio_CreateStream& params) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   DCHECK(Lookup(msg.routing_id(), stream_id) == NULL);
 
   IPCAudioSource* source = IPCAudioSource::CreateIPCAudioSource(
       this,
       process_id_,
       msg.routing_id(),
       stream_id,
       process_handle_,
       params.format,
       params.channels,
       params.sample_rate,
       params.bits_per_sample,
       params.packet_size,
       params.buffer_capacity);
 
   // If we have created the source successfully, adds it to the map.
   if (source) {
     sources_.insert(
         std::make_pair(
             SourceID(source->route_id(), source->stream_id()), source));
   } else {
     SendErrorMessage(msg.routing_id(), stream_id);
   }
 }
 
 void AudioRendererHost::OnPlayStream(const IPC::Message& msg, int stream_id) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   IPCAudioSource* source = Lookup(msg.routing_id(), stream_id);
   if (source) {
     source->Play();
   } else {
     SendErrorMessage(msg.routing_id(), stream_id);
   }
 }
 
 void AudioRendererHost::OnPauseStream(const IPC::Message& msg, int stream_id) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   IPCAudioSource* source = Lookup(msg.routing_id(), stream_id);
   if (source) {
     source->Pause();
   } else {
     SendErrorMessage(msg.routing_id(), stream_id);
   }
 }
 
 void AudioRendererHost::OnCloseStream(const IPC::Message& msg, int stream_id) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   IPCAudioSource* source = Lookup(msg.routing_id(), stream_id);
   if (source) {
     DestroySource(source);
   }
 }
 
 void AudioRendererHost::OnSetVolume(const IPC::Message& msg, int stream_id,
                                     double left_channel, double right_channel) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   IPCAudioSource* source = Lookup(msg.routing_id(), stream_id);
   if (source) {
     source->SetVolume(left_channel, right_channel);
   } else {
     SendErrorMessage(msg.routing_id(), stream_id);
   }
 }
 
 void AudioRendererHost::OnGetVolume(const IPC::Message& msg, int stream_id) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   IPCAudioSource* source = Lookup(msg.routing_id(), stream_id);
   if (source) {
     source->GetVolume();
   } else {
     SendErrorMessage(msg.routing_id(), stream_id);
   }
 }
 
 void AudioRendererHost::OnNotifyPacketReady(const IPC::Message& msg,
                                             int stream_id, size_t packet_size) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   IPCAudioSource* source = Lookup(msg.routing_id(), stream_id);
   if (source) {
     source->NotifyPacketReady(packet_size);
   } else {
     SendErrorMessage(msg.routing_id(), stream_id);
   }
 }
 
 void AudioRendererHost::OnInitialized() {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   // Increase the ref count of this object so it is active until we do
   // Release().
   AddRef();
 }
 
 void AudioRendererHost::OnDestroyed() {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   ipc_sender_ = NULL;
   process_handle_ = 0;
   process_id_ = 0;
   DestroyAllSources();
   // Decrease the reference to this object, which may lead to self-destruction.
   Release();
 }
 
 void AudioRendererHost::OnSend(IPC::Message* message) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   if (ipc_sender_) {
     ipc_sender_->Send(message);
   }
 }
 
 void AudioRendererHost::OnDestroySource(IPCAudioSource* source) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   if (source) {
     sources_.erase(SourceID(source->route_id(), source->stream_id()));
     source->Close();
     delete source;
   }
 }
 
 void AudioRendererHost::DestroyAllSources() {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   std::vector<IPCAudioSource*> sources;
   for (SourceMap::iterator i = sources_.begin(); i != sources_.end(); ++i) {
     sources.push_back(i->second);
   }
   for (size_t i = 0; i < sources.size(); ++i) {
     DestroySource(sources[i]);
   }
   DCHECK(sources_.empty());
 }
 
 AudioRendererHost::IPCAudioSource* AudioRendererHost::Lookup(int route_id,
                                                              int stream_id) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   SourceMap::iterator i = sources_.find(SourceID(route_id, stream_id));
   if (i != sources_.end())
     return i->second;
   return NULL;
 }
 
 void AudioRendererHost::Send(IPC::Message* message) {
-  if (MessageLoop::current() == io_loop_) {
+  if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
     OnSend(message);
   } else {
-    // TODO(hclam): make sure it's always safe to post a task to IO loop.
-    // It is possible that IO message loop is destroyed but there's still some
-    // dangling audio hardware threads that try to call this method.
-    io_loop_->PostTask(FROM_HERE,
+    ChromeThread::PostTask(
+        ChromeThread::IO, FROM_HERE,
         NewRunnableMethod(this, &AudioRendererHost::OnSend, message));
   }
 }
 
 void AudioRendererHost::SendErrorMessage(int32 render_view_id,
                                          int32 stream_id) {
   ViewMsg_AudioStreamState state;
   state.state = ViewMsg_AudioStreamState::kError;
   Send(new ViewMsg_NotifyAudioStreamStateChanged(
       render_view_id, stream_id, state));
 }
 
 void AudioRendererHost::DestroySource(IPCAudioSource* source) {
-  if (MessageLoop::current() == io_loop_) {
+  if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
     OnDestroySource(source);
   } else {
-    // TODO(hclam): make sure it's always safe to post a task to IO loop.
-    // It is possible that IO message loop is destroyed but there's still some
-    // dangling audio hardware threads that try to call this method.
-    io_loop_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &AudioRendererHost::OnDestroySource, source));
+    ChromeThread::PostTask(
+        ChromeThread::IO, FROM_HERE,
+        NewRunnableMethod(this, &AudioRendererHost::OnDestroySource, source));
   }
 }