Allow content embedders to create AudioManager.

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 {
 
 // The singleton instance of AudioManager. This is set when Create() is called.
 AudioManager* g_last_created = nullptr;
 
-// The singleton instance of AudioManagerFactory. This is only set if
-// SetFactory() is called. If it is set when Create() is called, its
-// CreateInstance() function is used to set |g_last_created|. Otherwise, the
-// linked implementation of media::CreateAudioManager is used to set
-// |g_last_created|.
-AudioManagerFactory* g_audio_manager_factory = nullptr;
-
 // Maximum number of failed pings to the audio thread allowed. A UMA will be
 // recorded once this count is reached; if enabled, a non-crash dump will be
 // captured as well. We require at least three failed pings before recording to
 // ensure unobservable power events aren't mistakenly caught (e.g., the system
 // suspends before a OnSuspend() event can be fired).
 const int kMaxFailedPingsCount = 3;
 
 // Helper class for managing global AudioManager data and hang monitor. If the
 // audio thread is hung for > |kMaxFailedPingsCount| * |max_hung_task_time_|, we
 // want to record a UMA and optionally a non-crash dump to find offenders in the
@@ skipping 10 matching lines @@
     THREAD_MAX = THREAD_RECOVERED
   };
 
   AudioManagerHelper() {}
   ~AudioManagerHelper() override {}
 
   void StartHangTimer(
       scoped_refptr<base::SingleThreadTaskRunner> monitor_task_runner) {
     CHECK(!monitor_task_runner_);
     CHECK(!audio_task_runner_);
-    CHECK(g_last_created);
     monitor_task_runner_ = std::move(monitor_task_runner);
-    audio_task_runner_ = g_last_created->GetTaskRunner();
+    audio_task_runner_ = AudioManager::Get()->GetTaskRunner();
     base::PowerMonitor::Get()->AddObserver(this);
 
     io_task_running_ = audio_task_running_ = true;
     audio_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&AudioManagerHelper::UpdateLastAudioThreadTimeTick,
                    base::Unretained(this)));
     monitor_task_runner_->PostTask(
         FROM_HERE, base::Bind(&AudioManagerHelper::RecordAudioThreadStatus,
                               base::Unretained(this)));
@@ skipping 220 matching lines @@
   // 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() {
   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
 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);
-  }
-
-  if (monitor_task_runner)
-    g_helper.Pointer()->StartHangTimer(std::move(monitor_task_runner));
-
-  return manager;
+  return CreateAudioManager(std::move(task_runner),
+                            std::move(worker_task_runner), audio_log_factory);
 }
 
 // static
 ScopedAudioManagerPtr AudioManager::CreateForTesting(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
 #if defined(OS_WIN)
   g_helper.Pointer()->InitializeCOMForTesting();
 #endif
-  return Create(task_runner, task_runner, nullptr,
+  return Create(task_runner, task_runner,
                 g_helper.Pointer()->fake_log_factory());
 }
 
 // static
+void AudioManager::StartHangMonitor(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  DCHECK(AudioManager::Get());
+  DCHECK(task_runner);
+  DCHECK_NE(task_runner, AudioManager::Get()->GetTaskRunner());
+
+  g_helper.Pointer()->StartHangTimer(std::move(task_runner));
+}
+
+// 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