Revert of WTF::ThreadSpecific should use base::ThreadLocalStorage.

third_party/WebKit/Source/wtf/ThreadSpecific.h

 /*
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Jian Li <jianli@chromium.org>
  * Copyright (C) 2012 Patrick Gansterer <paroga@paroga.com>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
@@ skipping 24 matching lines @@
  *     repeatedly if there is still non-NULL value associated with the function.
  *   @ In Windows native implementation, the destructor function will be called
  *     only once.
  * This semantic discrepancy does not impose any problem because nowhere in
  * WebKit the repeated call bahavior is utilized.
  */
 
 #ifndef WTF_ThreadSpecific_h
 #define WTF_ThreadSpecific_h
 
-#include "base/threading/thread_local_storage.h"
 #include "wtf/Allocator.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/Partitions.h"
+#include "wtf/StdLibExtras.h"
 #include "wtf/WTF.h"
+#include "wtf/WTFExport.h"
+
+#if OS(POSIX)
+#include <pthread.h>
+#elif OS(WIN)
+#include <windows.h>
+#endif
 
 namespace WTF {
 
-template<typename T>
-class ThreadSpecific {
+#if OS(WIN)
+// ThreadSpecificThreadExit should be called each time when a thread is detached.
+// This is done automatically for threads created with WTF::createThread.
+WTF_EXPORT void ThreadSpecificThreadExit();
+#endif
+
+template<typename T> class ThreadSpecific {
     USING_FAST_MALLOC(ThreadSpecific);
     WTF_MAKE_NONCOPYABLE(ThreadSpecific);
 public:
-    ThreadSpecific()
-        : m_slot(&destory)
-    { }
-
-    operator T*() { return get(); }
-    T* operator->() { return get(); }
-    T& operator*() { return *get(); }
+    ThreadSpecific();
+    bool isSet(); // Useful as a fast check to see if this thread has set this value.
+    T* operator->();
+    operator T*();
+    T& operator*();
 
 private:
+#if OS(WIN)
+    WTF_EXPORT friend void ThreadSpecificThreadExit();
+#endif
+
     // Not implemented. It's technically possible to destroy a thread specific key, but one would need
     // to make sure that all values have been destroyed already (usually, that all threads that used it
     // have exited). It's unlikely that any user of this call will be in that situation - and having
     // a destructor defined can be confusing, given that it has such strong pre-requisites to work correctly.
     ~ThreadSpecific();
 
-    T* get()
-    {
-        T* ptr = static_cast<T*>(m_slot.Get());
-        if (!ptr) {
-            // Set up thread-specific value's memory pointer before invoking constructor, in case any function it calls
-            // needs to access the value, to avoid recursion.
-            ptr = static_cast<T*>(Partitions::fastZeroedMalloc(sizeof(T), WTF_HEAP_PROFILER_TYPE_NAME(T)));
-            m_slot.Set(ptr);
-            new (NotNull, ptr) T;
-        }
-        return ptr;
+    T* get();
+    void set(T*);
+    void static destroy(void* ptr);
+
+    struct Data {
+        WTF_MAKE_NONCOPYABLE(Data);
+    public:
+        Data(T* value, ThreadSpecific<T>* owner) : value(value), owner(owner) {}
+
+        T* value;
+        ThreadSpecific<T>* owner;
+#if OS(WIN)
+        void (*destructor)(void*);
+#endif
+    };
+
+#if OS(POSIX)
+    pthread_key_t m_key;
+#elif OS(WIN)
+    int m_index;
+#endif
+};
+
+#if OS(POSIX)
+
+typedef pthread_key_t ThreadSpecificKey;
+
+inline void threadSpecificKeyCreate(ThreadSpecificKey* key, void (*destructor)(void *))
+{
+    int error = pthread_key_create(key, destructor);
+    if (error)
+        CRASH();
+}
+
+inline void threadSpecificKeyDelete(ThreadSpecificKey key)
+{
+    int error = pthread_key_delete(key);
+    if (error)
+        CRASH();
+}
+
+inline void threadSpecificSet(ThreadSpecificKey key, void* value)
+{
+    pthread_setspecific(key, value);
+}
+
+inline void* threadSpecificGet(ThreadSpecificKey key)
+{
+    return pthread_getspecific(key);
+}
+
+template<typename T>
+inline ThreadSpecific<T>::ThreadSpecific()
+{
+    int error = pthread_key_create(&m_key, destroy);
+    if (error)
+        CRASH();
+}
+
+template<typename T>
+inline T* ThreadSpecific<T>::get()
+{
+    Data* data = static_cast<Data*>(pthread_getspecific(m_key));
+    return data ? data->value : 0;
+}
+
+template<typename T>
+inline void ThreadSpecific<T>::set(T* ptr)
+{
+    ASSERT(!get());
+    pthread_setspecific(m_key, new Data(ptr, this));
+}
+
+#elif OS(WIN)
+
+// TLS_OUT_OF_INDEXES is not defined on WinCE.
+#ifndef TLS_OUT_OF_INDEXES
+#define TLS_OUT_OF_INDEXES 0xffffffff
+#endif
+
+// The maximum number of TLS keys that can be created. For simplification, we assume that:
+// 1) Once the instance of ThreadSpecific<> is created, it will not be destructed until the program dies.
+// 2) We do not need to hold many instances of ThreadSpecific<> data. This fixed number should be far enough.
+const int kMaxTlsKeySize = 256;
+
+WTF_EXPORT long& tlsKeyCount();
+WTF_EXPORT DWORD* tlsKeys();
+
+class PlatformThreadSpecificKey;
+typedef PlatformThreadSpecificKey* ThreadSpecificKey;
+
+WTF_EXPORT void threadSpecificKeyCreate(ThreadSpecificKey*, void (*)(void *));
+WTF_EXPORT void threadSpecificKeyDelete(ThreadSpecificKey);
+WTF_EXPORT void threadSpecificSet(ThreadSpecificKey, void*);
+WTF_EXPORT void* threadSpecificGet(ThreadSpecificKey);
+
+template<typename T>
+inline ThreadSpecific<T>::ThreadSpecific()
+    : m_index(-1)
+{
+    DWORD tlsKey = TlsAlloc();
+    if (tlsKey == TLS_OUT_OF_INDEXES)
+        CRASH();
+
+    m_index = InterlockedIncrement(&tlsKeyCount()) - 1;
+    if (m_index >= kMaxTlsKeySize)
+        CRASH();
+    tlsKeys()[m_index] = tlsKey;
+}
+
+template<typename T>
+inline ThreadSpecific<T>::~ThreadSpecific()
+{
+    // Does not invoke destructor functions. They will be called from ThreadSpecificThreadExit when the thread is detached.
+    TlsFree(tlsKeys()[m_index]);
+}
+
+template<typename T>
+inline T* ThreadSpecific<T>::get()
+{
+    Data* data = static_cast<Data*>(TlsGetValue(tlsKeys()[m_index]));
+    return data ? data->value : 0;
+}
+
+template<typename T>
+inline void ThreadSpecific<T>::set(T* ptr)
+{
+    ASSERT(!get());
+    Data* data = new Data(ptr, this);
+    data->destructor = &ThreadSpecific<T>::destroy;
+    TlsSetValue(tlsKeys()[m_index], data);
+}
+
+#else
+#error ThreadSpecific is not implemented for this platform.
+#endif
+
+template<typename T>
+inline void ThreadSpecific<T>::destroy(void* ptr)
+{
+    if (isShutdown())
+        return;
+
+    Data* data = static_cast<Data*>(ptr);
+
+#if OS(POSIX)
+    // We want get() to keep working while data destructor works, because it can be called indirectly by the destructor.
+    // Some pthreads implementations zero out the pointer before calling destroy(), so we temporarily reset it.
+    pthread_setspecific(data->owner->m_key, ptr);
+#endif
+
+    data->value->~T();
+    Partitions::fastFree(data->value);
+
+#if OS(POSIX)
+    pthread_setspecific(data->owner->m_key, 0);
+#elif OS(WIN)
+    TlsSetValue(tlsKeys()[data->owner->m_index], 0);
+#else
+#error ThreadSpecific is not implemented for this platform.
+#endif
+
+    delete data;
+}
+
+template<typename T>
+inline bool ThreadSpecific<T>::isSet()
+{
+    return !!get();
+}
+
+template<typename T>
+inline ThreadSpecific<T>::operator T*()
+{
+    T* ptr = static_cast<T*>(get());
+    if (!ptr) {
+        // Set up thread-specific value's memory pointer before invoking constructor, in case any function it calls
+        // needs to access the value, to avoid recursion.
+        ptr = static_cast<T*>(Partitions::fastZeroedMalloc(sizeof(T), WTF_HEAP_PROFILER_TYPE_NAME(T)));
+        set(ptr);
+        new (NotNull, ptr) T;
     }
-
-    static void destory(void* value)
-    {
-        if (isShutdown())
-            return;
-        T* ptr = static_cast<T*>(value);
-        ptr->~T();
-        Partitions::fastFree(ptr);
-    }
-
-    base::ThreadLocalStorage::Slot m_slot;
-};
+    return ptr;
+}
+
+template<typename T>
+inline T* ThreadSpecific<T>::operator->()
+{
+    return operator T*();
+}
+
+template<typename T>
+inline T& ThreadSpecific<T>::operator*()
+{
+    return *operator T*();
+}
 
 } // namespace WTF
 
 using WTF::ThreadSpecific;
 
 #endif // WTF_ThreadSpecific_h