Revert of 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"
@@ skipping 58 matching lines @@
   AudioManagerHelper() {}
   ~AudioManagerHelper() override {}
 
   void HistogramThreadStatus(ThreadStatus status) {
     audio_thread_status_ = status;
     UMA_HISTOGRAM_ENUMERATION("Media.AudioThreadStatus", audio_thread_status_,
                               THREAD_MAX + 1);
   }
 
   void StartHangTimer(
-      scoped_refptr<base::SingleThreadTaskRunner> monitor_task_runner) {
+      const scoped_refptr<base::SingleThreadTaskRunner>& monitor_task_runner) {
     CHECK(!monitor_task_runner_);
-    monitor_task_runner_ = std::move(monitor_task_runner);
+    monitor_task_runner_ = monitor_task_runner;
     base::PowerMonitor::Get()->AddObserver(this);
     failed_pings_ = 0;
     io_task_running_ = audio_task_running_ = true;
     UpdateLastAudioThreadTimeTick();
     RecordAudioThreadStatus();
   }
 
   // Disable hang detection when the system goes into the suspend state.
   void OnSuspend() override {
     base::AutoLock lock(hang_lock_);
@@ skipping 156 matching lines @@
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(AudioManagerHelper);
 };
 
 base::LazyInstance<AudioManagerHelper>::Leaky g_helper =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
-void AudioManagerDeleter::operator()(const AudioManager* instance) const {
-  CHECK(instance);
-  // We reset g_last_created here instead of in the destructor of AudioManager
-  // because the destructor runs on the audio thread. We want to always change
-  // g_last_created from the main thread.
-  if (g_last_created == instance) {
-    g_last_created = nullptr;
-  } else {
-    // We create multiple instances of AudioManager only when testing.
-    // We should not encounter this case in production.
-    LOG(WARNING) << "Multiple instances of AudioManager detected";
-  }
+// Forward declaration of the platform specific AudioManager factory function.
+AudioManager* CreateAudioManager(AudioLogFactory* audio_log_factory);
 
-  // AudioManager must be destroyed on the audio thread.
-  if (!instance->GetTaskRunner()->DeleteSoon(FROM_HERE, instance)) {
-    LOG(WARNING) << "Failed to delete AudioManager instance.";
-  }
-}
-
-// Forward declaration of the platform specific AudioManager factory function.
-ScopedAudioManagerPtr CreateAudioManager(
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner,
-    AudioLogFactory* audio_log_factory);
-
-AudioManager::AudioManager(
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner)
-    : task_runner_(std::move(task_runner)),
-      worker_task_runner_(std::move(worker_task_runner)) {
-  DCHECK(task_runner_);
-  DCHECK(worker_task_runner_);
-
-  if (g_last_created) {
-    // We create multiple instances of AudioManager only when testing.
-    // We should not encounter this case in production.
-    LOG(WARNING) << "Multiple instances of AudioManager detected";
-  }
-  // We always override |g_last_created| irrespective of whether it is already
-  // set or not becuase it represents the last created instance.
-  g_last_created = this;
-}
+AudioManager::AudioManager() {}
 
 AudioManager::~AudioManager() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  CHECK(!g_last_created || g_last_created == this);
+  g_last_created = nullptr;
 }
 
 // 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
-ScopedAudioManagerPtr AudioManager::Create(
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> monitor_task_runner,
-    AudioLogFactory* audio_log_factory) {
-  DCHECK(task_runner);
-  DCHECK(worker_task_runner);
-  ScopedAudioManagerPtr manager;
-  if (g_audio_manager_factory) {
-    manager = g_audio_manager_factory->CreateInstance(
-        std::move(task_runner), std::move(worker_task_runner),
-        audio_log_factory);
-  } else {
-    manager =
-        CreateAudioManager(std::move(task_runner),
-                           std::move(worker_task_runner), audio_log_factory);
-  }
+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);
 
-  if (monitor_task_runner)
-    g_helper.Pointer()->StartHangTimer(std::move(monitor_task_runner));
+  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
 
   return manager;
 }
 
 // static
-ScopedAudioManagerPtr AudioManager::CreateForTesting(
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+AudioManager* AudioManager::CreateForTesting() {
 #if defined(OS_WIN)
   g_helper.Pointer()->InitializeCOMForTesting();
 #endif
-  return Create(task_runner, task_runner, nullptr,
-                g_helper.Pointer()->fake_log_factory());
+  return Create(g_helper.Pointer()->fake_log_factory());
 }
 
 // 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