Remove some LazyInstance use in base/

base/win/scoped_handle.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 "base/win/scoped_handle.h"
 
 #include <stddef.h>
 
 #include <unordered_map>
 
 #include "base/debug/alias.h"
 #include "base/debug/stack_trace.h"
 #include "base/hash.h"
-#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/synchronization/lock_impl.h"
 #include "base/threading/thread_local.h"
 #include "base/win/base_features.h"
 #include "base/win/current_module.h"
 
 extern "C" {
 __declspec(dllexport) void* GetHandleVerifier();
 typedef void* (*GetHandleVerifierFn)();
@@ skipping 11 matching lines @@
 
 struct Info {
   const void* owner;
   const void* pc1;
   const void* pc2;
   base::debug::StackTrace stack;
   DWORD thread_id;
 };
 typedef std::unordered_map<HANDLE, Info, HandleHash> HandleMap;
 
-// g_lock protects the handle map and setting g_active_verifier within this
+// GetLock() protects the handle map and setting g_active_verifier within this
 // module.
 typedef base::internal::LockImpl NativeLock;
-base::LazyInstance<NativeLock>::Leaky g_lock = LAZY_INSTANCE_INITIALIZER;
+NativeLock* GetLock() {
+  static auto native_lock = new NativeLock();
+  return native_lock;
+}
 
 // Simple automatic locking using a native critical section so it supports
 // recursive locking.
 class AutoNativeLock {
  public:
   explicit AutoNativeLock(NativeLock& lock) : lock_(lock) {
     lock_.Lock();
   }
 
   ~AutoNativeLock() {
     lock_.Unlock();
   }
 
  private:
   NativeLock& lock_;
   DISALLOW_COPY_AND_ASSIGN(AutoNativeLock);
 };
 
 // Implements the actual object that is verifying handles for this process.
 // The active instance is shared across the module boundary but there is no
 // way to delete this object from the wrong side of it (or any side, actually).
 class ActiveVerifier {
  public:
-  explicit ActiveVerifier(bool enabled)
-      : enabled_(enabled), lock_(g_lock.Pointer()) {
-  }
+  explicit ActiveVerifier(bool enabled) : enabled_(enabled), lock_(GetLock()) {}
 
   // Retrieves the current verifier.
   static ActiveVerifier* Get();
 
   // The methods required by HandleTraits. They are virtual because we need to
   // forward the call execution to another module, instead of letting the
   // compiler call the version that is linked in the current module.
   virtual bool CloseHandle(HANDLE handle);
   virtual void StartTracking(HANDLE handle, const void* owner,
                              const void* pc1, const void* pc2);
@@ skipping 24 matching lines @@
 
   return g_active_verifier;
 }
 
 bool CloseHandleWrapper(HANDLE handle) {
   if (!::CloseHandle(handle))
     CHECK(false);  // CloseHandle failed.
   return true;
 }
 
-// Assigns the g_active_verifier global within the g_lock lock.
+// Assigns the g_active_verifier global within the GetLock() lock.
 // If |existing_verifier| is non-null then |enabled| is ignored.
 void ThreadSafeAssignOrCreateActiveVerifier(ActiveVerifier* existing_verifier,
                                             bool enabled) {
-  AutoNativeLock lock(g_lock.Get());
+  AutoNativeLock lock(*GetLock());
   // Another thread in this module might be trying to assign the global
   // verifier, so check that within the lock here.
   if (g_active_verifier)
     return;
   g_active_verifier =
       existing_verifier ? existing_verifier : new ActiveVerifier(enabled);
 }
 
 // static
 void ActiveVerifier::InstallVerifier() {
@@ skipping 147 matching lines @@
 void OnHandleBeingClosed(HANDLE handle) {
   return ActiveVerifier::Get()->OnHandleBeingClosed(handle);
 }
 
 HMODULE GetHandleVerifierModuleForTesting() {
   return g_active_verifier->GetModule();
 }
 
 }  // namespace win
 }  // namespace base