Introduce AudioHardwareConfig for renderer side audio device info.

content/renderer/media/webrtc_audio_device_unittest.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 "base/environment.h"
 #include "base/test/test_timeouts.h"
-#include "content/renderer/media/audio_hardware.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
 #include "content/renderer/media/webrtc_audio_renderer.h"
+#include "content/renderer/render_thread_impl.h"
 #include "content/test/webrtc_audio_device_test.h"
-#include "media/audio/audio_manager.h"
+#include "media/audio/audio_manager_base.h"
 #include "media/audio/audio_util.h"
+#include "media/base/audio_hardware_config.h"
 #include "testing/gmock/include/gmock/gmock.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_external_media.h"
 #include "third_party/webrtc/voice_engine/include/voe_file.h"
 #include "third_party/webrtc/voice_engine/include/voe_network.h"
 
 using testing::_;
 using testing::AnyNumber;
 using testing::InvokeWithoutArgs;
 using testing::Return;
 using testing::StrEq;
 
 namespace content {
 
 namespace {
 
 const int kRenderViewId = 1;
 
-class AudioUtil : public AudioUtilInterface {
- public:
-  AudioUtil() {}
-
-  virtual int GetAudioHardwareSampleRate() OVERRIDE {
-    return media::GetAudioHardwareSampleRate();
-  }
-  virtual int GetAudioInputHardwareSampleRate(
-      const std::string& device_id) OVERRIDE {
-    return media::GetAudioInputHardwareSampleRate(device_id);
-  }
-  virtual media::ChannelLayout GetAudioInputHardwareChannelLayout(
-      const std::string& device_id) OVERRIDE {
-    return media::GetAudioInputHardwareChannelLayout(device_id);
-  }
- private:
-  DISALLOW_COPY_AND_ASSIGN(AudioUtil);
-};
-
-class AudioUtilNoHardware : public AudioUtilInterface {
- public:
-  AudioUtilNoHardware(int output_rate, int input_rate,
-                      media::ChannelLayout input_channel_layout)
-      : output_rate_(output_rate),
-        input_rate_(input_rate),
-        input_channel_layout_(input_channel_layout) {
-  }
-
-  virtual int GetAudioHardwareSampleRate() OVERRIDE {
-    return output_rate_;
-  }
-  virtual int GetAudioInputHardwareSampleRate(
-      const std::string& device_id) OVERRIDE {
-    return input_rate_;
-  }
-  virtual media::ChannelLayout GetAudioInputHardwareChannelLayout(
-      const std::string& device_id) OVERRIDE {
-    return input_channel_layout_;
-  }
-
- private:
-  int output_rate_;
-  int input_rate_;
-  media::ChannelLayout input_channel_layout_;
-  DISALLOW_COPY_AND_ASSIGN(AudioUtilNoHardware);
-};
+scoped_ptr<media::AudioHardwareConfig> CreateRealHardwareConfig() {
+  return make_scoped_ptr(new media::AudioHardwareConfig(
+      media::GetAudioHardwareBufferSize(), media::GetAudioHardwareSampleRate(),
+      media::GetAudioInputHardwareSampleRate(
+          media::AudioManagerBase::kDefaultDeviceId),
+      media::GetAudioInputHardwareChannelLayout(
+          media::AudioManagerBase::kDefaultDeviceId)));
+}
 
 // Return true if at least one element in the array matches |value|.
 bool FindElementInArray(int* array, int size, int value) {
   return (std::find(&array[0], &array[0] + size, value) != &array[size]);
 }
 
 // This method returns false if a non-supported rate is detected on the
 // input or output side.
 // TODO(henrika): add support for automatic fallback to Windows Wave audio
 // if a non-supported rate is detected. It is probably better to detect
 // invalid audio settings by actually trying to open the audio streams instead
 // of relying on hard coded conditions.
 bool HardwareSampleRatesAreValid() {
   // These are the currently supported hardware sample rates in both directions.
   // The actual WebRTC client can limit these ranges further depending on
   // platform but this is the maximum range we support today.
   int valid_input_rates[] = {16000, 32000, 44100, 48000, 96000};
   int valid_output_rates[] = {44100, 48000, 96000};
 
+  media::AudioHardwareConfig* hardware_config =
+      RenderThreadImpl::current()->GetAudioHardwareConfig();
+
   // Verify the input sample rate.
-  int input_sample_rate = GetAudioInputSampleRate();
+  int input_sample_rate = hardware_config->GetInputSampleRate();
 
   if (!FindElementInArray(valid_input_rates, arraysize(valid_input_rates),
                           input_sample_rate)) {
     LOG(WARNING) << "Non-supported input sample rate detected.";
     return false;
   }
 
   // Given that the input rate was OK, verify the output rate as well.
-  int output_sample_rate = GetAudioOutputSampleRate();
+  int output_sample_rate = hardware_config->GetOutputSampleRate();
   if (!FindElementInArray(valid_output_rates, arraysize(valid_output_rates),
                           output_sample_rate)) {
     LOG(WARNING) << "Non-supported output sample rate detected.";
     return false;
   }
 
   return true;
 }
 
 // Utility method which initializes the audio capturer contained in the
 // WebRTC audio device. This method should be used in tests where
 // HardwareSampleRatesAreValid() has been called and returned true.
 bool InitializeCapturer(WebRtcAudioDeviceImpl* webrtc_audio_device) {
   // Access the capturer owned and created by the audio device.
   WebRtcAudioCapturer* capturer = webrtc_audio_device->capturer();
   if (!capturer)
     return false;
 
+  media::AudioHardwareConfig* hardware_config =
+      RenderThreadImpl::current()->GetAudioHardwareConfig();
+
   // Use native capture sample rate and channel configuration to get some
   // action in this test.
-  int sample_rate = GetAudioInputSampleRate();
-  media::ChannelLayout channel_layout = GetAudioInputChannelLayout();
+  int sample_rate = hardware_config->GetInputSampleRate();
+  media::ChannelLayout channel_layout =
+      hardware_config->GetInputChannelLayout();
   if (!capturer->Initialize(channel_layout, sample_rate))
     return false;
 
   // Ensures that the default capture device is utilized.
   webrtc_audio_device->capturer()->SetDevice(1);
   return true;
 }
 
 
 class WebRTCMediaProcessImpl : public webrtc::VoEMediaProcess {
@@ skipping 98 matching lines @@
   int invalid_rates[] = {-1, 0, 8000, 11025, 22050, 32000, 192000};
   for (size_t i = 0; i < arraysize(invalid_rates); ++i) {
     EXPECT_FALSE(FindElementInArray(valid_rates, arraysize(valid_rates),
         invalid_rates[i]));
   }
 }
 
 // Basic test that instantiates and initializes an instance of
 // WebRtcAudioDeviceImpl.
 TEST_F(WebRTCAudioDeviceTest, Construct) {
-  AudioUtilNoHardware audio_util(48000, 48000, media::CHANNEL_LAYOUT_MONO);
-  SetAudioUtilCallback(&audio_util);
+  media::AudioHardwareConfig audio_config(
+      480, 48000, 48000, media::CHANNEL_LAYOUT_MONO);
+  SetAudioHardwareConfig(&audio_config);
 
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
 
   // The capturer is not created until after the WebRtcAudioDeviceImpl has
   // been initialized.
   EXPECT_FALSE(InitializeCapturer(webrtc_audio_device.get()));
 
   WebRTCAutoDelete<webrtc::VoiceEngine> engine(webrtc::VoiceEngine::Create());
   ASSERT_TRUE(engine.valid());
@@ skipping 11 matching lines @@
 // webrtc::VoEExternalMedia implementation to hijack the output audio and
 // verify that streaming starts correctly.
 // Disabled when running headless since the bots don't have the required config.
 // Flaky, http://crbug.com/167299 .
 TEST_F(WebRTCAudioDeviceTest, DISABLED_StartPlayout) {
   if (!has_output_devices_) {
     LOG(WARNING) << "No output device detected.";
     return;
   }
 
-  AudioUtil audio_util;
-  SetAudioUtilCallback(&audio_util);
+  scoped_ptr<media::AudioHardwareConfig> config = CreateRealHardwareConfig();
+  SetAudioHardwareConfig(config.get());
 
   if (!HardwareSampleRatesAreValid())
     return;
 
   EXPECT_CALL(media_observer(),
       OnSetAudioStreamStatus(_, 1, StrEq("created"))).Times(1);
   EXPECT_CALL(media_observer(),
       OnSetAudioStreamPlaying(_, 1, true)).Times(1);
   EXPECT_CALL(media_observer(),
       OnSetAudioStreamStatus(_, 1, StrEq("closed"))).Times(1);
@@ skipping 56 matching lines @@
 // is also required to ensure that "sending" can start without actually trying
 // to send encoded packets to the network. Our main interest here is to ensure
 // that the audio capturing starts as it should.
 // Disabled when running headless since the bots don't have the required config.
 TEST_F(WebRTCAudioDeviceTest, StartRecording) {
   if (!has_input_devices_ || !has_output_devices_) {
     LOG(WARNING) << "Missing audio devices.";
     return;
   }
 
-  AudioUtil audio_util;
-  SetAudioUtilCallback(&audio_util);
+  scoped_ptr<media::AudioHardwareConfig> config = CreateRealHardwareConfig();
+  SetAudioHardwareConfig(config.get());
 
   if (!HardwareSampleRatesAreValid())
     return;
 
   // TODO(tommi): extend MediaObserver and MockMediaObserver with support
   // for new interfaces, like OnSetAudioStreamRecording(). When done, add
   // EXPECT_CALL() macros here.
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
 
@@ skipping 51 matching lines @@
 // Flaky, http://crbug.com/167298 .
 TEST_F(WebRTCAudioDeviceTest, DISABLED_PlayLocalFile) {
   if (!has_output_devices_) {
     LOG(WARNING) << "No output device detected.";
     return;
   }
 
   std::string file_path(
       GetTestDataPath(FILE_PATH_LITERAL("speechmusic_mono_16kHz.pcm")));
 
-  AudioUtil audio_util;
-  SetAudioUtilCallback(&audio_util);
+  scoped_ptr<media::AudioHardwareConfig> config = CreateRealHardwareConfig();
+  SetAudioHardwareConfig(config.get());
 
   if (!HardwareSampleRatesAreValid())
     return;
 
   EXPECT_CALL(media_observer(),
       OnSetAudioStreamStatus(_, 1, StrEq("created"))).Times(1);
   EXPECT_CALL(media_observer(),
       OnSetAudioStreamPlaying(_, 1, true)).Times(1);
   EXPECT_CALL(media_observer(),
       OnSetAudioStreamStatus(_, 1, StrEq("closed"))).Times(1);
@@ skipping 49 matching lines @@
 // where they are decoded and played out on the default audio output device.
 // Disabled when running headless since the bots don't have the required config.
 // TODO(henrika): improve quality by using a wideband codec, enabling noise-
 // suppressions etc.
 TEST_F(WebRTCAudioDeviceTest, FullDuplexAudioWithAGC) {
   if (!has_output_devices_ || !has_input_devices_) {
     LOG(WARNING) << "Missing audio devices.";
     return;
   }
 
-  AudioUtil audio_util;
-  SetAudioUtilCallback(&audio_util);
+  scoped_ptr<media::AudioHardwareConfig> config = CreateRealHardwareConfig();
+  SetAudioHardwareConfig(config.get());
 
   if (!HardwareSampleRatesAreValid())
     return;
 
   EXPECT_CALL(media_observer(),
       OnSetAudioStreamStatus(_, 1, StrEq("created")));
   EXPECT_CALL(media_observer(),
       OnSetAudioStreamPlaying(_, 1, true));
   EXPECT_CALL(media_observer(),
       OnSetAudioStreamStatus(_, 1, StrEq("closed")));
@@ skipping 44 matching lines @@
 
   renderer->Stop();
   EXPECT_EQ(0, base->StopSend(ch));
   EXPECT_EQ(0, base->StopPlayout(ch));
 
   EXPECT_EQ(0, base->DeleteChannel(ch));
   EXPECT_EQ(0, base->Terminate());
 }
 
 }  // namespace content