Re-enables three WebRTC unit tests in content

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 478 matching lines @@
   EXPECT_TRUE(CreateAndInitializeCapturer(webrtc_audio_device.get()));
   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.
-// Flaky, http://crbug.com/167299 .
-TEST_F(MAYBE_WebRTCAudioDeviceTest, DISABLED_StartPlayout) {
+// TODO(henrika): include on Android as well as soon as alla race conditions
+// in OpenSLES are resolved.
+#if defined(OS_ANDROID)
+#define MAYBE_StartPlayout DISABLED_StartPlayout
+#else
+#define MAYBE_StartPlayout StartPlayout
+#endif
+TEST_F(MAYBE_WebRTCAudioDeviceTest, MAYBE_StartPlayout) {
   if (!has_output_devices_) {
     LOG(WARNING) << "No output device detected.";
     return;
   }
 
   scoped_ptr<media::AudioHardwareConfig> config =
       CreateRealHardwareConfig(audio_manager_.get());
   SetAudioHardwareConfig(config.get());
+  media::AudioParameters params(config->GetOutputConfig());
 
   if (!HardwareSampleRatesAreValid())
     return;
 
   EXPECT_CALL(media_observer(),
-      OnSetAudioStreamStatus(_, 1, StrEq("created"))).Times(1);
+      OnAudioStreamCreated(_, 1, params, StrEq(""))).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<WebRtcAudioRenderer> renderer =
-      new WebRtcAudioRenderer(kRenderViewId);
+  WebRTCAutoDelete<webrtc::VoiceEngine> engine(webrtc::VoiceEngine::Create());
+  ASSERT_TRUE(engine.valid());
+  ScopedWebRTCPtr<webrtc::VoEBase> base(engine.get());
+  ASSERT_TRUE(base.valid());
+
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
-  EXPECT_TRUE(webrtc_audio_device->SetAudioRenderer(renderer.get()));
-
-  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);
 
-  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));
+  int ch = base->CreateChannel();
+  EXPECT_NE(-1, ch);
   EXPECT_EQ(0, external_media->RegisterExternalMediaProcessing(
       ch, webrtc::kPlaybackPerChannel, *media_process.get()));
 
   EXPECT_EQ(0, base->StartPlayout(ch));
+  scoped_refptr<WebRtcAudioRenderer> renderer =
+      new WebRtcAudioRenderer(kRenderViewId);
+  EXPECT_TRUE(webrtc_audio_device->SetAudioRenderer(renderer.get()));
   renderer->Play();
 
   EXPECT_TRUE(event.TimedWait(TestTimeouts::action_timeout()));
   WaitForIOThreadCompletion();
 
   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());
@@ skipping 107 matching lines @@
   EXPECT_EQ(0, external_media->DeRegisterExternalMediaProcessing(
       ch, webrtc::kRecordingPerChannel));
   EXPECT_EQ(0, base->StopSend(ch));
 
   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(MAYBE_WebRTCAudioDeviceTest, DISABLED_PlayLocalFile) {
+// 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
+#define MAYBE_PlayLocalFile PlayLocalFile
+#endif
+TEST_F(MAYBE_WebRTCAudioDeviceTest, MAYBE_PlayLocalFile) {
   if (!has_output_devices_) {
     LOG(WARNING) << "No output device detected.";
     return;
   }
 
   std::string file_path(
       GetTestDataPath(FILE_PATH_LITERAL("speechmusic_mono_16kHz.pcm")));
 
   scoped_ptr<media::AudioHardwareConfig> config =
       CreateRealHardwareConfig(audio_manager_.get());
   SetAudioHardwareConfig(config.get());
+  media::AudioParameters params(config->GetOutputConfig());
 
   if (!HardwareSampleRatesAreValid())
     return;
 
   EXPECT_CALL(media_observer(),
-      OnSetAudioStreamStatus(_, 1, StrEq("created"))).Times(1);
+      OnAudioStreamCreated(_, 1, params, StrEq(""))).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<WebRtcAudioRenderer> renderer =
-      new WebRtcAudioRenderer(kRenderViewId);
+  WebRTCAutoDelete<webrtc::VoiceEngine> engine(webrtc::VoiceEngine::Create());
+  ASSERT_TRUE(engine.valid());
+  ScopedWebRTCPtr<webrtc::VoEBase> base(engine.get());
+  ASSERT_TRUE(base.valid());
+
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
-  EXPECT_TRUE(webrtc_audio_device->SetAudioRenderer(renderer.get()));
-
-  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);
-
   int ch = base->CreateChannel();
   EXPECT_NE(-1, ch);
   EXPECT_EQ(0, base->StartPlayout(ch));
+  scoped_refptr<WebRtcAudioRenderer> renderer =
+      new WebRtcAudioRenderer(kRenderViewId);
+  EXPECT_TRUE(webrtc_audio_device->SetAudioRenderer(renderer.get()));
   renderer->Play();
 
   ScopedWebRTCPtr<webrtc::VoEFile> file(engine.get());
   ASSERT_TRUE(file.valid());
   int duration = 0;
   EXPECT_EQ(0, file->GetFileDuration(file_path.c_str(), duration,
                                      webrtc::kFileFormatPcm16kHzFile));
   EXPECT_NE(0, duration);
 
   EXPECT_EQ(0, file->StartPlayingFileLocally(ch, file_path.c_str(), false,
                                              webrtc::kFileFormatPcm16kHzFile));
 
   // Play 2 seconds worth of audio and then quit.
   message_loop_.PostDelayedTask(FROM_HERE,
                                 base::MessageLoop::QuitClosure(),
-                                base::TimeDelta::FromSeconds(6));
+                                base::TimeDelta::FromSeconds(2));
   message_loop_.Run();
 
   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());
 }
 
 // Uses WebRtcAudioDeviceImpl to play out recorded audio in loopback.
@@ skipping 13 matching lines @@
 #endif
 TEST_F(MAYBE_WebRTCAudioDeviceTest, MAYBE_FullDuplexAudioWithAGC) {
   if (!has_output_devices_ || !has_input_devices_) {
     LOG(WARNING) << "Missing audio devices.";
     return;
   }
 
   scoped_ptr<media::AudioHardwareConfig> config =
       CreateRealHardwareConfig(audio_manager_.get());
   SetAudioHardwareConfig(config.get());
+  media::AudioParameters params(config->GetOutputConfig());
 
   if (!HardwareSampleRatesAreValid())
     return;
 
   EXPECT_CALL(media_observer(),
+      OnAudioStreamCreated(_, 1, params, StrEq(""))).Times(1);
+  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<WebRtcAudioRenderer> renderer =
-      new WebRtcAudioRenderer(kRenderViewId);
+  WebRTCAutoDelete<webrtc::VoiceEngine> engine(webrtc::VoiceEngine::Create());
+  ASSERT_TRUE(engine.valid());
+  ScopedWebRTCPtr<webrtc::VoEBase> base(engine.get());
+  ASSERT_TRUE(base.valid());
+
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
-  EXPECT_TRUE(webrtc_audio_device->SetAudioRenderer(renderer.get()));
-
-  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);
 
   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));
@@ skipping 17 matching lines @@
   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 =
+      new WebRtcAudioRenderer(kRenderViewId);
+  EXPECT_TRUE(webrtc_audio_device->SetAudioRenderer(renderer.get()));
   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();
 
   local_audio_track->Stop();
   renderer->Stop();
@@ skipping 54 matching lines @@
   int delay = (base::Time::Now() - start_time).InMilliseconds();
   PrintPerfResultMs("webrtc_recording_setup_c", "t", delay);
 
   local_audio_track->RemoveSink(sink.get());
   local_audio_track->Stop();
   EXPECT_EQ(0, base->StopSend(ch));
   EXPECT_EQ(0, base->DeleteChannel(ch));
   EXPECT_EQ(0, base->Terminate());
 }
 
-TEST_F(MAYBE_WebRTCAudioDeviceTest, WebRtcPlayoutSetupTime) {
+
+// 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
+#else
+#define MAYBE_WebRtcPlayoutSetupTime WebRtcPlayoutSetupTime
+#endif
+TEST_F(MAYBE_WebRTCAudioDeviceTest, MAYBE_WebRtcPlayoutSetupTime) {
   if (!has_output_devices_) {
     LOG(WARNING) << "No output device detected.";
     return;
   }
 
   scoped_ptr<media::AudioHardwareConfig> config =
       CreateRealHardwareConfig(audio_manager_.get());
   SetAudioHardwareConfig(config.get());
+  media::AudioParameters params(config->GetOutputConfig());
 
   if (!HardwareSampleRatesAreValid())
     return;
 
   EXPECT_CALL(media_observer(),
+      OnAudioStreamCreated(_, 1, params, StrEq(""))).Times(1);
+  EXPECT_CALL(media_observer(),
               OnSetAudioStreamStatus(_, 1, _)).Times(AnyNumber());
   EXPECT_CALL(media_observer(),
               OnSetAudioStreamPlaying(_, 1, true));
   EXPECT_CALL(media_observer(),
               OnDeleteAudioStream(_, 1)).Times(AnyNumber());
 
   base::WaitableEvent event(false, false);
   scoped_ptr<MockWebRtcAudioRendererSource> renderer_source(
       new MockWebRtcAudioRendererSource(&event));
   scoped_refptr<WebRtcAudioRenderer> renderer =
@@ skipping 36 matching lines @@
 #endif
 
 TEST_F(MAYBE_WebRTCAudioDeviceTest,
        MAYBE_WebRtcLoopbackTimeWithSignalProcessing) {
   int latency = RunWebRtcLoopbackTimeTest(audio_manager_.get(), true);
   PrintPerfResultMs("webrtc_loopback_with_signal_processing (100 packets)",
                     "t", latency);
 }
 
 }  // namespace content