Tracks all open input streams in AudioManagerBase.

media/audio/audio_manager_base.cc

 // Copyright (c) 2012 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_manager_base.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/macros.h"
@@ skipping 64 matching lines @@
 };
 
 AudioManagerBase::AudioManagerBase(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner,
     AudioLogFactory* audio_log_factory)
     : AudioManager(std::move(task_runner), std::move(worker_task_runner)),
       max_num_output_streams_(kDefaultMaxOutputStreams),
       max_num_input_streams_(kDefaultMaxInputStreams),
       num_output_streams_(0),
-      num_input_streams_(0),
       // TODO(dalecurtis): Switch this to an base::ObserverListThreadSafe, so we
       // don't
       // block the UI thread when swapping devices.
       output_listeners_(
           base::ObserverList<AudioDeviceListener>::NOTIFY_EXISTING_ONLY),
       audio_log_factory_(audio_log_factory) {}
 
 AudioManagerBase::~AudioManagerBase() {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
 
   // All the output streams should have been deleted.
   CHECK_EQ(0, num_output_streams_);
   // All the input streams should have been deleted.
-  CHECK_EQ(0, num_input_streams_);
+  CHECK(input_streams_.empty());
 }
 
 base::string16 AudioManagerBase::GetAudioInputDeviceModel() {
   return base::string16();
 }
 
 AudioOutputStream* AudioManagerBase::MakeAudioOutputStream(
     const AudioParameters& params,
     const std::string& device_id,
     const LogCallback& log_callback) {
@@ skipping 46 matching lines @@
     const std::string& device_id,
     const LogCallback& log_callback) {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
 
   if (!params.IsValid() || (params.channels() > kMaxInputChannels) ||
       device_id.empty()) {
     DLOG(ERROR) << "Audio parameters are invalid for device " << device_id;
     return NULL;
   }
 
-  if (num_input_streams_ >= max_num_input_streams_) {
+  if (input_stream_count() >= max_num_input_streams_) {
     DLOG(ERROR) << "Number of opened input audio streams "
-                << num_input_streams_
-                << " exceed the max allowed number " << max_num_input_streams_;
+                << input_stream_count() << " exceed the max allowed number "
+                << max_num_input_streams_;
     return NULL;
   }
 
   DVLOG(2) << "Creating a new AudioInputStream with buffer size = "
            << params.frames_per_buffer();
 
   AudioInputStream* stream;
   switch (params.format()) {
     case AudioParameters::AUDIO_PCM_LINEAR:
       stream = MakeLinearInputStream(params, device_id, log_callback);
       break;
     case AudioParameters::AUDIO_PCM_LOW_LATENCY:
       stream = MakeLowLatencyInputStream(params, device_id, log_callback);
       break;
     case AudioParameters::AUDIO_FAKE:
       stream = FakeAudioInputStream::MakeFakeStream(this, params);
       break;
     default:
       stream = NULL;
       break;
   }
 
   if (stream) {
-    ++num_input_streams_;
+    input_streams_.insert(stream);
   }
 
   return stream;
 }
 
 AudioOutputStream* AudioManagerBase::MakeAudioOutputStreamProxy(
     const AudioParameters& params,
     const std::string& device_id) {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
 
@@ skipping 71 matching lines @@
 void AudioManagerBase::GetAudioInputDeviceNames(
     AudioDeviceNames* device_names) {
 }
 
 void AudioManagerBase::GetAudioOutputDeviceNames(
     AudioDeviceNames* device_names) {
 }
 
 void AudioManagerBase::ReleaseOutputStream(AudioOutputStream* stream) {
   DCHECK(stream);
+  CHECK_GT(num_output_streams_, 0);
   // TODO(xians) : Have a clearer destruction path for the AudioOutputStream.
   // For example, pass the ownership to AudioManager so it can delete the
   // streams.
   --num_output_streams_;
   delete stream;
 }
 
 void AudioManagerBase::ReleaseInputStream(AudioInputStream* stream) {
   DCHECK(stream);
   // TODO(xians) : Have a clearer destruction path for the AudioInputStream.
-  --num_input_streams_;
+  CHECK_EQ(1u, input_streams_.erase(stream));
   delete stream;
 }
 
 void AudioManagerBase::Shutdown() {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   // Close all output streams.
   while (!output_dispatchers_.empty()) {
     output_dispatchers_.back()->dispatcher->Shutdown();
     output_dispatchers_.pop_back();
   }
+
+#if defined(OS_MACOSX)
+  // On mac, AudioManager runs on the main thread, loop for which stops
+  // processing task queue at this point. So even if tasks to close the
+  // streams are enqueued, they would not run leading to CHECKs getting hit
+  // in the destructor about open streams. Close them explicitly here.
+  // crbug.com/608049.
+  for (auto iter = input_streams_.begin(); iter != input_streams_.end();) {
+    // Note: Closing the stream will invalidate the iterator.
+    // Increment the iterator before closing the stream.
+    AudioInputStream* stream = *iter++;
+    stream->Close();
+  }
+#endif  // OS_MACOSX
 }
 
 void AudioManagerBase::AddOutputDeviceChangeListener(
     AudioDeviceListener* listener) {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   output_listeners_.AddObserver(listener);
 }
 
 void AudioManagerBase::RemoveOutputDeviceChangeListener(
     AudioDeviceListener* listener) {
@@ skipping 66 matching lines @@
 
   return 0;
 }
 
 std::unique_ptr<AudioLog> AudioManagerBase::CreateAudioLog(
     AudioLogFactory::AudioComponent component) {
   return audio_log_factory_->CreateAudioLog(component);
 }
 
 }  // namespace media