Adds AudioDevice factory for all audio clients in Chrome

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_device_impl.h"
 #include "content/test/webrtc_audio_device_test.h"
 #include "media/audio/audio_manager.h"
@@ skipping 214 matching lines @@
     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, CHANNEL_LAYOUT_MONO);
   SetAudioUtilCallback(&audio_util);
-  scoped_refptr<WebRtcAudioDeviceImpl> audio_device(
+  scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
 
-  audio_device->SetSessionId(1);
+  webrtc_audio_device->SetSessionId(1);
 
   WebRTCAutoDelete<webrtc::VoiceEngine> engine(webrtc::VoiceEngine::Create());
   ASSERT_TRUE(engine.valid());
 
   ScopedWebRTCPtr<webrtc::VoEBase> base(engine.get());
-  int err = base->Init(audio_device);
+  int err = base->Init(webrtc_audio_device);
   EXPECT_EQ(0, err);
   EXPECT_EQ(0, base->Terminate());
 }
 
 // Verify that a call to webrtc::VoEBase::StartPlayout() starts audio output
 // with the correct set of parameters. A WebRtcAudioDeviceImpl instance will
 // be utilized to implement the actual audio path. The test registers a
 // 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.
@@ skipping 11 matching lines @@
 
   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);
   EXPECT_CALL(media_observer(),
       OnDeleteAudioStream(_, 1)).Times(AnyNumber());
 
-  scoped_refptr<WebRtcAudioDeviceImpl> audio_device(
+  scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
-  audio_device->SetSessionId(1);
+  webrtc_audio_device->SetSessionId(1);
   WebRTCAutoDelete<webrtc::VoiceEngine> engine(webrtc::VoiceEngine::Create());
   ASSERT_TRUE(engine.valid());
 
   ScopedWebRTCPtr<webrtc::VoEBase> base(engine.get());
   ASSERT_TRUE(base.valid());
-  int err = base->Init(audio_device);
+  int err = base->Init(webrtc_audio_device);
   ASSERT_EQ(0, err);
 
   int ch = base->CreateChannel();
   EXPECT_NE(-1, ch);
 
   ScopedWebRTCPtr<webrtc::VoEExternalMedia> external_media(engine.get());
   ASSERT_TRUE(external_media.valid());
 
   base::WaitableEvent event(false, false);
   scoped_ptr<WebRTCMediaProcessImpl> media_process(
       new WebRTCMediaProcessImpl(&event));
   EXPECT_EQ(0, external_media->RegisterExternalMediaProcessing(
       ch, webrtc::kPlaybackPerChannel, *media_process.get()));
 
   EXPECT_EQ(0, base->StartPlayout(ch));
 
   EXPECT_TRUE(event.TimedWait(
       base::TimeDelta::FromMilliseconds(TestTimeouts::action_timeout_ms())));
   WaitForIOThreadCompletion();
 
-  EXPECT_TRUE(audio_device->playing());
-  EXPECT_FALSE(audio_device->recording());
+  EXPECT_TRUE(webrtc_audio_device->playing());
+  EXPECT_FALSE(webrtc_audio_device->recording());
   EXPECT_EQ(ch, media_process->channel_id());
   EXPECT_EQ(webrtc::kPlaybackPerChannel, media_process->type());
   EXPECT_EQ(80, media_process->packet_size());
   EXPECT_EQ(8000, media_process->sample_rate());
 
   EXPECT_EQ(0, external_media->DeRegisterExternalMediaProcessing(
       ch, webrtc::kPlaybackPerChannel));
   EXPECT_EQ(0, base->StopPlayout(ch));
 
   EXPECT_EQ(0, base->DeleteChannel(ch));
@@ skipping 18 matching lines @@
   AudioUtil audio_util;
   SetAudioUtilCallback(&audio_util);
 
   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> audio_device(
+  scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
-  audio_device->SetSessionId(1);
+  webrtc_audio_device->SetSessionId(1);
   WebRTCAutoDelete<webrtc::VoiceEngine> engine(webrtc::VoiceEngine::Create());
   ASSERT_TRUE(engine.valid());
 
   ScopedWebRTCPtr<webrtc::VoEBase> base(engine.get());
   ASSERT_TRUE(base.valid());
-  int err = base->Init(audio_device);
+  int err = base->Init(webrtc_audio_device);
   ASSERT_EQ(0, err);
 
   int ch = base->CreateChannel();
   EXPECT_NE(-1, ch);
 
   ScopedWebRTCPtr<webrtc::VoEExternalMedia> external_media(engine.get());
   ASSERT_TRUE(external_media.valid());
 
   base::WaitableEvent event(false, false);
   scoped_ptr<WebRTCMediaProcessImpl> media_process(
       new WebRTCMediaProcessImpl(&event));
   EXPECT_EQ(0, external_media->RegisterExternalMediaProcessing(
       ch, webrtc::kRecordingPerChannel, *media_process.get()));
 
   // We must add an external transport implementation to be able to start
   // recording without actually sending encoded packets to the network. All
   // we want to do here is to verify that audio capturing starts as it should.
   ScopedWebRTCPtr<webrtc::VoENetwork> network(engine.get());
   scoped_ptr<WebRTCTransportImpl> transport(
       new WebRTCTransportImpl(network.get()));
   EXPECT_EQ(0, network->RegisterExternalTransport(ch, *transport.get()));
   EXPECT_EQ(0, base->StartSend(ch));
 
   EXPECT_TRUE(event.TimedWait(
       base::TimeDelta::FromMilliseconds(TestTimeouts::action_timeout_ms())));
   WaitForIOThreadCompletion();
 
-  EXPECT_FALSE(audio_device->playing());
-  EXPECT_TRUE(audio_device->recording());
+  EXPECT_FALSE(webrtc_audio_device->playing());
+  EXPECT_TRUE(webrtc_audio_device->recording());
   EXPECT_EQ(ch, media_process->channel_id());
   EXPECT_EQ(webrtc::kRecordingPerChannel, media_process->type());
   EXPECT_EQ(80, media_process->packet_size());
   EXPECT_EQ(8000, media_process->sample_rate());
 
   EXPECT_EQ(0, external_media->DeRegisterExternalMediaProcessing(
       ch, webrtc::kRecordingPerChannel));
   EXPECT_EQ(0, base->StopSend(ch));
 
   EXPECT_EQ(0, base->DeleteChannel(ch));
@@ skipping 19 matching lines @@
 
   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);
   EXPECT_CALL(media_observer(),
       OnDeleteAudioStream(_, 1)).Times(AnyNumber());
 
-  scoped_refptr<WebRtcAudioDeviceImpl> audio_device(
+  scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
-  audio_device->SetSessionId(1);
+  webrtc_audio_device->SetSessionId(1);
 
   WebRTCAutoDelete<webrtc::VoiceEngine> engine(webrtc::VoiceEngine::Create());
   ASSERT_TRUE(engine.valid());
 
   ScopedWebRTCPtr<webrtc::VoEBase> base(engine.get());
   ASSERT_TRUE(base.valid());
-  int err = base->Init(audio_device);
+  int err = base->Init(webrtc_audio_device);
   ASSERT_EQ(0, err);
 
   int ch = base->CreateChannel();
   EXPECT_NE(-1, ch);
   EXPECT_EQ(0, base->StartPlayout(ch));
 
   ScopedWebRTCPtr<webrtc::VoEFile> file(engine.get());
   ASSERT_TRUE(file.valid());
   int duration = 0;
   EXPECT_EQ(0, file->GetFileDuration(file_path.c_str(), duration,
@@ skipping 38 matching lines @@
 
   EXPECT_CALL(media_observer(),
       OnSetAudioStreamStatus(_, 1, StrEq("created")));
   EXPECT_CALL(media_observer(),
       OnSetAudioStreamPlaying(_, 1, true));
   EXPECT_CALL(media_observer(),
       OnSetAudioStreamStatus(_, 1, StrEq("closed")));
   EXPECT_CALL(media_observer(),
       OnDeleteAudioStream(_, 1)).Times(AnyNumber());
 
-  scoped_refptr<WebRtcAudioDeviceImpl> audio_device(
+  scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
-  audio_device->SetSessionId(1);
+  webrtc_audio_device->SetSessionId(1);
   WebRTCAutoDelete<webrtc::VoiceEngine> engine(webrtc::VoiceEngine::Create());
   ASSERT_TRUE(engine.valid());
 
   ScopedWebRTCPtr<webrtc::VoEBase> base(engine.get());
   ASSERT_TRUE(base.valid());
-  int err = base->Init(audio_device);
+  int err = base->Init(webrtc_audio_device);
   ASSERT_EQ(0, err);
 
   ScopedWebRTCPtr<webrtc::VoEAudioProcessing> audio_processing(engine.get());
   ASSERT_TRUE(audio_processing.valid());
   bool enabled = false;
   webrtc::AgcModes agc_mode =  webrtc::kAgcDefault;
   EXPECT_EQ(0, audio_processing->GetAgcStatus(enabled, agc_mode));
   EXPECT_TRUE(enabled);
   EXPECT_EQ(agc_mode, webrtc::kAgcAdaptiveAnalog);
 
@@ skipping 13 matching lines @@
                                 MessageLoop::QuitClosure(),
                                 TestTimeouts::action_timeout());
   message_loop_.Run();
 
   EXPECT_EQ(0, base->StopSend(ch));
   EXPECT_EQ(0, base->StopPlayout(ch));
 
   EXPECT_EQ(0, base->DeleteChannel(ch));
   EXPECT_EQ(0, base->Terminate());
 }