Remove the AudioManager singleton.

content/test/webrtc_audio_device_test.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 "content/test/webrtc_audio_device_test.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
@@ skipping 78 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(WebRTCMockResourceContext);
 };
 
 ACTION_P(QuitMessageLoop, loop_or_proxy) {
   loop_or_proxy->PostTask(FROM_HERE, new MessageLoop::QuitTask());
 }
 
 }  // end namespace
 
 WebRTCAudioDeviceTest::WebRTCAudioDeviceTest()
-    : render_thread_(NULL), event_(false, false), audio_util_callback_(NULL) {
+    : render_thread_(NULL), audio_util_callback_(NULL) {
 }
 
 WebRTCAudioDeviceTest::~WebRTCAudioDeviceTest() {}
 
 void WebRTCAudioDeviceTest::SetUp() {
   // This part sets up a RenderThread environment to ensure that
   // RenderThread::current() (<=> TLS pointer) is valid.
   // Main parts are inspired by the RenderViewFakeResourcesTest.
   // Note that, the IPC part is not utilized in this test.
   saved_content_renderer_.reset(
       new ReplaceContentClientRenderer(&mock_content_renderer_client_));
   mock_process_.reset(new WebRTCMockRenderProcess());
   ui_thread_.reset(new content::TestBrowserThread(content::BrowserThread::UI,
                                                   MessageLoop::current()));
 
   // Construct the resource context on the UI thread.
   resource_context_.reset(new WebRTCMockResourceContext());
 
   static const char kThreadName[] = "RenderThread";
-  ChildProcess::current()->io_message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&SetupTask::InitializeIOThread, new SetupTask(this),
-                 kThreadName));
+  ChildProcess::current()->io_message_loop()->PostTask(FROM_HERE,
+      base::Bind(&WebRTCAudioDeviceTest::InitializeIOThread,
+                 base::Unretained(this), kThreadName));
   WaitForIOThreadCompletion();
 
   render_thread_ = new RenderThreadImpl(kThreadName);
   mock_process_->set_main_thread(render_thread_);
 }
 
 void WebRTCAudioDeviceTest::TearDown() {
   SetAudioUtilCallback(NULL);
 
-  ChildProcess::current()->io_message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&SetupTask::UninitializeIOThread, new SetupTask(this)));
-  EXPECT_TRUE(event_.TimedWait(
-      base::TimeDelta::FromMilliseconds(TestTimeouts::action_timeout_ms())));
+  // Kick of the cleanup process by closing channel. This queues up

[henrika (OOO until Aug 14), 2011/12/07 10:26:43]

the

[tommi (sloooow) - chröme, 2011/12/07 12:26:44]

Can you clarify?

[henrika (OOO until Aug 14), 2011/12/07 12:48:01]

"..by closing *the* channel."

[tommi (sloooow) - chröme, 2011/12/07 14:46:23]

ah. sorry, refrigerator blindness. Done.

+  // OnStreamClosed calls to be executed on the audio thread.
+  ChildProcess::current()->io_message_loop()->PostTask(FROM_HERE,
+      base::Bind(&WebRTCAudioDeviceTest::DestroyChannel,
+                 base::Unretained(this)));
+  WaitForIOThreadCompletion();
+
+  // When audio [input] render hosts are notified that the channel has
+  // been closed, they post tasks to the audio thread to close the
+  // AudioOutputController and once that's completed, a task is posted back to
+  // the IO thread to actually delete the AudioEntry for the audio stream. Only
+  // then is the reference to the audio manager released, so we wait for the
+  // whole thing to be torn down before we finally uninitialize the io thread.
+  WaitForAudioManagerCompletion();
+
+  ChildProcess::current()->io_message_loop()->PostTask(FROM_HERE,
+      base::Bind(&WebRTCAudioDeviceTest::UninitializeIOThread,
+                 base::Unretained((this))));
+  WaitForIOThreadCompletion();
   mock_process_.reset();
 }
 
 bool WebRTCAudioDeviceTest::Send(IPC::Message* message) {
   return channel_->Send(message);
 }
 
 void WebRTCAudioDeviceTest::SetAudioUtilCallback(AudioUtilInterface* callback) {
   // Invalidate any potentially cached values since the new callback should
   // be used for those queries.
   audio_hardware::ResetCache();
   audio_util_callback_ = callback;
 }
 
 void WebRTCAudioDeviceTest::InitializeIOThread(const char* thread_name) {
   // We initialize COM (STA) on our IO thread as is done in Chrome.
   // See BrowserProcessSubThread::Init.
   initialize_com_.reset(new ScopedCOMInitializer());
 
   // Set the current thread as the IO thread.
   io_thread_.reset(new content::TestBrowserThread(content::BrowserThread::IO,
                                                   MessageLoop::current()));
+
+  audio_manager_ = AudioManager::Create();
+
+  // Populate our resource context.
   test_request_context_ = new TestURLRequestContext();
   resource_context_->set_request_context(test_request_context_.get());
   media_observer_.reset(new MockMediaObserver());
   resource_context_->set_media_observer(media_observer_.get());
-  media_stream_manager_.reset(new media_stream::MediaStreamManager());
+  media_stream_manager_.reset(new media_stream::MediaStreamManager(
+      audio_manager_.get()));
   resource_context_->set_media_stream_manager(media_stream_manager_.get());
+  resource_context_->set_audio_manager(audio_manager_.get());
 
-  CreateChannel(thread_name, resource_context_.get());
+  // Create an IPC channel that handles incoming messages on the IO thread.
+  CreateChannel(thread_name);
 }
 
 void WebRTCAudioDeviceTest::UninitializeIOThread() {
-  DestroyChannel();
   resource_context_.reset();
   media_stream_manager_.reset();
+
+  EXPECT_TRUE(audio_manager_->HasOneRef());
+  audio_manager_ = NULL;
   test_request_context_ = NULL;
   initialize_com_.reset();
-  event_.Signal();
 }
 
-void WebRTCAudioDeviceTest::CreateChannel(
-    const char* name,
-    content::ResourceContext* resource_context) {
+void WebRTCAudioDeviceTest::CreateChannel(const char* name) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-  audio_render_host_ = new AudioRendererHost(resource_context);
+  audio_render_host_ = new AudioRendererHost(resource_context_.get());
   audio_render_host_->OnChannelConnected(base::GetCurrentProcId());
 
-  audio_input_renderer_host_ = new AudioInputRendererHost(resource_context);
+  audio_input_renderer_host_ = new AudioInputRendererHost(
+      resource_context_.get());
   audio_input_renderer_host_->OnChannelConnected(base::GetCurrentProcId());
 
   channel_.reset(new IPC::Channel(name, IPC::Channel::MODE_SERVER, this));
   ASSERT_TRUE(channel_->Connect());
 
   audio_render_host_->OnFilterAdded(channel_.get());
   audio_input_renderer_host_->OnFilterAdded(channel_.get());
 }
 
 void WebRTCAudioDeviceTest::DestroyChannel() {
@@ skipping 54 matching lines @@
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
 
   EXPECT_TRUE(message_is_ok);
 
   return true;
 }
 
 // Posts a final task to the IO message loop and waits for completion.
 void WebRTCAudioDeviceTest::WaitForIOThreadCompletion() {
-  ChildProcess::current()->io_message_loop()->PostTask(
-      FROM_HERE, base::Bind(&base::WaitableEvent::Signal,
-                            base::Unretained(&event_)));
-  EXPECT_TRUE(event_.TimedWait(
-      base::TimeDelta::FromMilliseconds(TestTimeouts::action_timeout_ms())));
+  WaitForMessageLoopCompletion(ChildProcess::current()->io_message_loop());
+}
+
+void WebRTCAudioDeviceTest::WaitForAudioManagerCompletion() {
+  if (audio_manager_.get())
+    WaitForMessageLoopCompletion(audio_manager_->GetMessageLoop());
+}
+
+void WebRTCAudioDeviceTest::WaitForMessageLoopCompletion(MessageLoop* loop) {
+  base::WaitableEvent* event = new base::WaitableEvent(false, false);
+  loop->PostTask(FROM_HERE, base::Bind(&base::WaitableEvent::Signal,
+                 base::Unretained(event)));
+  if (event->TimedWait(base::TimeDelta::FromMilliseconds(
+          TestTimeouts::action_max_timeout_ms()))) {
+    delete event;
+  } else {
+    // Don't delete the event object in case the message ever gets processed.
+    // If we do, we will crash the test process.
+    ADD_FAILURE() << "Failed to wait for message loop";
+  }
 }
 
 std::string WebRTCAudioDeviceTest::GetTestDataPath(
     const FilePath::StringType& file_name) {
   FilePath path;
   EXPECT_TRUE(PathService::Get(content::DIR_TEST_DATA, &path));
   path = path.Append(file_name);
   EXPECT_TRUE(file_util::PathExists(path));
 #ifdef OS_WIN
   return WideToUTF8(path.value());
 #else
   return path.value();
 #endif
 }
 
 WebRTCTransportImpl::WebRTCTransportImpl(webrtc::VoENetwork* network)
     : network_(network) {
 }
 
 WebRTCTransportImpl::~WebRTCTransportImpl() {}
 
 int WebRTCTransportImpl::SendPacket(int channel, const void* data, int len) {
   return network_->ReceivedRTPPacket(channel, data, len);
 }
 
 int WebRTCTransportImpl::SendRTCPPacket(int channel, const void* data,
                                         int len) {
   return network_->ReceivedRTCPPacket(channel, data, len);
 }