Remove some LazyInstance use in base/

base/threading/thread_local_storage.cc

 // Copyright 2014 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/threading/thread_local_storage.h"
 
 #include "base/atomicops.h"
-#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/synchronization/lock.h"
 #include "build/build_config.h"
 
 using base::internal::PlatformThreadLocalStorage;
 
 // Chrome Thread Local Storage (TLS)
 //
 // This TLS system allows Chrome to use a single OS level TLS slot process-wide,
 // and allows us to control the slot limits instead of being at the mercy of the
@@ skipping 64 matching lines @@
   TlsStatus status;
   base::ThreadLocalStorage::TLSDestructorFunc destructor;
   uint32_t version;
 };
 
 struct TlsVectorEntry {
   void* data;
   uint32_t version;
 };
 
-// This LazyInstance isn't needed until after we've constructed the per-thread
-// TLS vector, so it's safe to use.
-base::LazyInstance<base::Lock>::Leaky g_tls_metadata_lock;
+// This lock isn't needed until after we've constructed the per-thread TLS
+// vector, so it's safe to use.
+base::Lock* GetTLSMetadataLock() {
+  static auto lock = new base::Lock();
+  return lock;
+}
 TlsMetadata g_tls_metadata[kThreadLocalStorageSize];
 size_t g_last_assigned_slot = 0;
 
 // The maximum number of times to try to clear slots by calling destructors.
 // Use pthread naming convention for clarity.
 constexpr int kMaxDestructorIterations = kThreadLocalStorageSize;
 
 // This function is called to initialize our entire Chromium TLS system.
 // It may be called very early, and we need to complete most all of the setup
 // (initialization) before calling *any* memory allocator functions, which may
@@ skipping 69 matching lines @@
   memcpy(stack_allocated_tls_data, tls_data, sizeof(stack_allocated_tls_data));
   // Ensure that any re-entrant calls change the temp version.
   PlatformThreadLocalStorage::TLSKey key =
       base::subtle::NoBarrier_Load(&g_native_tls_key);
   PlatformThreadLocalStorage::SetTLSValue(key, stack_allocated_tls_data);
   delete[] tls_data;  // Our last dependence on an allocator.
 
   // Snapshot the TLS Metadata so we don't have to lock on every access.
   TlsMetadata tls_metadata[kThreadLocalStorageSize];
   {
-    base::AutoLock auto_lock(g_tls_metadata_lock.Get());
+    base::AutoLock auto_lock(*GetTLSMetadataLock());
     memcpy(tls_metadata, g_tls_metadata, sizeof(g_tls_metadata));
   }
 
   int remaining_attempts = kMaxDestructorIterations;
   bool need_to_scan_destructors = true;
   while (need_to_scan_destructors) {
     need_to_scan_destructors = false;
     // Try to destroy the first-created-slot (which is slot 1) in our last
     // destructor call. That user was able to function, and define a slot with
     // no other services running, so perhaps it is a basic service (like an
@@ skipping 58 matching lines @@
       base::subtle::NoBarrier_Load(&g_native_tls_key);
   if (key == PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES ||
       !PlatformThreadLocalStorage::GetTLSValue(key)) {
     ConstructTlsVector();
   }
 
   // Grab a new slot.
   slot_ = kInvalidSlotValue;
   version_ = 0;
   {
-    base::AutoLock auto_lock(g_tls_metadata_lock.Get());
+    base::AutoLock auto_lock(*GetTLSMetadataLock());
     for (int i = 0; i < kThreadLocalStorageSize; ++i) {
       // Tracking the last assigned slot is an attempt to find the next
       // available slot within one iteration. Under normal usage, slots remain
       // in use for the lifetime of the process (otherwise before we reclaimed
       // slots, we would have run out of slots). This makes it highly likely the
       // next slot is going to be a free slot.
       size_t slot_candidate =
           (g_last_assigned_slot + 1 + i) % kThreadLocalStorageSize;
       if (g_tls_metadata[slot_candidate].status == TlsStatus::FREE) {
         g_tls_metadata[slot_candidate].status = TlsStatus::IN_USE;
         g_tls_metadata[slot_candidate].destructor = destructor;
         g_last_assigned_slot = slot_candidate;
         slot_ = slot_candidate;
         version_ = g_tls_metadata[slot_candidate].version;
         break;
       }
     }
   }
   CHECK_NE(slot_, kInvalidSlotValue);
   CHECK_LT(slot_, kThreadLocalStorageSize);
 
   // Setup our destructor.
   base::subtle::Release_Store(&initialized_, 1);
 }
 
 void ThreadLocalStorage::StaticSlot::Free() {
   DCHECK_NE(slot_, kInvalidSlotValue);
   DCHECK_LT(slot_, kThreadLocalStorageSize);
   {
-    base::AutoLock auto_lock(g_tls_metadata_lock.Get());
+    base::AutoLock auto_lock(*GetTLSMetadataLock());
     g_tls_metadata[slot_].status = TlsStatus::FREE;
     g_tls_metadata[slot_].destructor = nullptr;
     ++(g_tls_metadata[slot_].version);
   }
   slot_ = kInvalidSlotValue;
   base::subtle::Release_Store(&initialized_, 0);
 }
 
 void* ThreadLocalStorage::StaticSlot::Get() const {
   TlsVectorEntry* tls_data = static_cast<TlsVectorEntry*>(
@@ skipping 31 matching lines @@
 
 void* ThreadLocalStorage::Slot::Get() const {
   return tls_slot_.Get();
 }
 
 void ThreadLocalStorage::Slot::Set(void* value) {
   tls_slot_.Set(value);
 }
 
 }  // namespace base