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 {
+
+// WARNING: You should *NOT* be using this class directly.
+// PlatformThreadLocalStorage is low-level abstraction to the OS's TLS
+// interface, you should instead be using ThreadLocalStorage::StaticSlot/Slot,
+// see thread_local_storage.h.
+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.

[jar (doing other things), 2013/11/26 20:05:24]

nit: I don't understand the comment.  Perhaps you meant to say:

The following is a "reserved key" which is used in our generic Chromium
ThreadLocalStorage implementation.  We expect that an OS will not return such a
key... but if it is returned (i.e., the OS tries to allocate it) we will just
discard/leak it, and request another key.

[michaelbai, 2013/11/27 00:29:26]

Correct, update the comment.

On 2013/11/26 20:05:24, jar wrote:

+  enum { TLS_KEY_OUT_OF_INDEXES = 0x7FFFFFFF };
+#endif
+  // Cross-platform APIs

[jar (doing other things), 2013/11/26 20:05:24]

nit: Better comment is:

The following methods need to be supported on each OS platform, so that the
Chromium ThreadLocalStore functionality can be constructed.  Chromium will use
these methods to acquire a single OS slot, and then use that to support a much
larger number of Chromium slots (independent of the OS restrictions).

[michaelbai, 2013/11/27 00:29:26]

Done.

+  static bool AllocTLS(TLSKey* key);

[jar (doing other things), 2013/11/26 20:05:24]

You need a comment above line 40 this describing the API:

The following returns true IFF it successfully is able to return an OS key in
|key|.

[michaelbai, 2013/11/27 00:29:26]

Done.

+  static void FreeTLS(TLSKey key);

[jar (doing other things), 2013/11/26 20:05:24]

Why do we need to Free our OS slot?  Why do we care about the leak?

[michaelbai, 2013/11/27 00:29:26]

I think it just here for code looks clean.

On 2013/11/26 20:05:24, jar wrote:

+  static void SetTLSValue(TLSKey key, void* value);
+  static void* GetTLSValue(TLSKey key);
+
+  // This is the TLS destructor, the implementation of cross-platform APIs

[jar (doing other things), 2013/11/26 20:05:24]

Nit: Delete the phrase "This is the TLS destructor,"

I think the comment should be:

Each platform (OS implementation) is required to call this method on each
terminating thread when the thread is about to terminate.  This method will then
call all registered destructors for slots in Chromium ThreadLocalStorage, until
there are no slot values remaining as having been set on this thread.
[Destructors may end up being called multiple times on a terminating thread, as
other destructors may re-set slots that were previously destroyed.]

[michaelbai, 2013/11/27 00:29:26]

Done.

+  // should call this method on the terminating thread when a thread exits,
+  // this function calls any TLS destructors that were passed in from
+  // ThreadLocalStorage::StaticSlot::Initialize() and are pending for the
+  // thread.
+  static void OnThreadExit();
+};
+
+}  // 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_