Ensures that audio tasks cannot run after AudioManager is deleted.

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 65 matching lines @@
     //    dispatcher are the same as the request dispatcher.
     return (dispatcher_->input_params.Equals(dispatcher_in->input_params) &&
             dispatcher_->output_params.Equals(dispatcher_in->output_params) &&
             dispatcher_->output_device_id == dispatcher_in->output_device_id);
   }
 
  private:
   const DispatcherParams* dispatcher_;
 };
 
-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)),
+AudioManagerBase::AudioManagerBase(std::unique_ptr<AudioThread> audio_thread,
+                                   AudioLogFactory* audio_log_factory)
+    : AudioManager(std::move(audio_thread)),
       max_num_output_streams_(kDefaultMaxOutputStreams),
       max_num_input_streams_(kDefaultMaxInputStreams),
       num_output_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(input_streams_.empty());
 }
 
 base::string16 AudioManagerBase::GetAudioInputDeviceModel() {
   return base::string16();
 }
 
@@ skipping 173 matching lines @@
   if (it != output_dispatchers_.end()) {
     delete dispatcher_params;
     return (*it)->dispatcher->CreateStreamProxy();
   }
 
   const base::TimeDelta kCloseDelay =
       base::TimeDelta::FromSeconds(kStreamCloseDelaySeconds);
   std::unique_ptr<AudioOutputDispatcher> dispatcher;
   if (output_params.format() != AudioParameters::AUDIO_FAKE) {
     // Using unretained for |debug_recording_manager_| is safe since it
-    // outlives the dispatchers (cleared in Shutdown()).
+    // outlives the dispatchers (cleared in ShutdownOnAudioThread()).
     dispatcher = base::MakeUnique<AudioOutputResampler>(
         this, params, output_params, output_device_id, kCloseDelay,
         debug_recording_manager_
             ? base::BindRepeating(
                   &AudioDebugRecordingManager::RegisterDebugRecordingSource,
                   base::Unretained(debug_recording_manager_.get()),
                   FILE_PATH_LITERAL("output"))
             : base::BindRepeating(&GetNullptrAudioDebugRecorder));
   } else {
     dispatcher = base::MakeUnique<AudioOutputDispatcherImpl>(
@@ skipping 28 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::Shutdown() {
+void AudioManagerBase::ShutdownOnAudioThread() {
   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();
   }
-  CHECK(input_streams_.empty());
 #endif  // OS_MACOSX
 }
 
 void AudioManagerBase::AddOutputDeviceChangeListener(
     AudioDeviceListener* listener) {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   output_listeners_.AddObserver(listener);
 }
 
 void AudioManagerBase::RemoveOutputDeviceChangeListener(
@@ skipping 113 matching lines @@
       std::move(task_runner), std::move(file_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