Remove the AudioManager singleton.

content/browser/renderer_host/media/audio_renderer_host_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/bind.h"
 #include "base/environment.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/sync_socket.h"
@@ skipping 24 matching lines @@
 
 static bool IsRunningHeadless() {
   scoped_ptr<base::Environment> env(base::Environment::Create());
   if (env->HasVar("CHROME_HEADLESS"))
     return true;
   return false;
 }
 
 class MockAudioRendererHost : public AudioRendererHost {
  public:
-  MockAudioRendererHost(const content::ResourceContext* resource_context)
+  explicit MockAudioRendererHost(
+      const content::ResourceContext* resource_context)
       : AudioRendererHost(resource_context),
         shared_memory_length_(0) {
   }
 
   virtual ~MockAudioRendererHost() {
   }
 
   // A list of mock methods.
   MOCK_METHOD2(OnRequestPacket,
                void(int stream_id, AudioBuffersState buffers_state));
@@ skipping 119 matching lines @@
  protected:
   virtual void SetUp() {
     // Create a message loop so AudioRendererHost can use it.
     message_loop_.reset(new MessageLoop(MessageLoop::TYPE_IO));
 
     // Claim to be on both the UI and IO threads to pass all the DCHECKS.
     io_thread_.reset(new BrowserThreadImpl(BrowserThread::IO,
                                            message_loop_.get()));
     ui_thread_.reset(new BrowserThreadImpl(BrowserThread::UI,
                                            message_loop_.get()));
-
+    audio_manager_ = AudioManager::Create();
     observer_.reset(new MockMediaObserver());
     content::MockResourceContext* context =
         content::MockResourceContext::GetInstance();
     context->set_media_observer(observer_.get());
+    context->set_audio_manager(audio_manager_);
     host_ = new MockAudioRendererHost(context);
 
     // Simulate IPC channel connected.
     host_->OnChannelConnected(base::GetCurrentProcId());
   }
 
   virtual void TearDown() {
     // Simulate closing the IPC channel.
     host_->OnChannelClosing();
 
     // Release the reference to the mock object.  The object will be destructed
     // on message_loop_.
     host_ = NULL;
 
     // We need to continue running message_loop_ to complete all destructions.
     SyncWithAudioThread();
 
+    // Since the MockResourceContext object is a singleton that lives across
+    // multiple tests, we must clear pointers to objects that are about to die.
+    content::MockResourceContext* context =
+        content::MockResourceContext::GetInstance();
+    context->set_audio_manager(NULL);
+    context->set_media_observer(NULL);
+    audio_manager_ = NULL;
+
     io_thread_.reset();
     ui_thread_.reset();
   }
 
   void Create() {
     EXPECT_CALL(*observer_,
                 OnSetAudioStreamStatus(_, kStreamId, "created"));
     EXPECT_CALL(*observer_, OnDeleteAudioStream(_, kStreamId));
 
     InSequence s;
@@ skipping 114 matching lines @@
     // Expect the audio stream record is removed.
     EXPECT_EQ(0u, host_->audio_entries_.size());
   }
 
   // Called on the audio thread.
   static void PostQuitMessageLoop(MessageLoop* message_loop) {
     message_loop->PostTask(FROM_HERE, MessageLoop::QuitClosure());
   }
 
   // Called on the main thread.
-  static void PostQuitOnAudioThread(MessageLoop* message_loop) {
-    AudioManager::GetAudioManager()->GetMessageLoop()->PostTask(
-        FROM_HERE, base::Bind(&PostQuitMessageLoop, message_loop));
+  static void PostQuitOnAudioThread(AudioManager* audio_manager,
+                                    MessageLoop* message_loop) {
+    audio_manager->GetMessageLoop()->PostTask(FROM_HERE,
+        base::Bind(&PostQuitMessageLoop, message_loop));
   }
 
   // SyncWithAudioThread() waits until all pending tasks on the audio thread
   // are executed while also processing pending task in message_loop_ on the
   // current thread. It is used to synchronize with the audio thread when we are
   // closing an audio stream.
   void SyncWithAudioThread() {
+    // Don't use scoped_refptr to addref the AudioManager when posting
+    // to the thread that itself owns.
     message_loop_->PostTask(
-        FROM_HERE, base::Bind(&PostQuitOnAudioThread, message_loop_.get()));
+        FROM_HERE, base::Bind(&PostQuitOnAudioThread,
+            base::Unretained(audio_manager_.get()),
+            message_loop_.get()));
     message_loop_->Run();
   }
 
   MessageLoop* message_loop() { return message_loop_.get(); }
   MockAudioRendererHost* host() { return host_; }
   void EnableRealDevice() { mock_stream_ = false; }
 
  private:
   bool mock_stream_;
   scoped_ptr<MockMediaObserver> observer_;
   scoped_refptr<MockAudioRendererHost> host_;
   scoped_ptr<MessageLoop> message_loop_;
   scoped_ptr<BrowserThreadImpl> io_thread_;
   scoped_ptr<BrowserThreadImpl> ui_thread_;
+  scoped_refptr<AudioManager> audio_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioRendererHostTest);
 };
 
 TEST_F(AudioRendererHostTest, CreateAndClose) {
   if (!IsRunningHeadless())
     EnableRealDevice();
 
   Create();
   Close();
@@ skipping 120 matching lines @@
 
 // Simulate the case where a stream is not properly closed.
 TEST_F(AudioRendererHostTest, CreateLowLatencyAndShutdown) {
   if (!IsRunningHeadless())
     EnableRealDevice();
 
   CreateLowLatency();
 }
 
 // TODO(hclam): Add tests for data conversation in low latency mode.