Remove some LazyInstance use in base/

base/time/time_win.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.
 
 
 // Windows Timer Primer
 //
 // A good article:  http://www.ddj.com/windows/184416651
 // A good mozilla bug:  http://bugzilla.mozilla.org/show_bug.cgi?id=363258
 //
@@ skipping 22 matching lines @@
 
 #include "base/time/time.h"
 
 #include <windows.h>
 #include <mmsystem.h>
 #include <stdint.h>
 
 #include "base/atomicops.h"
 #include "base/bit_cast.h"
 #include "base/cpu.h"
-#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
 
 using base::ThreadTicks;
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace {
@@ skipping 36 matching lines @@
 // The two values that ActivateHighResolutionTimer uses to set the systemwide
 // timer interrupt frequency on Windows. It controls how precise timers are
 // but also has a big impact on battery life.
 const int kMinTimerIntervalHighResMs = 1;
 const int kMinTimerIntervalLowResMs = 4;
 // Track if kMinTimerIntervalHighResMs or kMinTimerIntervalLowResMs is active.
 bool g_high_res_timer_enabled = false;
 // How many times the high resolution timer has been called.
 uint32_t g_high_res_timer_count = 0;
 // The lock to control access to the above two variables.
-base::LazyInstance<base::Lock>::Leaky g_high_res_lock =
-    LAZY_INSTANCE_INITIALIZER;
+base::Lock* GetHighResLock() {
+  static auto lock = new base::Lock();
+  return lock;
+}
 
 // Returns the current value of the performance counter.
 uint64_t QPCNowRaw() {
   LARGE_INTEGER perf_counter_now = {};
   // According to the MSDN documentation for QueryPerformanceCounter(), this
   // will never fail on systems that run XP or later.
   // https://msdn.microsoft.com/library/windows/desktop/ms644904.aspx
   ::QueryPerformanceCounter(&perf_counter_now);
   return perf_counter_now.QuadPart;
 }
@@ skipping 72 matching lines @@
     result.dwLowDateTime = std::numeric_limits<DWORD>::max();
     return result;
   }
   FILETIME utc_ft;
   MicrosecondsToFileTime(us_, &utc_ft);
   return utc_ft;
 }
 
 // static
 void Time::EnableHighResolutionTimer(bool enable) {
-  base::AutoLock lock(g_high_res_lock.Get());
+  base::AutoLock lock(*GetHighResLock());
   if (g_high_res_timer_enabled == enable)
     return;
   g_high_res_timer_enabled = enable;
   if (!g_high_res_timer_count)
     return;
   // Since g_high_res_timer_count != 0, an ActivateHighResolutionTimer(true)
   // was called which called timeBeginPeriod with g_high_res_timer_enabled
   // with a value which is the opposite of |enable|. With that information we
   // call timeEndPeriod with the same value used in timeBeginPeriod and
   // therefore undo the period effect.
   if (enable) {
     timeEndPeriod(kMinTimerIntervalLowResMs);
     timeBeginPeriod(kMinTimerIntervalHighResMs);
   } else {
     timeEndPeriod(kMinTimerIntervalHighResMs);
     timeBeginPeriod(kMinTimerIntervalLowResMs);
   }
 }
 
 // static
 bool Time::ActivateHighResolutionTimer(bool activating) {
   // We only do work on the transition from zero to one or one to zero so we
   // can easily undo the effect (if necessary) when EnableHighResolutionTimer is
   // called.
   const uint32_t max = std::numeric_limits<uint32_t>::max();
 
-  base::AutoLock lock(g_high_res_lock.Get());
+  base::AutoLock lock(*GetHighResLock());
   UINT period = g_high_res_timer_enabled ? kMinTimerIntervalHighResMs
                                          : kMinTimerIntervalLowResMs;
   if (activating) {
     DCHECK_NE(g_high_res_timer_count, max);
     ++g_high_res_timer_count;
     if (g_high_res_timer_count == 1)
       timeBeginPeriod(period);
   } else {
     DCHECK_NE(g_high_res_timer_count, 0u);
     --g_high_res_timer_count;
     if (g_high_res_timer_count == 0)
       timeEndPeriod(period);
   }
   return (period == kMinTimerIntervalHighResMs);
 }
 
 // static
 bool Time::IsHighResolutionTimerInUse() {
-  base::AutoLock lock(g_high_res_lock.Get());
+  base::AutoLock lock(*GetHighResLock());
   return g_high_res_timer_enabled && g_high_res_timer_count > 0;
 }
 
 // static
 bool Time::FromExploded(bool is_local, const Exploded& exploded, Time* time) {
   // Create the system struct representing our exploded time. It will either be
   // in local time or UTC.If casting from int to WORD results in overflow,
   // fail and return Time(0).
   SYSTEMTIME st;
   if (!SafeConvertToWord(exploded.year, &st.wYear) ||
@@ skipping 423 matching lines @@
 TimeTicks TimeTicks::FromQPCValue(LONGLONG qpc_value) {
   return TimeTicks() + QPCValueToTimeDelta(qpc_value);
 }
 
 // TimeDelta ------------------------------------------------------------------
 
 // static
 TimeDelta TimeDelta::FromQPCValue(LONGLONG qpc_value) {
   return QPCValueToTimeDelta(qpc_value);
 }