Remove LazyInstance usage from media/

media/gpu/android_video_decode_accelerator.cc

 // Copyright (c) 2013 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/android_video_decode_accelerator.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/android/build_info.h"
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
-#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.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/trace_event/trace_event.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
@@ skipping 95 matching lines @@
 //  - Starting and stopping a shared "construction" thread for instantiating and
 //    releasing MediaCodecs.
 //  - Detecting when a task has hung on the construction thread so AVDAs can
 //    stop using it.
 //  - Running a RepeatingTimer so that AVDAs can get a regular callback to
 //    DoIOTask().
 //  - Tracking the allocation of surfaces to AVDAs and delivering callbacks when
 //    surfaces are released.
 class AVDAManager {
  public:
+  AVDAManager() {}
+
   // Request periodic callback of |avda|->DoIOTask(). Does nothing if the
   // instance is already registered and the timer started. The first request
   // will start the repeating timer on an interval of DecodePollDelay.
   void StartTimer(AndroidVideoDecodeAccelerator* avda) {
     DCHECK(thread_checker_.CalledOnValidThread());
 
     timer_avda_instances_.insert(avda);
 
     // If the timer is running, StopTimer() might have been called earlier, if
     // so remove the instance from the pending erasures.
@@ skipping 16 matching lines @@
       pending_erase_.insert(avda);
       return;
     }
 
     timer_avda_instances_.erase(avda);
     if (timer_avda_instances_.empty())
       io_timer_.Stop();
   }
 
  private:
-  friend struct base::DefaultLazyInstanceTraits<AVDAManager>;
-
-  AVDAManager() {}
-  ~AVDAManager() { NOTREACHED(); }
+  ~AVDAManager() = delete;
 
   void RunTimer() {
     {
       // Call out to all AVDA instances, some of which may attempt to remove
       // themselves from the list during this operation; those removals will be
       // deferred until after all iterations are complete.
       base::AutoReset<bool> scoper(&timer_running_, true);
       for (auto* avda : timer_avda_instances_)
         avda->DoIOTask(false);
     }
@@ skipping 16 matching lines @@
   std::set<AndroidVideoDecodeAccelerator*> pending_erase_;
 
   // Repeating timer responsible for draining pending IO to the codecs.
   base::RepeatingTimer io_timer_;
 
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(AVDAManager);
 };
 
-static base::LazyInstance<AVDAManager>::Leaky g_avda_manager =
-    LAZY_INSTANCE_INITIALIZER;
+static AVDAManager* GetManager() {
+  static AVDAManager* manager = new AVDAManager();
+  return manager;
+}
 
 AndroidVideoDecodeAccelerator::BitstreamRecord::BitstreamRecord(
     const BitstreamBuffer& bitstream_buffer)
     : buffer(bitstream_buffer) {
   if (buffer.id() != -1)
     memory.reset(new SharedMemoryRegion(buffer, true));
 }
 
 AndroidVideoDecodeAccelerator::BitstreamRecord::BitstreamRecord(
     BitstreamRecord&& other)
@@ skipping 15 matching lines @@
       pending_input_buf_index_(-1),
       during_initialize_(false),
       deferred_initialization_pending_(false),
       codec_needs_reset_(false),
       defer_surface_creation_(false),
       last_release_task_type_(TaskType::AUTO_CODEC),
       weak_this_factory_(this) {}
 
 AndroidVideoDecodeAccelerator::~AndroidVideoDecodeAccelerator() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  g_avda_manager.Get().StopTimer(this);
+  GetManager()->StopTimer(this);
   AVDACodecAllocator::Instance()->StopThread(this);
 
 #if defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
   if (!media_drm_bridge_cdm_context_)
     return;
 
   DCHECK(cdm_registration_id_);
 
   // Cancel previously registered callback (if any).
   media_drm_bridge_cdm_context_->SetMediaCryptoReadyCB(
@@ skipping 860 matching lines @@
   // Flush the codec if possible, or create a new one if not.
   if (!did_codec_error_happen &&
       !MediaCodecUtil::CodecNeedsFlushWorkaround(media_codec_.get())) {
     DVLOG(3) << __func__ << " Flushing MediaCodec.";
     media_codec_->Flush();
     // Since we just flushed all the output buffers, make sure that nothing is
     // using them.
     picture_buffer_manager_.CodecChanged(media_codec_.get());
   } else {
     DVLOG(3) << __func__ << " Deleting the MediaCodec and creating a new one.";
-    g_avda_manager.Get().StopTimer(this);
+    GetManager()->StopTimer(this);
     ConfigureMediaCodecAsynchronously();
   }
 }
 
 void AndroidVideoDecodeAccelerator::Reset() {
   DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "AVDA::Reset");
 
   if (defer_surface_creation_) {
@@ skipping 53 matching lines @@
 }
 
 void AndroidVideoDecodeAccelerator::ActualDestroy() {
   DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Note that async codec construction might still be in progress.  In that
   // case, the codec will be deleted when it completes once we invalidate all
   // our weak refs.
   weak_this_factory_.InvalidateWeakPtrs();
-  g_avda_manager.Get().StopTimer(this);
+  GetManager()->StopTimer(this);
   ReleaseCodec();
 
   // We no longer care about |surface_id|, in case we did before.  It's okay
   // if we have no surface and/or weren't the owner or a waiter.
   AVDACodecAllocator::Instance()->DeallocateSurface(this, config_.surface_id);
 
   // Hop the SurfaceTexture release call through the task runner used last time
   // we released a codec. This ensures that we release the surface texture after
   // the codec it's attached to (if any) is released. It's not sufficient to use
   // |codec_config_->task_type| because that might have changed since we
@@ skipping 202 matching lines @@
     // Make sure that we have done work recently enough, else stop the timer.
     if (now - most_recent_work_ > IdleTimerTimeOut) {
       most_recent_work_ = base::TimeTicks();
       should_be_running = false;
     }
   } else {
     most_recent_work_ = now;
   }
 
   if (should_be_running)
-    g_avda_manager.Get().StartTimer(this);
+    GetManager()->StartTimer(this);
   else
-    g_avda_manager.Get().StopTimer(this);
+    GetManager()->StopTimer(this);
 }
 
 // static
 VideoDecodeAccelerator::Capabilities
 AndroidVideoDecodeAccelerator::GetCapabilities(
     const gpu::GpuPreferences& gpu_preferences) {
   Capabilities capabilities;
   SupportedProfiles& profiles = capabilities.supported_profiles;
 
   if (MediaCodecUtil::IsVp8DecoderAvailable()) {
@@ skipping 156 matching lines @@
   if (!media_codec_)
     return;
 
   picture_buffer_manager_.CodecChanged(nullptr);
   AVDACodecAllocator::Instance()->ReleaseMediaCodec(
       std::move(media_codec_), codec_config_->task_type, config_.surface_id);
   last_release_task_type_ = codec_config_->task_type;
 }
 
 }  // namespace media