Integrate HTMLMediaElement with Web Audio API's MediaElementAudioSourceNode

content/renderer/media/audio_renderer_impl_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
@@ skipping 36 matching lines @@
 // This callback can be posted on the IO thread and will signal an event when
 // done. The caller can then wait for this signal to ensure that no
 // additional tasks remain in the task queue.
 void WaitCallback(base::WaitableEvent* event) {
   event->Signal();
 }
 
 // Class we would be testing.
 class TestAudioRendererImpl : public AudioRendererImpl {
  public:
-  explicit TestAudioRendererImpl()
-      : AudioRendererImpl() {
+  explicit TestAudioRendererImpl(media::AudioRendererSink* sink)
+      : AudioRendererImpl(sink) {
   }
 };
 
 class AudioRendererImplTest
     : public ::testing::Test,
       public IPC::Channel::Listener {
  public:
   // IPC::Channel::Listener implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) {
       NOTIMPLEMENTED();
@@ skipping 24 matching lines @@
     // Setup expectations for initialization.
     decoder_ = new media::MockAudioDecoder();
 
     EXPECT_CALL(*decoder_, bits_per_channel())
         .WillRepeatedly(Return(16));
     EXPECT_CALL(*decoder_, channel_layout())
         .WillRepeatedly(Return(CHANNEL_LAYOUT_MONO));
     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());
 
     // We need an event to verify that all tasks are done before leaving
     // our tests.
     event_.reset(new base::WaitableEvent(false, false));
   }
 
   virtual void TearDown() {
     mock_process_.reset();
@@ skipping 59 matching lines @@
   base::Time time_now = base::Time();  // Null time by default.
   renderer_->set_earliest_end_time(time_now);
   renderer_->UpdateEarliestEndTime(renderer_->bytes_per_second(),
                                    base::TimeDelta::FromMilliseconds(100),
                                    time_now);
   int time_delta = (renderer_->earliest_end_time() - time_now).InMilliseconds();
   EXPECT_EQ(1100, time_delta);
   renderer_->Stop(media::NewExpectedClosure());
   WaitForIOThreadCompletion();
 }