Create AudioRendererHost in BrowserRenderProcessHost and hook with ResourceMessageFilter

chrome/browser/renderer_host/audio_renderer_host.cc

 // Copyright (c) 2006-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.
 
 #include "base/message_loop.h"
 #include "base/process.h"
 #include "chrome/browser/renderer_host/audio_renderer_host.h"
 
 AudioRendererHost::IPCAudioSource::IPCAudioSource(
     AudioRendererHost* host,
@@ skipping 50 matching lines @@
   // TODO(cpu): make sure it is safe to close() in this method.
   stream_->Close();
 }
 
 void AudioRendererHost::IPCAudioSource::NotifyPacketReady() {
   // TODO(hclam): wake the thread waiting for buffer.
 }
 
 AudioRendererHost::AudioRendererHost(MessageLoop* message_loop)
     : next_id_(INVALID_ID+1),
-      message_loop_(message_loop) {
+      io_loop_(message_loop) {
+  // Make sure we perform actual initialization operations in the thread where
+  // this object should live.
+  io_loop_->PostTask(FROM_HERE,
+      NewRunnableMethod(this, &AudioRendererHost::OnInitialized));
 }
 
 AudioRendererHost::~AudioRendererHost() {
-  DestroyAllStreams();
 }
 
 int AudioRendererHost::CreateStream(
     IPC::Message::Sender* sender, base::ProcessHandle handle,
     AudioManager::Format format, int channels, int sample_rate,
     int bits_per_sample, size_t packet_size) {
-  DCHECK(MessageLoop::current() == message_loop_);
+  DCHECK(MessageLoop::current() == io_loop_);
 
   // Create the stream in the first place.
   AudioOutputStream* stream = AudioManager::GetAudioManager()->MakeAudioStream(
       format, channels, sample_rate, bits_per_sample);
   if (!stream)
     return INVALID_ID;
 
   // Try to open the stream if we can create it.
   if (stream->Open(packet_size)) {
     // Create the containing IPCAudioSource and save it to the map.
     IPCAudioSource* source =
         new IPCAudioSource(this, next_id_++, stream, sender, handle,
                            packet_size);
     sources_.AddWithID(source, source->id());
     return source->id();
   }
   return INVALID_ID;
 }
 
 bool AudioRendererHost::Start(int stream_id) {
-  DCHECK(MessageLoop::current() == message_loop_);
+  DCHECK(MessageLoop::current() == io_loop_);
   IPCAudioSource* source = sources_.Lookup(stream_id);
   if (source) {
     source->stream()->Start(source);
     return true;
   }
   return false;
 }
 
 bool AudioRendererHost::Stop(int stream_id) {
-  DCHECK(MessageLoop::current() == message_loop_);
+  DCHECK(MessageLoop::current() == io_loop_);
   IPCAudioSource* source = sources_.Lookup(stream_id);
   if (source) {
     source->stream()->Stop();
     return true;
   }
   return false;
 }
 
 bool AudioRendererHost::Close(int stream_id) {
-  DCHECK(MessageLoop::current() == message_loop_);
+  DCHECK(MessageLoop::current() == io_loop_);
   IPCAudioSource* source = sources_.Lookup(stream_id);
   if (source) {
     source->stream()->Close();
     return true;
   }
   return false;
 }
 
 bool AudioRendererHost::SetVolume(
     int stream_id, double left_channel, double right_channel) {
-  DCHECK(MessageLoop::current() == message_loop_);
+  DCHECK(MessageLoop::current() == io_loop_);
   IPCAudioSource* source = sources_.Lookup(stream_id);
   if (source) {
     source->stream()->SetVolume(left_channel, right_channel);
   }
   return false;
 }
 
 bool AudioRendererHost::GetVolume(
     int stream_id, double* left_channel, double* right_channel) {
-  DCHECK(MessageLoop::current() == message_loop_);
+  DCHECK(MessageLoop::current() == io_loop_);
   IPCAudioSource* source = sources_.Lookup(stream_id);
   if (source) {
     source->stream()->GetVolume(left_channel, right_channel);
     return true;
   }
   return false;
 }
 
 void AudioRendererHost::NotifyPacketReady(int stream_id) {
-  DCHECK(MessageLoop::current() == message_loop_);
+  DCHECK(MessageLoop::current() == io_loop_);
   IPCAudioSource* source = sources_.Lookup(stream_id);
   if (source) {
     source->NotifyPacketReady();
   }
 }
 
 void AudioRendererHost::DestroyAllStreams() {
-  DCHECK(MessageLoop::current() == message_loop_);
+  DCHECK(MessageLoop::current() == io_loop_);
   // TODO(hclam): iterate on the map, close and delete every stream, and clear
   // the map.
 }
 
 void AudioRendererHost::DestroySource(int stream_id) {
-  DCHECK(MessageLoop::current() == message_loop_);
+  DCHECK(MessageLoop::current() == io_loop_);
   IPCAudioSource* source = sources_.Lookup(stream_id);
   if (source) {
     sources_.Remove(stream_id);
     delete source;
   }
 }
+
+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));
+}
+
+void AudioRendererHost::OnInitialized() {
+  DCHECK(MessageLoop::current() == io_loop_);
+
+  // Increase the ref count of this object so it is active until we do
+  // Release().
+  AddRef();
+
+  // Also create the AudioManager singleton in this thread.
+  // TODO(hclam): figure out a better location to initialize the AudioManager
+  // singleton.
+  AudioManager::GetAudioManager();
+}
+
+void AudioRendererHost::OnDestroyed() {
+  DCHECK(MessageLoop::current() == io_loop_);
+
+  // Destroy audio streams only in the thread it should happen.
+  // TODO(hclam): make sure we don't call IPC::Message::Sender inside
+  // IPCAudioSource because it is most likely be destroyed.
+  DestroyAllStreams();
+
+  // Decrease the reference to this object, which may lead to self-destruction.
+  Release();
+}