start/stop the source of the capturer when 1st audiotrack/last audiotrack is added/removed

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/file_util.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
 #include "base/test/test_timeouts.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/media/webrtc_local_audio_track.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/test/webrtc_audio_device_test.h"
 #include "media/audio/audio_manager_base.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_codec.h"
 #include "third_party/webrtc/voice_engine/include/voe_external_media.h"
 #include "third_party/webrtc/voice_engine/include/voe_file.h"
@@ skipping 551 matching lines @@
 
   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(webrtc_audio_device.get());
   ASSERT_EQ(0, err);
 
   EXPECT_TRUE(InitializeCapturer(webrtc_audio_device.get()));
-  webrtc_audio_device->capturer()->Start();
+
+  // 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(
+      WebRtcLocalAudioTrack::Create(std::string(),
+                                    webrtc_audio_device->capturer(),
+                                    NULL));
+  local_audio_track->Start();
 
   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));
@@ skipping 16 matching lines @@
   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->capturer()->Stop();
+  local_audio_track->Stop();
   EXPECT_EQ(0, base->DeleteChannel(ch));
   EXPECT_EQ(0, base->Terminate());
 }
 
 // Uses WebRtcAudioDeviceImpl to play a local wave file.
 // Disabled when running headless since the bots don't have the required config.
 // Flaky, http://crbug.com/167298 .
 TEST_F(WebRTCAudioDeviceTest, DISABLED_PlayLocalFile) {
   if (!has_output_devices_) {
     LOG(WARNING) << "No output device detected.";
@@ skipping 105 matching lines @@
 
   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(webrtc_audio_device.get());
   ASSERT_EQ(0, err);
 
   EXPECT_TRUE(InitializeCapturer(webrtc_audio_device.get()));
-  webrtc_audio_device->capturer()->Start();
+  // 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(
+      WebRtcLocalAudioTrack::Create(std::string(),
+                                    webrtc_audio_device->capturer(),
+                                    NULL));
+  local_audio_track->Start();
 
   ScopedWebRTCPtr<webrtc::VoEAudioProcessing> audio_processing(engine.get());
   ASSERT_TRUE(audio_processing.valid());
 #if defined(OS_ANDROID)
   // On Android, by default AGC is off.
   bool enabled = true;
   webrtc::AgcModes agc_mode = webrtc::kAgcDefault;
   EXPECT_EQ(0, audio_processing->GetAgcStatus(enabled, agc_mode));
   EXPECT_FALSE(enabled);
 #else
@@ skipping 15 matching lines @@
   EXPECT_EQ(0, base->StartPlayout(ch));
   EXPECT_EQ(0, base->StartSend(ch));
   renderer->Play();
 
   LOG(INFO) << ">> 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->capturer()->Stop();
+  local_audio_track->Stop();
   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());
 }
 
 TEST_F(WebRTCAudioDeviceTest, WebRtcRecordingSetupTime) {
   if (!has_input_devices_) {
@@ skipping 13 matching lines @@
 
   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(webrtc_audio_device.get());
   ASSERT_EQ(0, err);
 
   EXPECT_TRUE(InitializeCapturer(webrtc_audio_device.get()));
-  webrtc_audio_device->capturer()->Start();
+  // 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(
+      WebRtcLocalAudioTrack::Create(std::string(),
+                                    webrtc_audio_device->capturer(),
+                                    NULL));
+  local_audio_track->Start();
 
   base::WaitableEvent event(false, false);
   scoped_ptr<MockWebRtcAudioCapturerSink> capturer_sink(
       new MockWebRtcAudioCapturerSink(&event));
   WebRtcAudioCapturer* capturer = webrtc_audio_device->capturer().get();
   capturer->AddSink(capturer_sink.get());
 
   int ch = base->CreateChannel();
   EXPECT_NE(-1, 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);
 
   capturer->RemoveSink(capturer_sink.get());
-  webrtc_audio_device->capturer()->Stop();
+  local_audio_track->Stop();
   EXPECT_EQ(0, base->StopSend(ch));
   EXPECT_EQ(0, base->DeleteChannel(ch));
   EXPECT_EQ(0, base->Terminate());
 }
 
 TEST_F(WebRTCAudioDeviceTest, WebRtcPlayoutSetupTime) {
   if (!has_output_devices_) {
     LOG(WARNING) << "No output device detected.";
     return;
   }
@@ skipping 35 matching lines @@
                     "t", latency);
 }
 
 TEST_F(WebRTCAudioDeviceTest, WebRtcLoopbackTimeWithSignalProcessing) {
   int latency = RunWebRtcLoopbackTimeTest(audio_manager_.get(), true);
   PrintPerfResultMs("webrtc_loopback_with_signal_processing (100 packets)",
                     "t", latency);
 }
 
 }  // namespace content