Remove LazyInstance usage from media/

media/gpu/avda_codec_allocator.cc

 // Copyright 2016 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/gpu/avda_codec_allocator.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/logging.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/default_tick_clock.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/android/sdk_media_codec_bridge.h"
 #include "media/base/limits.h"
 #include "media/base/media.h"
 #include "media/base/timestamp_constants.h"
 #include "media/gpu/android_video_decode_accelerator.h"
 
 namespace media {
 
 namespace {
 
-base::LazyInstance<AVDACodecAllocator>::Leaky g_avda_codec_allocator =
-    LAZY_INSTANCE_INITIALIZER;
-
 // Give tasks 800ms before considering them hung. MediaCodec.configure() calls
 // typically take 100-200ms on a N5, so 800ms is expected to very rarely result
 // in false positives. Also, false positives have low impact because we resume
 // using the thread when the task completes.
 constexpr base::TimeDelta kHungTaskDetectionTimeout =
     base::TimeDelta::FromMilliseconds(800);
 
 // Delete |codec| and signal |done_event| if it's not null.
 void DeleteMediaCodecAndSignal(std::unique_ptr<VideoCodecBridge> codec,
                                base::WaitableEvent* done_event) {
@@ skipping 26 matching lines @@
   base::AutoLock l(lock_);
   if (task_start_time_.is_null())
     return false;
 
   return (tick_clock_->NowTicks() - task_start_time_) >
          kHungTaskDetectionTimeout;
 }
 
 // static
 AVDACodecAllocator* AVDACodecAllocator::Instance() {
-  return g_avda_codec_allocator.Pointer();
+  static AVDACodecAllocator* allocator = new AVDACodecAllocator();
+  return allocator;
 }
 
 bool AVDACodecAllocator::StartThread(AVDACodecAllocatorClient* client) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Cancel any pending StopThreadTask()s because we need the threads now.
   weak_this_factory_.InvalidateWeakPtrs();
 
   // Try to start the threads if they haven't been started.
   for (auto* thread : threads_) {
@@ skipping 271 matching lines @@
 void AVDACodecAllocator::StopThreadTask(size_t index) {
   threads_[index]->thread.Stop();
   // Signal the stop event after both threads are stopped.
   if (stop_event_for_testing_ && !threads_[AUTO_CODEC]->thread.IsRunning() &&
       !threads_[SW_CODEC]->thread.IsRunning()) {
     stop_event_for_testing_->Signal();
   }
 }
 
 }  // namespace media