Making AudioManagerBase::ShutdownOnAudioThread() platform-agnostic

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 325 matching lines @@
 }
 
 void AudioManagerBase::ReleaseInputStream(AudioInputStream* stream) {
   CHECK(GetTaskRunner()->BelongsToCurrentThread());
   DCHECK(stream);
   // TODO(xians) : Have a clearer destruction path for the AudioInputStream.
   CHECK_EQ(1u, input_streams_.erase(stream));
   delete stream;
 }
 
-void AudioManagerBase::ShutdownOnAudioThread() {
+void AudioManagerBase::ShutdownOnAudioThread(bool immediately) {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
 
   // Close all output streams.
   output_dispatchers_.clear();
 
-#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();
+  if (immediately) {
+    // Even if tasks to close the streams are enqueued, they would not run

[alokp, 2017/06/09 16:59:17]

nit: Would it be better to run this block of code in AudioManagerMac, so that we
do not need to plumb "immediately" everywhere?

AudioManagerMac already tracks all input streams, so it should be pretty easy to
close them.

[o1ka, 2017/06/09 17:15:48]

Hmm.. Won't open streams be a problem on other platforms if we run AudioManager
on the main thread of the audio process? (see bug description in the CL)
I'm a bit confused, since crbug.com/608049 this comment refers to is not only
for Mac.

+    // 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();
+    }
+    CHECK(input_streams_.empty());
   }
-  CHECK(input_streams_.empty());
-#endif  // OS_MACOSX
 }
 
 void AudioManagerBase::AddOutputDeviceChangeListener(
     AudioDeviceListener* listener) {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   output_listeners_.AddObserver(listener);
 }
 
 void AudioManagerBase::RemoveOutputDeviceChangeListener(
     AudioDeviceListener* listener) {
@@ skipping 107 matching lines @@
   return base::MakeUnique<AudioDebugRecordingManager>(std::move(task_runner));
 }
 
 void AudioManagerBase::SetMaxStreamCountForTesting(int max_input,
                                                    int max_output) {
   max_num_output_streams_ = max_output;
   max_num_input_streams_ = max_input;
 }
 
 }  // namespace media