Remove the AudioManager singleton.

content/browser/renderer_host/media/media_stream_manager.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 "content/browser/renderer_host/media/media_stream_manager.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager.h"
 #include "content/browser/renderer_host/media/media_stream_device_settings.h"
 #include "content/browser/renderer_host/media/media_stream_requester.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/common/media/media_stream_options.h"
 #include "content/public/browser/browser_thread.h"
+#include "media/audio/audio_manager.h"
 
 using content::BrowserThread;
 
 namespace media_stream {
 
 // Creates a random label used to identify requests.
 static std::string RandomLabel() {
   // Alphabet according to WhatWG standard, i.e. containing 36 characters from
   // range: U+0021, U+0023 to U+0027, U+002A to U+002B, U+002D to U+002E,
   // U+0030 to U+0039, U+0041 to U+005A, U+005E to U+007E.
@@ skipping 44 matching lines @@
     kError
   };
 
   MediaStreamRequester* requester;
   StreamOptions options;
   std::vector<RequestState> state;
   StreamDeviceInfoArray audio_devices;
   StreamDeviceInfoArray video_devices;
 };
 
-MediaStreamManager::MediaStreamManager()
+MediaStreamManager::MediaStreamManager(AudioManager* audio_manager)
     : ALLOW_THIS_IN_INITIALIZER_LIST(
           device_settings_(new MediaStreamDeviceSettings(this))),
-      enumeration_in_progress_(kNumMediaStreamTypes, false) {
+      enumeration_in_progress_(kNumMediaStreamTypes, false),
+      audio_manager_(audio_manager) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 }
 
 MediaStreamManager::~MediaStreamManager() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 }
 
 VideoCaptureManager* MediaStreamManager::video_capture_manager() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!video_capture_manager_.get()) {
     video_capture_manager_.reset(new VideoCaptureManager());
     video_capture_manager_->Register(this);
   }
   return video_capture_manager_.get();
 }
 
 AudioInputDeviceManager* MediaStreamManager::audio_input_device_manager() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!audio_input_device_manager_.get()) {
-    audio_input_device_manager_.reset(new AudioInputDeviceManager());
+    audio_input_device_manager_.reset(
+        new AudioInputDeviceManager(audio_manager_.get()));
     audio_input_device_manager_->Register(this);
   }
   return audio_input_device_manager_.get();
 }
 
 void MediaStreamManager::GenerateStream(MediaStreamRequester* requester,
                                         int render_process_id,
                                         int render_view_id,
                                         const StreamOptions& options,
                                         const std::string& security_origin,
@@ skipping 321 matching lines @@
   if (stream_type == kVideoCapture) {
     return video_capture_manager();
   } else if (stream_type == kAudioCapture) {
     return audio_input_device_manager();
   }
   NOTREACHED();
   return NULL;
 }
 
 }  // namespace media_stream