Remove the AudioManager singleton.

media/audio/linux/alsa_input.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/linux/alsa_input.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "media/audio/audio_manager.h"
 #include "media/audio/linux/alsa_output.h"
 #include "media/audio/linux/alsa_util.h"
 #include "media/audio/linux/alsa_wrapper.h"
 #include "media/audio/linux/audio_manager_linux.h"
 
 static const int kNumPacketsInRingBuffer = 3;
 
 static const char kDefaultDevice1[] = "default";
 static const char kDefaultDevice2[] = "plug:default";
 
 const char* AlsaPcmInputStream::kAutoSelectDevice = "";
 
-AlsaPcmInputStream::AlsaPcmInputStream(const std::string& device_name,
+AlsaPcmInputStream::AlsaPcmInputStream(AudioManagerLinux* audio_manager,
+                                       const std::string& device_name,
                                        const AudioParameters& params,
                                        AlsaWrapper* wrapper)
-    : device_name_(device_name),
+    : audio_manager_(audio_manager),
+      device_name_(device_name),
       params_(params),
       bytes_per_packet_(params.samples_per_packet *
                         (params.channels * params.bits_per_sample) / 8),
       wrapper_(wrapper),
       packet_duration_ms_(
           (params.samples_per_packet * base::Time::kMillisecondsPerSecond) /
           params.sample_rate),
       callback_(NULL),
       device_handle_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
@@ skipping 64 matching lines @@
     // packet might have got filled, to accommodate some delays in the audio
     // driver. This could also give us a smooth read sequence going forward.
     int64 delay_ms = packet_duration_ms_ + packet_duration_ms_ / 2;
     next_read_time_ = base::Time::Now() + base::TimeDelta::FromMilliseconds(
         delay_ms);
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&AlsaPcmInputStream::ReadAudio, weak_factory_.GetWeakPtr()),
         delay_ms);
 
-    static_cast<AudioManagerLinux*>(AudioManager::GetAudioManager())->
-        IncreaseActiveInputStreamCount();
+    audio_manager_->IncreaseActiveInputStreamCount();
   }
 }
 
 bool AlsaPcmInputStream::Recover(int original_error) {
   int error = wrapper_->PcmRecover(device_handle_, original_error, 1);
   if (error < 0) {
     // Docs say snd_pcm_recover returns the original error if it is not one
     // of the recoverable ones, so this log message will probably contain the
     // same error twice.
     LOG(WARNING) << "Unable to recover from \""
@@ skipping 92 matching lines @@
       base::Bind(&AlsaPcmInputStream::ReadAudio, weak_factory_.GetWeakPtr()),
       delay_ms);
 }
 
 void AlsaPcmInputStream::Stop() {
   if (!device_handle_ || !callback_)
     return;
 
   // Stop is always called before Close. In case of error, this will be
   // also called when closing the input controller.
-  static_cast<AudioManagerLinux*>(AudioManager::GetAudioManager())->
-      DecreaseActiveInputStreamCount();
+  audio_manager_->DecreaseActiveInputStreamCount();
 
   weak_factory_.InvalidateWeakPtrs();  // Cancel the next scheduled read.
   int error = wrapper_->PcmDrop(device_handle_);
   if (error < 0)
     HandleError("PcmDrop", error);
 }
 
 void AlsaPcmInputStream::Close() {
   scoped_ptr<AlsaPcmInputStream> self_deleter(this);
 
   // Check in case we were already closed or not initialized yet.
   if (!device_handle_ || !callback_)
     return;
 
   weak_factory_.InvalidateWeakPtrs();  // Cancel the next scheduled read.
   int error = alsa_util::CloseDevice(wrapper_, device_handle_);
   if (error < 0)
     HandleError("PcmClose", error);
 
   audio_packet_.reset();
   device_handle_ = NULL;
   callback_->OnClose(this);
 }
 
 void AlsaPcmInputStream::HandleError(const char* method, int error) {
   LOG(WARNING) << method << ": " << wrapper_->StrError(error);
   callback_->OnError(this, error);
 }