Introduce AudioHardwareConfig for renderer side audio device info.

content/test/webrtc_audio_device_test.cc

 // Copyright (c) 2012 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/test/webrtc_audio_device_test.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "content/browser/renderer_host/media/audio_input_renderer_host.h"
 #include "content/browser/renderer_host/media/audio_mirroring_manager.h"
 #include "content/browser/renderer_host/media/audio_renderer_host.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/mock_media_observer.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_paths.h"
 #include "content/public/test/mock_resource_context.h"
 #include "content/public/test/test_browser_thread.h"
-#include "content/renderer/media/audio_hardware.h"
 #include "content/renderer/media/audio_input_message_filter.h"
 #include "content/renderer/media/audio_message_filter.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
 #include "content/renderer/render_process.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/renderer_webkitplatformsupport_impl.h"
+#include "media/base/audio_hardware_config.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/voice_engine/include/voe_audio_processing.h"
 #include "third_party/webrtc/voice_engine/include/voe_base.h"
 #include "third_party/webrtc/voice_engine/include/voe_file.h"
 #include "third_party/webrtc/voice_engine/include/voe_network.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_com_initializer.h"
@@ skipping 67 matching lines @@
   net::URLRequestContext* test_request_context_;
 
   DISALLOW_COPY_AND_ASSIGN(MockRTCResourceContext);
 };
 
 ACTION_P(QuitMessageLoop, loop_or_proxy) {
   loop_or_proxy->PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
 WebRTCAudioDeviceTest::WebRTCAudioDeviceTest()
-    : render_thread_(NULL), audio_util_callback_(NULL),
+    : render_thread_(NULL), audio_hardware_config_(NULL),
       has_input_devices_(false), has_output_devices_(false) {
 }
 
 WebRTCAudioDeviceTest::~WebRTCAudioDeviceTest() {}
 
 void WebRTCAudioDeviceTest::SetUp() {
   // This part sets up a RenderThread environment to ensure that
   // RenderThread::current() (<=> TLS pointer) is valid.
   // Main parts are inspired by the RenderViewFakeResourcesTest.
   // Note that, the IPC part is not utilized in this test.
@@ skipping 11 matching lines @@
       base::Bind(&WebRTCAudioDeviceTest::InitializeIOThread,
                  base::Unretained(this), kThreadName));
   WaitForIOThreadCompletion();
 
   sandbox_was_enabled_ =
       RendererWebKitPlatformSupportImpl::SetSandboxEnabledForTesting(false);
   render_thread_ = new RenderThreadImpl(kThreadName);
 }
 
 void WebRTCAudioDeviceTest::TearDown() {
-  SetAudioUtilCallback(NULL);
+  SetAudioHardwareConfig(NULL);
 
   // Run any pending cleanup tasks that may have been posted to the main thread.
   ChildProcess::current()->main_thread()->message_loop()->RunUntilIdle();
 
   // Kick of the cleanup process by closing the channel. This queues up
   // OnStreamClosed calls to be executed on the audio thread.
   ChildProcess::current()->io_message_loop()->PostTask(FROM_HERE,
       base::Bind(&WebRTCAudioDeviceTest::DestroyChannel,
                  base::Unretained(this)));
   WaitForIOThreadCompletion();
@@ skipping 15 matching lines @@
   mirroring_manager_.reset();
   audio_manager_.reset();
   RendererWebKitPlatformSupportImpl::SetSandboxEnabledForTesting(
       sandbox_was_enabled_);
 }
 
 bool WebRTCAudioDeviceTest::Send(IPC::Message* message) {
   return channel_->Send(message);
 }
 
-void WebRTCAudioDeviceTest::SetAudioUtilCallback(AudioUtilInterface* callback) {
-  // Invalidate any potentially cached values since the new callback should
-  // be used for those queries.
-  ResetAudioCache();
-  audio_util_callback_ = callback;
+void WebRTCAudioDeviceTest::SetAudioHardwareConfig(
+    media::AudioHardwareConfig* hardware_config) {
+  audio_hardware_config_ = hardware_config;
 }
 
 void WebRTCAudioDeviceTest::InitializeIOThread(const char* thread_name) {
 #if defined(OS_WIN)
   // We initialize COM (STA) on our IO thread as is done in Chrome.
   // See BrowserProcessSubThread::Init.
   initialize_com_.reset(new base::win::ScopedCOMInitializer());
 #endif
 
   // Set the current thread as the IO thread.
@@ skipping 53 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   audio_render_host_->OnChannelClosing();
   audio_render_host_->OnFilterRemoved();
   audio_input_renderer_host_->OnChannelClosing();
   audio_input_renderer_host_->OnFilterRemoved();
   channel_.reset();
   audio_render_host_ = NULL;
   audio_input_renderer_host_ = NULL;
 }
 
-void WebRTCAudioDeviceTest::OnGetHardwareSampleRate(int* sample_rate) {
-  EXPECT_TRUE(audio_util_callback_);
-  *sample_rate = audio_util_callback_ ?
-      audio_util_callback_->GetAudioHardwareSampleRate() : 0;
-}
+void WebRTCAudioDeviceTest::OnGetAudioHardwareConfig(
+    int* output_buffer_size, int* output_sample_rate, int* input_sample_rate,
+    media::ChannelLayout* input_channel_layout) {
+  ASSERT_TRUE(audio_hardware_config_);
 
-void WebRTCAudioDeviceTest::OnGetHardwareInputSampleRate(int* sample_rate) {
-  EXPECT_TRUE(audio_util_callback_);
-  *sample_rate = audio_util_callback_ ?
-      audio_util_callback_->GetAudioInputHardwareSampleRate(
-          media::AudioManagerBase::kDefaultDeviceId) : 0;
-}
+  *output_buffer_size = audio_hardware_config_->GetOutputBufferSize();
+  *output_sample_rate = audio_hardware_config_->GetOutputSampleRate();
 
-void WebRTCAudioDeviceTest::OnGetHardwareInputChannelLayout(
-    media::ChannelLayout* layout) {
-  EXPECT_TRUE(audio_util_callback_);
-  *layout = !audio_util_callback_ ? media::CHANNEL_LAYOUT_NONE :
-      audio_util_callback_->GetAudioInputHardwareChannelLayout(
-          media::AudioManagerBase::kDefaultDeviceId);
+  // TODO(henrika): add support for all available input devices.
+  *input_sample_rate = audio_hardware_config_->GetInputSampleRate();
+  *input_channel_layout = audio_hardware_config_->GetInputChannelLayout();
 }
 
 // IPC::Listener implementation.
 bool WebRTCAudioDeviceTest::OnMessageReceived(const IPC::Message& message) {
   if (render_thread_) {
     IPC::ChannelProxy::MessageFilter* filter =
         render_thread_->audio_input_message_filter();
     if (filter->OnMessageReceived(message))
       return true;
 
@@ skipping 10 matching lines @@
 
   if (audio_input_renderer_host_.get()) {
     bool message_was_ok = false;
     if (audio_input_renderer_host_->OnMessageReceived(message, &message_was_ok))
       return true;
   }
 
   bool handled ALLOW_UNUSED = true;
   bool message_is_ok = true;
   IPC_BEGIN_MESSAGE_MAP_EX(WebRTCAudioDeviceTest, message, message_is_ok)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_GetHardwareSampleRate,
-                        OnGetHardwareSampleRate)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_GetHardwareInputSampleRate,
-                        OnGetHardwareInputSampleRate)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_GetHardwareInputChannelLayout,
-                        OnGetHardwareInputChannelLayout)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_GetAudioHardwareConfig,
+                        OnGetAudioHardwareConfig)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
 
   EXPECT_TRUE(message_is_ok);
 
   return true;
 }
 
 // Posts a final task to the IO message loop and waits for completion.
 void WebRTCAudioDeviceTest::WaitForIOThreadCompletion() {
@@ skipping 42 matching lines @@
 int WebRTCTransportImpl::SendPacket(int channel, const void* data, int len) {
   return network_->ReceivedRTPPacket(channel, data, len);
 }
 
 int WebRTCTransportImpl::SendRTCPPacket(int channel, const void* data,
                                         int len) {
   return network_->ReceivedRTCPPacket(channel, data, len);
 }
 
 }  // namespace content