Remove the AudioManager singleton.

media/audio/linux/audio_manager_linux.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/audio_manager_linux.h"
 
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/nix/xdg_util.h"
@@ skipping 38 matching lines @@
 
 AudioOutputStream* AudioManagerLinux::MakeAudioOutputStream(
     const AudioParameters& params) {
   // Early return for testing hook.  Do this before checking for
   // |initialized_|.
   if (params.format == AudioParameters::AUDIO_MOCK) {
     return FakeAudioOutputStream::MakeFakeStream(params);
   }
 
   if (!initialized()) {
+    // We should never get here since this method is called on the audio thread.
+    NOTREACHED();
     return NULL;
   }
 
   // Don't allow opening more than |kMaxOutputStreams| streams.
-  if (active_streams_.size() >= kMaxOutputStreams) {
+  if (active_output_stream_count_ >= kMaxOutputStreams)
     return NULL;
-  }
 
   AudioOutputStream* stream;
 #if defined(USE_PULSEAUDIO)
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kUsePulseAudio)) {
     stream = new PulseAudioOutputStream(params, this, GetMessageLoop());
   } else {
 #endif
     std::string device_name = AlsaPcmOutputStream::kAutoSelectDevice;
     if (CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kAlsaOutputDevice)) {
       device_name = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kAlsaOutputDevice);
     }
     stream = new AlsaPcmOutputStream(device_name, params, wrapper_.get(), this,
                                      GetMessageLoop());
 #if defined(USE_PULSEAUDIO)
   }
 #endif
-  active_streams_.insert(stream);
+  ++active_output_stream_count_;

[scherkus (not reviewing), 2011/12/09 22:47:30]

we should probably re-think this active stream count business at some point

care to TODOify/file a bug for this stuff?

things I'm curious about:
  a) Is it even useful / used?
  b) If so, are all OSes implementing it?
  c) Can we converge on a scheme (i.e., input streams call
Increase/DecreaseActiveInputStreamCount() while output streams increment on
creation then call ReleaseOutputStream() later on)
  d) Can we make it less error prone (i.e, can the manager handle all of this
transparently, perhaps by requiring Stop() to be called on the manager instead
of the stream itself)

[tommi (sloooow) - chröme, 2011/12/10 00:11:14]

It's checked against kMaxOutputStreams above.  Other than that, it looks like a
debugging aid.
This is the only place I've seen it.
I think that's a good idea, provided that it is useful :)  I'll ask leandro and
satish about usefulness.
+1 on that.  I'd like to do that on a separate cl if that's alright and with
input from the other guys on usefulness etc.

[tommi (sloooow) - chröme, 2011/12/10 09:59:57]

bug filed: crbug.com/107088

   return stream;
 }
 
 AudioInputStream* AudioManagerLinux::MakeAudioInputStream(
     const AudioParameters& params, const std::string& device_id) {
   if (!params.IsValid() || params.channels > kMaxInputChannels ||
-      device_id.empty())
+      device_id.empty()) {
     return NULL;
+  }
 
   if (params.format == AudioParameters::AUDIO_MOCK) {
     return FakeAudioInputStream::MakeFakeStream(params);
   } else if (params.format != AudioParameters::AUDIO_PCM_LINEAR) {
     return NULL;
   }
 
   if (!initialized())
     return NULL;
 
   std::string device_name = (device_id == AudioManagerBase::kDefaultDeviceId) ?
       AlsaPcmInputStream::kAutoSelectDevice : device_id;
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAlsaInputDevice)) {
     device_name = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
         switches::kAlsaInputDevice);
   }
 
-  AlsaPcmInputStream* stream = new AlsaPcmInputStream(
+  AlsaPcmInputStream* stream = new AlsaPcmInputStream(this,
       device_name, params, wrapper_.get());
 
   return stream;
 }
 
-AudioManagerLinux::AudioManagerLinux() {
+AudioManagerLinux::AudioManagerLinux() : active_output_stream_count_(0U) {

[scherkus (not reviewing), 2011/12/09 22:47:30]

nit: collapse into {}

[tommi (sloooow) - chröme, 2011/12/10 00:11:14]

Done.

 }
 
 AudioManagerLinux::~AudioManagerLinux() {
-  // Make sure we stop the thread first. If we allow the default destructor to
-  // destroy the members, we may destroy audio streams before stopping the
-  // thread, resulting an unexpected behavior.
-  // This way we make sure activities of the audio streams are all stopped
-  // before we destroy them.
-  audio_thread_.Stop();
-
-  // Free output dispatchers, closing all remaining open streams.
-  output_dispatchers_.clear();
-
-  // Delete all the streams. Have to do it manually, we don't have ScopedSet<>,
-  // and we are not using ScopedVector<> because search there is slow.
-  STLDeleteElements(&active_streams_);
+  Shutdown();
+  // All the streams should have been deleted on the audio thread via Shutdown.
+  CHECK_EQ(active_output_stream_count_, 0U);
 }
 
 void AudioManagerLinux::Init() {
   AudioManagerBase::Init();
   wrapper_.reset(new AlsaWrapper());
 }
 
 void AudioManagerLinux::MuteAll() {
   NOTIMPLEMENTED();
 }
 
 void AudioManagerLinux::UnMuteAll() {
   NOTIMPLEMENTED();
 }
 
 void AudioManagerLinux::ReleaseOutputStream(AudioOutputStream* stream) {
   if (stream) {
-    active_streams_.erase(stream);
     delete stream;
+    --active_output_stream_count_;
+    DCHECK_GE(active_output_stream_count_, 0U);
   }
 }
 
 bool AudioManagerLinux::CanShowAudioInputSettings() {
   scoped_ptr<base::Environment> env(base::Environment::Create());
   base::nix::DesktopEnvironment desktop = base::nix::GetDesktopEnvironment(
       env.get());
   return (desktop == base::nix::DESKTOP_ENVIRONMENT_GNOME ||
           desktop == base::nix::DESKTOP_ENVIRONMENT_KDE3 ||
           desktop == base::nix::DESKTOP_ENVIRONMENT_KDE4);
@@ skipping 159 matching lines @@
     }
   }
 
   return has_device;
 }
 
 // static
 AudioManager* AudioManager::CreateAudioManager() {
   return new AudioManagerLinux();
 }