Remove the AudioManager singleton.

media/audio/audio_output_controller.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 "media/audio/audio_output_controller.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/threading/platform_thread.h"
 #include "base/time.h"
 
 using base::Time;
 
 namespace media {
 
 // Signal a pause in low-latency mode.
 const int AudioOutputController::kPauseMark = -1;
 
 // Polling-related constants.
 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),
       buffer_(0, capacity),
       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() {
   DCHECK_EQ(kClosed, state_);
   StopCloseAndClearStream();
 }
 
 // static
 scoped_refptr<AudioOutputController> AudioOutputController::Create(
+    AudioManager* audio_manager,
     EventHandler* event_handler,
     const AudioParameters& params,
     uint32 buffer_capacity) {
-
-  if (!params.IsValid())
-    return NULL;
-
-  if (!AudioManager::GetAudioManager())
+  DCHECK(audio_manager);
+  if (!params.IsValid() ||  !audio_manager)
     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())
-    return NULL;
-
-  if (!AudioManager::GetAudioManager())
+  if (!params.IsValid() || !audio_manager)
     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) {
   // Write data to the push source and ask for more data if needed.
   base::AutoLock auto_lock(lock_);
   pending_request_ = false;
   // If |size| is set to 0, it indicates that the audio source doesn't have
   // more data right now, and so it doesn't make sense to send additional
   // request.
   if (size) {
     buffer_.Append(data, size);
     SubmitOnMoreData_Locked();
   }
 }
 
 void AudioOutputController::DoCreate(const AudioParameters& params) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   // Close() can be called before DoCreate() is executed.
   if (state_ == kClosed)
     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);
     return;
   }
 
   if (!stream_->Open()) {
     StopCloseAndClearStream();
 
     // TODO(hclam): Define error types.
@@ skipping 28 matching lines @@
     state_ = kStarting;
 
     // Ask for first packet.
     sync_reader_->UpdatePendingBytes(0);
 
     // Cannot start stream immediately, should give renderer some time
     // to deliver data.
     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();
   }
 }
 
 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;
 
   bool pausing = (state_ == kPausedWhenStarting);
   // If we are ready to start the stream, start it.
   // Of course we may have to stop it immediately...
   if (--number_polling_attempts_left_ == 0 ||
       pausing ||
       sync_reader_->DataReady()) {
     StartStream();
     if (pausing) {
       DoPause();
     }
   } else {
     message_loop_->PostDelayedTask(
         FROM_HERE,
-        base::Bind(&AudioOutputController::PollAndStartIfDataReady, this),
+        base::Bind(&AudioOutputController::PollAndStartIfDataReady,
+        weak_this_.GetWeakPtr()),
         kPollPauseInMilliseconds);
   }
 }
 
 void AudioOutputController::StartStream() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   state_ = kPlaying;
 
   // We start the AudioOutputStream lazily.
   stream_->Start(this);
@@ skipping 138 matching lines @@
     do {
       base::PlatformThread::Sleep(1);
     } while (!sync_reader_->DataReady() &&
              (Time::Now() - start_time).InMilliseconds() < kMaxPollingDelayMs);
   }
 }
 
 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() {
   lock_.AssertAcquired();
 
   if (buffer_.forward_bytes() > buffer_.forward_capacity())
     return;
 
   if (pending_request_)
     return;
   pending_request_ = true;
 
   AudioBuffersState buffers_state = buffers_state_;
   buffers_state.pending_bytes += buffer_.forward_bytes();
 
   // If we need more data then call the event handler to ask for more data.
   // It is okay that we don't lock in this block because the parameters are
   // correct and in the worst case we are just asking more data than needed.
   base::AutoUnlock auto_unlock(lock_);
   handler_->OnMoreData(this, buffers_state);
 }
 
 void AudioOutputController::StopCloseAndClearStream() {
   // Allow calling unconditionally and bail if we don't have a stream_ to close.
   if (!stream_)
     return;
   stream_->Stop();
   stream_->Close();
   stream_ = NULL;
+  weak_this_.InvalidateWeakPtrs();
 }
 
 }  // namespace media