From 5ff11135bfe657fab30536b393522ba9b9b9a7bf Mon Sep 17 00:00:00 2001
From: "miu@chromium.org"
 <miu@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>
Date: Tue, 4 Dec 2012 09:53:29 +0000
Subject: [PATCH] Associate audio streams with their source/destination
 RenderView.

This is a first step towards implementing three major Chromium features, all of which need to associate audio outputs with their source tabs.  See BUGs referenced by this change for more details.

Previous attempt/approach: https://codereview.chromium.org/11166002/

Specifics:

1. Added two new IPC messages: AudioHostMsg_AssociateStreamWithProducer and AudioInputHostMsg_AssociateStreamWithConsumer.
2. Added "associate to render_view_id" IPC calls: PepperPlatformAudioInputImpl, PepperPlatformAudioOutputImpl, RenderAudioSourceProvider, RendererWebAudioDeviceImpl, WebRtcAudioRenderer.
3. AudioOutputDevice instances re-use the same stream IDs.
4. Removed AudioDeviceFactory and replaced test-injection scheme in AudioRendererMixerManager.

Not in scope:

1. Associating RenderViews with audio input to WebRTC.
2. Associating RenderViews with streams produced by the AudioRendererMixer.
3. Speech Input (implementation is in the browser process, not the render process).

Testing method: Confirm correct render_view_id shows up in debug logging when engaging the various audio code paths.  Some of the many test sites used:

1. PPAPI (in and out): http://www.midomi.com/index.php?action=main.mic_check
2. WebMediaPlayer (e.g., <audio> and <video>): http://html5video.org/
3. WebAudio API: http://chromium.googlecode.com/svn/trunk/samples/audio/convolution-effects.html
4. WebRTC (output only): http://apprtc.appspot.com/

BUG=3541,64215,153392
TEST=Enabled debug logging via --vmodule=audio_renderer_host=1,audio_input_renderer_host=1 and then engaged the various Chrome audio code paths to confirm correct render_view_id shows up in browser process.


Review URL: https://chromiumcodereview.appspot.com/11359196

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@170919 0039d316-1c4b-4281-b951-d872f2087c98
---
 .../media/audio_input_renderer_host.cc             | 10 ++++
 .../media/audio_input_renderer_host.h              |  4 ++
 .../renderer_host/media/audio_renderer_host.cc     | 10 ++++
 .../renderer_host/media/audio_renderer_host.h      |  4 ++
 content/common/media/audio_messages.h              | 10 ++++
 content/content_renderer.gypi                      |  2 +
 content/renderer/media/audio_device_factory.cc     | 10 ++--
 content/renderer/media/audio_device_factory.h      | 23 ++++----
 .../renderer/media/audio_input_message_filter.cc   |  6 ++
 .../renderer/media/audio_input_message_filter.h    |  3 +
 content/renderer/media/audio_message_filter.cc     | 66 ++++++++++++++--------
 content/renderer/media/audio_message_filter.h      | 18 +++++-
 .../renderer/media/audio_renderer_mixer_manager.cc | 14 ++++-
 .../renderer/media/audio_renderer_mixer_manager.h  |  6 ++
 .../media/audio_renderer_mixer_manager_unittest.cc | 45 ++++++---------
 content/renderer/media/media_stream_impl.cc        |  2 +-
 .../renderer/media/render_audiosourceprovider.cc   | 12 +++-
 .../renderer/media/render_audiosourceprovider.h    |  4 +-
 .../renderer/media/renderer_audio_output_device.cc | 63 +++++++++++++++++++++
 .../renderer/media/renderer_audio_output_device.h  | 58 +++++++++++++++++++
 .../renderer/media/renderer_webaudiodevice_impl.cc | 63 +++++++++++++++------
 .../renderer/media/renderer_webaudiodevice_impl.h  | 16 +++++-
 content/renderer/media/webrtc_audio_capturer.cc    |  2 +-
 content/renderer/media/webrtc_audio_capturer.h     |  3 +-
 content/renderer/media/webrtc_audio_device_impl.cc |  1 -
 .../renderer/media/webrtc_audio_device_unittest.cc | 13 +++--
 content/renderer/media/webrtc_audio_renderer.cc    |  6 +-
 content/renderer/media/webrtc_audio_renderer.h     | 10 +++-
 .../pepper/pepper_platform_audio_input_impl.cc     |  7 ++-
 .../pepper/pepper_platform_audio_input_impl.h      |  6 +-
 .../pepper/pepper_platform_audio_output_impl.cc    | 17 ++++--
 .../pepper/pepper_platform_audio_output_impl.h     |  9 ++-
 .../renderer/pepper/pepper_plugin_delegate_impl.cc |  3 +-
 content/renderer/render_view_impl.cc               |  2 +-
 content/test/webrtc_audio_device_test.cc           |  1 -
 media/audio/audio_output_device.cc                 | 66 ++++++++++------------
 media/audio/audio_output_device.h                  | 25 +++++---
 media/audio/audio_output_device_unittest.cc        | 44 +++++++--------
 38 files changed, 471 insertions(+), 193 deletions(-)
 create mode 100644 content/renderer/media/renderer_audio_output_device.cc
 create mode 100644 content/renderer/media/renderer_audio_output_device.h

diff --git a/content/browser/renderer_host/media/audio_input_renderer_host.cc b/content/browser/renderer_host/media/audio_input_renderer_host.cc
index 144af56015f7..dda485005119 100644
--- a/content/browser/renderer_host/media/audio_input_renderer_host.cc
+++ b/content/browser/renderer_host/media/audio_input_renderer_host.cc
@@ -184,6 +184,8 @@ bool AudioInputRendererHost::OnMessageReceived(const IPC::Message& message,
   IPC_BEGIN_MESSAGE_MAP_EX(AudioInputRendererHost, message, *message_was_ok)
     IPC_MESSAGE_HANDLER(AudioInputHostMsg_StartDevice, OnStartDevice)
     IPC_MESSAGE_HANDLER(AudioInputHostMsg_CreateStream, OnCreateStream)
+    IPC_MESSAGE_HANDLER(AudioInputHostMsg_AssociateStreamWithConsumer,
+                        OnAssociateStreamWithConsumer)
     IPC_MESSAGE_HANDLER(AudioInputHostMsg_RecordStream, OnRecordStream)
     IPC_MESSAGE_HANDLER(AudioInputHostMsg_CloseStream, OnCloseStream)
     IPC_MESSAGE_HANDLER(AudioInputHostMsg_SetVolume, OnSetVolume)
@@ -279,6 +281,14 @@ void AudioInputRendererHost::OnCreateStream(
   audio_entries_.insert(std::make_pair(stream_id, entry.release()));
 }
 
+void AudioInputRendererHost::OnAssociateStreamWithConsumer(int stream_id,
+                                                           int render_view_id) {
+  // TODO(miu): Will use render_view_id in upcoming change.
+  DVLOG(1) << "AudioInputRendererHost@" << this
+           << "::OnAssociateStreamWithConsumer(stream_id=" << stream_id
+           << ", render_view_id=" << render_view_id << ")";
+}
+
 void AudioInputRendererHost::OnRecordStream(int stream_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
diff --git a/content/browser/renderer_host/media/audio_input_renderer_host.h b/content/browser/renderer_host/media/audio_input_renderer_host.h
index 8f5a13ce1367..d0d4438d2383 100644
--- a/content/browser/renderer_host/media/audio_input_renderer_host.h
+++ b/content/browser/renderer_host/media/audio_input_renderer_host.h
@@ -127,6 +127,10 @@ class CONTENT_EXPORT AudioInputRendererHost
                       const std::string& device_id,
                       bool automatic_gain_control);
 
+  // Track that the data for the audio stream referenced by |stream_id| is
+  // consumed by an entity in the render view referenced by |render_view_id|.
+  void OnAssociateStreamWithConsumer(int stream_id, int render_view_id);
+
   // Record the audio input stream referenced by |stream_id|.
   void OnRecordStream(int stream_id);
 
diff --git a/content/browser/renderer_host/media/audio_renderer_host.cc b/content/browser/renderer_host/media/audio_renderer_host.cc
index c043c2cb3331..83b5f2510baa 100644
--- a/content/browser/renderer_host/media/audio_renderer_host.cc
+++ b/content/browser/renderer_host/media/audio_renderer_host.cc
@@ -203,6 +203,8 @@ bool AudioRendererHost::OnMessageReceived(const IPC::Message& message,
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(AudioRendererHost, message, *message_was_ok)
     IPC_MESSAGE_HANDLER(AudioHostMsg_CreateStream, OnCreateStream)
+    IPC_MESSAGE_HANDLER(AudioHostMsg_AssociateStreamWithProducer,
+                        OnAssociateStreamWithProducer)
     IPC_MESSAGE_HANDLER(AudioHostMsg_PlayStream, OnPlayStream)
     IPC_MESSAGE_HANDLER(AudioHostMsg_PauseStream, OnPauseStream)
     IPC_MESSAGE_HANDLER(AudioHostMsg_FlushStream, OnFlushStream)
@@ -281,6 +283,14 @@ void AudioRendererHost::OnCreateStream(
     media_observer_->OnSetAudioStreamStatus(this, stream_id, "created");
 }
 
+void AudioRendererHost::OnAssociateStreamWithProducer(int stream_id,
+                                                      int render_view_id) {
+  // TODO(miu): Will use render_view_id in upcoming change.
+  DVLOG(1) << "AudioRendererHost@" << this
+           << "::OnAssociateStreamWithProducer(stream_id=" << stream_id
+           << ", render_view_id=" << render_view_id << ")";
+}
+
 void AudioRendererHost::OnPlayStream(int stream_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
diff --git a/content/browser/renderer_host/media/audio_renderer_host.h b/content/browser/renderer_host/media/audio_renderer_host.h
index 43e9395ac50f..44daef21f836 100644
--- a/content/browser/renderer_host/media/audio_renderer_host.h
+++ b/content/browser/renderer_host/media/audio_renderer_host.h
@@ -106,6 +106,10 @@ class CONTENT_EXPORT AudioRendererHost
                       const media::AudioParameters& params,
                       int input_channels);
 
+  // Track that the data for the audio stream referenced by |stream_id| is
+  // produced by an entity in the render view referenced by |render_view_id|.
+  void OnAssociateStreamWithProducer(int stream_id, int render_view_id);
+
   // Play the audio stream referenced by |stream_id|.
   void OnPlayStream(int stream_id);
 
diff --git a/content/common/media/audio_messages.h b/content/common/media/audio_messages.h
index fd16fbca8dc6..e78cfddfb885 100644
--- a/content/common/media/audio_messages.h
+++ b/content/common/media/audio_messages.h
@@ -97,6 +97,16 @@ IPC_MESSAGE_CONTROL4(AudioInputHostMsg_CreateStream,
                      std::string /* device_id */,
                      bool /* automatic_gain_control */)
 
+// Indicate that audio for a stream is produced by the specified render view.
+IPC_MESSAGE_CONTROL2(AudioHostMsg_AssociateStreamWithProducer,
+                     int /* stream_id */,
+                     int /* render_view_id */)
+
+// Indicate that audio for a stream is consumed by the specified render view.
+IPC_MESSAGE_CONTROL2(AudioInputHostMsg_AssociateStreamWithConsumer,
+                     int /* stream_id */,
+                     int /* render_view_id */)
+
 // Start buffering and play the audio stream specified by stream_id.
 IPC_MESSAGE_CONTROL1(AudioHostMsg_PlayStream,
                      int /* stream_id */)
diff --git a/content/content_renderer.gypi b/content/content_renderer.gypi
index a66c714572d2..5d7d537b40f9 100644
--- a/content/content_renderer.gypi
+++ b/content/content_renderer.gypi
@@ -135,6 +135,8 @@
     'renderer/media/render_audiosourceprovider.h',
     'renderer/media/render_media_log.cc',
     'renderer/media/render_media_log.h',
+    'renderer/media/renderer_audio_output_device.cc',
+    'renderer/media/renderer_audio_output_device.h',
     'renderer/media/renderer_gpu_video_decoder_factories.cc',
     'renderer/media/renderer_gpu_video_decoder_factories.h',
     'renderer/media/renderer_webaudiodevice_impl.cc',
diff --git a/content/renderer/media/audio_device_factory.cc b/content/renderer/media/audio_device_factory.cc
index ad7968884e78..baf687757752 100644
--- a/content/renderer/media/audio_device_factory.cc
+++ b/content/renderer/media/audio_device_factory.cc
@@ -8,8 +8,8 @@
 #include "content/common/child_process.h"
 #include "content/renderer/media/audio_input_message_filter.h"
 #include "content/renderer/media/audio_message_filter.h"
+#include "content/renderer/media/renderer_audio_output_device.h"
 #include "media/audio/audio_input_device.h"
-#include "media/audio/audio_output_device.h"
 
 namespace content {
 
@@ -17,18 +17,18 @@ namespace content {
 AudioDeviceFactory* AudioDeviceFactory::factory_ = NULL;
 
 // static
-media::AudioRendererSink* AudioDeviceFactory::NewOutputDevice() {
-  media::AudioRendererSink* device = NULL;
+scoped_refptr<RendererAudioOutputDevice> AudioDeviceFactory::NewOutputDevice() {
+  RendererAudioOutputDevice* device = NULL;
   if (factory_)
     device = factory_->CreateOutputDevice();
 
-  return device ? device : new media::AudioOutputDevice(
+  return device ? device : new RendererAudioOutputDevice(
       AudioMessageFilter::Get(),
       ChildProcess::current()->io_message_loop()->message_loop_proxy());
 }
 
 // static
-media::AudioInputDevice* AudioDeviceFactory::NewInputDevice() {
+scoped_refptr<media::AudioInputDevice> AudioDeviceFactory::NewInputDevice() {
   media::AudioInputDevice* device = NULL;
   if (factory_)
     device = factory_->CreateInputDevice();
diff --git a/content/renderer/media/audio_device_factory.h b/content/renderer/media/audio_device_factory.h
index e95e487e88a9..b06ace7aea31 100644
--- a/content/renderer/media/audio_device_factory.h
+++ b/content/renderer/media/audio_device_factory.h
@@ -6,29 +6,26 @@
 #define CONTENT_RENDERER_MEDIA_AUDIO_DEVICE_FACTORY_H_
 
 #include "base/basictypes.h"
-#include "content/common/content_export.h"
+#include "base/memory/ref_counted.h"
 
 namespace media {
 class AudioInputDevice;
-class AudioRendererSink;
 }
 
 namespace content {
 
-// A factory for creating AudioRendererSinks. There is a global factory
+class RendererAudioOutputDevice;
+
+// A factory for creating RendererAudioOutputDevices.  There is a global factory
 // function that can be installed for the purposes of testing to provide
 // a specialized AudioRendererSink class.
-class CONTENT_EXPORT AudioDeviceFactory {
+class AudioDeviceFactory {
  public:
-  // Creates an AudioRendererSink using the currently registered factory,
-  // or the default one if no factory is registered. Ownership of the returned
-  // pointer will be passed to the caller.
-  static media::AudioRendererSink* NewOutputDevice();
+  // Creates a RendererAudioOutputDevice using the currently registered factory.
+  static scoped_refptr<RendererAudioOutputDevice> NewOutputDevice();
 
-  // TODO(henrika): Update AudioInputDevice to inherit from an interface
-  // similar to AudioRendererSink, but for input.  Same for the callback
-  // interfaces.
-  static media::AudioInputDevice* NewInputDevice();
+  // Creates an AudioInputDevice using the currently registered factory,
+  static scoped_refptr<media::AudioInputDevice> NewInputDevice();
 
  protected:
   AudioDeviceFactory();
@@ -38,7 +35,7 @@ class CONTENT_EXPORT AudioDeviceFactory {
   // functions to provide alternate audio device implementations.
   // If the return value of either of these function is NULL, we fall back
   // on the default implementation.
-  virtual media::AudioRendererSink* CreateOutputDevice() = 0;
+  virtual RendererAudioOutputDevice* CreateOutputDevice() = 0;
   virtual media::AudioInputDevice* CreateInputDevice() = 0;
 
  private:
diff --git a/content/renderer/media/audio_input_message_filter.cc b/content/renderer/media/audio_input_message_filter.cc
index ab49ec5f0f71..e70dcd0656fa 100644
--- a/content/renderer/media/audio_input_message_filter.cc
+++ b/content/renderer/media/audio_input_message_filter.cc
@@ -167,6 +167,12 @@ void AudioInputMessageFilter::CreateStream(int stream_id,
       stream_id, params, device_id, automatic_gain_control));
 }
 
+void AudioInputMessageFilter::AssociateStreamWithConsumer(
+    int stream_id, int render_view_id) {
+  Send(new AudioInputHostMsg_AssociateStreamWithConsumer(
+      stream_id, render_view_id));
+}
+
 void AudioInputMessageFilter::StartDevice(int stream_id, int session_id) {
   Send(new AudioInputHostMsg_StartDevice(stream_id, session_id));
 }
diff --git a/content/renderer/media/audio_input_message_filter.h b/content/renderer/media/audio_input_message_filter.h
index fd7d641245ed..b0298e875a41 100644
--- a/content/renderer/media/audio_input_message_filter.h
+++ b/content/renderer/media/audio_input_message_filter.h
@@ -29,6 +29,9 @@ class CONTENT_EXPORT AudioInputMessageFilter
   // Getter for the one AudioInputMessageFilter object.
   static AudioInputMessageFilter* Get();
 
+  // Associates |render_view_id| as the destination of audio for a stream.
+  void AssociateStreamWithConsumer(int stream_id, int render_view_id);
+
   // Implementation of AudioInputIPC.
   virtual int AddDelegate(
       media::AudioInputIPCDelegate* delegate) OVERRIDE;
diff --git a/content/renderer/media/audio_message_filter.cc b/content/renderer/media/audio_message_filter.cc
index d8a6e70c77ea..22915c521c53 100644
--- a/content/renderer/media/audio_message_filter.cc
+++ b/content/renderer/media/audio_message_filter.cc
@@ -22,18 +22,23 @@ AudioMessageFilter* AudioMessageFilter::Get() {
 }
 
 AudioMessageFilter::AudioMessageFilter()
-    : channel_(NULL) {
+    : next_stream_id_(1),
+      channel_(NULL) {
   DVLOG(1) << "AudioMessageFilter::AudioMessageFilter()";
   DCHECK(!filter_);
   filter_ = this;
 }
 
 int AudioMessageFilter::AddDelegate(media::AudioOutputIPCDelegate* delegate) {
-  return delegates_.Add(delegate);
+  base::AutoLock guard(delegates_lock_);
+  const int id = next_stream_id_++;
+  delegates_.insert(std::make_pair(id, delegate));
+  return id;
 }
 
 void AudioMessageFilter::RemoveDelegate(int id) {
-  delegates_.Remove(id);
+  base::AutoLock guard(delegates_lock_);
+  delegates_.erase(id);
 }
 
 void AudioMessageFilter::CreateStream(int stream_id,
@@ -42,6 +47,11 @@ void AudioMessageFilter::CreateStream(int stream_id,
   Send(new AudioHostMsg_CreateStream(stream_id, params, input_channels));
 }
 
+void AudioMessageFilter::AssociateStreamWithProducer(int stream_id,
+                                                     int render_view_id) {
+  Send(new AudioHostMsg_AssociateStreamWithProducer(stream_id, render_view_id));
+}
+
 void AudioMessageFilter::PlayStream(int stream_id) {
   Send(new AudioHostMsg_PlayStream(stream_id));
 }
@@ -102,14 +112,19 @@ void AudioMessageFilter::OnFilterRemoved() {
 
 void AudioMessageFilter::OnChannelClosing() {
   channel_ = NULL;
-  LOG_IF(WARNING, !delegates_.IsEmpty())
+
+  DelegateMap zombies;
+  {
+    base::AutoLock guard(delegates_lock_);
+    delegates_.swap(zombies);
+  }
+
+  LOG_IF(WARNING, !zombies.empty())
       << "Not all audio devices have been closed.";
 
-  IDMap<media::AudioOutputIPCDelegate>::iterator it(&delegates_);
-  while (!it.IsAtEnd()) {
-    it.GetCurrentValue()->OnIPCClosed();
-    delegates_.Remove(it.GetCurrentKey());
-    it.Advance();
+  for (DelegateMap::const_iterator it = zombies.begin(); it != zombies.end();
+       ++it) {
+    it->second->OnIPCClosed();
   }
 }
 
@@ -136,25 +151,30 @@ void AudioMessageFilter::OnStreamCreated(
 #if !defined(OS_WIN)
   base::SyncSocket::Handle socket_handle = socket_descriptor.fd;
 #endif
-  media::AudioOutputIPCDelegate* delegate = delegates_.Lookup(stream_id);
-  if (!delegate) {
-    DLOG(WARNING) << "Got audio stream event for a non-existent or removed"
-                    " audio renderer. (stream_id=" << stream_id << ").";
-    base::SharedMemory::CloseHandle(handle);
-    base::SyncSocket socket(socket_handle);
-    return;
+
+  {
+    base::AutoLock guard(delegates_lock_);
+    DelegateMap::const_iterator it = delegates_.find(stream_id);
+    if (it != delegates_.end()) {
+      it->second->OnStreamCreated(handle, socket_handle, length);
+      return;
+    }
   }
-  delegate->OnStreamCreated(handle, socket_handle, length);
+
+  DLOG(WARNING) << "Got audio stream event for a non-existent or removed"
+                   " audio renderer. (stream_id=" << stream_id << ").";
+  base::SharedMemory::CloseHandle(handle);
+  base::SyncSocket socket(socket_handle);
 }
 
 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);
+  base::AutoLock guard(delegates_lock_);
+  DelegateMap::const_iterator it = delegates_.find(stream_id);
+  DLOG_IF(WARNING, it == delegates_.end())
+      << "No delegate found for state change. " << state;
+  if (it != delegates_.end())
+    it->second->OnStateChanged(state);
 }
 
 }  // namespace content
diff --git a/content/renderer/media/audio_message_filter.h b/content/renderer/media/audio_message_filter.h
index 3e3c9c9b067e..de746d5d31cd 100644
--- a/content/renderer/media/audio_message_filter.h
+++ b/content/renderer/media/audio_message_filter.h
@@ -11,9 +11,10 @@
 #define CONTENT_RENDERER_MEDIA_AUDIO_MESSAGE_FILTER_H_
 
 #include "base/gtest_prod_util.h"
-#include "base/id_map.h"
+#include "base/hash_tables.h"
 #include "base/shared_memory.h"
 #include "base/sync_socket.h"
+#include "base/synchronization/lock.h"
 #include "content/common/content_export.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "media/audio/audio_buffers_state.h"
@@ -30,7 +31,10 @@ class CONTENT_EXPORT AudioMessageFilter
   // Getter for the one AudioMessageFilter object.
   static AudioMessageFilter* Get();
 
-  // media::AudioOutputIPCDelegate implementation.
+  // Associates |render_view_id| as the source of audio rendered for a stream.
+  void AssociateStreamWithProducer(int stream_id, int render_view_id);
+
+  // media::AudioOutputIPC implementation.
   virtual int AddDelegate(media::AudioOutputIPCDelegate* delegate) OVERRIDE;
   virtual void RemoveDelegate(int id) OVERRIDE;
   virtual void CreateStream(int stream_id,
@@ -74,8 +78,16 @@ class CONTENT_EXPORT AudioMessageFilter
   // The singleton instance for this filter.
   static AudioMessageFilter* filter_;
 
+  // Guards delegates_ since AddDelegate() and RemoveDelegate() are called from
+  // threads other than the IO thread.
+  base::Lock delegates_lock_;
+
   // A map of stream ids to delegates.
-  IDMap<media::AudioOutputIPCDelegate> delegates_;
+  typedef base::hash_map<int, media::AudioOutputIPCDelegate*> DelegateMap;
+  DelegateMap delegates_;
+
+  // Unique ID to use for next added delegate.
+  int next_stream_id_;
 
   IPC::Channel* channel_;
 
diff --git a/content/renderer/media/audio_renderer_mixer_manager.cc b/content/renderer/media/audio_renderer_mixer_manager.cc
index 67daf2cbeb9a..8392d7712483 100644
--- a/content/renderer/media/audio_renderer_mixer_manager.cc
+++ b/content/renderer/media/audio_renderer_mixer_manager.cc
@@ -7,6 +7,7 @@
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "content/renderer/media/audio_device_factory.h"
+#include "content/renderer/media/renderer_audio_output_device.h"
 #include "media/base/audio_renderer_mixer.h"
 #include "media/base/audio_renderer_mixer_input.h"
 
@@ -15,7 +16,8 @@ namespace content {
 AudioRendererMixerManager::AudioRendererMixerManager(int hardware_sample_rate,
                                                      int hardware_buffer_size)
     : hardware_sample_rate_(hardware_sample_rate),
-      hardware_buffer_size_(hardware_buffer_size) {
+      hardware_buffer_size_(hardware_buffer_size),
+      sink_for_testing_(NULL) {
 }
 
 AudioRendererMixerManager::~AudioRendererMixerManager() {
@@ -30,6 +32,11 @@ media::AudioRendererMixerInput* AudioRendererMixerManager::CreateInput() {
           &AudioRendererMixerManager::RemoveMixer, base::Unretained(this)));
 }
 
+void AudioRendererMixerManager::SetAudioRendererSinkForTesting(
+    media::AudioRendererSink* sink) {
+  sink_for_testing_ = sink;
+}
+
 media::AudioRendererMixer* AudioRendererMixerManager::GetMixer(
     const media::AudioParameters& params) {
   base::AutoLock auto_lock(mixers_lock_);
@@ -53,7 +60,10 @@ media::AudioRendererMixer* AudioRendererMixerManager::GetMixer(
     output_params = params;
 
   media::AudioRendererMixer* mixer = new media::AudioRendererMixer(
-      params, output_params, AudioDeviceFactory::NewOutputDevice());
+      params, output_params,
+      sink_for_testing_ ?
+          sink_for_testing_ :
+          AudioDeviceFactory::NewOutputDevice());
 
   AudioRendererMixerReference mixer_reference = { mixer, 1 };
   mixers_[params] = mixer_reference;
diff --git a/content/renderer/media/audio_renderer_mixer_manager.h b/content/renderer/media/audio_renderer_mixer_manager.h
index dba3ba82df7a..6c6e0e871e6f 100644
--- a/content/renderer/media/audio_renderer_mixer_manager.h
+++ b/content/renderer/media/audio_renderer_mixer_manager.h
@@ -14,6 +14,7 @@
 namespace media {
 class AudioRendererMixer;
 class AudioRendererMixerInput;
+class AudioRendererSink;
 }
 
 namespace content {
@@ -45,6 +46,9 @@ class CONTENT_EXPORT AudioRendererMixerManager {
  private:
   friend class AudioRendererMixerManagerTest;
 
+  // Overrides the AudioRendererSink implementation for unit testing.
+  void SetAudioRendererSinkForTesting(media::AudioRendererSink* sink);
+
   // Returns a mixer instance based on AudioParameters; an existing one if one
   // with the provided AudioParameters exists or a new one if not.
   media::AudioRendererMixer* GetMixer(const media::AudioParameters& params);
@@ -71,6 +75,8 @@ class CONTENT_EXPORT AudioRendererMixerManager {
   int hardware_sample_rate_;
   int hardware_buffer_size_;
 
+  media::AudioRendererSink* sink_for_testing_;
+
   DISALLOW_COPY_AND_ASSIGN(AudioRendererMixerManager);
 };
 
diff --git a/content/renderer/media/audio_renderer_mixer_manager_unittest.cc b/content/renderer/media/audio_renderer_mixer_manager_unittest.cc
index 40b642e44b0e..63a1660c267b 100644
--- a/content/renderer/media/audio_renderer_mixer_manager_unittest.cc
+++ b/content/renderer/media/audio_renderer_mixer_manager_unittest.cc
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
-#include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/media/audio_renderer_mixer_manager.h"
 #include "media/base/audio_renderer_mixer.h"
 #include "media/base/audio_renderer_mixer_input.h"
@@ -19,36 +19,15 @@ static const int kSampleRate = 48000;
 static const int kBufferSize = 8192;
 static const media::ChannelLayout kChannelLayout = media::CHANNEL_LAYOUT_STEREO;
 
-// By sub-classing AudioDeviceFactory we've overridden the factory to use our
-// CreateAudioDevice() method globally.
-class MockAudioRenderSinkFactory : public AudioDeviceFactory {
- public:
-  MockAudioRenderSinkFactory() {}
-  virtual ~MockAudioRenderSinkFactory() {}
-
- protected:
-  virtual media::MockAudioRendererSink* CreateOutputDevice() OVERRIDE {
-    media::MockAudioRendererSink* sink = new media::MockAudioRendererSink();
-    EXPECT_CALL(*sink, Start());
-    EXPECT_CALL(*sink, Stop());
-    return sink;
-  }
-
-  virtual media::AudioInputDevice* CreateInputDevice() OVERRIDE {
-    ADD_FAILURE();
-    return NULL;
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(MockAudioRenderSinkFactory);
-};
-
 class AudioRendererMixerManagerTest : public testing::Test {
  public:
   AudioRendererMixerManagerTest() {
-    // We don't want to deal with instantiating a real AudioOutputDevice since
-    // it's not important to our testing, so use a mock AudioDeviceFactory.
-    mock_sink_factory_.reset(new MockAudioRenderSinkFactory());
     manager_.reset(new AudioRendererMixerManager(kSampleRate, kBufferSize));
+
+    // We don't want to deal with instantiating a real AudioOutputDevice since
+    // it's not important to our testing, so we inject a mock.
+    mock_sink_ = new media::MockAudioRendererSink();
+    manager_->SetAudioRendererSinkForTesting(mock_sink_);
   }
 
   media::AudioRendererMixer* GetMixer(const media::AudioParameters& params) {
@@ -65,8 +44,8 @@ class AudioRendererMixerManagerTest : public testing::Test {
   }
 
  protected:
-  scoped_ptr<MockAudioRenderSinkFactory> mock_sink_factory_;
   scoped_ptr<AudioRendererMixerManager> manager_;
+  scoped_refptr<media::MockAudioRendererSink> mock_sink_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioRendererMixerManagerTest);
 };
@@ -74,6 +53,11 @@ class AudioRendererMixerManagerTest : public testing::Test {
 // Verify GetMixer() and RemoveMixer() both work as expected; particularly with
 // respect to the explicit ref counting done.
 TEST_F(AudioRendererMixerManagerTest, GetRemoveMixer) {
+  // Since we're testing two different sets of parameters, we expect
+  // AudioRendererMixerManager to call Start and Stop on our mock twice.
+  EXPECT_CALL(*mock_sink_, Start()).Times(2);
+  EXPECT_CALL(*mock_sink_, Stop()).Times(2);
+
   // There should be no mixers outstanding to start with.
   EXPECT_EQ(mixer_count(), 0);
 
@@ -113,6 +97,11 @@ TEST_F(AudioRendererMixerManagerTest, GetRemoveMixer) {
 // Verify CreateInput() provides AudioRendererMixerInput with the appropriate
 // callbacks and they are working as expected.
 TEST_F(AudioRendererMixerManagerTest, CreateInput) {
+  // Since we're testing only one set of parameters, we expect
+  // AudioRendererMixerManager to call Start and Stop on our mock once each.
+  EXPECT_CALL(*mock_sink_, Start()).Times(1);
+  EXPECT_CALL(*mock_sink_, Stop()).Times(1);
+
   media::AudioParameters params(
       media::AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout, kSampleRate,
       kBitsPerChannel, kBufferSize);
diff --git a/content/renderer/media/media_stream_impl.cc b/content/renderer/media/media_stream_impl.cc
index 04f3d1d1a7ec..f08f19073f3a 100644
--- a/content/renderer/media/media_stream_impl.cc
+++ b/content/renderer/media/media_stream_impl.cc
@@ -552,7 +552,7 @@ scoped_refptr<WebRtcAudioRenderer> MediaStreamImpl::CreateRemoteAudioRenderer(
   DVLOG(1) << "MediaStreamImpl::CreateRemoteAudioRenderer label:"
            << stream->label();
 
-  return new WebRtcAudioRenderer();
+  return new WebRtcAudioRenderer(RenderViewObserver::routing_id());
 }
 
 MediaStreamSourceExtraData::MediaStreamSourceExtraData(
diff --git a/content/renderer/media/render_audiosourceprovider.cc b/content/renderer/media/render_audiosourceprovider.cc
index 750db7fe0a47..96e6149ba4c4 100644
--- a/content/renderer/media/render_audiosourceprovider.cc
+++ b/content/renderer/media/render_audiosourceprovider.cc
@@ -11,6 +11,7 @@
 #include "base/logging.h"
 #include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/media/audio_renderer_mixer_manager.h"
+#include "content/renderer/media/renderer_audio_output_device.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/base/audio_renderer_mixer_input.h"
 #include "media/base/media_switches.h"
@@ -21,7 +22,7 @@ using WebKit::WebVector;
 
 namespace content {
 
-RenderAudioSourceProvider::RenderAudioSourceProvider()
+RenderAudioSourceProvider::RenderAudioSourceProvider(int source_render_view_id)
     : is_initialized_(false),
       channels_(0),
       sample_rate_(0),
@@ -44,8 +45,15 @@ RenderAudioSourceProvider::RenderAudioSourceProvider()
   if (use_mixing) {
     default_sink_ = RenderThreadImpl::current()->
         GetAudioRendererMixerManager()->CreateInput();
+    // TODO(miu): Partition mixer instances per RenderView.
   } else {
-    default_sink_ = AudioDeviceFactory::NewOutputDevice();
+    scoped_refptr<RendererAudioOutputDevice> device =
+        AudioDeviceFactory::NewOutputDevice();
+    // The RenderView creating RenderAudioSourceProvider will be the source of
+    // the audio (WebMediaPlayer is always associated with a document in a frame
+    // at the time RenderAudioSourceProvider is instantiated).
+    device->SetSourceRenderView(source_render_view_id);
+    default_sink_ = device;
   }
 }
 
diff --git a/content/renderer/media/render_audiosourceprovider.h b/content/renderer/media/render_audiosourceprovider.h
index b264c0e42cd3..148b11ffd1dc 100644
--- a/content/renderer/media/render_audiosourceprovider.h
+++ b/content/renderer/media/render_audiosourceprovider.h
@@ -37,7 +37,7 @@ class RenderAudioSourceProvider
     : public WebKit::WebAudioSourceProvider,
       public media::AudioRendererSink {
  public:
-  RenderAudioSourceProvider();
+  explicit RenderAudioSourceProvider(int source_render_view_id);
 
   // WebKit::WebAudioSourceProvider implementation.
 
@@ -79,7 +79,7 @@ class RenderAudioSourceProvider
   // default_sink_ is the default sink.
   scoped_refptr<media::AudioRendererSink> default_sink_;
 
-  DISALLOW_COPY_AND_ASSIGN(RenderAudioSourceProvider);
+  DISALLOW_IMPLICIT_CONSTRUCTORS(RenderAudioSourceProvider);
 };
 
 }  // namespace content
diff --git a/content/renderer/media/renderer_audio_output_device.cc b/content/renderer/media/renderer_audio_output_device.cc
new file mode 100644
index 000000000000..1cbf1e30d7cf
--- /dev/null
+++ b/content/renderer/media/renderer_audio_output_device.cc
@@ -0,0 +1,63 @@
+// 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/renderer_audio_output_device.h"
+
+#include "base/bind.h"
+#include "base/message_loop_proxy.h"
+#include "content/renderer/media/audio_message_filter.h"
+
+namespace content {
+
+RendererAudioOutputDevice::RendererAudioOutputDevice(
+    AudioMessageFilter* message_filter,
+    const scoped_refptr<base::MessageLoopProxy>& io_loop)
+    : AudioOutputDevice(message_filter, io_loop),
+      source_render_view_id_(MSG_ROUTING_NONE),
+      is_after_stream_created_(false) {
+}
+
+RendererAudioOutputDevice::~RendererAudioOutputDevice() {}
+
+void RendererAudioOutputDevice::Start() {
+  AudioOutputDevice::Start();
+  message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&RendererAudioOutputDevice::OnStart, this));
+}
+
+void RendererAudioOutputDevice::Stop() {
+  AudioOutputDevice::Stop();
+  message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&RendererAudioOutputDevice::OnStop, this));
+}
+
+void RendererAudioOutputDevice::SetSourceRenderView(int render_view_id) {
+  message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&RendererAudioOutputDevice::OnSourceChange, this,
+                 render_view_id));
+}
+
+void RendererAudioOutputDevice::OnStart() {
+  is_after_stream_created_ = true;
+  OnSourceChange(source_render_view_id_);
+}
+
+void RendererAudioOutputDevice::OnStop() {
+  is_after_stream_created_ = false;
+}
+
+void RendererAudioOutputDevice::OnSourceChange(int render_view_id) {
+  source_render_view_id_ = render_view_id;
+  if (is_after_stream_created_ && source_render_view_id_ != MSG_ROUTING_NONE) {
+    AudioMessageFilter* const filter =
+        static_cast<AudioMessageFilter*>(audio_output_ipc());
+    if (filter)
+      filter->AssociateStreamWithProducer(stream_id(), source_render_view_id_);
+  }
+}
+
+}  // namespace content
diff --git a/content/renderer/media/renderer_audio_output_device.h b/content/renderer/media/renderer_audio_output_device.h
new file mode 100644
index 000000000000..601cca508135
--- /dev/null
+++ b/content/renderer/media/renderer_audio_output_device.h
@@ -0,0 +1,58 @@
+// 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.
+
+#ifndef CONTENT_RENDERER_MEDIA_RENDERER_AUDIO_OUTPUT_DEVICE_H_
+#define CONTENT_RENDERER_MEDIA_RENDERER_AUDIO_OUTPUT_DEVICE_H_
+
+#include "base/memory/ref_counted.h"
+#include "media/audio/audio_output_device.h"
+
+namespace base {
+class MessageLoopProxy;
+}
+
+namespace content {
+
+class AudioDeviceFactory;
+class AudioMessageFilter;
+
+// Subclass of media::AudioOutputDevice to support additional concepts within
+// the content component.  Use AudioDeviceFactory to instantiate this class.
+class RendererAudioOutputDevice
+    : NON_EXPORTED_BASE(public media::AudioOutputDevice) {
+ public:
+  // Set the source of the rendered audio data to the RenderView specified by
+  // |render_view_id|.  Callers should keep in mind that the RenderView which
+  // caused the instantiation of RendererAudioOutputDevice might not necessarily
+  // be same as the RenderView which actually renders the audio data.
+  void SetSourceRenderView(int render_view_id);
+
+  virtual void Start() OVERRIDE;
+  virtual void Stop() OVERRIDE;
+
+ protected:
+  friend class AudioDeviceFactory;
+
+  // Creates an uninitialized RendererAudioOutputDevice.  Clients must call
+  // Initialize() before using.
+  RendererAudioOutputDevice(
+      AudioMessageFilter* message_filter,
+      const scoped_refptr<base::MessageLoopProxy>& io_loop);
+
+ private:
+  virtual ~RendererAudioOutputDevice();
+
+  void OnStart();
+  void OnStop();
+  void OnSourceChange(int render_view_id);
+
+  int source_render_view_id_;
+  bool is_after_stream_created_;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(RendererAudioOutputDevice);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_RENDERER_MEDIA_RENDERER_AUDIO_OUTPUT_DEVICE_H_
diff --git a/content/renderer/media/renderer_webaudiodevice_impl.cc b/content/renderer/media/renderer_webaudiodevice_impl.cc
index 4c72e8ca65b3..46920f735535 100644
--- a/content/renderer/media/renderer_webaudiodevice_impl.cc
+++ b/content/renderer/media/renderer_webaudiodevice_impl.cc
@@ -7,19 +7,38 @@
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "content/renderer/media/audio_device_factory.h"
+#include "content/renderer/media/renderer_audio_output_device.h"
+#include "content/renderer/render_view_impl.h"
 #include "media/base/media_switches.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 
 using WebKit::WebAudioDevice;
+using WebKit::WebFrame;
 using WebKit::WebVector;
+using WebKit::WebView;
 
 namespace content {
 
 RendererWebAudioDeviceImpl::RendererWebAudioDeviceImpl(
     const media::AudioParameters& params,
     WebAudioDevice::RenderCallback* callback)
-    : is_running_(false),
+    : params_(params),
       client_callback_(callback) {
-  audio_device_ = AudioDeviceFactory::NewOutputDevice();
+  DCHECK(client_callback_);
+}
+
+RendererWebAudioDeviceImpl::~RendererWebAudioDeviceImpl() {
+  DCHECK(!output_device_);
+}
+
+void RendererWebAudioDeviceImpl::start() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (output_device_)
+    return;  // Already started.
+
+  output_device_ = AudioDeviceFactory::NewOutputDevice();
 
   // TODO(crogers): remove once we properly handle input device selection.
   // https://code.google.com/p/chromium/issues/detail?id=147327
@@ -27,32 +46,41 @@ RendererWebAudioDeviceImpl::RendererWebAudioDeviceImpl(
       switches::kEnableWebAudioInput)) {
     // TODO(crogers): support more than hard-coded stereo:
     // https://code.google.com/p/chromium/issues/detail?id=147326
-    audio_device_->InitializeIO(params, 2, this);
+    output_device_->InitializeIO(params_, 2, this);
   } else {
-    audio_device_->Initialize(params, this);
+    output_device_->Initialize(params_, this);
   }
-}
-
-RendererWebAudioDeviceImpl::~RendererWebAudioDeviceImpl() {
-  stop();
-}
 
-void RendererWebAudioDeviceImpl::start() {
-  if (!is_running_) {
-    audio_device_->Start();
-    is_running_ = true;
+  // Assumption: This method is being invoked within a V8 call stack.  CHECKs
+  // will fail in the call to frameForCurrentContext() otherwise.
+  //
+  // Therefore, we can perform look-ups to determine which RenderView is
+  // starting the audio device.  The reason for all this is because the creator
+  // of the WebAudio objects might not be the actual source of the audio (e.g.,
+  // an extension creates a object that is passed and used within a page).
+  WebFrame* const web_frame = WebFrame::frameForCurrentContext();
+  WebView* const web_view = web_frame ? web_frame->view() : NULL;
+  RenderViewImpl* const render_view =
+      web_view ? RenderViewImpl::FromWebView(web_view) : NULL;
+  if (render_view) {
+    output_device_->SetSourceRenderView(render_view->routing_id());
   }
+
+  output_device_->Start();
+  // Note: Default behavior is to auto-play on start.
 }
 
 void RendererWebAudioDeviceImpl::stop() {
-  if (is_running_) {
-    audio_device_->Stop();
-    is_running_ = false;
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (output_device_) {
+    output_device_->Stop();
+    output_device_ = NULL;
   }
 }
 
 double RendererWebAudioDeviceImpl::sampleRate() {
-  return 44100.0;
+  return params_.sample_rate();
 }
 
 int RendererWebAudioDeviceImpl::Render(media::AudioBus* dest,
@@ -65,7 +93,6 @@ void RendererWebAudioDeviceImpl::RenderIO(media::AudioBus* source,
                                           media::AudioBus* dest,
                                           int audio_delay_milliseconds) {
   // Make the client callback for an I/O cycle.
-  DCHECK(client_callback_);
   if (client_callback_) {
     // Wrap the input pointers using WebVector.
     size_t input_channels =
diff --git a/content/renderer/media/renderer_webaudiodevice_impl.h b/content/renderer/media/renderer_webaudiodevice_impl.h
index 2e747c948ecc..fb58a2c7c453 100644
--- a/content/renderer/media/renderer_webaudiodevice_impl.h
+++ b/content/renderer/media/renderer_webaudiodevice_impl.h
@@ -6,12 +6,16 @@
 #define CONTENT_RENDERER_MEDIA_MEDIA_RENDERER_WEBAUDIODEVICE_IMPL_H_
 
 #include "base/memory/ref_counted.h"
+#include "base/threading/thread_checker.h"
+#include "media/audio/audio_parameters.h"
 #include "media/base/audio_renderer_sink.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebAudioDevice.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebVector.h"
 
 namespace content {
 
+class RendererAudioOutputDevice;
+
 class RendererWebAudioDeviceImpl
     : public WebKit::WebAudioDevice,
       public media::AudioRendererSink::RenderCallback {
@@ -36,11 +40,17 @@ class RendererWebAudioDeviceImpl
   virtual void OnRenderError() OVERRIDE;
 
  private:
-  scoped_refptr<media::AudioRendererSink> audio_device_;
-  bool is_running_;
+  const media::AudioParameters params_;
 
   // Weak reference to the callback into WebKit code.
-  WebKit::WebAudioDevice::RenderCallback* client_callback_;
+  WebKit::WebAudioDevice::RenderCallback* const client_callback_;
+
+  // To avoid the need for locking, ensure the control methods of the
+  // WebKit::WebAudioDevice implementation are called on the same thread.
+  base::ThreadChecker thread_checker_;
+
+  // When non-NULL, we are started.  When NULL, we are stopped.
+  scoped_refptr<RendererAudioOutputDevice> output_device_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererWebAudioDeviceImpl);
 };
diff --git a/content/renderer/media/webrtc_audio_capturer.cc b/content/renderer/media/webrtc_audio_capturer.cc
index 8340ae827f3c..ce714ba9e1f2 100644
--- a/content/renderer/media/webrtc_audio_capturer.cc
+++ b/content/renderer/media/webrtc_audio_capturer.cc
@@ -95,7 +95,7 @@ void WebRtcAudioCapturer::RemoveCapturerSink(WebRtcAudioCapturerSink* sink) {
 }
 
 void WebRtcAudioCapturer::SetCapturerSource(
-    media::AudioCapturerSource* source) {
+    const scoped_refptr<media::AudioCapturerSource>& source) {
   DVLOG(1) <<  "SetCapturerSource()";
   scoped_refptr<media::AudioCapturerSource> old_source;
   {
diff --git a/content/renderer/media/webrtc_audio_capturer.h b/content/renderer/media/webrtc_audio_capturer.h
index f01f8d0e27ca..c584a53e66c7 100644
--- a/content/renderer/media/webrtc_audio_capturer.h
+++ b/content/renderer/media/webrtc_audio_capturer.h
@@ -40,7 +40,8 @@ class WebRtcAudioCapturer
   // SetCapturerSource() is called if client on the source side desires to
   // provide their own captured audio data. Client is responsible for calling
   // Start() on its own source to have the ball rolling.
-  void SetCapturerSource(media::AudioCapturerSource* source);
+  void SetCapturerSource(
+      const scoped_refptr<media::AudioCapturerSource>& source);
 
   // Starts recording audio.
   void Start();
diff --git a/content/renderer/media/webrtc_audio_device_impl.cc b/content/renderer/media/webrtc_audio_device_impl.cc
index 811ed4178041..d1968d55c091 100644
--- a/content/renderer/media/webrtc_audio_device_impl.cc
+++ b/content/renderer/media/webrtc_audio_device_impl.cc
@@ -8,7 +8,6 @@
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/win/windows_version.h"
-#include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/media/audio_hardware.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
 #include "content/renderer/media/webrtc_audio_renderer.h"
diff --git a/content/renderer/media/webrtc_audio_device_unittest.cc b/content/renderer/media/webrtc_audio_device_unittest.cc
index ee160c9dbf37..a1730feb946d 100644
--- a/content/renderer/media/webrtc_audio_device_unittest.cc
+++ b/content/renderer/media/webrtc_audio_device_unittest.cc
@@ -27,6 +27,8 @@ namespace content {
 
 namespace {
 
+const int kRenderViewId = 1;
+
 class AudioUtil : public AudioUtilInterface {
  public:
   AudioUtil() {}
@@ -265,7 +267,8 @@ TEST_F(WebRTCAudioDeviceTest, StartPlayout) {
   EXPECT_CALL(media_observer(),
       OnDeleteAudioStream(_, 1)).Times(AnyNumber());
 
-  scoped_refptr<WebRtcAudioRenderer> renderer = new WebRtcAudioRenderer();
+  scoped_refptr<WebRtcAudioRenderer> renderer =
+      new WebRtcAudioRenderer(kRenderViewId);
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   webrtc_audio_device->SetSessionId(1);
@@ -414,8 +417,8 @@ TEST_F(WebRTCAudioDeviceTest, PlayLocalFile) {
   EXPECT_CALL(media_observer(),
       OnDeleteAudioStream(_, 1)).Times(AnyNumber());
 
-  scoped_refptr<WebRtcAudioRenderer> renderer = new WebRtcAudioRenderer();
-
+  scoped_refptr<WebRtcAudioRenderer> renderer =
+      new WebRtcAudioRenderer(kRenderViewId);
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   webrtc_audio_device->SetSessionId(1);
@@ -486,8 +489,8 @@ TEST_F(WebRTCAudioDeviceTest, FullDuplexAudioWithAGC) {
   EXPECT_CALL(media_observer(),
       OnDeleteAudioStream(_, 1)).Times(AnyNumber());
 
-  scoped_refptr<WebRtcAudioRenderer> renderer = new WebRtcAudioRenderer();
-
+  scoped_refptr<WebRtcAudioRenderer> renderer =
+      new WebRtcAudioRenderer(kRenderViewId);
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   webrtc_audio_device->SetSessionId(1);
diff --git a/content/renderer/media/webrtc_audio_renderer.cc b/content/renderer/media/webrtc_audio_renderer.cc
index 4c3427e459a2..2012d23aec7f 100644
--- a/content/renderer/media/webrtc_audio_renderer.cc
+++ b/content/renderer/media/webrtc_audio_renderer.cc
@@ -9,6 +9,7 @@
 #include "base/string_util.h"
 #include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/media/audio_hardware.h"
+#include "content/renderer/media/renderer_audio_output_device.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
 #include "media/audio/audio_util.h"
 #include "media/audio/sample_rates.h"
@@ -80,8 +81,9 @@ void AddHistogramFramesPerBuffer(int param) {
 
 }  // namespace
 
-WebRtcAudioRenderer::WebRtcAudioRenderer()
+WebRtcAudioRenderer::WebRtcAudioRenderer(int source_render_view_id)
     : state_(UNINITIALIZED),
+      source_render_view_id_(source_render_view_id),
       source_(NULL) {
 }
 
@@ -191,7 +193,7 @@ bool WebRtcAudioRenderer::Initialize(WebRtcAudioRendererSource* source) {
 
   // Configure the audio rendering client and start the rendering.
   sink_->Initialize(params_, this);
-
+  sink_->SetSourceRenderView(source_render_view_id_);
   sink_->Start();
 
   state_ = PAUSED;
diff --git a/content/renderer/media/webrtc_audio_renderer.h b/content/renderer/media/webrtc_audio_renderer.h
index 02bcbd13537c..28d5f42adb93 100644
--- a/content/renderer/media/webrtc_audio_renderer.h
+++ b/content/renderer/media/webrtc_audio_renderer.h
@@ -14,6 +14,7 @@
 
 namespace content {
 
+class RendererAudioOutputDevice;
 class WebRtcAudioRendererSource;
 
 // This renderer handles calls from the pipeline and WebRtc ADM. It is used
@@ -22,7 +23,7 @@ class CONTENT_EXPORT WebRtcAudioRenderer
     : NON_EXPORTED_BASE(public media::AudioRendererSink::RenderCallback),
       NON_EXPORTED_BASE(public webkit_media::MediaStreamAudioRenderer) {
  public:
-  WebRtcAudioRenderer();
+  explicit WebRtcAudioRenderer(int source_render_view_id);
 
   // Initialize function called by clients like WebRtcAudioDeviceImpl. Note,
   // Stop() has to be called before |source| is deleted.
@@ -53,8 +54,11 @@ class CONTENT_EXPORT WebRtcAudioRenderer
                      int audio_delay_milliseconds) OVERRIDE;
   virtual void OnRenderError() OVERRIDE;
 
+  // The render view in which the audio is rendered into |sink_|.
+  const int source_render_view_id_;
+
   // The sink (destination) for rendered audio.
-  scoped_refptr<media::AudioRendererSink> sink_;
+  scoped_refptr<RendererAudioOutputDevice> sink_;
 
   // Audio data source from the browser process.
   WebRtcAudioRendererSource* source_;
@@ -69,7 +73,7 @@ class CONTENT_EXPORT WebRtcAudioRenderer
   // Protect access to |state_|.
   base::Lock lock_;
 
-  DISALLOW_COPY_AND_ASSIGN(WebRtcAudioRenderer);
+  DISALLOW_IMPLICIT_CONSTRUCTORS(WebRtcAudioRenderer);
 };
 
 }  // namespace content
diff --git a/content/renderer/pepper/pepper_platform_audio_input_impl.cc b/content/renderer/pepper/pepper_platform_audio_input_impl.cc
index 94b9e922ce74..c1545798f14e 100644
--- a/content/renderer/pepper/pepper_platform_audio_input_impl.cc
+++ b/content/renderer/pepper/pepper_platform_audio_input_impl.cc
@@ -10,6 +10,7 @@
 #include "build/build_config.h"
 #include "content/common/child_process.h"
 #include "content/common/media/audio_messages.h"
+#include "content/renderer/media/audio_input_message_filter.h"
 #include "content/renderer/pepper/pepper_plugin_delegate_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/audio/audio_manager_base.h"
@@ -138,6 +139,7 @@ PepperPlatformAudioInputImpl::~PepperPlatformAudioInputImpl() {
 PepperPlatformAudioInputImpl::PepperPlatformAudioInputImpl()
     : client_(NULL),
       stream_id_(0),
+      render_view_id_(MSG_ROUTING_NONE),
       main_message_loop_proxy_(base::MessageLoopProxy::current()),
       shutdown_called_(false) {
   ipc_ = RenderThreadImpl::current()->audio_input_message_filter();
@@ -155,6 +157,7 @@ bool PepperPlatformAudioInputImpl::Initialize(
     return false;
 
   plugin_delegate_ = plugin_delegate;
+  render_view_id_ = plugin_delegate_->GetRoutingID();
   client_ = client;
 
   params_.Reset(media::AudioParameters::AUDIO_PCM_LINEAR,
@@ -202,8 +205,10 @@ void PepperPlatformAudioInputImpl::StartCaptureOnIOThread() {
   DCHECK(ChildProcess::current()->io_message_loop_proxy()->
       BelongsToCurrentThread());
 
-  if (stream_id_)
+  if (stream_id_) {
+    ipc_->AssociateStreamWithConsumer(stream_id_, render_view_id_);
     ipc_->RecordStream(stream_id_);
+  }
 }
 
 void PepperPlatformAudioInputImpl::StopCaptureOnIOThread() {
diff --git a/content/renderer/pepper/pepper_platform_audio_input_impl.h b/content/renderer/pepper/pepper_platform_audio_input_impl.h
index 864afa191d0e..5dac69663c55 100644
--- a/content/renderer/pepper/pepper_platform_audio_input_impl.h
+++ b/content/renderer/pepper/pepper_platform_audio_input_impl.h
@@ -21,6 +21,7 @@ class AudioParameters;
 
 namespace content {
 
+class AudioInputMessageFilter;
 class PepperPluginDelegateImpl;
 
 // PepperPlatformAudioInputImpl is operated on two threads: the main thread (the
@@ -93,12 +94,15 @@ class PepperPlatformAudioInputImpl
 
   // Used to send/receive IPC. THIS MUST ONLY BE ACCESSED ON THE
   // I/O thread except to send messages and get the message loop.
-  media::AudioInputIPC* ipc_;
+  scoped_refptr<AudioInputMessageFilter> ipc_;
 
   // Our ID on the MessageFilter. THIS MUST ONLY BE ACCESSED ON THE I/O THREAD
   // or else you could race with the initialize function which sets it.
   int32 stream_id_;
 
+  // The render view into which the audio is sent.
+  int render_view_id_;
+
   base::MessageLoopProxy* main_message_loop_proxy_;
 
   // THIS MUST ONLY BE ACCESSED ON THE MAIN THREAD.
diff --git a/content/renderer/pepper/pepper_platform_audio_output_impl.cc b/content/renderer/pepper/pepper_platform_audio_output_impl.cc
index ffed20ad081d..ecb833a0475c 100644
--- a/content/renderer/pepper/pepper_platform_audio_output_impl.cc
+++ b/content/renderer/pepper/pepper_platform_audio_output_impl.cc
@@ -22,10 +22,12 @@ namespace content {
 PepperPlatformAudioOutputImpl* PepperPlatformAudioOutputImpl::Create(
     int sample_rate,
     int frames_per_buffer,
+    int source_render_view_id,
     webkit::ppapi::PluginDelegate::PlatformAudioOutputClient* client) {
   scoped_refptr<PepperPlatformAudioOutputImpl> audio_output(
       new PepperPlatformAudioOutputImpl());
-  if (audio_output->Initialize(sample_rate, frames_per_buffer, client)) {
+  if (audio_output->Initialize(sample_rate, frames_per_buffer,
+                               source_render_view_id, client)) {
     // Balanced by Release invoked in
     // PepperPlatformAudioOutputImpl::ShutDownOnIOThread().
     return audio_output.release();
@@ -114,11 +116,9 @@ PepperPlatformAudioOutputImpl::PepperPlatformAudioOutputImpl()
 bool PepperPlatformAudioOutputImpl::Initialize(
     int sample_rate,
     int frames_per_buffer,
+    int source_render_view_id,
     webkit::ppapi::PluginDelegate::PlatformAudioOutputClient* client) {
   DCHECK(client);
-  // Make sure we don't call init more than once.
-  DCHECK_EQ(0, stream_id_);
-
   client_ = client;
 
   media::AudioParameters::Format format;
@@ -145,14 +145,19 @@ bool PepperPlatformAudioOutputImpl::Initialize(
   ChildProcess::current()->io_message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&PepperPlatformAudioOutputImpl::InitializeOnIOThread,
-                 this, params));
+                 this, params, source_render_view_id));
   return true;
 }
 
 void PepperPlatformAudioOutputImpl::InitializeOnIOThread(
-    const media::AudioParameters& params) {
+    const media::AudioParameters& params, int source_render_view_id) {
+  // Make sure we don't call init more than once.
+  DCHECK_EQ(0, stream_id_);
   stream_id_ = ipc_->AddDelegate(this);
+  DCHECK_NE(0, stream_id_);
+
   ipc_->CreateStream(stream_id_, params, 0);
+  ipc_->AssociateStreamWithProducer(stream_id_, source_render_view_id);
 }
 
 void PepperPlatformAudioOutputImpl::StartPlaybackOnIOThread() {
diff --git a/content/renderer/pepper/pepper_platform_audio_output_impl.h b/content/renderer/pepper/pepper_platform_audio_output_impl.h
index 5fab0e4af4b3..0be7588afd8b 100644
--- a/content/renderer/pepper/pepper_platform_audio_output_impl.h
+++ b/content/renderer/pepper/pepper_platform_audio_output_impl.h
@@ -20,6 +20,8 @@ class MessageLoopProxy;
 
 namespace content {
 
+class AudioMessageFilter;
+
 class PepperPlatformAudioOutputImpl
     : public webkit::ppapi::PluginDelegate::PlatformAudioOutput,
       public media::AudioOutputIPCDelegate,
@@ -30,6 +32,7 @@ class PepperPlatformAudioOutputImpl
   static PepperPlatformAudioOutputImpl* Create(
       int sample_rate,
       int frames_per_buffer,
+      int source_render_view_id,
       webkit::ppapi::PluginDelegate::PlatformAudioOutputClient* client);
 
   // PlatformAudioOutput implementation (called on main thread).
@@ -56,10 +59,12 @@ class PepperPlatformAudioOutputImpl
   bool Initialize(
       int sample_rate,
       int frames_per_buffer,
+      int source_render_view_id,
       webkit::ppapi::PluginDelegate::PlatformAudioOutputClient* client);
 
   // I/O thread backends to above functions.
-  void InitializeOnIOThread(const media::AudioParameters& params);
+  void InitializeOnIOThread(const media::AudioParameters& params,
+                            int source_render_view_id);
   void StartPlaybackOnIOThread();
   void StopPlaybackOnIOThread();
   void ShutDownOnIOThread();
@@ -70,7 +75,7 @@ class PepperPlatformAudioOutputImpl
 
   // Used to send/receive IPC. THIS MUST ONLY BE ACCESSED ON THE
   // I/O thread except to send messages and get the message loop.
-  media::AudioOutputIPC* ipc_;
+  scoped_refptr<AudioMessageFilter> ipc_;
 
   // Our ID on the MessageFilter. THIS MUST ONLY BE ACCESSED ON THE I/O THREAD
   // or else you could race with the initialize function which sets it.
diff --git a/content/renderer/pepper/pepper_plugin_delegate_impl.cc b/content/renderer/pepper/pepper_plugin_delegate_impl.cc
index 93dd75944118..e088c9660ed4 100644
--- a/content/renderer/pepper/pepper_plugin_delegate_impl.cc
+++ b/content/renderer/pepper/pepper_plugin_delegate_impl.cc
@@ -840,7 +840,8 @@ PepperPluginDelegateImpl::CreateAudioOutput(
     uint32_t sample_count,
     webkit::ppapi::PluginDelegate::PlatformAudioOutputClient* client) {
   return PepperPlatformAudioOutputImpl::Create(
-      static_cast<int>(sample_rate), static_cast<int>(sample_count), client);
+      static_cast<int>(sample_rate), static_cast<int>(sample_count),
+      GetRoutingID(), client);
 }
 
 webkit::ppapi::PluginDelegate::PlatformAudioInput*
diff --git a/content/renderer/render_view_impl.cc b/content/renderer/render_view_impl.cc
index b56a17eb6b24..bf789db64077 100644
--- a/content/renderer/render_view_impl.cc
+++ b/content/renderer/render_view_impl.cc
@@ -2575,7 +2575,7 @@ WebMediaPlayer* RenderViewImpl::createMediaPlayer(
   if (!cmd_line->HasSwitch(switches::kDisableAudio)) {
     // audio_source_provider is a "provider" to WebKit, and a sink
     // from the perspective of the audio renderer.
-    audio_source_provider = new RenderAudioSourceProvider();
+    audio_source_provider = new RenderAudioSourceProvider(routing_id_);
 
     // Add the chrome specific audio renderer, using audio_source_provider
     // as the sink.
diff --git a/content/test/webrtc_audio_device_test.cc b/content/test/webrtc_audio_device_test.cc
index 78013ad1e23d..72d94e597f26 100644
--- a/content/test/webrtc_audio_device_test.cc
+++ b/content/test/webrtc_audio_device_test.cc
@@ -20,7 +20,6 @@
 #include "content/public/common/content_paths.h"
 #include "content/public/test/mock_resource_context.h"
 #include "content/public/test/test_browser_thread.h"
-#include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/media/audio_hardware.h"
 #include "content/renderer/media/audio_input_message_filter.h"
 #include "content/renderer/media/audio_message_filter.h"
diff --git a/media/audio/audio_output_device.cc b/media/audio/audio_output_device.cc
index d09e32c4a77c..567c2f6661cc 100644
--- a/media/audio/audio_output_device.cc
+++ b/media/audio/audio_output_device.cc
@@ -47,20 +47,16 @@ AudioOutputDevice::AudioOutputDevice(
       input_channels_(0),
       callback_(NULL),
       ipc_(ipc),
-      stream_id_(0),
+      state_(IDLE),
       play_on_start_(true),
-      is_started_(false),
       stopping_hack_(false) {
   CHECK(ipc_);
+  stream_id_ = ipc_->AddDelegate(this);
 }
 
 void AudioOutputDevice::Initialize(const AudioParameters& params,
                                    RenderCallback* callback) {
-  CHECK_EQ(0, stream_id_) <<
-      "AudioOutputDevice::Initialize() must be called before Start()";
-
-  CHECK(!callback_);  // Calling Initialize() twice?
-
+  DCHECK(!callback_) << "Calling Initialize() twice?";
   audio_parameters_ = params;
   callback_ = callback;
 }
@@ -77,7 +73,10 @@ void AudioOutputDevice::InitializeIO(const AudioParameters& params,
 AudioOutputDevice::~AudioOutputDevice() {
   // The current design requires that the user calls Stop() before deleting
   // this class.
-  CHECK_EQ(0, stream_id_);
+  DCHECK(audio_thread_.IsStopped());
+
+  if (ipc_)
+    ipc_->RemoveDelegate(stream_id_);
 }
 
 void AudioOutputDevice::Start() {
@@ -123,49 +122,44 @@ bool AudioOutputDevice::SetVolume(double volume) {
 void AudioOutputDevice::CreateStreamOnIOThread(const AudioParameters& params,
                                                int input_channels) {
   DCHECK(message_loop()->BelongsToCurrentThread());
-  // Make sure we don't create the stream more than once.
-  DCHECK_EQ(0, stream_id_);
-  if (stream_id_)
-    return;
-
-  stream_id_ = ipc_->AddDelegate(this);
-  ipc_->CreateStream(stream_id_, params, input_channels);
+  if (state_ == IDLE) {
+    state_ = CREATING_STREAM;
+    ipc_->CreateStream(stream_id_, params, input_channels);
+  }
 }
 
 void AudioOutputDevice::PlayOnIOThread() {
   DCHECK(message_loop()->BelongsToCurrentThread());
-  if (stream_id_ && is_started_)
+  if (state_ == PAUSED) {
     ipc_->PlayStream(stream_id_);
-  else
+    state_ = PLAYING;
+    play_on_start_ = false;
+  } else {
     play_on_start_ = true;
+  }
 }
 
 void AudioOutputDevice::PauseOnIOThread(bool flush) {
   DCHECK(message_loop()->BelongsToCurrentThread());
-  if (stream_id_ && is_started_) {
+  if (state_ == PLAYING) {
     ipc_->PauseStream(stream_id_);
     if (flush)
       ipc_->FlushStream(stream_id_);
+    state_ = PAUSED;
   } else {
     // Note that |flush| isn't relevant here since this is the case where
     // the stream is first starting.
-    play_on_start_ = false;
   }
+  play_on_start_ = false;
 }
 
 void AudioOutputDevice::ShutDownOnIOThread() {
   DCHECK(message_loop()->BelongsToCurrentThread());
 
   // Make sure we don't call shutdown more than once.
-  if (stream_id_) {
-    is_started_ = false;
-
-    if (ipc_) {
-      ipc_->CloseStream(stream_id_);
-      ipc_->RemoveDelegate(stream_id_);
-    }
-
-    stream_id_ = 0;
+  if (state_ >= CREATING_STREAM) {
+    ipc_->CloseStream(stream_id_);
+    state_ = IDLE;
   }
 
   // We can run into an issue where ShutDownOnIOThread is called right after
@@ -185,7 +179,7 @@ void AudioOutputDevice::ShutDownOnIOThread() {
 
 void AudioOutputDevice::SetVolumeOnIOThread(double volume) {
   DCHECK(message_loop()->BelongsToCurrentThread());
-  if (stream_id_)
+  if (state_ >= PAUSED)
     ipc_->SetVolume(stream_id_, volume);
 }
 
@@ -193,7 +187,7 @@ void AudioOutputDevice::OnStateChanged(AudioOutputIPCDelegate::State state) {
   DCHECK(message_loop()->BelongsToCurrentThread());
 
   // Do nothing if the stream has been closed.
-  if (!stream_id_)
+  if (state_ < CREATING_STREAM)
     return;
 
   if (state == AudioOutputIPCDelegate::kError) {
@@ -222,12 +216,8 @@ void AudioOutputDevice::OnStreamCreated(
   DCHECK_GE(socket_handle, 0);
 #endif
 
-  // We should only get this callback if stream_id_ is valid.  If it is not,
-  // the IPC layer should have closed the shared memory and socket handles
-  // for us and not invoked the callback.  The basic assertion is that when
-  // stream_id_ is 0 the AudioOutputDevice instance is not registered as a
-  // delegate and hence it should not receive callbacks.
-  DCHECK(stream_id_);
+  if (state_ != CREATING_STREAM)
+    return;
 
   // We can receive OnStreamCreated() on the IO thread after the client has
   // called Stop() but before ShutDownOnIOThread() is processed. In such a
@@ -250,15 +240,17 @@ void AudioOutputDevice::OnStreamCreated(
       audio_parameters_, input_channels_, handle, length, callback_));
   audio_thread_.Start(audio_callback_.get(), socket_handle,
       "AudioOutputDevice");
+  state_ = PAUSED;
 
   // We handle the case where Play() and/or Pause() may have been called
   // multiple times before OnStreamCreated() gets called.
-  is_started_ = true;
   if (play_on_start_)
     PlayOnIOThread();
 }
 
 void AudioOutputDevice::OnIPCClosed() {
+  DCHECK(message_loop()->BelongsToCurrentThread());
+  state_ = IPC_CLOSED;
   ipc_ = NULL;
 }
 
diff --git a/media/audio/audio_output_device.h b/media/audio/audio_output_device.h
index fe4459cc5018..66500284d26d 100644
--- a/media/audio/audio_output_device.h
+++ b/media/audio/audio_output_device.h
@@ -99,8 +99,6 @@ class MEDIA_EXPORT AudioOutputDevice
 
   // Creates an uninitialized AudioOutputDevice. Clients must call Initialize()
   // before using.
-  // TODO(tommi): When all dependencies on |content| have been removed
-  // from AudioOutputDevice, move this class over to media/audio.
   AudioOutputDevice(AudioOutputIPC* ipc,
                     const scoped_refptr<base::MessageLoopProxy>& io_loop);
 
@@ -110,7 +108,20 @@ class MEDIA_EXPORT AudioOutputDevice
   friend class base::RefCountedThreadSafe<AudioOutputDevice>;
   virtual ~AudioOutputDevice();
 
+  // Accessors for subclasses (via IO thread only).
+  int stream_id() const { return stream_id_; }
+  AudioOutputIPC* audio_output_ipc() const { return ipc_; }
+
  private:
+  // Note: The ordering of members in this enum is critical to correct behavior!
+  enum State {
+    IPC_CLOSED,  // No more IPCs can take place.
+    IDLE,  // Not started.
+    CREATING_STREAM,  // Waiting for OnStreamCreated() to be called back.
+    PAUSED,  // Paused.  OnStreamCreated() has been called.  Can Play()/Stop().
+    PLAYING,  // Playing back.  Can Pause()/Stop().
+  };
+
   // Methods called on IO thread ----------------------------------------------
   // The following methods are tasks posted on the IO thread that needs to
   // be executed on that thread. They interact with AudioMessageFilter and
@@ -142,15 +153,13 @@ class MEDIA_EXPORT AudioOutputDevice
   // Must only be modified on the IO thread.
   int stream_id_;
 
+  // Current state (must only be accessed from the IO thread).  See comments for
+  // State enum above.
+  State state_;
+
   // State of Play() / Pause() calls before OnStreamCreated() is called.
   bool play_on_start_;
 
-  // Set to |true| when OnStreamCreated() is called.
-  // Set to |false| when ShutDownOnIOThread() is called.
-  // This is for use with play_on_start_ to track Play() / Pause() state.
-  // Must only be touched from the IO thread.
-  bool is_started_;
-
   // Our audio thread callback class.  See source file for details.
   class AudioThreadCallback;
 
diff --git a/media/audio/audio_output_device_unittest.cc b/media/audio/audio_output_device_unittest.cc
index 3952cf38d128..70e2a49c05f8 100644
--- a/media/audio/audio_output_device_unittest.cc
+++ b/media/audio/audio_output_device_unittest.cc
@@ -96,19 +96,9 @@ class AudioOutputDeviceTest
     : public testing::Test,
       public testing::WithParamInterface<bool> {
  public:
-  AudioOutputDeviceTest()
-      : default_audio_parameters_(AudioParameters::AUDIO_PCM_LINEAR,
-                                  CHANNEL_LAYOUT_STEREO,
-                                  48000, 16, 1024),
-        audio_device_(new AudioOutputDevice(
-            &audio_output_ipc_, io_loop_.message_loop_proxy())),
-        synchronized_io_(GetParam()),
-        input_channels_(synchronized_io_ ? 2 : 0) {
-  }
-
-  ~AudioOutputDeviceTest() {}
+  AudioOutputDeviceTest();
+  ~AudioOutputDeviceTest();
 
-  void Initialize();
   void StartAudioDevice();
   void CreateStream();
   void ExpectRenderCallback();
@@ -157,7 +147,18 @@ int AudioOutputDeviceTest::CalculateMemorySize() {
   return TotalSharedMemorySizeInBytes(io_buffer_size);
 }
 
-void AudioOutputDeviceTest::Initialize() {
+AudioOutputDeviceTest::AudioOutputDeviceTest()
+    : default_audio_parameters_(AudioParameters::AUDIO_PCM_LINEAR,
+                                CHANNEL_LAYOUT_STEREO,
+                                48000, 16, 1024),
+      synchronized_io_(GetParam()),
+      input_channels_(synchronized_io_ ? 2 : 0) {
+  EXPECT_CALL(audio_output_ipc_, AddDelegate(_))
+      .WillOnce(Return(kStreamId));
+
+  audio_device_ = new AudioOutputDevice(
+      &audio_output_ipc_, io_loop_.message_loop_proxy());
+
   if (synchronized_io_) {
     audio_device_->InitializeIO(default_audio_parameters_,
                                 input_channels_,
@@ -169,11 +170,15 @@ void AudioOutputDeviceTest::Initialize() {
   io_loop_.RunUntilIdle();
 }
 
+AudioOutputDeviceTest::~AudioOutputDeviceTest() {
+  EXPECT_CALL(audio_output_ipc_, RemoveDelegate(kStreamId));
+
+  audio_device_ = NULL;
+}
+
 void AudioOutputDeviceTest::StartAudioDevice() {
   audio_device_->Start();
 
-  EXPECT_CALL(audio_output_ipc_, AddDelegate(audio_device_.get()))
-      .WillOnce(Return(kStreamId));
   EXPECT_CALL(audio_output_ipc_, CreateStream(kStreamId, _, _));
 
   io_loop_.RunUntilIdle();
@@ -245,26 +250,24 @@ void AudioOutputDeviceTest::StopAudioDevice() {
   audio_device_->Stop();
 
   EXPECT_CALL(audio_output_ipc_, CloseStream(kStreamId));
-  EXPECT_CALL(audio_output_ipc_, RemoveDelegate(kStreamId));
 
   io_loop_.RunUntilIdle();
 }
 
 TEST_P(AudioOutputDeviceTest, Initialize) {
-  Initialize();
+  // Tests that the object can be constructed, initialized and destructed
+  // without having ever been started/stopped.
 }
 
 // Calls Start() followed by an immediate Stop() and check for the basic message
 // filter messages being sent in that case.
 TEST_P(AudioOutputDeviceTest, StartStop) {
-  Initialize();
   StartAudioDevice();
   StopAudioDevice();
 }
 
 // AudioOutputDevice supports multiple start/stop sequences.
 TEST_P(AudioOutputDeviceTest, StartStopStartStop) {
-  Initialize();
   StartAudioDevice();
   StopAudioDevice();
   StartAudioDevice();
@@ -274,7 +277,6 @@ TEST_P(AudioOutputDeviceTest, StartStopStartStop) {
 // Simulate receiving OnStreamCreated() prior to processing ShutDownOnIOThread()
 // on the IO loop.
 TEST_P(AudioOutputDeviceTest, StopBeforeRender) {
-  Initialize();
   StartAudioDevice();
 
   // Call Stop() but don't run the IO loop yet.
@@ -283,13 +285,11 @@ TEST_P(AudioOutputDeviceTest, StopBeforeRender) {
   // Expect us to shutdown IPC but not to render anything despite the stream
   // getting created.
   EXPECT_CALL(audio_output_ipc_, CloseStream(kStreamId));
-  EXPECT_CALL(audio_output_ipc_, RemoveDelegate(kStreamId));
   CreateStream();
 }
 
 // Full test with output only.
 TEST_P(AudioOutputDeviceTest, CreateStream) {
-  Initialize();
   StartAudioDevice();
   ExpectRenderCallback();
   CreateStream();
-- 
2.11.4.GIT