Remove LazyInstance usage from media/

media/filters/vpx_video_decoder.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/filters/vpx_video_decoder.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
-#include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/sys_info.h"
 #include "base/threading/thread.h"
@@ skipping 75 matching lines @@
       offload_thread_.Stop();
   }
 
   int offload_thread_users_ = 0;
   base::Thread offload_thread_;
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(VpxOffloadThread);
 };
 
-static base::LazyInstance<VpxOffloadThread>::Leaky g_vpx_offload_thread =
-    LAZY_INSTANCE_INITIALIZER;
+static VpxOffloadThread* GetOffloadThread() {
+  static VpxOffloadThread* thread = new VpxOffloadThread();
+  return thread;
+}
 
 // Always try to use three threads for video decoding.  There is little reason
 // not to since current day CPUs tend to be multi-core and we measured
 // performance benefits on older machines such as P4s with hyperthreading.
 static const int kDecodeThreads = 2;
 static const int kMaxDecodeThreads = 16;
 
 // Returns the number of threads.
 static int GetThreadCount(const VideoDecoderConfig& config) {
   // Refer to http://crbug.com/93932 for tsan suppressions on decoding.
@@ skipping 309 matching lines @@
         FROM_HERE, base::Bind(&VpxVideoDecoder::DecodeBuffer,
                               base::Unretained(this), buffer, bound_decode_cb));
   } else {
     DecodeBuffer(buffer, bound_decode_cb);
   }
 }
 
 void VpxVideoDecoder::Reset(const base::Closure& closure) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (offload_task_runner_)
-    g_vpx_offload_thread.Pointer()->WaitForOutstandingTasks();
+    GetOffloadThread()->WaitForOutstandingTasks();
 
   state_ = kNormal;
   // PostTask() to avoid calling |closure| inmediately.
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, closure);
 }
 
 bool VpxVideoDecoder::ConfigureDecoder(const VideoDecoderConfig& config) {
   if (config.codec() != kCodecVP8 && config.codec() != kCodecVP9)
     return false;
 
@@ skipping 21 matching lines @@
   // Configure VP9 to decode on our buffers to skip a data copy on
   // decoding. For YV12A-VP9, we use our buffers for the Y, U and V planes and
   // copy the A plane.
   if (config.codec() == kCodecVP9) {
     DCHECK(vpx_codec_get_caps(vpx_codec_->iface) &
            VPX_CODEC_CAP_EXTERNAL_FRAME_BUFFER);
 
     // Move high resolution vp9 decodes off of the main media thread (otherwise
     // decode may block audio decoding, demuxing, and other control activities).
     if (config.coded_size().width() >= 1024) {
-      offload_task_runner_ =
-          g_vpx_offload_thread.Pointer()->RequestOffloadThread();
+      offload_task_runner_ = GetOffloadThread()->RequestOffloadThread();
     }
 
     DCHECK(!memory_pool_);
     memory_pool_ = new MemoryPool();
     base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
         memory_pool_.get(), "VpxVideoDecoder",
         base::ThreadTaskRunnerHandle::Get());
 
     if (vpx_codec_set_frame_buffer_functions(vpx_codec_,
                                              &MemoryPool::GetVP9FrameBuffer,
                                              &MemoryPool::ReleaseVP9FrameBuffer,
                                              memory_pool_.get())) {
       DLOG(ERROR) << "Failed to configure external buffers. "
                   << vpx_codec_error(vpx_codec_);
       return false;
     }
   }
 
   if (config.format() != PIXEL_FORMAT_YV12A)
     return true;
 
   vpx_codec_alpha_ = InitializeVpxContext(vpx_codec_alpha_, config);
   return !!vpx_codec_alpha_;
 }
 
 void VpxVideoDecoder::CloseDecoder() {
   if (offload_task_runner_) {
-    g_vpx_offload_thread.Pointer()
-        ->WaitForOutstandingTasksAndReleaseOffloadThread();
+    GetOffloadThread()->WaitForOutstandingTasksAndReleaseOffloadThread();
     offload_task_runner_ = nullptr;
   }
 
   if (vpx_codec_) {
     vpx_codec_destroy(vpx_codec_);
     delete vpx_codec_;
     vpx_codec_ = nullptr;
     base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
         memory_pool_.get());
     memory_pool_ = nullptr;
@@ skipping 319 matching lines @@
       (*video_frame)->visible_data(VideoFrame::kUPlane),
       (*video_frame)->stride(VideoFrame::kUPlane),
       (*video_frame)->visible_data(VideoFrame::kVPlane),
       (*video_frame)->stride(VideoFrame::kVPlane), coded_size.width(),
       coded_size.height());
 
   return true;
 }
 
 }  // namespace media