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 34 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(
-      const scoped_refptr<base::SingleThreadTaskRunner>& monitor_task_runner) {
+      scoped_refptr<base::SingleThreadTaskRunner> monitor_task_runner) {

[tommi (sloooow) - chröme, 2016/03/19 02:32:41]

does the caller use std::move?

[alokp, 2016/03/22 21:47:06]

Done.

     CHECK(!monitor_task_runner_);
     monitor_task_runner_ = monitor_task_runner;

[tommi (sloooow) - chröme, 2016/03/19 02:32:41]

if the above is intended, then you should use std::move here.

[alokp, 2016/03/22 21:47:06]

Done.

     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 84 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;
   bool enable_crash_key_logging_ = false;
   uint32_t successful_pings_ = 0;
 
 #if defined(OS_WIN)
   scoped_ptr<base::win::ScopedCOMInitializer> com_initializer_for_testing_;
 #endif
 
 #if defined(OS_LINUX)
   std::string app_name_;
 #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);
+  CHECK_EQ(g_last_created, 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;
+
+  // AudioManager must be destroyed on the audio thread.
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner =

[tommi (sloooow) - chröme, 2016/03/19 02:32:41]

won't we always be on the main thread when we get here?  If we're on a random
thread, then we might have a (theoratical) problem with changing g_last_created.

[alokp, 2016/03/22 21:47:06]

Are you suggesting always posting the task to delete the instance?

Yes we will always be on the main thread. This check avoids posting the delete
task when audio task runner belongs to the main thread (mac and unittests).

+      instance->GetTaskRunner();
+  if (task_runner->BelongsToCurrentThread()) {
+    delete instance;
+  } else {
+    task_runner->DeleteSoon(FROM_HERE, instance);
+  }
+}
+
 // Forward declaration of the platform specific AudioManager factory function.
-AudioManager* CreateAudioManager(AudioLogFactory* audio_log_factory);
+ScopedAudioManagerPtr CreateAudioManager(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner,
+    AudioLogFactory* audio_log_factory);
 
-AudioManager::AudioManager() {}
+AudioManager::AudioManager(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+    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);
+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) {
+  ScopedAudioManagerPtr manager;
+  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);

[tommi (sloooow) - chröme, 2016/03/19 02:32:41]

std::move() (or see other comment)

[alokp, 2016/03/22 21:47:06]

Done.

 
   return manager;
 }
 
 // static
-AudioManager* AudioManager::CreateForTesting() {
-#if defined(OS_WIN)
-  g_helper.Pointer()->InitializeCOMForTesting();
-#endif
-  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
 void AudioManager::SetGlobalAppName(const std::string& app_name) {
   g_helper.Pointer()->set_app_name(app_name);
 }
@@ skipping 23 matching lines @@
 std::string AudioManager::GetCommunicationsDeviceName() {
 #if defined(OS_WIN)
   return GetLocalizedStringUTF8(COMMUNICATIONS_AUDIO_DEVICE_NAME);
 #else
   NOTREACHED();
   return "";
 #endif
 }
 
 }  // namespace media