Used 10ms native buffer size for webrtc audio renderer on Linux and Mac

content/renderer/media/webrtc_audio_renderer_unittest.cc

 // Copyright 2014 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 <vector>
 
 #include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/media/audio_message_filter.h"
 #include "content/renderer/media/media_stream_audio_renderer.h"
 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
 #include "content/renderer/media/webrtc_audio_renderer.h"
 #include "media/audio/audio_output_device.h"
 #include "media/audio/audio_output_ipc.h"
 #include "media/base/audio_bus.h"
 #include "media/base/mock_audio_renderer_sink.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h"
 
 using testing::Return;
 
 namespace content {
 
 namespace {
 
+const int kHardwareSampleRate = 44100;
+const int kHardwareBufferSize = 512;
+
 class MockAudioOutputIPC : public media::AudioOutputIPC {
  public:
   MockAudioOutputIPC() {}
   virtual ~MockAudioOutputIPC() {}
 
   MOCK_METHOD3(CreateStream, void(media::AudioOutputIPCDelegate* delegate,
                                   const media::AudioParameters& params,
                                   int session_id));
   MOCK_METHOD0(PlayStream, void());
   MOCK_METHOD0(PauseStream, void());
@@ skipping 44 matching lines @@
  protected:
   WebRtcAudioRendererTest()
       : message_loop_(new base::MessageLoopForIO),
         mock_ipc_(new MockAudioOutputIPC()),
         mock_output_device_(new FakeAudioOutputDevice(
             scoped_ptr<media::AudioOutputIPC>(mock_ipc_),
             message_loop_->message_loop_proxy())),
         factory_(new MockAudioDeviceFactory()),
         source_(new MockAudioRendererSource()),
         stream_(new rtc::RefCountedObject<MockMediaStream>("label")),
-        renderer_(new WebRtcAudioRenderer(stream_, 1, 1, 1, 44100, 441)) {
+        renderer_(new WebRtcAudioRenderer(stream_, 1, 1, 1, 44100,
+                                          kHardwareBufferSize)) {
     EXPECT_CALL(*factory_.get(), CreateOutputDevice(1))
         .WillOnce(Return(mock_output_device_.get()));
     EXPECT_CALL(*mock_output_device_.get(), Start());
     EXPECT_TRUE(renderer_->Initialize(source_.get()));
     renderer_proxy_ = renderer_->CreateSharedAudioRendererProxy(stream_);
   }
 
   // Used to construct |mock_output_device_|.
   scoped_ptr<base::MessageLoopForIO> message_loop_;
   MockAudioOutputIPC* mock_ipc_;  // Owned by AudioOuputDevice.
@@ skipping 42 matching lines @@
       EXPECT_CALL(*mock_output_device_.get(), Stop()).Times(0);
     } else {
       // When the last proxy is stopped, the sink will stop.
       EXPECT_CALL(*source_.get(), RemoveAudioRenderer(renderer_.get()));
       EXPECT_CALL(*mock_output_device_.get(), Stop());
     }
     renderer_proxies_[i]->Stop();
   }
 }
 
+// Verify that the sink of the renderer is using the expected sample rate and
+// buffer size.
+TEST_F(WebRtcAudioRendererTest, VerifySinkParameters) {
+  renderer_proxy_->Start();
+#if defined(OS_LINUX) || defined(OS_MACOSX)
+  static const int kExpectedBufferSize = kHardwareSampleRate / 100;
+#elif defined(OS_ANDROID)
+  static const int kExpectedBufferSize = 2 * kHardwareSampleRate / 100;
+#else
+  // Windows.
+  static const int kExpectedBufferSize = kHardwareBufferSize;
+#endif
+  EXPECT_EQ(kExpectedBufferSize, renderer_->frames_per_buffer());
+  EXPECT_EQ(kHardwareSampleRate, renderer_->sample_rate());
+  EXPECT_EQ(2, renderer_->channels());
+
+  EXPECT_CALL(*mock_output_device_.get(), Stop());
+  EXPECT_CALL(*source_.get(), RemoveAudioRenderer(renderer_.get()));
+  renderer_proxy_->Stop();
+}
+
 }  // namespace content