Rename OS(WINDOWS) to OS(WIN)

Source/wtf/FastMalloc.cpp

 // Copyright (c) 2005, 2007, Google Inc.
 // All rights reserved.
 // Copyright (C) 2005, 2006, 2007, 2008, 2009, 2011 Apple Inc. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 69 matching lines @@
 #include "wtf/Assertions.h"
 #include "wtf/CPU.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/UnusedParam.h"
 
 #if OS(MACOSX)
 #include <AvailabilityMacros.h>
 #endif
 
 #include <limits>
-#if OS(WINDOWS)
+#if OS(WIN)
 #include <windows.h>
 #else
 #include <pthread.h>
 #endif
 #include <stdlib.h>
 #include <string.h>
 
 #ifndef NO_TCMALLOC_SAMPLES
 #define NO_TCMALLOC_SAMPLES
 #endif
 
 #if !USE(SYSTEM_MALLOC) && defined(NDEBUG)
 #define FORCE_SYSTEM_MALLOC 0
 #else
 #define FORCE_SYSTEM_MALLOC 1
 #endif
 
 // Harden the pointers stored in the TCMalloc linked lists
 #if COMPILER(GCC)
 #define ENABLE_TCMALLOC_HARDENING 1
 #endif
 
 // Use a background thread to periodically scavenge memory to release back to the system
 #define USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY 1
 
 #ifndef NDEBUG
 namespace WTF {
 
-#if OS(WINDOWS)
+#if OS(WIN)
 
 // TLS_OUT_OF_INDEXES is not defined on WinCE.
 #ifndef TLS_OUT_OF_INDEXES
 #define TLS_OUT_OF_INDEXES 0xffffffff
 #endif
 
 static DWORD isForibiddenTlsIndex = TLS_OUT_OF_INDEXES;
 static const LPVOID kTlsAllowValue = reinterpret_cast<LPVOID>(0); // Must be zero.
 static const LPVOID kTlsForbiddenValue = reinterpret_cast<LPVOID>(1);
 
@@ skipping 14 matching lines @@
     TlsSetValue(isForibiddenTlsIndex, kTlsForbiddenValue);
 }
 
 void fastMallocAllow()
 {
     if (isForibiddenTlsIndex == TLS_OUT_OF_INDEXES)
         return;
     TlsSetValue(isForibiddenTlsIndex, kTlsAllowValue);
 }
 
-#else // !OS(WINDOWS)
+#else // !OS(WIN)
 
 static pthread_key_t isForbiddenKey;
 static pthread_once_t isForbiddenKeyOnce = PTHREAD_ONCE_INIT;
 static void initializeIsForbiddenKey()
 {
   pthread_key_create(&isForbiddenKey, 0);
 }
 
 #if !ASSERT_DISABLED
 static bool isForbidden()
 {
     pthread_once(&isForbiddenKeyOnce, initializeIsForbiddenKey);
     return !!pthread_getspecific(isForbiddenKey);
 }
 #endif
 
 void fastMallocForbid()
 {
     pthread_once(&isForbiddenKeyOnce, initializeIsForbiddenKey);
     pthread_setspecific(isForbiddenKey, &isForbiddenKey);
 }
 
 void fastMallocAllow()
 {
     pthread_once(&isForbiddenKeyOnce, initializeIsForbiddenKey);
     pthread_setspecific(isForbiddenKey, 0);
 }
-#endif // OS(WINDOWS)
+#endif // OS(WIN)
 
 } // namespace WTF
 #endif // NDEBUG
 
 namespace WTF {
 
 void* fastZeroedMalloc(size_t n)
 {
     void* result = fastMalloc(n);
     memset(result, 0, n);
     return result;
 }
 
 char* fastStrDup(const char* src)
 {
     size_t len = strlen(src) + 1;
     char* dup = static_cast<char*>(fastMalloc(len));
     memcpy(dup, src, len);
     return dup;
 }
 
 } // namespace WTF
 
 #if FORCE_SYSTEM_MALLOC
 
 #if OS(MACOSX)
 #include <malloc/malloc.h>
-#elif OS(WINDOWS)
+#elif OS(WIN)
 #include <malloc.h>
 #endif
 
 namespace WTF {
 
 size_t fastMallocGoodSize(size_t bytes)
 {
 #if OS(MACOSX)
     return malloc_good_size(bytes);
 #else
@@ skipping 62 matching lines @@
 #include "TCSpinLock.h"
 #include "TCSystemAlloc.h"
 #include <algorithm>
 #include <errno.h>
 #include <pthread.h>
 #include <stdarg.h>
 #include <stddef.h>
 #if OS(UNIX)
 #include <unistd.h>
 #endif
-#if OS(WINDOWS)
+#if OS(WIN)
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN
 #endif
 #include <windows.h>
 #endif
 
 #if OS(MACOSX)
 #include "MallocZoneSupport.h"
 #include "wtf/HashSet.h"
 #include "wtf/Vector.h"
@@ skipping 1289 matching lines @@
 #if OS(MACOSX)
   friend class FastMallocZone;
 #endif
 
 #if USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY
   void initializeScavenger();
   ALWAYS_INLINE void signalScavenger();
   void scavenge();
   ALWAYS_INLINE bool shouldScavenge() const;
 
-#if HAVE(DISPATCH_H) || OS(WINDOWS)
+#if HAVE(DISPATCH_H) || OS(WIN)
   void periodicScavenge();
   ALWAYS_INLINE bool isScavengerSuspended();
   ALWAYS_INLINE void scheduleScavenger();
   ALWAYS_INLINE void rescheduleScavenger();
   ALWAYS_INLINE void suspendScavenger();
 #endif
 
 #if HAVE(DISPATCH_H)
   dispatch_queue_t m_scavengeQueue;
   dispatch_source_t m_scavengeTimer;
   bool m_scavengingSuspended;
-#elif OS(WINDOWS)
+#elif OS(WIN)
   static void CALLBACK scavengerTimerFired(void*, BOOLEAN);
   HANDLE m_scavengeQueueTimer;
 #else
   static NO_RETURN_WITH_VALUE void* runScavengerThread(void*);
   NO_RETURN void scavengerThread();
 
   // Keeps track of whether the background thread is actively scavenging memory every kScavengeDelayInSeconds, or
   // it's blocked waiting for more pages to be deleted.
   bool m_scavengeThreadActive;
 
@@ skipping 66 matching lines @@
     // Nothing to do here for libdispatch.
 }
 
 ALWAYS_INLINE void TCMalloc_PageHeap::suspendScavenger()
 {
     ASSERT(pageheap_lock.IsHeld());
     m_scavengingSuspended = true;
     dispatch_suspend(m_scavengeTimer);
 }
 
-#elif OS(WINDOWS)
+#elif OS(WIN)
 
 void TCMalloc_PageHeap::scavengerTimerFired(void* context, BOOLEAN)
 {
     static_cast<TCMalloc_PageHeap*>(context)->periodicScavenge();
 }
 
 void TCMalloc_PageHeap::initializeScavenger()
 {
     m_scavengeQueueTimer = 0;
 }
@@ skipping 650 matching lines @@
   }
 };
 
 //-------------------------------------------------------------------
 // Data kept per thread
 //-------------------------------------------------------------------
 
 class TCMalloc_ThreadCache {
  private:
   typedef TCMalloc_ThreadCache_FreeList FreeList;
-#if OS(WINDOWS)
+#if OS(WIN)
   typedef DWORD ThreadIdentifier;
 #else
   typedef pthread_t ThreadIdentifier;
 #endif
 
   size_t        size_;                  // Combined size of data
   ThreadIdentifier tid_;                // Which thread owns it
   bool          in_setspecific_;           // Called pthread_setspecific?
   FreeList      list_[kNumClasses];     // Array indexed by size-class
 
@@ skipping 84 matching lines @@
 
 size_t fastMallocGoodSize(size_t bytes)
 {
     if (!phinited)
         TCMalloc_ThreadCache::InitModule();
     return AllocationSize(bytes);
 }
 
 #if USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY
 
-#if HAVE(DISPATCH_H) || OS(WINDOWS)
+#if HAVE(DISPATCH_H) || OS(WIN)
 
 void TCMalloc_PageHeap::periodicScavenge()
 {
     SpinLockHolder h(&pageheap_lock);
     pageheap->scavenge();
 
     if (shouldScavenge()) {
         rescheduleScavenger();
         return;
     }
@@ skipping 61 matching lines @@
 #ifdef HAVE_TLS
 static __thread TCMalloc_ThreadCache *threadlocal_heap;
 #endif
 // Thread-specific key.  Initialization here is somewhat tricky
 // because some Linux startup code invokes malloc() before it
 // is in a good enough state to handle pthread_keycreate().
 // Therefore, we use TSD keys only after tsd_inited is set to true.
 // Until then, we use a slow path to get the heap object.
 static bool tsd_inited = false;
 static pthread_key_t heap_key;
-#if OS(WINDOWS)
+#if OS(WIN)
 DWORD tlsIndex = TLS_OUT_OF_INDEXES;
 #endif
 
 static ALWAYS_INLINE void setThreadHeap(TCMalloc_ThreadCache* heap)
 {
 #if USE(PTHREAD_GETSPECIFIC_DIRECT)
     // Can't have two libraries both doing this in the same process,
     // so check and make this crash right away.
     if (pthread_getspecific(heap_key))
         CRASH();
 #endif
 
     // Still do pthread_setspecific even if there's an alternate form
     // of thread-local storage in use, to benefit from the delete callback.
     pthread_setspecific(heap_key, heap);
 
-#if OS(WINDOWS)
+#if OS(WIN)
     TlsSetValue(tlsIndex, heap);
 #endif
 }
 
 // Allocator for thread heaps
 static PageHeapAllocator<TCMalloc_ThreadCache> threadheap_allocator;
 
 // Linked list of heap objects.  Protected by pageheap_lock.
 static TCMalloc_ThreadCache* thread_heaps = NULL;
 static int thread_heap_count = 0;
@@ skipping 237 matching lines @@
   lock_.Unlock();
   const size_t npages = class_to_pages[size_class_];
 
   Span* span;
   {
     SpinLockHolder h(&pageheap_lock);
     span = pageheap->New(npages);
     if (span) pageheap->RegisterSizeClass(span, size_class_);
   }
   if (span == NULL) {
-#if OS(WINDOWS)
+#if OS(WIN)
     MESSAGE("allocation failed: %d\n", ::GetLastError());
 #else
     MESSAGE("allocation failed: %d\n", errno);
 #endif
     lock_.Lock();
     return;
   }
   ASSERT_SPAN_COMMITTED(span);
   ASSERT(span->length == npages);
   // Cache sizeclass info eagerly.  Locking is not necessary.
@@ skipping 264 matching lines @@
   thread_heap_count++;
   RecomputeThreadCacheSize();
   return heap;
 }
 
 inline TCMalloc_ThreadCache* TCMalloc_ThreadCache::GetThreadHeap() {
 #ifdef HAVE_TLS
     // __thread is faster, but only when the kernel supports it
   if (KernelSupportsTLS())
     return threadlocal_heap;
-#elif OS(WINDOWS)
+#elif OS(WIN)
     return static_cast<TCMalloc_ThreadCache*>(TlsGetValue(tlsIndex));
 #else
     return static_cast<TCMalloc_ThreadCache*>(pthread_getspecific(heap_key));
 #endif
 }
 
 inline TCMalloc_ThreadCache* TCMalloc_ThreadCache::GetCache() {
   TCMalloc_ThreadCache* ptr = NULL;
   if (!tsd_inited) {
     InitModule();
@@ skipping 13 matching lines @@
   return reinterpret_cast<TCMalloc_ThreadCache*>(p);
 }
 
 void TCMalloc_ThreadCache::InitTSD() {
   ASSERT(!tsd_inited);
 #if USE(PTHREAD_GETSPECIFIC_DIRECT)
   pthread_key_init_np(heap_key, DestroyThreadCache);
 #else
   pthread_key_create(&heap_key, DestroyThreadCache);
 #endif
-#if OS(WINDOWS)
+#if OS(WIN)
   tlsIndex = TlsAlloc();
 #endif
   tsd_inited = true;
 
-#if !OS(WINDOWS)
+#if !OS(WIN)
   // We may have used a fake pthread_t for the main thread.  Fix it.
   pthread_t zero;
   memset(&zero, 0, sizeof(zero));
 #endif
   ASSERT(pageheap_lock.IsHeld());
   for (TCMalloc_ThreadCache* h = thread_heaps; h != NULL; h = h->next_) {
-#if OS(WINDOWS)
+#if OS(WIN)
     if (h->tid_ == 0) {
       h->tid_ = GetCurrentThreadId();
     }
 #else
     if (pthread_equal(h->tid_, zero)) {
       h->tid_ = pthread_self();
     }
 #endif
   }
 }
 
 TCMalloc_ThreadCache* TCMalloc_ThreadCache::CreateCacheIfNecessary() {
   // Initialize per-thread data if necessary
   TCMalloc_ThreadCache* heap = NULL;
   {
     SpinLockHolder h(&pageheap_lock);
 
-#if OS(WINDOWS)
+#if OS(WIN)
     DWORD me;
     if (!tsd_inited) {
       me = 0;
     } else {
       me = GetCurrentThreadId();
     }
 #else
     // Early on in glibc's life, we cannot even call pthread_self()
     pthread_t me;
     if (!tsd_inited) {
       memset(&me, 0, sizeof(me));
     } else {
       me = pthread_self();
     }
 #endif
 
     // This may be a recursive malloc call from pthread_setspecific()
     // In that case, the heap for this thread has already been created
     // and added to the linked list.  So we search for that first.
     for (TCMalloc_ThreadCache* h = thread_heaps; h != NULL; h = h->next_) {
-#if OS(WINDOWS)
+#if OS(WIN)
       if (h->tid_ == me) {
 #else
       if (pthread_equal(h->tid_, me)) {
 #endif
         heap = h;
         break;
       }
     }
 
     if (heap == NULL) heap = NewHeap(me, HARDENING_ENTROPY);
@@ skipping 675 matching lines @@
 void FastMallocZone::init()
 {
     static FastMallocZone zone(pageheap, &thread_heaps, static_cast<TCMalloc_Central_FreeListPadded*>(central_cache), &span_allocator, &threadheap_allocator);
 }
 
 #endif // OS(MACOSX)
 
 } // namespace WTF
 
 #endif // FORCE_SYSTEM_MALLOC