Reduce race potential for lazy testing initialization of profiler

base/tracked_objects.cc

 // Copyright (c) 2011 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 <math.h>
 
 #include "base/format_macros.h"
 #include "base/message_loop.h"
@@ skipping 565 matching lines @@
     it->second.Clear();
   for (BirthMap::iterator it = birth_map_.begin();
        it != birth_map_.end(); ++it)
     it->second->Clear();
 }
 
 bool ThreadData::Initialize() {
   if (!kTrackAllTaskObjects)
     return false;  // Not compiled in.
   if (status_ != UNINITIALIZED)
-    return true;
-  // Initialize all leaking constants that are difficult to toggle in and out
-  // of existance.
-  // First call must be made when single threaded at startup.
+    return true;  // 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());
+  if (status_ != UNINITIALIZED)
+    return true;  // 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.
+  if (!tls_index_.initialized()) {  // Testing may have initialized this.
     tls_index_.Initialize(&ThreadData::OnThreadTermination);
-  DCHECK(tls_index_.initialized());
+    if (!tls_index_.initialized())
+      return false;
+  }
+
+  // Incarnation counter is only significant to testing, as it otherwise will
+  // never again change in this process.
+  ++incarnation_counter_;
+
+  // The lock is not critical for setting status_, but it doesn't hurt. It also
+  // ensures that if we have a racy initialization, that we'll bail as soon as
+  // we get the lock earlier in this method.
   status_ = kInitialStartupState;
-
-  base::AutoLock lock(*list_lock_.Pointer());
-  ++incarnation_counter_;
+  DCHECK(status_ != UNINITIALIZED);
   return true;
 }
 
 // static
 bool ThreadData::InitializeAndSetTrackingStatus(bool status) {
   if (!Initialize())  // No-op if already initialized.
     return false;  // Not compiled in.
 
   status_ = status ? ACTIVE : DEACTIVATED;
   return true;
@@ skipping 644 matching lines @@
                         (combined_selectors_ & BIRTH_THREAD) ? "*" :
                           sample.birth().birth_thread()->thread_name().c_str(),
                         (combined_selectors_ & DEATH_THREAD) ? "*" :
                           sample.DeathThreadName().c_str());
   sample.birth().location().Write(!(combined_selectors_ & BIRTH_FILE),
                                   !(combined_selectors_ & BIRTH_FUNCTION),
                                   output);
 }
 
 }  // namespace tracked_objects