Remove some LazyInstance use in base/

base/tracked_objects.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/tracked_objects.h"
 
 #include <ctype.h>
 #include <limits.h>
 #include <stdlib.h>
 
@@ skipping 376 matching lines @@
 // static
 int ThreadData::incarnation_counter_ = 0;
 
 // static
 ThreadData* ThreadData::all_thread_data_list_head_ = NULL;
 
 // static
 ThreadData* ThreadData::first_retired_thread_data_ = NULL;
 
 // static
-base::LazyInstance<base::Lock>::Leaky
-    ThreadData::list_lock_ = LAZY_INSTANCE_INITIALIZER;
-
-// static
 base::subtle::Atomic32 ThreadData::status_ = ThreadData::UNINITIALIZED;
 
 ThreadData::ThreadData(const std::string& sanitized_thread_name)
     : next_(NULL),
       next_retired_thread_data_(NULL),
       sanitized_thread_name_(sanitized_thread_name),
       incarnation_count_for_pool_(-1),
       current_stopwatch_(NULL) {
   DCHECK(sanitized_thread_name_.empty() ||
          !isdigit(sanitized_thread_name_.back()));
   PushToHeadOfList();  // Which sets real incarnation_count_for_pool_.
 }
 
 ThreadData::~ThreadData() {
 }
 
 void ThreadData::PushToHeadOfList() {
   // Toss in a hint of randomness (atop the uniniitalized value).
   (void)VALGRIND_MAKE_MEM_DEFINED_IF_ADDRESSABLE(&random_number_,
                                                  sizeof(random_number_));
   MSAN_UNPOISON(&random_number_, sizeof(random_number_));
   random_number_ += static_cast<uint32_t>(this - static_cast<ThreadData*>(0));
   random_number_ ^= (Now() - TrackedTime()).InMilliseconds();
 
   DCHECK(!next_);
-  base::AutoLock lock(*list_lock_.Pointer());
+  base::AutoLock lock(*ListLock());
   incarnation_count_for_pool_ = incarnation_counter_;
   next_ = all_thread_data_list_head_;
   all_thread_data_list_head_ = this;
 }
 
 // static
 ThreadData* ThreadData::first() {
-  base::AutoLock lock(*list_lock_.Pointer());
+  base::AutoLock lock(*ListLock());
   return all_thread_data_list_head_;
 }
 
 ThreadData* ThreadData::next() const { return next_; }
 
 // static
 void ThreadData::InitializeThreadContext(const std::string& thread_name) {
   if (base::WorkerPool::RunsTasksOnCurrentThread())
     return;
   DCHECK_NE(thread_name, kWorkerThreadSanitizedName);
@@ skipping 27 matching lines @@
   DCHECK(thread_data);  // TLS should *never* call us with a NULL.
   // We must NOT do any allocations during this callback.  There is a chance
   // that the allocator is no longer active on this thread.
   reinterpret_cast<ThreadData*>(thread_data)->OnThreadTerminationCleanup();
 }
 
 void ThreadData::OnThreadTerminationCleanup() {
   // We must NOT do any allocations during this callback. There is a chance that
   // the allocator is no longer active on this thread.
 
-  // The list_lock_ was created when we registered the callback, so it won't be
+  // The list lock was created when we registered the callback, so it won't be
   // allocated here despite the lazy reference.
-  base::AutoLock lock(*list_lock_.Pointer());
+  base::AutoLock lock(*ListLock());
   if (incarnation_counter_ != incarnation_count_for_pool_)
     return;  // ThreadData was constructed in an earlier unit test.
   ++cleanup_count_;
 
   // Add this ThreadData to a retired list so that it can be reused by a thread
   // with the same name sanitized name in the future.
   // |next_retired_thread_data_| is expected to be nullptr for a ThreadData
   // associated with an active thread.
   DCHECK(!next_retired_thread_data_);
   next_retired_thread_data_ = first_retired_thread_data_;
@@ skipping 257 matching lines @@
 
 void ThreadData::EnsureTlsInitialization() {
   if (base::subtle::Acquire_Load(&status_) >= DEACTIVATED)
     return;  // Someone else did the initialization.
   // Due to racy lazy initialization in tests, we'll need to recheck status_
   // after we acquire the lock.
 
   // Ensure that we don't double initialize tls.  We are called when single
   // threaded in the product, but some tests may be racy and lazy about our
   // initialization.
-  base::AutoLock lock(*list_lock_.Pointer());
+  base::AutoLock lock(*ListLock());
   if (base::subtle::Acquire_Load(&status_) >= DEACTIVATED)
     return;  // Someone raced in here and beat us.
 
   // Perform the "real" TLS initialization now, and leave it intact through
   // process termination.
   if (!tls_index_.initialized()) {  // Testing may have initialized this.
     DCHECK_EQ(base::subtle::NoBarrier_Load(&status_), UNINITIALIZED);
     tls_index_.Initialize(&ThreadData::OnThreadTermination);
     DCHECK(tls_index_.initialized());
   } else {
@@ skipping 57 matching lines @@
 TrackedTime ThreadData::Now() {
   if (now_function_for_testing_)
     return TrackedTime::FromMilliseconds((*now_function_for_testing_)());
   if (IsProfilerTimingEnabled() && TrackingStatus())
     return TrackedTime::Now();
   return TrackedTime();  // Super fast when disabled, or not compiled.
 }
 
 // static
 void ThreadData::EnsureCleanupWasCalled(int major_threads_shutdown_count) {
-  base::AutoLock lock(*list_lock_.Pointer());
+  base::AutoLock lock(*ListLock());
 
   // TODO(jar): until this is working on XP, don't run the real test.
 #if 0
   // Verify that we've at least shutdown/cleanup the major namesd threads.  The
   // caller should tell us how many thread shutdowns should have taken place by
   // now.
   CHECK_GT(cleanup_count_, major_threads_shutdown_count);
 #endif
 }
 
 // static
 void ThreadData::ShutdownSingleThreadedCleanup(bool leak) {
   // This is only called from test code, where we need to cleanup so that
   // additional tests can be run.
   // We must be single threaded... but be careful anyway.
   InitializeAndSetTrackingStatus(DEACTIVATED);
 
   ThreadData* thread_data_list;
   {
-    base::AutoLock lock(*list_lock_.Pointer());
+    base::AutoLock lock(*ListLock());
     thread_data_list = all_thread_data_list_head_;
     all_thread_data_list_head_ = NULL;
     ++incarnation_counter_;
     // To be clean, break apart the retired worker list (though we leak them).
     while (first_retired_thread_data_) {
       ThreadData* thread_data = first_retired_thread_data_;
       first_retired_thread_data_ = thread_data->next_retired_thread_data_;
       thread_data->next_retired_thread_data_ = nullptr;
     }
   }
@@ skipping 29 matching lines @@
     delete next_thread_data;  // Includes all Death Records.
   }
 }
 
 // static
 ThreadData* ThreadData::GetRetiredOrCreateThreadData(
     const std::string& sanitized_thread_name) {
   SCOPED_UMA_HISTOGRAM_TIMER("TrackedObjects.GetRetiredOrCreateThreadData");
 
   {
-    base::AutoLock lock(*list_lock_.Pointer());
+    base::AutoLock lock(*ListLock());
     ThreadData** pcursor = &first_retired_thread_data_;
     ThreadData* cursor = first_retired_thread_data_;
 
     // Assuming that there aren't more than a few tens of retired ThreadData
     // instances, this lookup should be quick compared to the thread creation
     // time. Retired ThreadData instances cannot be stored in a map because
     // insertions are done from OnThreadTerminationCleanup() where allocations
     // are not allowed.
     //
     // Note: Test processes may have more than a few tens of retired ThreadData
@@ skipping 168 matching lines @@
 #endif
 }
 
 ProcessDataSnapshot::ProcessDataSnapshot(const ProcessDataSnapshot& other) =
     default;
 
 ProcessDataSnapshot::~ProcessDataSnapshot() {
 }
 
 }  // namespace tracked_objects