Rename OS(WINDOWS) to OS(WIN)

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 30 matching lines @@
 
 #ifndef WTF_ThreadSpecific_h
 #define WTF_ThreadSpecific_h
 
 #include "wtf/Noncopyable.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/WTFExport.h"
 
 #if USE(PTHREADS)
 #include <pthread.h>
-#elif OS(WINDOWS)
+#elif OS(WIN)
 #include <windows.h>
 #endif
 
 namespace WTF {
 
-#if OS(WINDOWS)
+#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 {
     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(WINDOWS)
+#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(WINDOWS)
+#if OS(WIN)
         void (*destructor)(void*);
 #endif
     };
 
 #if USE(PTHREADS)
     pthread_key_t m_key;
-#elif OS(WINDOWS)
+#elif OS(WIN)
     int m_index;
 #endif
 };
 
 #if USE(PTHREADS)
 
 typedef pthread_key_t ThreadSpecificKey;
 
 inline void threadSpecificKeyCreate(ThreadSpecificKey* key, void (*destructor)(void *))
 {
@@ skipping 34 matching lines @@
     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(WINDOWS)
+#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;
@@ skipping 59 matching lines @@
     // 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();
     fastFree(data->value);
 
 #if USE(PTHREADS)
     pthread_setspecific(data->owner->m_key, 0);
-#elif OS(WINDOWS)
+#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()
@@ skipping 23 matching lines @@
 
 template<typename T>
 inline T& ThreadSpecific<T>::operator*()
 {
     return *operator T*();
 }
 
 } // namespace WTF
 
 #endif // WTF_ThreadSpecific_h