media::WebAudioSourceProviderImpl, add support for getting a copy of passing AudioBuses

media/blink/webaudiosourceprovider_impl_unittest.cc

 // Copyright 2013 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 <stddef.h>
 
+#include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/fake_audio_render_callback.h"
 #include "media/base/mock_audio_renderer_sink.h"
 #include "media/blink/webaudiosourceprovider_impl.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebAudioSourceProviderClient.h"
 
+using ::testing::_;
+
 namespace media {
 
 namespace {
 const float kTestVolume = 0.25;
 }  // namespace
 
 class WebAudioSourceProviderImplTest
     : public testing::Test,
       public blink::WebAudioSourceProviderClient {
  public:
@@ skipping 50 matching lines @@
                  sizeof(*bus1->channel(ch)) * bus1->frames()) != 0) {
         return false;
       }
     }
     return true;
   }
 
   // blink::WebAudioSourceProviderClient implementation.
   MOCK_METHOD2(setFormat, void(size_t numberOfChannels, float sampleRate));
 
+  // OnAudioBusCB
+  MOCK_METHOD2(DoOnAudioBusCB, void(AudioBus*, uint32_t delay_milliseconds));
+  void OnAudioBus(scoped_ptr<AudioBus> bus, uint32_t delay_milliseconds) {
+    DoOnAudioBusCB(bus.get(), delay_milliseconds);
+  }
+
  protected:
   AudioParameters params_;
   FakeAudioRenderCallback fake_callback_;
   scoped_refptr<MockAudioRendererSink> mock_sink_;
   scoped_refptr<WebAudioSourceProviderImpl> wasp_impl_;
   base::MessageLoop message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(WebAudioSourceProviderImplTest);
 };
 
@@ skipping 12 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   // setClient() with the same client should do nothing.
   wasp_impl_->setClient(this);
   base::RunLoop().RunUntilIdle();
 }
 
 // Verify AudioRendererSink functionality w/ and w/o a client.
 TEST_F(WebAudioSourceProviderImplTest, SinkMethods) {
   wasp_impl_->Initialize(params_, &fake_callback_);
-  ASSERT_EQ(mock_sink_->callback(), &fake_callback_);
+  // Callbacks: |mock_sink_| uses |wasp_impl_| that uses |fake_callback_|.
+  ASSERT_EQ(mock_sink_->callback(), wasp_impl_.get());
 
   // Without a client all WASP calls should fall through to the underlying sink.
   CallAllSinkMethodsAndVerify(true);
 
   // With a client no calls should reach the Stop()'d sink.  Also, setClient()
   // should propagate the params provided during Initialize() at call time.
   SetClient(this);
   CallAllSinkMethodsAndVerify(false);
 
   // Removing the client should cause WASP to revert to the underlying sink.
@@ skipping 102 matching lines @@
   ASSERT_TRUE(CompareBusses(bus1.get(), bus2.get()));
 
   // Stop() should return silence.
   wasp_impl_->Stop();
   bus1->channel(0)[0] = 1;
   bus2->Zero();
   wasp_impl_->provideInput(audio_data, params_.frames_per_buffer());
   ASSERT_TRUE(CompareBusses(bus1.get(), bus2.get()));
 }
 
+// Verify OnAudioBusCB is called if registered.
+TEST_F(WebAudioSourceProviderImplTest, OnAudioBusCallback) {
+  testing::InSequence s;
+  wasp_impl_->Initialize(params_, &fake_callback_);
+  wasp_impl_->RegisterOnAudioBusCallback(base::Bind(
+      &WebAudioSourceProviderImplTest::OnAudioBus, base::Unretained(this)));
+
+  const scoped_ptr<AudioBus> bus1 = AudioBus::Create(params_);
+  const uint32_t kDelayMilliseconds = 3;
+  EXPECT_CALL(*this, DoOnAudioBusCB(_, kDelayMilliseconds)).Times(1);
+  wasp_impl_->Render(bus1.get(), kDelayMilliseconds, 0 /* frames_skipped */);
+
+  wasp_impl_->ResetOnAudioBusCallback();
+  EXPECT_CALL(*this, DoOnAudioBusCB(_, _)).Times(0);
+  wasp_impl_->Render(bus1.get(), 0 /* delay_milliseconds */,
+                     0 /* frames_skipped */);
+
+  testing::Mock::VerifyAndClear(mock_sink_.get());
+}
+
 }  // namespace media