Port last remaining test case in base/stats_table_unittest.cc, and...

base/stats_table.h

 // Copyright (c) 2006-2008 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.
 //
 // A StatsTable is a table of statistics.  It can be used across multiple
 // processes and threads, maintaining cheap statistics counters without
 // locking.
 //
 // The goal is to make it very cheap and easy for developers to add
 // counters to code, without having to build one-off utilities or mechanisms
@@ skipping 58 matching lines @@
   // write its counter data.
   //
   // name is just a debugging tag to label the thread, and it does not
   // need to be unique.  It will be truncated to kMaxThreadNameLength-1
   // characters.
   //
   // On success, returns the slot id for this thread.  On failure,
   // returns 0.
   int RegisterThread(const std::wstring& name);
 
-  // Returns the space occupied by a thread in the table.  Generally used
-  // if a thread terminates but the process continues.  This function
-  // does not zero out the thread's counters.
-  void UnregisterThread();
-
   // Returns the number of threads currently registered.  This is really not
   // useful except for diagnostics and debugging.
   int CountThreadsRegistered() const;
 
   // Find a counter in the StatsTable.
   //
   // Returns an id for the counter which can be used to call GetLocation().
   // If the counter does not exist, attempts to create a row for the new
   // counter.  If there is no space in the table for the new counter,
   // returns 0.
@@ skipping 36 matching lines @@
   // The maximum length (in characters) of a Counter's name including
   // null terminator, as stored in the shared memory.
   static const int kMaxCounterNameLength = 32;
 
   // Convenience function to lookup a counter location for a
   // counter by name for the calling thread.  Will register
   // the thread if it is not already registered.
   static int* FindLocation(const wchar_t *name);
 
  private:
+  // Returns the space occupied by a thread in the table.  Generally used
+  // if a thread terminates but the process continues.  This function
+  // does not zero out the thread's counters.
+  void UnregisterThread();
+
+  // This variant expects the tls data to be passed in, so it is safe to
+  // call from inside a posix tls destructor (see doc for pthread_key_create).
+  void UnregisterThread(StatsTableTLSData *tls_data);

[Evan Martin, 2008/10/31 19:17:13]

nit: star on the left.

+
+  // The SlotReturnFunction is called at thread exit for each thread
+  // which used the StatsTable.
+  static void SlotReturnFunction(void* data);
+
   // Locates a free slot in the table.  Returns a number > 0 on success,
   // or 0 on failure.  The caller must hold the shared_memory lock when
   // calling this function.
   int FindEmptyThread() const;
 
   // Locates a counter in the table or finds an empty row.  Returns a
   // number > 0 on success, or 0 on failure.  The caller must hold the
   // shared_memory_lock when calling this function.
   int FindCounterOrEmptyRow(const std::wstring& name) const;
 
@@ skipping 23 matching lines @@
   // we don't have a counter in our hash table, another process may
   // have created it.
   CountersMap         counters_;
   TLSSlot             tls_index_;
 
   static StatsTable*  global_table_;
   DISALLOW_EVIL_CONSTRUCTORS(StatsTable);
 };
 
 #endif  // BASE_STATS_TABLE_H__