Remove LazyInstance usage from media/

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/fake_audio_log_factory.h"
 #include "media/base/media_switches.h"
 
@@ skipping 227 matching lines @@
   std::unique_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;
+AudioManagerHelper* GetHelper() {
+  static AudioManagerHelper* helper = new AudioManagerHelper();
+  return helper;
+}
 
 }  // 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;
@@ skipping 62 matching lines @@
   DCHECK(task_runner);
   DCHECK(worker_task_runner);
   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();
+  GetHelper()->InitializeCOMForTesting();
 #endif
-  return Create(task_runner, task_runner,
-                g_helper.Pointer()->fake_log_factory());
+  return Create(task_runner, task_runner, GetHelper()->fake_log_factory());
 }
 
 // static
 void AudioManager::StartHangMonitorIfNeeded(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
-  if (g_helper.Pointer()->monitor_task_runner())
+  if (GetHelper()->monitor_task_runner())
     return;
 
   DCHECK(AudioManager::Get());
   DCHECK(task_runner);
   DCHECK_NE(task_runner, AudioManager::Get()->GetTaskRunner());
 
-  g_helper.Pointer()->StartHangTimer(std::move(task_runner));
+  GetHelper()->StartHangTimer(std::move(task_runner));
 }
 
 // static
 void AudioManager::EnableCrashKeyLoggingForAudioThreadHangs() {
   CHECK(!g_last_created);
-  g_helper.Pointer()->enable_crash_key_logging();
+  GetHelper()->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);
+  GetHelper()->set_app_name(app_name);
 }
 
 // static
 const std::string& AudioManager::GetGlobalAppName() {
-  return g_helper.Pointer()->app_name();
+  return GetHelper()->app_name();
 }
 #endif
 
 // static
 AudioManager* AudioManager::Get() {
   return g_last_created;
 }
 
 }  // namespace media