Remove some LazyInstance use in base/

base/tracked_objects.h

 // 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.
 
 #ifndef BASE_TRACKED_OBJECTS_H_
 #define BASE_TRACKED_OBJECTS_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <set>
 #include <stack>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/allocator/features.h"
 #include "base/atomicops.h"
 #include "base/base_export.h"
 #include "base/containers/hash_tables.h"
 #include "base/debug/debugging_flags.h"
 #include "base/debug/thread_heap_usage_tracker.h"
 #include "base/gtest_prod_util.h"
-#include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/process/process_handle.h"
 #include "base/profiler/tracked_time.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_local_storage.h"
 
 namespace base {
 struct TrackingInfo;
@@ skipping 84 matching lines @@
 // name without trailing digits) as the current thread is available, it is
 // reused. Otherwise, a new ThreadData instance is instantiated. Since a
 // ThreadData is bound to at most one thread at a time, there is no need to
 // acquire a lock to access its maps. Over time, a ThreadData may be bound to
 // different threads that share the same sanitized name.
 //
 // We maintain a list of all ThreadData instances for the current process. Each
 // ThreadData instance has a pointer to the next one. A static member of
 // ThreadData provides a pointer to the first item on this global list, and
 // access via that all_thread_data_list_head_ item requires the use of the
-// list_lock_.
+// ListLock().
 //
 // When new ThreadData instances are added to the global list, they are pre-
 // pended, which ensures that any prior acquisition of the list is valid (i.e.,
 // the holder can iterate over it without fear of it changing, or the necessity
 // of using an additional lock.  Iterations are actually pretty rare (used
 // primarily for cleanup, or snapshotting data for display), so this lock has
 // very little global performance impact.
 //
 // The above description tries to define the high performance (run time)
 // portions of these classes.  After gathering statistics, calls instigated
@@ skipping 569 matching lines @@
 
   // When non-null, this specifies an external function that supplies monotone
   // increasing time functcion.
   static NowFunction* now_function_for_testing_;
 
   // We use thread local store to identify which ThreadData to interact with.
   static base::ThreadLocalStorage::StaticSlot tls_index_;
 
   // Linked list of ThreadData instances that were associated with threads that
   // have been terminated and that have not been associated with a new thread
-  // since then. This is only accessed while |list_lock_| is held.
+  // since then. This is only accessed while |ListLock()| is held.
   static ThreadData* first_retired_thread_data_;
 
   // Link to the most recently created instance (starts a null terminated list).
   // The list is traversed by about:profiler when it needs to snapshot data.
-  // This is only accessed while list_lock_ is held.
+  // This is only accessed while ListLock() is held.
   static ThreadData* all_thread_data_list_head_;
 
   // The number of times TLS has called us back to cleanup a ThreadData
-  // instance.  This is only accessed while list_lock_ is held.
+  // instance.  This is only accessed while ListLock() is held.
   static int cleanup_count_;
 
   // Incarnation sequence number, indicating how many times (during unittests)
   // we've either transitioned out of UNINITIALIZED, or into that state.  This
-  // value is only accessed while the list_lock_ is held.
+  // value is only accessed while the ListLock() is held.
   static int incarnation_counter_;
 
   // Protection for access to all_thread_data_list_head_, and to
   // unregistered_thread_data_pool_.  This lock is leaked at shutdown.
   // The lock is very infrequently used, so we can afford to just make a lazy
   // instance and be safe.
-  static base::LazyInstance<base::Lock>::Leaky list_lock_;
+  static base::Lock* ListLock() {
+    static auto lock = new base::Lock();
+    return lock;
+  }
 
   // We set status_ to SHUTDOWN when we shut down the tracking service.
   static base::subtle::Atomic32 status_;
 
   // Link to next instance (null terminated list).  Used to globally track all
   // registered instances (corresponds to all registered threads where we keep
   // data). Only modified in the constructor.
   ThreadData* next_;
 
   // Pointer to another retired ThreadData instance. This value is nullptr if
@@ skipping 138 matching lines @@
   ProcessDataSnapshot(const ProcessDataSnapshot& other);
   ~ProcessDataSnapshot();
 
   PhasedProcessDataSnapshotMap phased_snapshots;
   base::ProcessId process_id;
 };
 
 }  // namespace tracked_objects
 
 #endif  // BASE_TRACKED_OBJECTS_H_