Move files in wtf/ to platform/wtf/ (Part 7).

third_party/WebKit/Source/wtf/ThreadSpecific.h

Index: third_party/WebKit/Source/wtf/ThreadSpecific.h
diff --git a/third_party/WebKit/Source/wtf/ThreadSpecific.h b/third_party/WebKit/Source/wtf/ThreadSpecific.h
index 57c6392d3b3708febb032e0ee0a3fc6b4c3f1a36..25935b0c7214ab50680e76b548a87c719edc86bd 100644
--- a/third_party/WebKit/Source/wtf/ThreadSpecific.h
+++ b/third_party/WebKit/Source/wtf/ThreadSpecific.h
@@ -1,316 +1,9 @@
-/*
- * 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
- *     notice, this list of conditions and the following disclaimer.
- * 2.  Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
- *     its contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+// Copyright 2017 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.
 
-/* Thread local storage is implemented by using either pthread API or Windows
- * native API. There is subtle semantic discrepancy for the cleanup function
- * implementation as noted below:
- *   @ In pthread implementation, the destructor function will be called
- *     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.
- */
+#include "platform/wtf/ThreadSpecific.h"
 
-#ifndef WTF_ThreadSpecific_h
-#define WTF_ThreadSpecific_h
-
-#include "wtf/Allocator.h"
-#include "wtf/Noncopyable.h"
-#include "wtf/StackUtil.h"
-#include "wtf/StdLibExtras.h"
-#include "wtf/WTF.h"
-#include "wtf/WTFExport.h"
-#include "wtf/allocator/PartitionAllocator.h"
-#include "wtf/allocator/Partitions.h"
-
-#if OS(POSIX)
-#include <pthread.h>
-#elif OS(WIN)
-#include <windows.h>
-#endif
-
-namespace WTF {
-
-#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();
-  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();
-  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
-  // This member must only be accessed or modified on the main thread.
-  T* m_mainThreadStorage = nullptr;
-};
-
-#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) {
-  DCHECK(!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) {
-  DCHECK(!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) {
-  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
-
-  // Never call destructors on the main thread. This is fine because Blink no
-  // longer has a graceful shutdown sequence. Be careful to call this function
-  // (which can be re-entrant) while the pointer is still set, to avoid lazily
-  // allocating WTFThreadData after it is destroyed.
-  if (isMainThread())
-    return;
-
-  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* offThreadPtr;
-#if defined(__GLIBC__) || OS(ANDROID) || OS(FREEBSD)
-  // TLS is fast on these platforms.
-  // TODO(csharrison): Qualify this statement for Android.
-  const bool mainThreadAlwaysChecksTLS = true;
-  T** ptr = &offThreadPtr;
-  offThreadPtr = static_cast<T*>(get());
-#else
-  const bool mainThreadAlwaysChecksTLS = false;
-  T** ptr = &m_mainThreadStorage;
-  if (UNLIKELY(mayNotBeMainThread())) {
-    offThreadPtr = static_cast<T*>(get());
-    ptr = &offThreadPtr;
-  }
-#endif
-  // 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.
-  if (UNLIKELY(!*ptr)) {
-    *ptr = static_cast<T*>(Partitions::fastZeroedMalloc(
-        sizeof(T), WTF_HEAP_PROFILER_TYPE_NAME(T)));
-
-    // Even if we didn't realize we're on the main thread, we might still be.
-    // We need to double-check so that |m_mainThreadStorage| is populated.
-    if (!mainThreadAlwaysChecksTLS && UNLIKELY(ptr != &m_mainThreadStorage) &&
-        isMainThread()) {
-      m_mainThreadStorage = *ptr;
-    }
-
-    set(*ptr);
-    new (NotNull, *ptr) T;
-  }
-  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
+// The contents of this header was moved to platform/wtf as part of
+// WTF migration project. See the following post for details:
+// https://groups.google.com/a/chromium.org/d/msg/blink-dev/tLdAZCTlcAA/bYXVT8gYCAAJ