Cleaned up the WebRtcAudioCapturer a bit.

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 <vector>
 
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
@@ skipping 86 matching lines @@
   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 creates and initializes the audio capturer and adds it
-// to WebRTC audio device. This method should be used in tests where
+// Utility method which creates the audio capturer, it returns a scoped
+// reference of the capturer if it is created successfully, otherwise it returns
+// NULL. This method should be used in tests where
 // HardwareSampleRatesAreValid() has been called and returned true.
-bool CreateAndInitializeCapturer(WebRtcAudioDeviceImpl* webrtc_audio_device) {
-  DCHECK(webrtc_audio_device);
-  scoped_refptr<WebRtcAudioCapturer> capturer(
-      WebRtcAudioCapturer::CreateCapturer());
-
+scoped_refptr<WebRtcAudioCapturer> CreateAudioCapturer(
+    WebRtcAudioDeviceImpl* webrtc_audio_device) {
   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 = hardware_config->GetInputSampleRate();
   media::ChannelLayout channel_layout =
       hardware_config->GetInputChannelLayout();
   blink::WebMediaConstraints constraints;
-  if (!capturer->Initialize(kRenderViewId, channel_layout, sample_rate, 0, 1,
-                            media::AudioManagerBase::kDefaultDeviceId, 0, 0,
-                            media::AudioParameters::NO_EFFECTS, constraints)) {
-    return false;
-  }
-
-  // Add the capturer to the WebRtcAudioDeviceImpl.
-  webrtc_audio_device->AddAudioCapturer(capturer);
-
-  return true;
+  StreamDeviceInfo device(MEDIA_DEVICE_AUDIO_CAPTURE,
+                          media::AudioManagerBase::kDefaultDeviceName,
+                          media::AudioManagerBase::kDefaultDeviceId,
+                          sample_rate, channel_layout, 0);
+  device.session_id = 1;
+  return WebRtcAudioCapturer::CreateCapturer(kRenderViewId, device,
+                                             constraints,
+                                             webrtc_audio_device);
 }
 
 // Create and start a local audio track. Starting the audio track will connect
 // the audio track to the capturer and also start the source of the capturer.
 // Also, connect the sink to the audio track.
 scoped_refptr<WebRtcLocalAudioTrack>
 CreateAndStartLocalAudioTrack(WebRtcAudioCapturer* capturer,
                               PeerConnectionAudioSink* sink) {
   scoped_refptr<WebRtcLocalAudioTrack> local_audio_track(
       WebRtcLocalAudioTrack::Create(std::string(), capturer, NULL, NULL));
@@ skipping 339 matching lines @@
   SetAudioHardwareConfig(&audio_config);
 
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
 
   WebRTCAutoDelete<webrtc::VoiceEngine> engine(webrtc::VoiceEngine::Create());
   ASSERT_TRUE(engine.valid());
 
   ScopedWebRTCPtr<webrtc::VoEBase> base(engine.get());
   int err = base->Init(webrtc_audio_device.get());
-  EXPECT_TRUE(CreateAndInitializeCapturer(webrtc_audio_device.get()));
+  EXPECT_TRUE(CreateAudioCapturer(webrtc_audio_device) != NULL);
   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.
 // TODO(henrika): include on Android as well as soon as alla race conditions
@@ skipping 128 matching lines @@
 
   // 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));
 
-  // Create and initialize the capturer which starts the source of the data
-  // flow.
-  EXPECT_TRUE(CreateAndInitializeCapturer(webrtc_audio_device.get()));
+  // Create the capturer which starts the source of the data flow.
+  scoped_refptr<WebRtcAudioCapturer> capturer(
+      CreateAudioCapturer(webrtc_audio_device));
+  EXPECT_TRUE(capturer);
 
   // Create and start a local audio track which is bridging the data flow
   // between the capturer and WebRtcAudioDeviceImpl.
   scoped_refptr<WebRtcLocalAudioTrack> local_audio_track(
-      CreateAndStartLocalAudioTrack(webrtc_audio_device->GetDefaultCapturer(),
-                                    webrtc_audio_device));
+      CreateAndStartLocalAudioTrack(capturer, webrtc_audio_device));
   // connect the VoE voice channel to the audio track
   static_cast<webrtc::AudioTrackInterface*>(local_audio_track.get())->
       GetRenderer()->AddChannel(ch);
 
   // Verify we get the data flow.
   EXPECT_TRUE(event.TimedWait(TestTimeouts::action_timeout()));
   WaitForIOThreadCompletion();
 
   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));
 
-  webrtc_audio_device->GetDefaultCapturer()->Stop();
+  capturer->Stop();
   EXPECT_EQ(0, base->DeleteChannel(ch));
   EXPECT_EQ(0, base->Terminate());
 }
 
 // Uses WebRtcAudioDeviceImpl to play a local wave file.
 // TODO(henrika): include on Android as well as soon as alla race conditions
 // in OpenSLES are resolved.
 #if defined(OS_ANDROID)
 #define MAYBE_PlayLocalFile DISABLED_PlayLocalFile
 #else
@@ skipping 108 matching lines @@
   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);
 #endif
 
   int ch = base->CreateChannel();
   EXPECT_NE(-1, ch);
 
-  EXPECT_TRUE(CreateAndInitializeCapturer(webrtc_audio_device.get()));
+  scoped_refptr<WebRtcAudioCapturer> capturer(
+      CreateAudioCapturer(webrtc_audio_device));
+  EXPECT_TRUE(capturer);
   scoped_refptr<WebRtcLocalAudioTrack> local_audio_track(
-      CreateAndStartLocalAudioTrack(webrtc_audio_device->GetDefaultCapturer(),
-                                    webrtc_audio_device));
+      CreateAndStartLocalAudioTrack(capturer, webrtc_audio_device));
   // connect the VoE voice channel to the audio track
   static_cast<webrtc::AudioTrackInterface*>(local_audio_track.get())->
       GetRenderer()->AddChannel(ch);
 
   ScopedWebRTCPtr<webrtc::VoENetwork> network(engine.get());
   ASSERT_TRUE(network.valid());
   scoped_ptr<WebRTCTransportImpl> transport(
       new WebRTCTransportImpl(network.get()));
   EXPECT_EQ(0, network->RegisterExternalTransport(ch, *transport.get()));
   EXPECT_EQ(0, base->StartPlayout(ch));
   EXPECT_EQ(0, base->StartSend(ch));
   scoped_refptr<WebRtcAudioRenderer> renderer(
       CreateDefaultWebRtcAudioRenderer(kRenderViewId));
   scoped_refptr<MediaStreamAudioRenderer> proxy(
       renderer->CreateSharedAudioRendererProxy());
   EXPECT_TRUE(webrtc_audio_device->SetAudioRenderer(renderer.get()));
   proxy->Start();
   proxy->Play();
 
   VLOG(0) << ">> You should now be able to hear yourself in loopback...";
   message_loop_.PostDelayedTask(FROM_HERE,
                                 base::MessageLoop::QuitClosure(),
                                 base::TimeDelta::FromSeconds(2));
   message_loop_.Run();
 
-  webrtc_audio_device->GetDefaultCapturer()->Stop();
+  capturer->Stop();
   proxy->Stop();
   EXPECT_EQ(0, base->StopSend(ch));
   EXPECT_EQ(0, base->StopPlayout(ch));
 
   EXPECT_EQ(0, base->DeleteChannel(ch));
   EXPECT_EQ(0, base->Terminate());
 }
 
 // Test times out on bots, see http://crbug.com/247447
 TEST_F(MAYBE_WebRTCAudioDeviceTest, DISABLED_WebRtcRecordingSetupTime) {
@@ skipping 16 matching lines @@
   ASSERT_TRUE(engine.valid());
 
   ScopedWebRTCPtr<webrtc::VoEBase> base(engine.get());
   ASSERT_TRUE(base.valid());
   int err = base->Init(webrtc_audio_device.get());
   ASSERT_EQ(0, err);
 
   int ch = base->CreateChannel();
   EXPECT_NE(-1, ch);
 
-  EXPECT_TRUE(CreateAndInitializeCapturer(webrtc_audio_device.get()));
+  scoped_refptr<WebRtcAudioCapturer> capturer(
+      CreateAudioCapturer(webrtc_audio_device));
+  EXPECT_TRUE(capturer);
   base::WaitableEvent event(false, false);
   scoped_ptr<MockMediaStreamAudioSink> sink(
       new MockMediaStreamAudioSink(&event));
 
   // Create and start a local audio track. Starting the audio track will connect
   // the audio track to the capturer and also start the source of the capturer.
   scoped_refptr<WebRtcLocalAudioTrack> local_audio_track(
-      CreateAndStartLocalAudioTrack(
-          webrtc_audio_device->GetDefaultCapturer().get(), sink.get()));
+      CreateAndStartLocalAudioTrack(capturer, sink.get()));
 
   // connect the VoE voice channel to the audio track.
   static_cast<webrtc::AudioTrackInterface*>(local_audio_track.get())->
       GetRenderer()->AddChannel(ch);
 
   base::Time start_time = base::Time::Now();
   EXPECT_EQ(0, base->StartSend(ch));
 
   EXPECT_TRUE(event.TimedWait(TestTimeouts::action_timeout()));
   int delay = (base::Time::Now() - start_time).InMilliseconds();
   PrintPerfResultMs("webrtc_recording_setup_c", "t", delay);
 
-  webrtc_audio_device->GetDefaultCapturer()->Stop();
+  capturer->Stop();
   EXPECT_EQ(0, base->StopSend(ch));
   EXPECT_EQ(0, base->DeleteChannel(ch));
   EXPECT_EQ(0, base->Terminate());
 }
 
 
 // TODO(henrika): include on Android as well as soon as alla race conditions
 // in OpenSLES are resolved.
 #if defined(OS_ANDROID)
 #define MAYBE_WebRtcPlayoutSetupTime DISABLED_WebRtcPlayoutSetupTime
@@ skipping 74 matching lines @@
     LOG(WARNING) << "Test disabled due to the test hangs on WinXP.";
     return;
   }
 #endif
   int latency = RunWebRtcLoopbackTimeTest(audio_manager_.get(), true);
   PrintPerfResultMs("webrtc_loopback_with_signal_processing (100 packets)",
                     "t", latency);
 }
 
 }  // namespace content