Integrate HTMLMediaElement with Web Audio API's MediaElementAudioSourceNode

RenderAudioSourceProvider implements WebKit::WebAudioSourceProvider using AudioRendererImpl

BUG=none
TEST=none
(tested locally)
Review URL: http://codereview.chromium.org/8980008

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@116643 0039d316-1c4b-4281-b951-d872f2087c98

14 files changed, 317 insertions, 69 deletions

diff --git a/content/content_renderer.gypi b/content/content_renderer.gypi
index 97f4afd..b75579d 100644
--- a/content/content_renderer.gypi
+++ b/content/content_renderer.gypi
@@ -139,6 +139,8 @@
     'renderer/pepper_plugin_delegate_impl.h',
     'renderer/plugin_channel_host.cc',
     'renderer/plugin_channel_host.h',
+    'renderer/render_audiosourceprovider.cc',
+    'renderer/render_audiosourceprovider.h',
     'renderer/render_process.h',
     'renderer/render_process_impl.cc',
     'renderer/render_process_impl.h',
diff --git a/content/public/renderer/content_renderer_client.h b/content/public/renderer/content_renderer_client.h
index c666fda..279d65b 100644
--- a/content/public/renderer/content_renderer_client.h
+++ b/content/public/renderer/content_renderer_client.h
@@ -18,6 +18,7 @@ class GURL;
 class SkBitmap;
 
 namespace WebKit {
+class WebAudioSourceProvider;
 class WebFrame;
 class WebMediaPlayerClient;
 class WebPlugin;
@@ -111,6 +112,7 @@ class ContentRendererClient {
       WebKit::WebMediaPlayerClient* client,
       base::WeakPtr<webkit_media::WebMediaPlayerDelegate> delegate,
       media::FilterCollection* collection,
+      WebKit::WebAudioSourceProvider* audio_source_provider,
       media::MessageLoopFactory* message_loop_factory,
       webkit_media::MediaStreamClient* media_stream_client,
       media::MediaLog* media_log,
diff --git a/content/renderer/media/audio_device.cc b/content/renderer/media/audio_device.cc
index f6ead33..75c2bad 100644
--- a/content/renderer/media/audio_device.cc
+++ b/content/renderer/media/audio_device.cc
@@ -62,6 +62,8 @@ void AudioDevice::Initialize(size_t buffer_size,
   CHECK_EQ(0, stream_id_) <<
       "AudioDevice::Initialize() must be called before Start()";
 
+  CHECK(!is_initialized_);
+
   buffer_size_ = buffer_size;
   channels_ = channels;
   sample_rate_ = sample_rate;
@@ -81,10 +83,6 @@ void AudioDevice::Initialize(size_t buffer_size,
   is_initialized_ = true;
 }
 
-bool AudioDevice::IsInitialized() {
-  return is_initialized_;
-}
-
 AudioDevice::~AudioDevice() {
   // The current design requires that the user calls Stop() before deleting
   // this class.
diff --git a/content/renderer/media/audio_device.h b/content/renderer/media/audio_device.h
index d8680c0..815a493 100644
--- a/content/renderer/media/audio_device.h
+++ b/content/renderer/media/audio_device.h
@@ -73,25 +73,13 @@
 #include "content/common/content_export.h"
 #include "content/renderer/media/audio_message_filter.h"
 #include "media/audio/audio_parameters.h"
+#include "media/base/audio_renderer_sink.h"
 
 class CONTENT_EXPORT AudioDevice
-    : public AudioMessageFilter::Delegate,
-      public base::DelegateSimpleThread::Delegate,
-      public base::RefCountedThreadSafe<AudioDevice> {
+    : public media::AudioRendererSink,
+      public AudioMessageFilter::Delegate,
+      public base::DelegateSimpleThread::Delegate {
  public:
-  class CONTENT_EXPORT RenderCallback {
-   public:
-    // Fills entire buffer of length |number_of_frames| but returns actual
-    // number of frames it got from its source (|number_of_frames| in case of
-    // continuous stream). That actual number of frames is passed to host
-    // together with PCM audio data and host is free to use or ignore it.
-    virtual size_t Render(const std::vector<float*>& audio_data,
-                          size_t number_of_frames,
-                          size_t audio_delay_milliseconds) = 0;
-   protected:
-    virtual ~RenderCallback() {}
-  };
-
   // Methods called on main render thread -------------------------------------
 
   // Minimal constructor where Initialize() must be called later.
@@ -103,38 +91,38 @@ class CONTENT_EXPORT AudioDevice
               RenderCallback* callback);
   virtual ~AudioDevice();
 
-  void Initialize(size_t buffer_size,
-                  int channels,
-                  double sample_rate,
-                  AudioParameters::Format latency_format,
-                  RenderCallback* callback);
-  bool IsInitialized();
+  // AudioRendererSink implementation.
 
+  virtual void Initialize(size_t buffer_size,
+                          int channels,
+                          double sample_rate,
+                          AudioParameters::Format latency_format,
+                          RenderCallback* callback) OVERRIDE;
   // Starts audio playback.
-  void Start();
+  virtual void Start() OVERRIDE;
 
   // Stops audio playback.
-  void Stop();
+  virtual void Stop() OVERRIDE;
 
   // Resumes playback if currently paused.
   // TODO(crogers): it should be possible to remove the extra complexity
   // of Play() and Pause() with additional re-factoring work in
   // AudioRendererImpl.
-  void Play();
+  virtual void Play() OVERRIDE;
 
   // Pauses playback.
   // If |flush| is true then any pending audio that is in the pipeline
   // (has not yet reached the hardware) will be discarded.  In this case,
   // when Play() is later called, no previous pending audio will be
   // rendered.
-  void Pause(bool flush);
+  virtual void Pause(bool flush) OVERRIDE;
 
   // Sets the playback volume, with range [0.0, 1.0] inclusive.
   // Returns |true| on success.
-  bool SetVolume(double volume);
+  virtual bool SetVolume(double volume) OVERRIDE;
 
   // Gets the playback volume, with range [0.0, 1.0] inclusive.
-  void GetVolume(double* volume);
+  virtual void GetVolume(double* volume) OVERRIDE;
 
   double sample_rate() const { return sample_rate_; }
   size_t buffer_size() const { return buffer_size_; }
diff --git a/content/renderer/media/audio_renderer_impl.cc b/content/renderer/media/audio_renderer_impl.cc
index ca905a0..eb54186 100644
--- a/content/renderer/media/audio_renderer_impl.cc
+++ b/content/renderer/media/audio_renderer_impl.cc
@@ -35,16 +35,12 @@ static size_t GetBufferSizeForSampleRate(int sample_rate) {
   return kNominalBufferSize * 4;
 }
 
-AudioRendererImpl::AudioRendererImpl()
+AudioRendererImpl::AudioRendererImpl(media::AudioRendererSink* sink)
     : AudioRendererBase(),
       bytes_per_second_(0),
-      stopped_(false) {
-  // We create the AudioDevice here because it must be created in the
-  // main thread.  But we don't yet know the audio format (sample-rate, etc.)
-  // at this point.  Later, when OnInitialize() is called, we have
-  // the audio format information and call the AudioDevice::Initialize()
-  // method to fully initialize it.
-  audio_device_ = new AudioDevice();
+      stopped_(false),
+      sink_(sink),
+      is_initialized_(false) {
 }
 
 AudioRendererImpl::~AudioRendererImpl() {
@@ -90,28 +86,30 @@ bool AudioRendererImpl::OnInitialize(int bits_per_channel,
 
   bytes_per_second_ = audio_parameters_.GetBytesPerSecond();
 
-  DCHECK(audio_device_.get());
+  DCHECK(sink_.get());
 
-  if (!audio_device_->IsInitialized()) {
-    audio_device_->Initialize(
+  if (!is_initialized_) {
+    sink_->Initialize(
         GetBufferSizeForSampleRate(sample_rate),
         audio_parameters_.channels,
         audio_parameters_.sample_rate,
         audio_parameters_.format,
         this);
 
-    audio_device_->Start();
+    sink_->Start();
+    is_initialized_ = true;
+    return true;
   }
 
-  return true;
+  return false;
 }
 
 void AudioRendererImpl::OnStop() {
   if (stopped_)
     return;
 
-  DCHECK(audio_device_.get());
-  audio_device_->Stop();
+  DCHECK(sink_.get());
+  sink_->Stop();
 
   stopped_ = true;
 }
@@ -169,27 +167,27 @@ void AudioRendererImpl::Play(const base::Closure& callback) {
 void AudioRendererImpl::SetVolume(float volume) {
   if (stopped_)
     return;
-  DCHECK(audio_device_.get());
-  audio_device_->SetVolume(volume);
+  DCHECK(sink_.get());
+  sink_->SetVolume(volume);
 }
 
 void AudioRendererImpl::DoPlay() {
   earliest_end_time_ = base::Time::Now();
-  DCHECK(audio_device_.get());
-  audio_device_->Play();
+  DCHECK(sink_.get());
+  sink_->Play();
 }
 
 void AudioRendererImpl::DoPause() {
-  DCHECK(audio_device_.get());
-  audio_device_->Pause(false);
+  DCHECK(sink_.get());
+  sink_->Pause(false);
 }
 
 void AudioRendererImpl::DoSeek() {
   earliest_end_time_ = base::Time::Now();
 
   // Pause and flush the stream when we seek to a new location.
-  DCHECK(audio_device_.get());
-  audio_device_->Pause(true);
+  DCHECK(sink_.get());
+  sink_->Pause(true);
 }
 
 size_t AudioRendererImpl::Render(const std::vector<float*>& audio_data,
diff --git a/content/renderer/media/audio_renderer_impl.h b/content/renderer/media/audio_renderer_impl.h
index f555b11..cc84a50 100644
--- a/content/renderer/media/audio_renderer_impl.h
+++ b/content/renderer/media/audio_renderer_impl.h
@@ -25,16 +25,18 @@
 #include "content/renderer/media/audio_device.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_parameters.h"
+#include "media/base/audio_renderer_sink.h"
 #include "media/filters/audio_renderer_base.h"
 
 class AudioMessageFilter;
 
 class CONTENT_EXPORT AudioRendererImpl
     : public media::AudioRendererBase,
-      public AudioDevice::RenderCallback {
+      public media::AudioRendererSink::RenderCallback {
  public:
   // Methods called on Render thread ------------------------------------------
-  AudioRendererImpl();
+  // An AudioRendererSink is used as the destination for the rendered audio.
+  explicit AudioRendererImpl(media::AudioRendererSink* sink);
   virtual ~AudioRendererImpl();
 
   // Methods called on pipeline thread ----------------------------------------
@@ -74,7 +76,7 @@ class CONTENT_EXPORT AudioRendererImpl
   void DoPause();
   void DoSeek();
 
-  // AudioDevice::RenderCallback implementation.
+  // media::AudioRendererSink::RenderCallback implementation.
   virtual size_t Render(const std::vector<float*>& audio_data,
                         size_t number_of_frames,
                         size_t audio_delay_milliseconds) OVERRIDE;
@@ -103,8 +105,11 @@ class CONTENT_EXPORT AudioRendererImpl
   // A flag that indicates this filter is called to stop.
   bool stopped_;
 
-  // audio_device_ is the sink (destination) for rendered audio.
-  scoped_refptr<AudioDevice> audio_device_;
+  // The sink (destination) for rendered audio.
+  scoped_refptr<media::AudioRendererSink> sink_;
+
+  // Set to true when OnInitialize() is called.
+  bool is_initialized_;
 
   // We're supposed to know amount of audio data OS or hardware buffered, but
   // that is not always so -- on my Linux box
diff --git a/content/renderer/media/audio_renderer_impl_unittest.cc b/content/renderer/media/audio_renderer_impl_unittest.cc
index 7a2895b..f760798 100644
--- a/content/renderer/media/audio_renderer_impl_unittest.cc
+++ b/content/renderer/media/audio_renderer_impl_unittest.cc
@@ -54,8 +54,8 @@ void WaitCallback(base::WaitableEvent* event) {
 // Class we would be testing.
 class TestAudioRendererImpl : public AudioRendererImpl {
  public:
-  explicit TestAudioRendererImpl()
-      : AudioRendererImpl() {
+  explicit TestAudioRendererImpl(media::AudioRendererSink* sink)
+      : AudioRendererImpl(sink) {
   }
 };
 
@@ -100,8 +100,12 @@ class AudioRendererImplTest
     EXPECT_CALL(*decoder_, samples_per_second())
         .WillRepeatedly(Return(44100));
 
+    // Create a sink for the audio renderer.
+    scoped_refptr<media::AudioRendererSink> default_sink =
+        new AudioDevice();
+
     // Create and initialize the audio renderer.
-    renderer_ = new TestAudioRendererImpl();
+    renderer_ = new TestAudioRendererImpl(default_sink.get());
     renderer_->Initialize(decoder_, media::NewExpectedClosure(),
                           NewUnderflowClosure());
 
diff --git a/content/renderer/mock_content_renderer_client.cc b/content/renderer/mock_content_renderer_client.cc
index c3c97fe..5a50a0e 100644
--- a/content/renderer/mock_content_renderer_client.cc
+++ b/content/renderer/mock_content_renderer_client.cc
@@ -47,6 +47,7 @@ bool MockContentRendererClient::OverrideCreateWebMediaPlayer(
     WebKit::WebMediaPlayerClient* client,
     base::WeakPtr<webkit_media::WebMediaPlayerDelegate> delegate,
     media::FilterCollection* collection,
+    WebKit::WebAudioSourceProvider* audio_source_provider,
     media::MessageLoopFactory* message_loop_factory,
     webkit_media::MediaStreamClient* media_stream_client,
     media::MediaLog* media_log,
diff --git a/content/renderer/mock_content_renderer_client.h b/content/renderer/mock_content_renderer_client.h
index 4bddf8d..7bd1c33 100644
--- a/content/renderer/mock_content_renderer_client.h
+++ b/content/renderer/mock_content_renderer_client.h
@@ -39,6 +39,7 @@ class MockContentRendererClient : public ContentRendererClient {
       WebKit::WebMediaPlayerClient* client,
       base::WeakPtr<webkit_media::WebMediaPlayerDelegate> delegate,
       media::FilterCollection* collection,
+      WebKit::WebAudioSourceProvider* audio_source_provider,
       media::MessageLoopFactory* message_loop_factory,
       webkit_media::MediaStreamClient* media_stream_client,
       media::MediaLog* media_log,
diff --git a/content/renderer/render_audiosourceprovider.cc b/content/renderer/render_audiosourceprovider.cc
new file mode 100644
index 0000000..6f070d5
--- /dev/null
+++ b/content/renderer/render_audiosourceprovider.cc
@@ -0,0 +1,148 @@
+// 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/render_audiosourceprovider.h"
+
+#include "base/basictypes.h"
+#include "base/logging.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebAudioSourceProviderClient.h"
+
+using std::vector;
+using WebKit::WebVector;
+
+RenderAudioSourceProvider::RenderAudioSourceProvider()
+    : is_initialized_(false),
+      channels_(0),
+      sample_rate_(0.0),
+      is_running_(false),
+      volume_(1.0),
+      renderer_(NULL),
+      client_(NULL) {
+  // We create the AudioDevice here because it must be created in the
+  // main thread.  But we don't yet know the audio format (sample-rate, etc.)
+  // at this point.  Later, when Initialize() is called, we have
+  // the audio format information and call the AudioDevice::Initialize()
+  // method to fully initialize it.
+  default_sink_ = new AudioDevice();
+}
+
+RenderAudioSourceProvider::~RenderAudioSourceProvider() {}
+
+void RenderAudioSourceProvider::Start() {
+  base::AutoLock auto_lock(sink_lock_);
+  if (!client_)
+    default_sink_->Start();
+  is_running_ = true;
+}
+
+void RenderAudioSourceProvider::Stop() {
+  base::AutoLock auto_lock(sink_lock_);
+  if (!client_)
+    default_sink_->Stop();
+  is_running_ = false;
+}
+
+void RenderAudioSourceProvider::Play() {
+  base::AutoLock auto_lock(sink_lock_);
+  if (!client_)
+    default_sink_->Play();
+  is_running_ = true;
+}
+
+void RenderAudioSourceProvider::Pause(bool flush) {
+  base::AutoLock auto_lock(sink_lock_);
+  if (!client_)
+    default_sink_->Pause(flush);
+  is_running_ = false;
+}
+
+bool RenderAudioSourceProvider::SetVolume(double volume) {
+  base::AutoLock auto_lock(sink_lock_);
+  if (!client_)
+    default_sink_->SetVolume(volume);
+  volume_ = volume;
+  return true;
+}
+
+void RenderAudioSourceProvider::GetVolume(double* volume) {
+  if (!client_)
+    default_sink_->GetVolume(volume);
+  else if (volume)
+    *volume = volume_;
+}
+
+void RenderAudioSourceProvider::Initialize(
+    size_t buffer_size,
+    int channels,
+    double sample_rate,
+    AudioParameters::Format latency_format,
+    RenderCallback* renderer) {
+  base::AutoLock auto_lock(sink_lock_);
+  CHECK(!is_initialized_);
+  renderer_ = renderer;
+
+  default_sink_->Initialize(buffer_size,
+                            channels,
+                            sample_rate,
+                            latency_format,
+                            renderer);
+
+  if (client_) {
+    // Inform WebKit about the audio stream format.
+    client_->setFormat(channels, sample_rate);
+  }
+
+  // Keep track of the format in case the client hasn't yet been set.
+  channels_ = channels;
+  sample_rate_ = sample_rate;
+  is_initialized_ = true;
+}
+
+void RenderAudioSourceProvider::setClient(
+    WebKit::WebAudioSourceProviderClient* client) {
+  // Synchronize with other uses of client_ and default_sink_.
+  base::AutoLock auto_lock(sink_lock_);
+
+  if (client && client != client_) {
+    // Detach the audio renderer from normal playback.
+    default_sink_->Pause(true);
+
+    // The client will now take control by calling provideInput() periodically.
+    client_ = client;
+
+    if (is_initialized_) {
+      // The client needs to be notified of the audio format, if available.
+      // If the format is not yet available, we'll be notified later
+      // when Initialize() is called.
+
+      // Inform WebKit about the audio stream format.
+      client->setFormat(channels_, sample_rate_);
+    }
+  } else if (!client && client_) {
+    // Restore normal playback.
+    client_ = NULL;
+    // TODO(crogers): We should call default_sink_->Play() if we're
+    // in the playing state.
+  }
+}
+
+void RenderAudioSourceProvider::provideInput(
+    const WebVector<float*>& audio_data, size_t number_of_frames) {
+  DCHECK(client_);
+
+  if (renderer_ && is_initialized_ && is_running_) {
+    // Wrap WebVector as std::vector.
+    vector<float*> v(audio_data.size());
+    for (size_t i = 0; i < audio_data.size(); ++i)
+      v[i] = audio_data[i];
+
+    // TODO(crogers): figure out if we should volume scale here or in common
+    // WebAudio code.  In any case we need to take care of volume.
+    renderer_->Render(v, number_of_frames, 0);
+  } else {
+    // Provide silence if the source is not running.
+    for (size_t i = 0; i < audio_data.size(); ++i)
+      memset(audio_data[i], 0, sizeof(float) * number_of_frames);
+  }
+}
diff --git a/content/renderer/render_audiosourceprovider.h b/content/renderer/render_audiosourceprovider.h
new file mode 100644
index 0000000..02f6b73
--- /dev/null
+++ b/content/renderer/render_audiosourceprovider.h
@@ -0,0 +1,88 @@
+// 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.
+//
+// RenderAudioSourceProvider provides a bridge between classes:
+//     WebKit::WebAudioSourceProvider <---> media::AudioRendererSink
+//
+// RenderAudioSourceProvider is a "sink" of audio, and uses a default
+// AudioDevice if a client has not explicitly been set.
+//
+// WebKit optionally sets a client, and then periodically calls provideInput()
+// to render a certain number of audio sample-frames.  provideInput()
+// uses the renderer to get this data, and then massages it into the form
+// required by provideInput().  In this case, the default AudioDevice
+// is no longer used.
+//
+// THREAD SAFETY:
+// It is assumed that the callers to setClient() and provideInput()
+// implement appropriate locking for thread safety when making
+// these calls.  This happens in WebKit.
+
+#ifndef CONTENT_RENDERER_RENDER_AUDIOSOURCEPROVIDER_H_
+#define CONTENT_RENDERER_RENDER_AUDIOSOURCEPROVIDER_H_
+
+#include <vector>
+
+#include "content/renderer/media/audio_device.h"
+#include "media/base/audio_renderer_sink.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebVector.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebAudioSourceProvider.h"
+
+namespace WebKit {
+class WebAudioSourceProviderClient;
+}
+
+class RenderAudioSourceProvider
+    : public WebKit::WebAudioSourceProvider,
+      public media::AudioRendererSink {
+ public:
+  RenderAudioSourceProvider();
+  virtual ~RenderAudioSourceProvider();
+
+  // WebKit::WebAudioSourceProvider implementation.
+
+  // WebKit calls setClient() if it desires to take control of the rendered
+  // audio stream.  We call client's setFormat() when the audio stream format
+  // is known.
+  virtual void setClient(WebKit::WebAudioSourceProviderClient* client);
+
+  // If setClient() has been called, then WebKit calls provideInput()
+  // periodically to get the rendered audio stream.
+  virtual void provideInput(const WebKit::WebVector<float*>& audio_data,
+                            size_t number_of_frames);
+
+  // AudioRendererSink implementation.
+  virtual void Start() OVERRIDE;
+  virtual void Stop() OVERRIDE;
+  virtual void Play() OVERRIDE;
+  virtual void Pause(bool flush) OVERRIDE;
+  virtual bool SetVolume(double volume) OVERRIDE;
+  virtual void GetVolume(double* volume) OVERRIDE;
+  virtual void Initialize(size_t buffer_size,
+                          int channels,
+                          double sample_rate,
+                          AudioParameters::Format latency_format,
+                          RenderCallback* renderer) OVERRIDE;
+
+ private:
+  // Set to true when Initialize() is called.
+  bool is_initialized_;
+  int channels_;
+  double sample_rate_;
+
+  bool is_running_;
+  double volume_;
+  media::AudioRendererSink::RenderCallback* renderer_;
+  WebKit::WebAudioSourceProviderClient* client_;
+
+  // Protects access to sink_
+  base::Lock sink_lock_;
+
+  // default_sink_ is the default sink.
+  scoped_refptr<media::AudioRendererSink> default_sink_;
+
+  DISALLOW_COPY_AND_ASSIGN(RenderAudioSourceProvider);
+};
+
+#endif  // CONTENT_RENDERER_RENDER_AUDIOSOURCEPROVIDER_H_
diff --git a/content/renderer/render_view_impl.cc b/content/renderer/render_view_impl.cc
index 515ef64..53f68bf 100644
--- a/content/renderer/render_view_impl.cc
+++ b/content/renderer/render_view_impl.cc
@@ -65,6 +65,7 @@
 #include "content/renderer/notification_provider.h"
 #include "content/renderer/p2p/socket_dispatcher.h"
 #include "content/renderer/plugin_channel_host.h"
+#include "content/renderer/render_audiosourceprovider.h"
 #include "content/renderer/render_process.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_widget_fullscreen_pepper.h"
@@ -1931,11 +1932,20 @@ WebMediaPlayer* RenderViewImpl::createMediaPlayer(
   media::FilterCollection* collection = new media::FilterCollection();
   RenderMediaLog* render_media_log = new RenderMediaLog();
 
+  RenderAudioSourceProvider* audio_source_provider = NULL;
+
   // Add in any custom filter factories first.
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   if (!cmd_line->HasSwitch(switches::kDisableAudio)) {
-    // Add the chrome specific audio renderer.
-    collection->AddAudioRenderer(new AudioRendererImpl());
+    // audio_source_provider is a "provider" to WebKit, and a sink
+    // from the perspective of the audio renderer.
+    audio_source_provider = new RenderAudioSourceProvider();
+
+    // Add the chrome specific audio renderer, using audio_source_provider
+    // as the sink.
+    AudioRendererImpl* audio_renderer =
+        new AudioRendererImpl(audio_source_provider);
+    collection->AddAudioRenderer(audio_renderer);
   }
 
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL)
@@ -1959,11 +1969,12 @@ WebMediaPlayer* RenderViewImpl::createMediaPlayer(
 
   webkit_media::WebMediaPlayerImpl* result_ptr;
   if (!content::GetContentClient()->renderer()->OverrideCreateWebMediaPlayer(
-      this, client, AsWeakPtr(), collection, message_loop_factory,
-      media_stream_impl_.get(), render_media_log, &result_ptr)) {
+      this, client, AsWeakPtr(), collection, audio_source_provider,
+      message_loop_factory, media_stream_impl_.get(), render_media_log,
+      &result_ptr)) {
     result_ptr = new webkit_media::WebMediaPlayerImpl(
-        client, AsWeakPtr(), collection, message_loop_factory,
-        media_stream_impl_.get(), render_media_log);
+        client, AsWeakPtr(), collection, audio_source_provider,
+        message_loop_factory, media_stream_impl_.get(), render_media_log);
   }
 
   DCHECK(result_ptr);
diff --git a/content/shell/shell_content_renderer_client.cc b/content/shell/shell_content_renderer_client.cc
index ac09373..ddf3c44 100644
--- a/content/shell/shell_content_renderer_client.cc
+++ b/content/shell/shell_content_renderer_client.cc
@@ -53,6 +53,7 @@ bool ShellContentRendererClient::OverrideCreateWebMediaPlayer(
     WebKit::WebMediaPlayerClient* client,
     base::WeakPtr<webkit_media::WebMediaPlayerDelegate> delegate,
     media::FilterCollection* collection,
+    WebKit::WebAudioSourceProvider* audio_source_provider,
     media::MessageLoopFactory* message_loop_factory,
     webkit_media::MediaStreamClient* media_stream_client,
     media::MediaLog* media_log,
diff --git a/content/shell/shell_content_renderer_client.h b/content/shell/shell_content_renderer_client.h
index 36d428e..e0cdc87 100644
--- a/content/shell/shell_content_renderer_client.h
+++ b/content/shell/shell_content_renderer_client.h
@@ -36,6 +36,7 @@ class ShellContentRendererClient : public ContentRendererClient {
       WebKit::WebMediaPlayerClient* client,
       base::WeakPtr<webkit_media::WebMediaPlayerDelegate> delegate,
       media::FilterCollection* collection,
+      WebKit::WebAudioSourceProvider* audio_source_provider,
       media::MessageLoopFactory* message_loop_factory,
       webkit_media::MediaStreamClient* media_stream_client,
       media::MediaLog* media_log,