Support for AudioContextOptions latencyHint.

content/renderer/media/renderer_webaudiodevice_impl_unittest.cc

Index: content/renderer/media/renderer_webaudiodevice_impl_unittest.cc
diff --git a/content/renderer/media/renderer_webaudiodevice_impl_unittest.cc b/content/renderer/media/renderer_webaudiodevice_impl_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..795c0fa00fc0f59e1bbcc718e0c6d96314cd3826
--- /dev/null
+++ b/content/renderer/media/renderer_webaudiodevice_impl_unittest.cc
@@ -0,0 +1,167 @@
+// Copyright 2016 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_webaudiodevice_impl.h"
+
+#include "base/bind.h"
+#include "content/renderer/media/audio_device_factory.h"
+#include "media/base/audio_capturer_source.h"
+#include "media/base/mock_audio_renderer_sink.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using testing::_;
+
+namespace content {
+
+namespace {
+
+const int kHardwareSampleRate = 44100;
+const int kHardwareBufferSize = 128;
+const int kRenderFrameId = 100;
+
+int MockFrameIdFromCurrentContext() {
+  return kRenderFrameId;
+}
+
+media::AudioParameters MockGetOutputDeviceParameters(
+    int frame_id,
+    int session_id,
+    const std::string& device_id,
+    const url::Origin& security_origin) {
+  return media::AudioParameters(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
+                                media::CHANNEL_LAYOUT_STEREO,
+                                kHardwareSampleRate, 16, kHardwareBufferSize);
+}
+
+class RendererWebAudioDeviceImplUnderTest : public RendererWebAudioDeviceImpl {
+ public:
+  RendererWebAudioDeviceImplUnderTest(
+      media::ChannelLayout layout,
+      const blink::WebAudioLatencyHint& latency_hint,
+      blink::WebAudioDevice::RenderCallback* callback,
+      int session_id,
+      const url::Origin& security_origin)
+      : RendererWebAudioDeviceImpl(layout,
+                                   latency_hint,
+                                   callback,
+                                   session_id,
+                                   security_origin,
+                                   base::Bind(&MockGetOutputDeviceParameters),
+                                   base::Bind(&MockFrameIdFromCurrentContext)) {
+  }
+};
+
+}  // namespace
+
+class RendererWebAudioDeviceImplTest
+    : public blink::WebAudioDevice::RenderCallback,
+      public AudioDeviceFactory,
+      public testing::Test {
+ public:
+  MOCK_METHOD3(render,
+               void(const blink::WebVector<float*>& sourceData,
+                    const blink::WebVector<float*>& destinationData,
+                    size_t numberOfFrames));
+
+ protected:
+  RendererWebAudioDeviceImplTest() {}
+
+  void SetupDevice(blink::WebAudioLatencyHint latencyHint) {
+    webaudio_device_.reset(new RendererWebAudioDeviceImplUnderTest(
+        media::CHANNEL_LAYOUT_MONO, latencyHint, this, 0, url::Origin()));
+  }
+
+  MOCK_METHOD1(CreateAudioCapturerSource,
+               scoped_refptr<media::AudioCapturerSource>(int));
+  MOCK_METHOD4(CreateFinalAudioRendererSink,
+               scoped_refptr<media::AudioRendererSink>(int,
+                                                       int,
+                                                       const std::string&,
+                                                       const url::Origin&));
+  MOCK_METHOD5(
+      CreateSwitchableAudioRendererSink,
+      scoped_refptr<media::SwitchableAudioRendererSink>(SourceType,
+                                                        int,
+                                                        int,
+                                                        const std::string&,
+                                                        const url::Origin&));
+
+  scoped_refptr<media::AudioRendererSink> CreateAudioRendererSink(
+      SourceType source_type,
+      int render_frame_id,
+      int session_id,
+      const std::string& device_id,
+      const url::Origin& security_origin) {
+    mock_sink_ = new media::MockAudioRendererSink(
+        device_id, media::OUTPUT_DEVICE_STATUS_OK,
+        MockGetOutputDeviceParameters(render_frame_id, session_id, device_id,
+                                      security_origin));
+
+    EXPECT_CALL(*mock_sink_.get(), Start());
+    EXPECT_CALL(*mock_sink_.get(), Play());
+    EXPECT_CALL(*mock_sink_.get(), Stop());
+
+    return mock_sink_;
+  }
+
+  void TearDown() override {
+    webaudio_device_.reset();
+    mock_sink_ = nullptr;
+  }
+
+  std::unique_ptr<RendererWebAudioDeviceImpl> webaudio_device_;
+  scoped_refptr<media::MockAudioRendererSink> mock_sink_;
+};
+
+TEST_F(RendererWebAudioDeviceImplTest, TestLatencyHint) {
+  SetupDevice(blink::WebAudioLatencyHint(
+      blink::WebAudioLatencyHint::CategoryInteractive));
+  int interactive_frames = webaudio_device_->framesPerBuffer();
+  media::AudioLatency::LatencyType interactive_latency =
+      webaudio_device_->latencyType();
+
+  SetupDevice(
+      blink::WebAudioLatencyHint(blink::WebAudioLatencyHint::CategoryBalanced));
+  int balanced_frames = webaudio_device_->framesPerBuffer();
+  media::AudioLatency::LatencyType balanced_latency =
+      webaudio_device_->latencyType();
+
+  SetupDevice(
+      blink::WebAudioLatencyHint(blink::WebAudioLatencyHint::CategoryPlayback));
+  int playback_frames = webaudio_device_->framesPerBuffer();
+  media::AudioLatency::LatencyType playback_latency =
+      webaudio_device_->latencyType();
+
+  EXPECT_GE(playback_frames, balanced_frames);
+  EXPECT_GE(balanced_frames, interactive_frames);
+
+  EXPECT_GT(playback_latency, balanced_latency);
+  EXPECT_GT(balanced_latency, interactive_latency);
+}
+
+TEST_F(RendererWebAudioDeviceImplTest, TestStartStopValues) {
+  SetupDevice(blink::WebAudioLatencyHint(
+      blink::WebAudioLatencyHint::CategoryInteractive));
+  EXPECT_EQ(webaudio_device_->sampleRate(), kHardwareSampleRate);
+  EXPECT_EQ(webaudio_device_->framesPerBuffer(), kHardwareBufferSize);

[o1ka, 2016/12/08 10:57:19]

Here and below: shouldn't WAD return latency-dependent buffer size?

[Andrew MacPherson, 2016/12/08 12:22:54]

Yes you're right, I was cutting a corner since the interactive size is currently
the same as the hardware buffer size but have updated this correctly now. :)

[o1ka, 2016/12/08 13:10:16]

Could you check it for each latency type, so that we are sure that we do not mix
up hardware buffer size and sink buffer size at any stage? It may worth
combining TestLatencyHint and this one

[Andrew MacPherson, 2016/12/08 13:53:53]

No problem, done. The code for checking each type could be refactored out into a
function that each type calls but I like that the failure message now gives a
line number that points to exactly which type is failing, let me know if this is
not recommended though.

+
+  webaudio_device_->start();
+  EXPECT_EQ(webaudio_device_->sampleRate(), kHardwareSampleRate);
+  EXPECT_EQ(webaudio_device_->framesPerBuffer(), kHardwareBufferSize);
+
+  webaudio_device_->stop();
+  EXPECT_EQ(webaudio_device_->sampleRate(), kHardwareSampleRate);
+  EXPECT_EQ(webaudio_device_->framesPerBuffer(), kHardwareBufferSize);
+
+  webaudio_device_->start();
+  EXPECT_EQ(webaudio_device_->sampleRate(), kHardwareSampleRate);
+  EXPECT_EQ(webaudio_device_->framesPerBuffer(), kHardwareBufferSize);
+
+  webaudio_device_->stop();
+  EXPECT_EQ(webaudio_device_->sampleRate(), kHardwareSampleRate);
+  EXPECT_EQ(webaudio_device_->framesPerBuffer(), kHardwareBufferSize);
+}
+
+}  // namespace content