Remove the AudioManager singleton.

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/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 118 matching lines @@
   int channel_id_;
   webrtc::ProcessingTypes type_;
   int packet_size_;
   int sample_rate_;
   int channels_;
   DISALLOW_COPY_AND_ASSIGN(WebRTCMediaProcessImpl);
 };
 
 }  // end namespace
 
-// Utility class to delete the AudioManager.
-// TODO(tommi): Remove when we've fixed issue 105249.
-class AutoAudioManagerCleanup {
- public:
-  AutoAudioManagerCleanup() {
-    // Log an error if a previous test didn't clean up the AudioManager.
-    if (DeleteAndResurrect()) {
-      LOG(ERROR)
-          << "AudioManager singleton was not cleaned up by some previous test!";
-    }
-  }
-  ~AutoAudioManagerCleanup() {
-    DeleteAndResurrect();
-  }
-
- private:
-  // Returns true iff the AudioManager existed and was deleted.
-  bool DeleteAndResurrect() {
-    if (AudioManager::SingletonExists()) {
-      AudioManager::Destroy(NULL);
-      AudioManager::Resurrect();
-      return true;
-    }
-    return false;
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(AutoAudioManagerCleanup);
-};
-
 // Basic test that instantiates and initializes an instance of
 // WebRtcAudioDeviceImpl.
 TEST_F(WebRTCAudioDeviceTest, Construct) {
-  AutoAudioManagerCleanup audio_manager_cleanup;
   AudioUtilNoHardware audio_util(48000.0, 48000.0);
   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) {
-  AutoAudioManagerCleanup audio_manager_cleanup;
-
   if (IsRunningHeadless())
     return;
 
   AudioUtil audio_util;
   SetAudioUtilCallback(&audio_util);
 
   if (!HardwareSampleRatesAreValid())
     return;
 
   EXPECT_CALL(media_observer(),
@@ skipping 52 matching lines @@
 // Verify that a call to webrtc::VoEBase::StartRecording() starts audio input
 // 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 input audio and
 // 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) {
-  AutoAudioManagerCleanup audio_manager_cleanup;
-
   if (IsRunningHeadless())
     return;
 
   AudioUtil audio_util;
   SetAudioUtilCallback(&audio_util);
 
   if (!HardwareSampleRatesAreValid())
     return;
 
   // TODO(tommi): extend MediaObserver and MockMediaObserver with support
@@ skipping 47 matching lines @@
       ch, webrtc::kRecordingPerChannel));
   EXPECT_EQ(0, base->StopSend(ch));
 
   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.
 TEST_F(WebRTCAudioDeviceTest, PlayLocalFile) {
-  AutoAudioManagerCleanup audio_manager_cleanup;
-
   if (IsRunningHeadless())
     return;
 
   std::string file_path(
       GetTestDataPath(FILE_PATH_LITERAL("speechmusic_mono_16kHz.pcm")));
 
   AudioUtil audio_util;
   SetAudioUtilCallback(&audio_util);
 
   if (!HardwareSampleRatesAreValid())
@@ skipping 26 matching lines @@
 
   ScopedWebRTCPtr<webrtc::VoEFile> file(engine.get());
   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,
                                 new MessageLoop::QuitTask(),
-                                TestTimeouts::action_timeout_ms());
+                                2000);

[scherkus (not reviewing), 2011/12/09 22:47:30]

was action_timeout_ms not enough or too much?

would tiny_timeout_ms_ work? (100ms)

perhaps action_timeout_ms() divided by some #?

[tommi (sloooow) - chröme, 2011/12/10 00:11:14]

action_timeout is 10seconds, which is too long when running all the tests
routinely.  I wanted to go with a fixed value since this is an audio file and
it's long enough for you to hear a word or two.  A second or even less would do
fine too.  I initially used action_timeout_ms() here since tiny was too short
and this was the next timeout value in the line.  However, since what we're
doing here isn't really an "action" I figured having a constant would make more
sense.
I can change it to e.g. action_timeout_ms() / 10 or 5 if you want.

   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());
 }
 
 // Uses WebRtcAudioDeviceImpl to play out recorded audio in loopback.
 // An external transport implementation is utilized to feed back RTP packets
 // 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) {
-  AutoAudioManagerCleanup audio_manager_cleanup;
-
   if (IsRunningHeadless())
     return;
 
   AudioUtil audio_util;
   SetAudioUtilCallback(&audio_util);
 
   if (!HardwareSampleRatesAreValid())
     return;
 
   EXPECT_CALL(media_observer(),
@@ skipping 31 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());
 }