Refactor the Get*Hardware* routines a bit.

content/renderer/media/webrtc_audio_device_unittest.cc

 // Copyright (c) 2011 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/webrtc_audio_device_impl.h"
 #include "content/test/webrtc_audio_device_test.h"
 #include "media/audio/audio_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/webrtc/voice_engine/main/interface/voe_audio_processing.h"
 #include "third_party/webrtc/voice_engine/main/interface/voe_base.h"
 #include "third_party/webrtc/voice_engine/main/interface/voe_external_media.h"
 #include "third_party/webrtc/voice_engine/main/interface/voe_file.h"
 #include "third_party/webrtc/voice_engine/main/interface/voe_network.h"
 
 using testing::_;
+using testing::AnyNumber;
 using testing::InvokeWithoutArgs;
 using testing::Return;
 using testing::StrEq;
 
 namespace {
 
 ACTION_P(QuitMessageLoop, loop_or_proxy) {
   loop_or_proxy->PostTask(FROM_HERE, new MessageLoop::QuitTask());
 }
 
@@ skipping 82 matching lines @@
   int channels_;
   DISALLOW_COPY_AND_ASSIGN(WebRTCMediaProcessImpl);
 };
 
 }  // end namespace
 
 // Basic test that instantiates and initializes an instance of
 // WebRtcAudioDeviceImpl.
 TEST_F(WebRTCAudioDeviceTest, Construct) {
   AudioUtilNoHardware audio_util(48000.0, 48000.0);
-  set_audio_util_callback(&audio_util);
+  SetAudioUtilCallback(&audio_util);
   scoped_refptr<WebRtcAudioDeviceImpl> audio_device(
       new WebRtcAudioDeviceImpl());
   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);
   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.
 TEST_F(WebRTCAudioDeviceTest, StartPlayout) {
   if (IsRunningHeadless())
     return;
 
   AudioUtil audio_util;
-  set_audio_util_callback(&audio_util);
+  SetAudioUtilCallback(&audio_util);
 
   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(1);
+      OnDeleteAudioStream(_, 1)).Times(AnyNumber());
 
   scoped_refptr<WebRtcAudioDeviceImpl> audio_device(
       new WebRtcAudioDeviceImpl());
   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);
@@ skipping 39 matching lines @@
 // verify that streaming starts correctly. An external transport implementation
 // 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 (IsRunningHeadless())
     return;
 
   AudioUtil audio_util;
-  set_audio_util_callback(&audio_util);
+  SetAudioUtilCallback(&audio_util);
 
   // 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(
       new WebRtcAudioDeviceImpl());
   audio_device->SetSessionId(1);
   WebRTCAutoDelete<webrtc::VoiceEngine> engine(webrtc::VoiceEngine::Create());
   ASSERT_TRUE(engine.valid());
@@ skipping 46 matching lines @@
 // Uses WebRtcAudioDeviceImpl to play a local wave file.
 // Disabled when running headless since the bots don't have the required config.
 TEST_F(WebRTCAudioDeviceTest, PlayLocalFile) {
   if (IsRunningHeadless())
     return;
 
   std::string file_path(
       GetTestDataPath(FILE_PATH_LITERAL("speechmusic_mono_16kHz.pcm")));
 
   AudioUtil audio_util;
-  set_audio_util_callback(&audio_util);
+  SetAudioUtilCallback(&audio_util);
 
   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(1);
+      OnDeleteAudioStream(_, 1)).Times(AnyNumber());
 
   scoped_refptr<WebRtcAudioDeviceImpl> audio_device(
       new WebRtcAudioDeviceImpl());
   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());
@@ skipping 26 matching lines @@
 // which are recorded, encoded, packetized into RTP packets and finally
 // "transmitted". The RTP packets are then fed back into the VoiceEngine
 // 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 and perhaps also the digital AGC.
 TEST_F(WebRTCAudioDeviceTest, FullDuplexAudio) {
   if (IsRunningHeadless())
     return;
 
+  EXPECT_CALL(media_observer(),
+      OnSetAudioStreamStatus(_, 1, StrEq("created")));
+  EXPECT_CALL(media_observer(),
+      OnSetAudioStreamPlaying(_, 1, true));
+  EXPECT_CALL(media_observer(),
+      OnSetAudioStreamStatus(_, 1, StrEq("closed")));
+
   AudioUtil audio_util;
-  set_audio_util_callback(&audio_util);
+  SetAudioUtilCallback(&audio_util);
 
   scoped_refptr<WebRtcAudioDeviceImpl> audio_device(
       new WebRtcAudioDeviceImpl());
   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);
@@ skipping 14 matching lines @@
                                 new MessageLoop::QuitTask(),
                                 TestTimeouts::action_timeout_ms());
   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());
 }