Remove the AudioManager singleton.

media/audio/audio_input_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_input_controller.h"
 
 #include "base/bind.h"
 #include "base/threading/thread_restrictions.h"
 #include "media/base/limits.h"
 
 namespace {
 const int kMaxInputChannels = 2;
-const int kTimerResetInterval = 1; // One second.
+const int kTimerResetInterval = 1;  // One second.
 }
 
 namespace media {
 
 // static
 AudioInputController::Factory* AudioInputController::factory_ = NULL;
 
-AudioInputController::AudioInputController(EventHandler* handler,
+AudioInputController::AudioInputController(AudioManager* audio_manager,
+                                           EventHandler* handler,
                                            SyncWriter* sync_writer)
-    : handler_(handler),
+    : audio_manager_(audio_manager),
+      handler_(handler),
       stream_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(no_data_timer_(FROM_HERE,
           base::TimeDelta::FromSeconds(kTimerResetInterval),
           this,
           &AudioInputController::DoReportNoDataError)),
       state_(kEmpty),
       thread_("AudioInputControllerThread"),
       sync_writer_(sync_writer) {
+  DCHECK(audio_manager_);  // Fail early.
 }
 
 AudioInputController::~AudioInputController() {
   DCHECK(kClosed == state_ || kCreated == state_ || kEmpty == state_);
 }
 
 // static
 scoped_refptr<AudioInputController> AudioInputController::Create(
+    AudioManager* audio_manager,
     EventHandler* event_handler,
     const AudioParameters& params) {
+  DCHECK(audio_manager);
   if (!params.IsValid() || (params.channels > kMaxInputChannels))
     return NULL;
 
   if (factory_) {
-    return factory_->Create(event_handler, params);
+    return factory_->Create(audio_manager, event_handler, params);
   }
 
   scoped_refptr<AudioInputController> controller(new AudioInputController(
-      event_handler, NULL));
+      audio_manager, event_handler, NULL));
 
   // Start the thread and post a task to create the audio input stream.
   // Pass an empty string to indicate using default device.
   std::string device_id = AudioManagerBase::kDefaultDeviceId;
   controller->thread_.Start();
   controller->thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
       &AudioInputController::DoCreate, controller.get(),
       params, device_id));
   return controller;
 }
 
 // static
 scoped_refptr<AudioInputController> AudioInputController::CreateLowLatency(
+    AudioManager* audio_manager,
     EventHandler* event_handler,
     const AudioParameters& params,
     const std::string& device_id,
     SyncWriter* sync_writer) {
+  DCHECK(audio_manager);
   DCHECK(sync_writer);
 
   if (!params.IsValid() || (params.channels > kMaxInputChannels))
     return NULL;
 
-  if (!AudioManager::GetAudioManager())
-    return NULL;
-
   // Starts the audio controller thread.
   scoped_refptr<AudioInputController> controller(new AudioInputController(
-      event_handler, sync_writer));
+      audio_manager, event_handler, sync_writer));
 
   // Start the thread and post a task to create the audio input stream.
   controller->thread_.Start();
   controller->thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
       &AudioInputController::DoCreate, controller.get(), params, device_id));
   return controller;
 }
 
 void AudioInputController::Record() {
   DCHECK(thread_.IsRunning());
@@ skipping 18 matching lines @@
   // thread (it is missnamed) being used here. This object overrides
   // temporarily this restriction and should be used only in specific
   // infrequent cases where joining is guaranteed to be fast.
   // Bug: http://code.google.com/p/chromium/issues/detail?id=67806
   base::ThreadRestrictions::ScopedAllowIO allow_io_for_thread_join;
   thread_.Stop();
 }
 
 void AudioInputController::DoCreate(const AudioParameters& params,
                                     const std::string& device_id) {
-  stream_ = AudioManager::GetAudioManager()->MakeAudioInputStream(params,
-                                                                  device_id);
+  stream_ = audio_manager_->MakeAudioInputStream(params, device_id);
 
   if (!stream_) {
     // TODO(satish): Define error types.
     handler_->OnError(this, 0);
     return;
   }
 
   if (stream_ && !stream_->Open()) {
     stream_->Close();
     stream_ = NULL;
@@ skipping 86 matching lines @@
   // such cases here.
 }
 
 void AudioInputController::OnError(AudioInputStream* stream, int code) {
   // Handle error on the audio controller thread.
   thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
       &AudioInputController::DoReportError, this, code));
 }
 
 }  // namespace media