wtf reformat test

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 45 matching lines @@
 #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*();
+template <typename T>
+class ThreadSpecific {
+  USING_FAST_MALLOC(ThreadSpecific);
+  WTF_MAKE_NONCOPYABLE(ThreadSpecific);
 
-private:
+ 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();
+  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();
+  // 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);
+  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) {}
+  struct Data {
+    WTF_MAKE_NONCOPYABLE(Data);
 
-        T* value;
-        ThreadSpecific<T>* owner;
+   public:
+    Data(T* value, ThreadSpecific<T>* owner) : value(value), owner(owner) {}
+
+    T* value;
+    ThreadSpecific<T>* owner;
 #if OS(WIN)
-        void (*destructor)(void*);
+    void (*destructor)(void*);
 #endif
-    };
+  };
 
 #if OS(POSIX)
-    pthread_key_t m_key;
+  pthread_key_t m_key;
 #elif OS(WIN)
-    int m_index;
+  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 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 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 threadSpecificSet(ThreadSpecificKey key, void* value) {
+  pthread_setspecific(key, value);
 }
 
-inline void* threadSpecificGet(ThreadSpecificKey key)
-{
-    return pthread_getspecific(key);
+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 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 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));
+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 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();
+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;
+  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 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 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);
+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;
+template <typename T>
+inline void ThreadSpecific<T>::destroy(void* ptr) {
+  if (isShutdown())
+    return;
 
-    Data* data = static_cast<Data*>(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);
+  // 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);
+  data->value->~T();
+  Partitions::fastFree(data->value);
 
 #if OS(POSIX)
-    pthread_setspecific(data->owner->m_key, 0);
+  pthread_setspecific(data->owner->m_key, 0);
 #elif OS(WIN)
-    TlsSetValue(tlsKeys()[data->owner->m_index], 0);
+  TlsSetValue(tlsKeys()[data->owner->m_index], 0);
 #else
 #error ThreadSpecific is not implemented for this platform.
 #endif
 
-    delete data;
+  delete data;
 }
 
-template<typename T>
-inline bool ThreadSpecific<T>::isSet()
-{
-    return !!get();
+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;
-    }
-    return ptr;
+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;
+  }
+  return ptr;
 }
 
-template<typename T>
-inline T* ThreadSpecific<T>::operator->()
-{
-    return operator T*();
+template <typename T>
+inline T* ThreadSpecific<T>::operator->() {
+  return operator T*();
 }
 
-template<typename T>
-inline T& ThreadSpecific<T>::operator*()
-{
-    return *operator T*();
+template <typename T>
+inline T& ThreadSpecific<T>::operator*() {
+  return *operator T*();
 }
 
-} // namespace WTF
+}  // namespace WTF
 
 using WTF::ThreadSpecific;
 
-#endif // WTF_ThreadSpecific_h
+#endif  // WTF_ThreadSpecific_h