Plumb render view ID from audio-related code in renderer through IPCs to AudioRendererHost in brows…

content/renderer/media/audio_message_filter.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_message_filter.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "content/common/child_process.h"
 #include "content/common/media/audio_messages.h"
 #include "content/renderer/render_thread_impl.h"
 #include "ipc/ipc_logging.h"
 
-AudioMessageFilter* AudioMessageFilter::filter_ = NULL;
-
-// static
-AudioMessageFilter* AudioMessageFilter::Get() {
-  return filter_;
-}
-
 AudioMessageFilter::AudioMessageFilter()
     : channel_(NULL) {
   DVLOG(1) << "AudioMessageFilter::AudioMessageFilter()";
-  DCHECK(!filter_);
-  filter_ = this;
 }
 
-int AudioMessageFilter::AddDelegate(media::AudioOutputIPCDelegate* delegate) {
-  return delegates_.Add(delegate);
-}
+class AudioMessageFilter::AudioOutputIPCImpl
+    : public NON_EXPORTED_BASE(media::AudioOutputIPC) {
+ public:
+  AudioOutputIPCImpl(int render_view_id, AudioMessageFilter* filter)
+      : render_view_id_(render_view_id), filter_(filter) {}
+  virtual ~AudioOutputIPCImpl() {}
 
-void AudioMessageFilter::RemoveDelegate(int id) {
-  delegates_.Remove(id);
-}
+  // media::AudioOutputIPC implementation.
+  virtual int AddDelegate(media::AudioOutputIPCDelegate* delegate) OVERRIDE {
+    return filter_->delegates_.Add(delegate);
+  }
+  virtual void RemoveDelegate(int id) OVERRIDE {
+    filter_->delegates_.Remove(id);
+  }
+  virtual void CreateStream(int stream_id,
+                            const media::AudioParameters& params,
+                            int input_channels) OVERRIDE {
+    filter_->Send(new AudioHostMsg_CreateStream(
+        render_view_id_, stream_id, params, input_channels));
+  }
+  virtual void PlayStream(int stream_id) OVERRIDE {
+    filter_->Send(new AudioHostMsg_PlayStream(stream_id));
+  }
+  virtual void PauseStream(int stream_id) OVERRIDE {
+    filter_->Send(new AudioHostMsg_PauseStream(stream_id));
+  }
+  virtual void FlushStream(int stream_id) OVERRIDE {
+    filter_->Send(new AudioHostMsg_FlushStream(stream_id));
+  }
+  virtual void CloseStream(int stream_id) OVERRIDE {
+    filter_->Send(new AudioHostMsg_CloseStream(stream_id));
+  }
+  virtual void SetVolume(int stream_id, double volume) OVERRIDE {
+    filter_->Send(new AudioHostMsg_SetVolume(stream_id, volume));
+  }
 
-void AudioMessageFilter::CreateStream(int stream_id,
-                                      const media::AudioParameters& params,
-                                      int input_channels) {
-  Send(new AudioHostMsg_CreateStream(stream_id, params, input_channels));
-}
+ private:
+  const int render_view_id_;
 
-void AudioMessageFilter::PlayStream(int stream_id) {
-  Send(new AudioHostMsg_PlayStream(stream_id));
-}
+  // Holds a reference to the audio message filter (lives on the main render
+  // thread) for the lifetime of this instance.
+  scoped_refptr<AudioMessageFilter> filter_;
 
-void AudioMessageFilter::PauseStream(int stream_id) {
-  Send(new AudioHostMsg_PauseStream(stream_id));
-}
+  DISALLOW_IMPLICIT_CONSTRUCTORS(AudioOutputIPCImpl);
+};
 
-void AudioMessageFilter::FlushStream(int stream_id) {
-  Send(new AudioHostMsg_FlushStream(stream_id));
-}
-
-void AudioMessageFilter::CloseStream(int stream_id) {
-  Send(new AudioHostMsg_CloseStream(stream_id));
-}
-
-void AudioMessageFilter::SetVolume(int stream_id, double volume) {
-  Send(new AudioHostMsg_SetVolume(stream_id, volume));
+scoped_ptr<media::AudioOutputIPC> AudioMessageFilter::CreateAudioOutputIPC(
+    int render_view_id) {
+  return scoped_ptr<media::AudioOutputIPC>(
+      new AudioOutputIPCImpl(render_view_id, this));
 }
 
 bool AudioMessageFilter::Send(IPC::Message* message) {
   if (!channel_) {
     delete message;
     return false;
   }
 
   if (MessageLoop::current() != ChildProcess::current()->io_message_loop()) {
     // Can only access the IPC::Channel on the IPC thread since it's not thread
@@ skipping 39 matching lines @@
     it.Advance();
   }
 }
 
 AudioMessageFilter::~AudioMessageFilter() {
   DVLOG(1) << "AudioMessageFilter::~AudioMessageFilter()";
 
   // Just in case the message filter is deleted before the channel
   // is closed and there are still living audio devices.
   OnChannelClosing();
-
-  DCHECK(filter_);
-  filter_ = NULL;
 }
 
 void AudioMessageFilter::OnStreamCreated(
     int stream_id,
     base::SharedMemoryHandle handle,
 #if defined(OS_WIN)
     base::SyncSocket::Handle socket_handle,
 #else
     base::FileDescriptor socket_descriptor,
 #endif
@@ skipping 14 matching lines @@
 
 void AudioMessageFilter::OnStreamStateChanged(
     int stream_id, media::AudioOutputIPCDelegate::State state) {
   media::AudioOutputIPCDelegate* delegate = delegates_.Lookup(stream_id);
   if (!delegate) {
     DLOG(WARNING) << "No delegate found for state change. " << state;
     return;
   }
   delegate->OnStateChanged(state);
 }