Pass task runners to AudioManager constructor.

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 63 matching lines @@
   }
 
  private:
   const DispatcherParams* dispatcher_;
 };
 
 static bool IsDefaultDeviceId(const std::string& device_id) {
   return device_id.empty() || device_id == AudioManagerBase::kDefaultDeviceId;
 }
 
-AudioManagerBase::AudioManagerBase(AudioLogFactory* audio_log_factory)
-    : max_num_output_streams_(kDefaultMaxOutputStreams),
+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) {
-}
+      audio_log_factory_(audio_log_factory) {}
 
 AudioManagerBase::~AudioManagerBase() {
-  // The platform specific AudioManager implementation must have already
-  // stopped the audio thread. Otherwise, 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.
-  CHECK(!audio_thread_);
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+  // Close all output streams.
+  while (!output_dispatchers_.empty()) {
+    output_dispatchers_.back()->dispatcher->Shutdown();
+    output_dispatchers_.pop_back();
+  }
   // All the output streams should have been deleted.
   DCHECK_EQ(0, num_output_streams_);
   // All the input streams should have been deleted.
   DCHECK_EQ(0, num_input_streams_);
 }
 
 base::string16 AudioManagerBase::GetAudioInputDeviceModel() {
   return base::string16();
 }
 
-scoped_refptr<base::SingleThreadTaskRunner> AudioManagerBase::GetTaskRunner() {
-  if (!audio_thread_) {
-    audio_thread_.reset(new base::Thread("AudioThread"));
-#if defined(OS_WIN)
-    audio_thread_->init_com_with_mta(true);
-#endif
-    CHECK(audio_thread_->Start());
-  }
-  return audio_thread_->task_runner();
-}
-
-scoped_refptr<base::SingleThreadTaskRunner>
-AudioManagerBase::GetWorkerTaskRunner() {
-  return GetTaskRunner();
-}
-
 AudioOutputStream* AudioManagerBase::MakeAudioOutputStream(
     const AudioParameters& params,
     const std::string& device_id) {
   // TODO(miu): Fix ~50 call points across several unit test modules to call
   // this method on the audio thread, then uncomment the following:
   // DCHECK(GetTaskRunner()->BelongsToCurrentThread());
 
   if (!params.IsValid()) {
     DLOG(ERROR) << "Audio parameters are invalid";
     return NULL;
@@ skipping 173 matching lines @@
   delete stream;
 }
 
 void AudioManagerBase::ReleaseInputStream(AudioInputStream* stream) {
   DCHECK(stream);
   // TODO(xians) : Have a clearer destruction path for the AudioInputStream.
   --num_input_streams_;
   delete stream;
 }
 
-void AudioManagerBase::Shutdown() {
-  // Only true when we're sharing the UI message loop with the browser.  The UI
-  // loop is no longer running at this time and browser destruction is imminent.
-  auto task_runner = GetTaskRunner();
-  if (task_runner->BelongsToCurrentThread()) {
-    ShutdownOnAudioThread();
-  } else {
-    task_runner->PostTask(FROM_HERE,
-                          base::Bind(&AudioManagerBase::ShutdownOnAudioThread,
-                                     base::Unretained(this)));
-  }
-
-  // Stop() will wait for any posted messages to be processed first.
-  if (audio_thread_) {
-    audio_thread_->Stop();
-    audio_thread_.reset();
-  }
-}
-
-void AudioManagerBase::ShutdownOnAudioThread() {
-  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
-  while (!output_dispatchers_.empty()) {
-    output_dispatchers_.back()->dispatcher->Shutdown();
-    output_dispatchers_.pop_back();
-  }
-}
-
 void AudioManagerBase::AddOutputDeviceChangeListener(
     AudioDeviceListener* listener) {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   output_listeners_.AddObserver(listener);
 }
 
 void AudioManagerBase::RemoveOutputDeviceChangeListener(
     AudioDeviceListener* listener) {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   output_listeners_.RemoveObserver(listener);
@@ skipping 41 matching lines @@
 
   return 0;
 }
 
 scoped_ptr<AudioLog> AudioManagerBase::CreateAudioLog(
     AudioLogFactory::AudioComponent component) {
   return audio_log_factory_->CreateAudioLog(component);
 }
 
 }  // namespace media