Pass task runners to AudioManager constructor.

media/audio/audio_manager.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.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/debug/crash_logging.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "media/audio/audio_manager_factory.h"
-#include "media/audio/fake_audio_log_factory.h"
 #include "media/base/media_resources.h"
 #include "media/base/media_switches.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_com_initializer.h"
 #include "media/audio/win/core_audio_util_win.h"
 #endif
 
 namespace media {
 namespace {
@@ skipping 141 matching lines @@
     }
 
     // Don't hold the lock while posting the next task.
     g_last_created->GetTaskRunner()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&AudioManagerHelper::UpdateLastAudioThreadTimeTick,
                    base::Unretained(this)),
         max_hung_task_time_ / 5);
   }
 
-  AudioLogFactory* fake_log_factory() { return &fake_log_factory_; }
-
 #if defined(OS_WIN)
   // This should be called before creating an AudioManager in tests to ensure
   // that the creating thread is COM initialized.
   void InitializeCOMForTesting() {
     com_initializer_for_testing_.reset(new base::win::ScopedCOMInitializer());
   }
 #endif
 
 #if defined(OS_LINUX)
   void set_app_name(const std::string& app_name) {
@@ skipping 19 matching lines @@
     base::debug::ScopedCrashKey crash_key(
         "hung-audio-thread-details",
         base::StringPrintf("%s:%s", driver_name.c_str(),
                            driver_version.c_str()));
 
     // Please forward crash reports to http://crbug.com/422522
     base::debug::DumpWithoutCrashing();
 #endif
   }
 
-  FakeAudioLogFactory fake_log_factory_;
-
   const base::TimeDelta max_hung_task_time_ = base::TimeDelta::FromMinutes(1);
   scoped_refptr<base::SingleThreadTaskRunner> monitor_task_runner_;
 
   base::Lock hang_lock_;
   bool hang_detection_enabled_ = true;
   base::TimeTicks last_audio_thread_timer_tick_;
   uint32_t failed_pings_ = 0;
   bool io_task_running_ = false;
   bool audio_task_running_ = false;
   ThreadStatus audio_thread_status_ = THREAD_NONE;
@@ skipping 10 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(AudioManagerHelper);
 };
 
 base::LazyInstance<AudioManagerHelper>::Leaky g_helper =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 // Forward declaration of the platform specific AudioManager factory function.
-AudioManager* CreateAudioManager(AudioLogFactory* audio_log_factory);
+AudioManager* CreateAudioManager(
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    const scoped_refptr<base::SingleThreadTaskRunner>& worker_task_runner,
+    AudioLogFactory* audio_log_factory);
 
-AudioManager::AudioManager() {}
+AudioManager::AudioManager(
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    const scoped_refptr<base::SingleThreadTaskRunner>& worker_task_runner)
+    : task_runner_(task_runner), worker_task_runner_(worker_task_runner) {
+  DCHECK(task_runner_);
+  DCHECK(worker_task_runner_);
+  g_last_created = this;
+}
 
 AudioManager::~AudioManager() {
-  CHECK(!g_last_created || g_last_created == this);
-  g_last_created = nullptr;
+  DCHECK(task_runner_->BelongsToCurrentThread());
 }
 
 // static
 void AudioManager::SetFactory(AudioManagerFactory* factory) {
   CHECK(factory);
   CHECK(!g_last_created);
   CHECK(!g_audio_manager_factory);
   g_audio_manager_factory = factory;
 }
 
 // static
 void AudioManager::ResetFactoryForTesting() {
   if (g_audio_manager_factory) {
     delete g_audio_manager_factory;
     g_audio_manager_factory = nullptr;
   }
 }
 
 // static
-AudioManager* AudioManager::Create(AudioLogFactory* audio_log_factory) {
-  CHECK(!g_last_created);
-  if (g_audio_manager_factory)
-    g_last_created = g_audio_manager_factory->CreateInstance(audio_log_factory);
-  else
-    g_last_created = CreateAudioManager(audio_log_factory);
+AudioManager* AudioManager::Create(
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    const scoped_refptr<base::SingleThreadTaskRunner>& worker_task_runner,
+    const scoped_refptr<base::SingleThreadTaskRunner>& monitor_task_runner,
+    AudioLogFactory* audio_log_factory) {
+  AudioManager* manager = nullptr;
+  if (g_audio_manager_factory) {
+    manager = g_audio_manager_factory->CreateInstance(
+        task_runner, worker_task_runner, audio_log_factory);
+  } else {
+    manager =
+        CreateAudioManager(task_runner, worker_task_runner, audio_log_factory);
+  }
 
-  return g_last_created;
-}
-
-// static
-AudioManager* AudioManager::CreateWithHangTimer(
-    AudioLogFactory* audio_log_factory,
-    const scoped_refptr<base::SingleThreadTaskRunner>& monitor_task_runner) {
-  AudioManager* manager = Create(audio_log_factory);
-
-// On OSX the audio thread is the UI thread, for which a hang monitor is not
-// necessary or recommended.
-#if !defined(OS_MACOSX)
-  g_helper.Pointer()->StartHangTimer(monitor_task_runner);
-#endif
+  if (monitor_task_runner)
+    g_helper.Pointer()->StartHangTimer(monitor_task_runner);
 
   return manager;
 }
 
 // static
-AudioManager* AudioManager::CreateForTesting() {
-#if defined(OS_WIN)
-  g_helper.Pointer()->InitializeCOMForTesting();
-#endif
-  return Create(g_helper.Pointer()->fake_log_factory());
+void AudioManager::Destroy(AudioManager* instance) {
+  CHECK(instance);
+  CHECK_EQ(g_last_created, instance);
+
+  // AudioManager must be destroyed on the audio thread.
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner =
+      instance->GetTaskRunner();
+  if (task_runner->BelongsToCurrentThread()) {
+    delete instance;
+  } else {
+    task_runner->DeleteSoon(FROM_HERE, instance);
+  }
+
+  // We reset g_last_created here instead of in the destructor of AudioManager
+  // to allow construction of another AudioManager while the current instance
+  // is being destroyed. This overlap does not happen in production - only in
+  // unittests.
+  g_last_created = nullptr;
 }
 
 // static
 void AudioManager::EnableCrashKeyLoggingForAudioThreadHangs() {
   CHECK(!g_last_created);
   g_helper.Pointer()->enable_crash_key_logging();
 }
 
 #if defined(OS_LINUX)
 // static
@@ skipping 26 matching lines @@
 std::string AudioManager::GetCommunicationsDeviceName() {
 #if defined(OS_WIN)
   return GetLocalizedStringUTF8(COMMUNICATIONS_AUDIO_DEVICE_NAME);
 #else
   NOTREACHED();
   return "";
 #endif
 }
 
 }  // namespace media