Implements AudioMessageFilter as member in RenderThread

content/renderer/media/audio_renderer_impl.cc

 // Copyright (c) 2011 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_renderer_impl.h"
 
 #include <math.h>
 
 #include "content/common/media/audio_messages.h"
 #include "content/renderer/render_thread.h"
 #include "content/renderer/render_view.h"
 #include "media/base/filter_host.h"
 
 namespace {
 
 // We will try to fill 200 ms worth of audio samples in each packet. A round
 // trip latency for IPC messages are typically 10 ms, this should give us
 // plenty of time to avoid clicks.
 const int kMillisecondsPerPacket = 200;
 
 // We have at most 3 packets in browser, i.e. 600 ms. This is a reasonable
 // amount to avoid clicks.
 const int kPacketsInBuffer = 3;
 
 }  // namespace
 
-AudioRendererImpl::AudioRendererImpl(AudioMessageFilter* filter)
+AudioRendererImpl::AudioRendererImpl(int routing_id)
     : AudioRendererBase(),
       bytes_per_second_(0),
-      filter_(filter),
       stream_id_(0),
       shared_memory_(NULL),
       shared_memory_size_(0),
-      io_loop_(filter->message_loop()),
       stopped_(false),
       pending_request_(false),
       prerolling_(false),
       preroll_bytes_(0) {
+  AudioMessageFilter* audio_message_filter = AudioMessageFilter::GetInstance();
+  DCHECK(audio_message_filter);
+  if (!audio_message_filter->RoutingIDHasBeenSet()) {
+    // Ensure that first user sets a valid routing ID.
+    // This routing ID will remain during the lifetime of the audio message
+    // filter (which is a singleton).
+    audio_message_filter->SetRoutingID(routing_id);
+  }
+  io_loop_ = audio_message_filter->message_loop();
   DCHECK(io_loop_);
 }
 
 AudioRendererImpl::~AudioRendererImpl() {
 }
 
 base::TimeDelta AudioRendererImpl::ConvertToDuration(int bytes) {
   if (bytes_per_second_) {
     return base::TimeDelta::FromMicroseconds(
         base::Time::kMicrosecondsPerSecond * bytes / bytes_per_second_);
@@ skipping 184 matching lines @@
 
 void AudioRendererImpl::CreateStreamTask(const AudioParameters& audio_params) {
   DCHECK(MessageLoop::current() == io_loop_);
 
   base::AutoLock auto_lock(lock_);
   if (stopped_)
     return;
 
   // Make sure we don't call create more than once.
   DCHECK_EQ(0, stream_id_);
-  stream_id_ = filter_->AddDelegate(this);
+  stream_id_ = AudioMessageFilter::GetInstance()->AddDelegate(this);
   io_loop_->AddDestructionObserver(this);
 
   AudioParameters params_to_send(audio_params);
   // Let the browser choose packet size.
   params_to_send.samples_per_packet = 0;
 
-  filter_->Send(new AudioHostMsg_CreateStream(
-      0, stream_id_, params_to_send, false));
+  Send(new AudioHostMsg_CreateStream(0, stream_id_, params_to_send, false));
 }
 
 void AudioRendererImpl::PlayTask() {
   DCHECK(MessageLoop::current() == io_loop_);
 
-  filter_->Send(new AudioHostMsg_PlayStream(0, stream_id_));
+  Send(new AudioHostMsg_PlayStream(0, stream_id_));
 }
 
 void AudioRendererImpl::PauseTask() {
   DCHECK(MessageLoop::current() == io_loop_);
 
-  filter_->Send(new AudioHostMsg_PauseStream(0, stream_id_));
+  Send(new AudioHostMsg_PauseStream(0, stream_id_));
 }
 
 void AudioRendererImpl::SeekTask() {
   DCHECK(MessageLoop::current() == io_loop_);
 
   // We have to pause the audio stream before we can flush.
-  filter_->Send(new AudioHostMsg_PauseStream(0, stream_id_));
-  filter_->Send(new AudioHostMsg_FlushStream(0, stream_id_));
+  Send(new AudioHostMsg_PauseStream(0, stream_id_));
+  Send(new AudioHostMsg_FlushStream(0, stream_id_));
 }
 
 void AudioRendererImpl::DestroyTask() {
   DCHECK(MessageLoop::current() == io_loop_);
 
   // Make sure we don't call destroy more than once.
   DCHECK_NE(0, stream_id_);
-  filter_->RemoveDelegate(stream_id_);
-  filter_->Send(new AudioHostMsg_CloseStream(0, stream_id_));
+  AudioMessageFilter::GetInstance()->RemoveDelegate(stream_id_);
+  Send(new AudioHostMsg_CloseStream(0, stream_id_));
   io_loop_->RemoveDestructionObserver(this);
   stream_id_ = 0;
 }
 
 void AudioRendererImpl::SetVolumeTask(double volume) {
   DCHECK(MessageLoop::current() == io_loop_);
 
   base::AutoLock auto_lock(lock_);
   if (stopped_)
     return;
-  filter_->Send(new AudioHostMsg_SetVolume(0, stream_id_, volume));
+  Send(new AudioHostMsg_SetVolume(0, stream_id_, volume));
 }
 
 void AudioRendererImpl::NotifyPacketReadyTask() {
   DCHECK(MessageLoop::current() == io_loop_);
 
   base::AutoLock auto_lock(lock_);
   if (stopped_)
     return;
   if (pending_request_ && GetPlaybackRate() > 0.0f) {
     DCHECK(shared_memory_.get());
@@ skipping 22 matching lines @@
       request_delay = base::TimeDelta::FromMicroseconds(
           static_cast<int64>(ceil(request_delay.InMicroseconds() *
                                   GetPlaybackRate())));
     }
 
     uint32 filled = FillBuffer(static_cast<uint8*>(shared_memory_->memory()),
                                shared_memory_size_, request_delay,
                                request_buffers_state_.pending_bytes == 0);
     pending_request_ = false;
     // Then tell browser process we are done filling into the buffer.
-    filter_->Send(new AudioHostMsg_NotifyPacketReady(0, stream_id_, filled));
+    Send(new AudioHostMsg_NotifyPacketReady(0, stream_id_, filled));
   }
 }
 
 void AudioRendererImpl::WillDestroyCurrentMessageLoop() {
   DCHECK(MessageLoop::current() == io_loop_);
 
   // We treat the IO loop going away the same as stopping.
   base::AutoLock auto_lock(lock_);
   if (stopped_)
     return;
 
   stopped_ = true;
   DestroyTask();
 }
+
+void AudioRendererImpl::Send(IPC::Message* message) {
+  DCHECK(MessageLoop::current() == io_loop_);
+  AudioMessageFilter::GetInstance()->Send(message);
+}