Implement chromium's TLS.

base/threading/thread_local_storage.h

 // Copyright (c) 2012 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_THREADING_THREAD_LOCAL_STORAGE_H_
 #define BASE_THREADING_THREAD_LOCAL_STORAGE_H_
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
 
-#if defined(OS_POSIX)
+#if defined(OS_WIN)
+#include <windows.h>
+#elif defined(OS_POSIX)
 #include <pthread.h>
 #endif
 
 namespace base {
 
+namespace internal {
+
+// Helper functions that abstract the cross-platform APIs. Do not use directly
+class BASE_EXPORT PlatformThreadLocalStorage {
+ public:
+
+#if defined(OS_WIN)
+  typedef unsigned long TLSKey;
+  enum { TLS_KEY_OUT_OF_INDEXES = TLS_OUT_OF_INDEXES };
+#elif defined(OS_POSIX)
+  typedef pthread_key_t TLSKey;
+  // In theory, there is no invalid key in Posix, It is critical to define
+  // one, so we can use minimal system service to implement TLS.
+  // It is almost imposible to get the defined invalid key, if we do get it,
+  // just alloc another one.
+  enum { TLS_KEY_OUT_OF_INDEXES = 0x7FFFFFFF };
+#endif
+  // Cross-platform APIs
+  static bool AllocTLS(TLSKey* key);

[jar (doing other things), 2013/11/20 01:46:15]

The cross platform API must include destructors (called on each thread as the
thread is terminated).  Why are you not including it?

[michaelbai, 2013/11/20 05:27:30]

That because Windows doesn't support destructor key mapping, I explain why I did
this in cc file's comment, please check that.

On 2013/11/20 01:46:15, jar wrote:

+  static void FreeTLS(TLSKey key);
+  static void SetTLSValue(TLSKey key, void* value);
+  static void* GetTLSValue(TLSKey key);
+
+  // This is the TLS destructor and not a cross-platform API. The implementation

[jar (doing other things), 2013/11/20 01:46:15]

Please describe what the method is for, or what it does.

+  // of cross-platform APIs should call this method when thread exit. The

[jar (doing other things), 2013/11/20 01:46:15]

I couldn't grok:

...call this method when thread exit.

Do you mean:
...call this method on the terminating thread when a thread exits.

+  // |value| is always NULL in Windows.

[jar (doing other things), 2013/11/20 01:46:15]

I couldn't understand this comment, from start to finish.  This last line tells
me that an argument is null one one platform, but gave no hint as to what the
argument is, does, or is used for on any other platform.

+  static void OnThreadExit(void* value);
+};
+
+}  // namespace internal
+
 // Wrapper for thread local storage.  This class doesn't do much except provide
 // an API for portability.
 class BASE_EXPORT ThreadLocalStorage {
  public:
 
   // Prototype for the TLS destructor function, which can be optionally used to
   // cleanup thread local storage on thread exit.  'value' is the data that is
   // stored in thread local storage.
   typedef void (*TLSDestructorFunc)(void* value);
 
@@ skipping 26 matching lines @@
     void* Get() const;
 
     // Set the thread-local value stored in slot 'slot' to
     // value 'value'.
     void Set(void* value);
 
     bool initialized() const { return initialized_; }
 
     // The internals of this struct should be considered private.
     bool initialized_;
-#if defined(OS_WIN)
     int slot_;
-#elif defined(OS_POSIX)
-    pthread_key_t key_;
-#endif
-
   };
 
   // A convenience wrapper around StaticSlot with a constructor. Can be used
   // as a member variable.
   class BASE_EXPORT Slot : public StaticSlot {
    public:
     // Calls StaticSlot::Initialize().
     explicit Slot(TLSDestructorFunc destructor = NULL);
 
    private:
     using StaticSlot::initialized_;
-#if defined(OS_WIN)
     using StaticSlot::slot_;
-#elif defined(OS_POSIX)
-    using StaticSlot::key_;
-#endif
+
     DISALLOW_COPY_AND_ASSIGN(Slot);
   };
 
   DISALLOW_COPY_AND_ASSIGN(ThreadLocalStorage);
 };
 
 }  // namespace base
 
 #endif  // BASE_THREADING_THREAD_LOCAL_STORAGE_H_