Remove the AudioManager singleton.

media/audio/audio_output_controller.cc

Index: media/audio/audio_output_controller.cc
===================================================================
--- media/audio/audio_output_controller.cc	(revision 114012)
+++ media/audio/audio_output_controller.cc	(working copy)
@@ -21,10 +21,12 @@
 const int AudioOutputController::kPollNumAttempts = 3;
 const int AudioOutputController::kPollPauseInMilliseconds = 3;
 
-AudioOutputController::AudioOutputController(EventHandler* handler,
+AudioOutputController::AudioOutputController(AudioManager* audio_manager,
+                                             EventHandler* handler,
                                              uint32 capacity,
                                              SyncReader* sync_reader)
-    : handler_(handler),
+    : audio_manager_(audio_manager),
+      handler_(handler),
       stream_(NULL),
       volume_(1.0),
       state_(kEmpty),
@@ -32,7 +34,8 @@
       pending_request_(false),
       sync_reader_(sync_reader),
       message_loop_(NULL),
-      number_polling_attempts_left_(0) {
+      number_polling_attempts_left_(0),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_this_(this)) {
 }
 
 AudioOutputController::~AudioOutputController() {
@@ -42,81 +45,77 @@
 
 // static
 scoped_refptr<AudioOutputController> AudioOutputController::Create(
+    AudioManager* audio_manager,
     EventHandler* event_handler,
     const AudioParameters& params,
     uint32 buffer_capacity) {
-
-  if (!params.IsValid())
+  DCHECK(audio_manager);
+  if (!params.IsValid() ||  !audio_manager)
     return NULL;
 
-  if (!AudioManager::GetAudioManager())
-    return NULL;
-
   // Starts the audio controller thread.
   scoped_refptr<AudioOutputController> controller(new AudioOutputController(
-      event_handler, buffer_capacity, NULL));
+      audio_manager, event_handler, buffer_capacity, NULL));
 
-  controller->message_loop_ =
-      AudioManager::GetAudioManager()->GetMessageLoop();
+  controller->message_loop_ = audio_manager->GetMessageLoop();
   controller->message_loop_->PostTask(FROM_HERE, base::Bind(
-      &AudioOutputController::DoCreate, controller.get(), params));
+      &AudioOutputController::DoCreate, base::Unretained(controller.get()),
+      params));
   return controller;
 }
 
 // static
 scoped_refptr<AudioOutputController> AudioOutputController::CreateLowLatency(
+    AudioManager* audio_manager,
     EventHandler* event_handler,
     const AudioParameters& params,
     SyncReader* sync_reader) {
-
+  DCHECK(audio_manager);
   DCHECK(sync_reader);
 
-  if (!params.IsValid())
+  if (!params.IsValid() || !audio_manager)
     return NULL;
 
-  if (!AudioManager::GetAudioManager())
-    return NULL;
-
   // Starts the audio controller thread.
   scoped_refptr<AudioOutputController> controller(new AudioOutputController(
-      event_handler, 0, sync_reader));
+      audio_manager, event_handler, 0, sync_reader));
 
-  controller->message_loop_ =
-      AudioManager::GetAudioManager()->GetMessageLoop();
+  controller->message_loop_ = audio_manager->GetMessageLoop();
   controller->message_loop_->PostTask(FROM_HERE, base::Bind(
-      &AudioOutputController::DoCreate, controller.get(), params));
+      &AudioOutputController::DoCreate, base::Unretained(controller.get()),
+      params));
   return controller;
 }
 
 void AudioOutputController::Play() {
   DCHECK(message_loop_);
   message_loop_->PostTask(FROM_HERE, base::Bind(
-      &AudioOutputController::DoPlay, this));
+      &AudioOutputController::DoPlay, base::Unretained(this)));
 }
 
 void AudioOutputController::Pause() {
   DCHECK(message_loop_);
   message_loop_->PostTask(FROM_HERE, base::Bind(
-      &AudioOutputController::DoPause, this));
+      &AudioOutputController::DoPause, base::Unretained(this)));
 }
 
 void AudioOutputController::Flush() {
   DCHECK(message_loop_);
   message_loop_->PostTask(FROM_HERE, base::Bind(
-      &AudioOutputController::DoFlush, this));
+      &AudioOutputController::DoFlush, base::Unretained(this)));
 }
 
 void AudioOutputController::Close(const base::Closure& closed_task) {
   DCHECK(!closed_task.is_null());
   DCHECK(message_loop_);
   message_loop_->PostTask(FROM_HERE, base::Bind(
-      &AudioOutputController::DoClose, this, closed_task));
+      &AudioOutputController::DoClose, base::Unretained(this), closed_task));
 }
 
 void AudioOutputController::SetVolume(double volume) {
   DCHECK(message_loop_);
   message_loop_->PostTask(FROM_HERE, base::Bind(
-      &AudioOutputController::DoSetVolume, this, volume));
+      &AudioOutputController::DoSetVolume, base::Unretained(this), volume));
 }
 
 void AudioOutputController::EnqueueData(const uint8* data, uint32 size) {
@@ -140,11 +139,8 @@
     return;
   DCHECK_EQ(kEmpty, state_);
 
-  if (!AudioManager::GetAudioManager())
-    return;
-
   StopCloseAndClearStream();
-  stream_ = AudioManager::GetAudioManager()->MakeAudioOutputStreamProxy(params);
+  stream_ = audio_manager_->MakeAudioOutputStreamProxy(params);
   if (!stream_) {
     // TODO(hclam): Define error types.
     handler_->OnError(this, 0);
@@ -193,7 +189,8 @@
     number_polling_attempts_left_ = kPollNumAttempts;
     message_loop_->PostDelayedTask(
         FROM_HERE,
-        base::Bind(&AudioOutputController::PollAndStartIfDataReady, this),
+        base::Bind(&AudioOutputController::PollAndStartIfDataReady,
+        weak_this_.GetWeakPtr()),
         kPollPauseInMilliseconds);
   } else {
     StartStream();
@@ -203,7 +200,7 @@
 void AudioOutputController::PollAndStartIfDataReady() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
-  // Being paranoic: do nothing if state unexpectedly changed.
+  // Being paranoid: do nothing if state unexpectedly changed.
   if ((state_ != kStarting) && (state_ != kPausedWhenStarting))
     return;
 
@@ -220,7 +217,8 @@
   } else {
     message_loop_->PostDelayedTask(
         FROM_HERE,
-        base::Bind(&AudioOutputController::PollAndStartIfDataReady, this),
+        base::Bind(&AudioOutputController::PollAndStartIfDataReady,
+        weak_this_.GetWeakPtr()),
         kPollPauseInMilliseconds);
   }
 }
@@ -379,7 +377,7 @@
 void AudioOutputController::OnError(AudioOutputStream* stream, int code) {
   // Handle error on the audio controller thread.
   message_loop_->PostTask(FROM_HERE, base::Bind(
-      &AudioOutputController::DoReportError, this, code));
+      &AudioOutputController::DoReportError, base::Unretained(this), code));
 }
 
 void AudioOutputController::SubmitOnMoreData_Locked() {
@@ -409,6 +407,7 @@
   stream_->Stop();
   stream_->Close();
   stream_ = NULL;
+  weak_this_.InvalidateWeakPtrs();
 }
 
 }  // namespace media