Switch LiveAudio to source provider solution.

content/renderer/media/webrtc_local_audio_source_provider_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 "base/logging.h"
+#include "content/renderer/media/webrtc_local_audio_source_provider.h"
+#include "media/audio/audio_parameters.h"
+#include "media/base/audio_bus.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace content {
+
+class WebRtcLocalAudioSourceProviderTest : public testing::Test {
+ protected:
+  virtual void SetUp() OVERRIDE {
+    source_params_.Reset(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
+                         media::CHANNEL_LAYOUT_MONO, 1, 0, 48000, 16, 480);
+    sink_params_.Reset(
+        media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
+        media::CHANNEL_LAYOUT_STEREO, 2, 0, 44100, 16,
+        WebRtcLocalAudioSourceProvider::kWebAudioRenderBufferSize);
+    source_bus_ = media::AudioBus::Create(source_params_);
+    sink_bus_ = media::AudioBus::Create(sink_params_);
+    source_provider_.reset(new WebRtcLocalAudioSourceProvider());
+    source_provider_->SetSinkParamsForTesting(sink_params_);
+    source_provider_->Initialize(source_params_);
+  }
+
+  media::AudioParameters source_params_;
+  media::AudioParameters sink_params_;
+  scoped_ptr<media::AudioBus> source_bus_;
+  scoped_ptr<media::AudioBus> sink_bus_;
+  scoped_ptr<WebRtcLocalAudioSourceProvider> source_provider_;
+};
+
+TEST_F(WebRtcLocalAudioSourceProviderTest, VerifyDataFlow) {
+  // Point the WebVector into memory owned by |sink_bus_|.
+  WebKit::WebVector<float*> audio_data(
+      static_cast<size_t>(sink_bus_->channels()));
+  for (size_t i = 0; i < audio_data.size(); ++i)
+    audio_data[i] = sink_bus_->channel(i);
+
+  // Enable the |source_provider_| by asking for data. This will inject
+  // source_params_.frames_per_buffer() of zero into the resampler since there
+  // no available data in the FIFO.
+  source_provider_->provideInput(audio_data, sink_params_.frames_per_buffer());
+  EXPECT_TRUE(sink_bus_->channel(0)[0] == 0);
+
+  // Set the value of source data to be 1.
+  for (int i = 0; i < source_params_.frames_per_buffer(); ++i) {
+    source_bus_->channel(0)[i] = 1;
+  }
+
+  // Deliver data to |source_provider_|.
+  source_provider_->DeliverData(source_bus_.get(), 0, 0, false);
+
+  // Consume the first packet in the resampler, which contains only zero.
+  // And the consumption of the data will trigger pulling the real packet from
+  // the source provider FIFO into the resampler.
+  // Note that we need to count in the provideInput() call a few lines above.
+  for (int i = sink_params_.frames_per_buffer();
+       i < source_params_.frames_per_buffer();
+       i += sink_params_.frames_per_buffer()) {
+    sink_bus_->Zero();
+    source_provider_->provideInput(audio_data,
+                                   sink_params_.frames_per_buffer());
+    EXPECT_DOUBLE_EQ(0.0, sink_bus_->channel(0)[0]);
+    EXPECT_DOUBLE_EQ(0.0, sink_bus_->channel(1)[0]);
+  }
+
+  // Prepare the second packet for featching.
+  source_provider_->DeliverData(source_bus_.get(), 0, 0, false);
+
+  // Verify the packets.
+  for (int i = 0; i < source_params_.frames_per_buffer();
+       i += sink_params_.frames_per_buffer()) {
+    sink_bus_->Zero();
+    source_provider_->provideInput(audio_data,
+                                   sink_params_.frames_per_buffer());
+    EXPECT_GT(sink_bus_->channel(0)[0], 0);
+    EXPECT_GT(sink_bus_->channel(1)[0], 0);
+    EXPECT_DOUBLE_EQ(sink_bus_->channel(0)[0], sink_bus_->channel(1)[0]);
+  }
+}
+
+TEST_F(WebRtcLocalAudioSourceProviderTest, VerifyAudioProcessingParams) {
+  // Point the WebVector into memory owned by |sink_bus_|.
+  WebKit::WebVector<float*> audio_data(
+      static_cast<size_t>(sink_bus_->channels()));
+  for (size_t i = 0; i < audio_data.size(); ++i)
+    audio_data[i] = sink_bus_->channel(i);
+
+  // Enable the source provider.
+  source_provider_->provideInput(audio_data, sink_params_.frames_per_buffer());
+
+  // Deliver data to |source_provider_| with audio processing params.
+  int source_delay = 5;
+  int source_volume = 255;
+  bool source_key_pressed = true;
+  source_provider_->DeliverData(source_bus_.get(), source_delay,
+                                source_volume, source_key_pressed);
+
+  int delay = 0, volume = 0;
+  bool key_pressed = false;
+  source_provider_->GetAudioProcessingParams(&delay, &volume, &key_pressed);
+  EXPECT_EQ(volume, source_volume);
+  EXPECT_EQ(key_pressed, source_key_pressed);
+  int expected_delay = source_delay + static_cast<int>(
+      source_bus_->frames() / source_params_.sample_rate() + 0.5);
+  EXPECT_GE(delay, expected_delay);
+
+  // Sleep a few ms to simulate processing time. This should increase the delay
+  // value as time passes.
+  int cached_delay = delay;
+  const int kSleepMs = 10;
+  base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(kSleepMs));
+  source_provider_->GetAudioProcessingParams(&delay, &volume, &key_pressed);
+  EXPECT_GT(delay, cached_delay);
+}
+
+}  // namespace content