Avoid any possibility of an Alloc during TLS thread teardown

base/tracked_objects.h

 // 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.
 
 #ifndef BASE_TRACKED_OBJECTS_H_
 #define BASE_TRACKED_OBJECTS_H_
 #pragma once
 
 #include <map>
 #include <stack>
@@ skipping 507 matching lines @@
   // the profiler enabled.  It will generally be optimized away when it is
   // ifdef'ed to be small enough (allowing the profiler to be "compiled out" of
   // the code).
   static TrackedTime Now();
 
  private:
   // Allow only tests to call ShutdownSingleThreadedCleanup.  We NEVER call it
   // in production code.
   friend class TrackedObjectsTest;
 
-  typedef std::stack<const ThreadData*> ThreadDataPool;
+  // Implment a stack that avoids allocations during a push() by having enough
+  // space ahead of time.
+  class ThreadDataPool {
+   public:
+    ThreadDataPool();
+    ~ThreadDataPool();
+
+    // Make sure the stack is large enough to support the indicated number of
+    // elements.
+    void reserve(size_t largest_worker_pool_number);
+
+    bool empty() const;
+    const ThreadData* top() const;
+    void push(const ThreadData* thread_data);
+    void pop();
+
+   private:
+    std::vector<const ThreadData*> stack_;
+    size_t empty_slot_;
+    DISALLOW_COPY_AND_ASSIGN(ThreadDataPool);
+  };
 
   // Worker thread construction creates a name since there is none.
-  ThreadData();
+  explicit ThreadData(size_t thread_number);
+
   // Message loop based construction should provide a name.
   explicit ThreadData(const std::string& suggested_name);
 
   ~ThreadData();
 
   // Push this instance to the head of all_thread_data_list_head_, linking it to
   // the previous head.  This is performed after each construction, and leaves
   // the instance permanently on that list.
   void PushToHeadOfList();
 
@@ skipping 67 matching lines @@
   // registered instances (corresponds to all registered threads where we keep
   // data).
   ThreadData* next_;
 
   // The name of the thread that is being recorded.  If this thread has no
   // message_loop, then this is a worker thread, with a sequence number postfix.
   std::string thread_name_;
 
   // Indicate if this is a worker thread, and the ThreadData contexts should be
   // stored in the unregistered_thread_data_pool_ when not in use.
-  bool is_a_worker_thread_;
+  // Value is zero when it is not a worker thread.  Value is a positive integer
+  // corresponding to the created thread name if it is a worker thread.
+  size_t worker_thread_number_;
 
   // A map used on each thread to keep track of Births on this thread.
   // This map should only be accessed on the thread it was constructed on.
   // When a snapshot is needed, this structure can be locked in place for the
   // duration of the snapshotting activity.
   BirthMap birth_map_;
 
   // Similar to birth_map_, this records informations about death of tracked
   // instances (i.e., when a tracked instance was destroyed on this thread).
   // It is locked before changing, and hence other threads may access it by
@@ skipping 31 matching lines @@
   }
 
  private:
 
   DISALLOW_COPY_AND_ASSIGN(AutoTracking);
 };
 
 }  // namespace tracked_objects
 
 #endif  // BASE_TRACKED_OBJECTS_H_