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

base/stats_table.cc

 // 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.
 
 #include "base/stats_table.h"
 
 #include "base/logging.h"
 #include "base/platform_thread.h"
+#include "base/process_util.h"
 #include "base/shared_memory.h"
 #include "base/string_util.h"
 #include "base/thread_local_storage.h"
 
 #if defined(OS_POSIX)
 #include "errno.h"
 #endif
 
 // The StatsTable uses a shared memory segment that is laid out as follows
 //
@@ skipping 65 matching lines @@
 // StatsTable.  This is used so that we can properly cleanup when the
 // thread exits and return the table slot.
 //
 // Each thread that calls RegisterThread in the StatsTable will have
 // a StatsTableTLSData stored in its TLS.
 struct StatsTableTLSData {
   StatsTable* table;
   int slot;
 };
 
-// The SlotReturnFunction is called at thread exit for each thread
-// which used the StatsTable.
-static void SlotReturnFunction(void* data) {
-  StatsTableTLSData* tls_data = static_cast<StatsTableTLSData*>(data);
-  if (tls_data) {
-    DCHECK(tls_data->table);
-    tls_data->table->UnregisterThread();
-  }
-}
-
 }  // namespace
 
 // The StatsTablePrivate maintains convenience pointers into the
 // shared memory segment.  Use this class to keep the data structure
 // clean and accessible.
 class StatsTablePrivate {
  public:
   // Various header information contained in the memory mapped segment.
   struct TableHeader {
     int version;
@@ skipping 192 matching lines @@
 
     DCHECK(impl_);
 
     // We have space, so consume a column in the table.
     std::wstring thread_name = name;
     if (name.empty())
       thread_name = kUnknownName;
     base::wcslcpy(impl_->thread_name(slot), thread_name.c_str(),
                   kMaxThreadNameLength);
     *(impl_->thread_tid(slot)) = PlatformThread::CurrentId();
-    // TODO(pinkerton): these should go into process_utils when it's ported
-#if defined(OS_WIN)
-    *(impl_->thread_pid(slot)) = GetCurrentProcessId();
-#elif defined(OS_POSIX)
-    *(impl_->thread_pid(slot)) = getpid();
-#endif  
+    *(impl_->thread_pid(slot)) = process_util::GetCurrentProcId();
   }
 
   // Set our thread local storage.
   StatsTableTLSData* data = new StatsTableTLSData;
   data->table = this;
   data->slot = slot;
   tls_index_.Set(data);
   return slot;
 }
 
 StatsTableTLSData* StatsTable::GetTLSData() const {
   StatsTableTLSData* data =
     static_cast<StatsTableTLSData*>(tls_index_.Get());
   if (!data)
     return NULL;
 
   DCHECK(data->slot);
   DCHECK_EQ(data->table, this);
   return data;
 }
 
 void StatsTable::UnregisterThread() {
-  StatsTableTLSData* data = GetTLSData();
+  UnregisterThread(GetTLSData());
+}
+
+void StatsTable::UnregisterThread(StatsTableTLSData* data) {
   if (!data)
     return;
   DCHECK(impl_);
 
   // Mark the slot free by zeroing out the thread name.
   wchar_t* name = impl_->thread_name(data->slot);
   *name = L'\0';
 
   // Remove the calling thread's TLS so that it cannot use the slot.
   tls_index_.Set(NULL);
   delete data;
 }
 

[Dean McNamee, 2008/10/31 19:20:37]

Is this because you can no longer access the TLS key when you get the callback
on posix?  Can you make a note of that?

+void StatsTable::SlotReturnFunction(void* data) {
+  StatsTableTLSData* tls_data = static_cast<StatsTableTLSData*>(data);
+  if (tls_data) {
+    DCHECK(tls_data->table);
+    tls_data->table->UnregisterThread(tls_data);
+  }
+}
+
 int StatsTable::CountThreadsRegistered() const {
   if (!impl_)
     return 0;
 
   // Loop through the shared memory and count the threads that are active.
   // We intentionally do not lock the table during the operation.
   int count = 0;
   for (int index = 1; index <= impl_->max_threads(); index++) {
     wchar_t* name = impl_->thread_name(index);
     if (*name != L'\0')
@@ skipping 181 matching lines @@
       return NULL;
 
   // Find the counter id for the counter.
   std::wstring str_name(name);
   int counter = table->FindCounter(str_name);
 
   // Now we can find the location in the table.
   return table->GetLocation(counter, slot);
 }