Make ThreadLocalStorage more posix pthread compliant

base/threading/thread_local_storage_unittest.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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <process.h>
 #endif
 
 #include "base/threading/simple_thread.h"
 #include "base/threading/thread_local_storage.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_WIN)
 // Ignore warnings about ptr->int conversions that we use when
 // storing ints into ThreadLocalStorage.
 #pragma warning(disable : 4311 4312)
 #endif
 
 namespace base {
 
 namespace {
 
 const int kInitialTlsValue = 0x5555;
+const int kFinalTlsValue = 0x7777;
+// How many times must a destructor be called before we really are done.
+const int kNumberDestructorCallRepetitions = 8;
+
 static ThreadLocalStorage::Slot tls_slot(LINKER_INITIALIZED);
 
 class ThreadLocalStorageRunner : public DelegateSimpleThread::Delegate {
  public:
   explicit ThreadLocalStorageRunner(int* tls_value_ptr)
       : tls_value_ptr_(tls_value_ptr) {}
 
   virtual ~ThreadLocalStorageRunner() {}
 
   virtual void Run() {
     *tls_value_ptr_ = kInitialTlsValue;
     tls_slot.Set(tls_value_ptr_);
 
     int *ptr = static_cast<int*>(tls_slot.Get());
     EXPECT_EQ(ptr, tls_value_ptr_);
     EXPECT_EQ(*ptr, kInitialTlsValue);
     *tls_value_ptr_ = 0;
 
     ptr = static_cast<int*>(tls_slot.Get());
     EXPECT_EQ(ptr, tls_value_ptr_);
     EXPECT_EQ(*ptr, 0);
+
+    *ptr = kFinalTlsValue + kNumberDestructorCallRepetitions;
   }
 
  private:
   int* tls_value_ptr_;
   DISALLOW_COPY_AND_ASSIGN(ThreadLocalStorageRunner);
 };
 
 
 void ThreadLocalStorageCleanup(void *value) {
   int *ptr = reinterpret_cast<int*>(value);
-  if (ptr)
-    *ptr = kInitialTlsValue;
+  // Destructors should never be called wit a NULL.

[willchan no longer on Chromium, 2011/11/29 01:46:49]

s/wit/with/

[jar (doing other things), 2011/11/29 02:32:45]

Done.

+  ASSERT_NE(ptr, reinterpret_cast<int*>(NULL));

[willchan no longer on Chromium, 2011/11/29 01:46:49]

Should be ASSERT_OP(expected, actual). You have it reversed here.

[jar (doing other things), 2011/11/29 02:32:45]

Done.

+  if (*ptr == kFinalTlsValue)
+    return;  // We've been called enough times.
+  ASSERT_GT(*ptr, kFinalTlsValue);
+  ASSERT_LE(*ptr, kFinalTlsValue + kNumberDestructorCallRepetitions);
+  --*ptr;  // Move closer to our target.
+  // Tell tls that we're not done with this thread, and still need destruction.
+  tls_slot.Set(value);
 }
 
 }  // namespace
 
 TEST(ThreadLocalStorageTest, Basics) {
   ThreadLocalStorage::Slot slot;
   slot.Set(reinterpret_cast<void*>(123));
   int value = reinterpret_cast<intptr_t>(slot.Get());
   EXPECT_EQ(value, 123);
 }
@@ skipping 18 matching lines @@
     threads[index]->Start();
   }
 
   // Wait for the threads to finish.
   for (int index = 0; index < kNumThreads; index++) {
     threads[index]->Join();
     delete threads[index];
     delete thread_delegates[index];
 
     // Verify that the destructor was called and that we reset.
-    EXPECT_EQ(values[index], kInitialTlsValue);
+    EXPECT_EQ(values[index], kFinalTlsValue);

[willchan no longer on Chromium, 2011/11/29 01:46:49]

Looks like this one was wrong too, can you fix the order?

[jar (doing other things), 2011/11/29 02:32:45]

Done.

   }
   tls_slot.Free();  // Stop doing callbacks to cleanup threads.
 }
 
 }  // namespace base