Fix trailing whitespace in .cpp, .h, and .idl files (ex. Source/core)

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.
 //     * 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.
 //     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
 // OWNER OR 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
@@ skipping 165 matching lines @@
 #endif
 
 NO_RETURN_DUE_TO_CRASH void fastMallocMatchFailed(void*)
 {
     CRASH();
 }
 
 } // namespace Internal
 
 
-void* fastZeroedMalloc(size_t n) 
+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;
 }
 
-TryMallocReturnValue tryFastZeroedMalloc(size_t n) 
+TryMallocReturnValue tryFastZeroedMalloc(size_t n)
 {
     void* result;
     if (!tryFastMalloc(n).getValue(result))
         return 0;
     memset(result, 0, n);
     return result;
 }
 
 } // namespace WTF
 
 #if FORCE_SYSTEM_MALLOC
 
 #if OS(DARWIN)
 #include <malloc/malloc.h>
 #elif OS(WINDOWS)
 #include <malloc.h>
 #endif
 
 namespace WTF {
 
 size_t fastMallocGoodSize(size_t bytes)
 {
 #if OS(DARWIN)
     return malloc_good_size(bytes);
 #else
     return bytes;
 #endif
 }
 
-TryMallocReturnValue tryFastMalloc(size_t n) 
+TryMallocReturnValue tryFastMalloc(size_t n)
 {
     ASSERT(!isForbidden());
 
 #if ENABLE(WTF_MALLOC_VALIDATION)
     if (std::numeric_limits<size_t>::max() - Internal::ValidationBufferSize <= n)  // If overflow would occur...
         return 0;
 
     void* result = malloc(n + Internal::ValidationBufferSize);
     if (!result)
         return 0;
     Internal::ValidationHeader* header = static_cast<Internal::ValidationHeader*>(result);
     header->m_size = n;
     header->m_type = Internal::AllocTypeMalloc;
     header->m_prefix = static_cast<unsigned>(Internal::ValidationPrefix);
     result = header + 1;
     *Internal::fastMallocValidationSuffix(result) = Internal::ValidationSuffix;
     fastMallocValidate(result);
     return result;
 #else
     return malloc(n);
 #endif
 }
 
-void* fastMalloc(size_t n) 
+void* fastMalloc(size_t n)
 {
     ASSERT(!isForbidden());
 
 #if ENABLE(WTF_MALLOC_VALIDATION)
     TryMallocReturnValue returnValue = tryFastMalloc(n);
     void* result;
     if (!returnValue.getValue(result))
         CRASH();
 #else
     void* result = malloc(n);
@@ skipping 43 matching lines @@
     return result;
 }
 
 void fastFree(void* p)
 {
     ASSERT(!isForbidden());
 
 #if ENABLE(WTF_MALLOC_VALIDATION)
     if (!p)
         return;
-    
+
     fastMallocMatchValidateFree(p, Internal::AllocTypeMalloc);
     Internal::ValidationHeader* header = Internal::fastMallocValidationHeader(p);
     memset(p, 0xCC, header->m_size);
     free(header);
 #else
     free(p);
 #endif
 }
 
 TryMallocReturnValue tryFastRealloc(void* p, size_t n)
@@ skipping 33 matching lines @@
 #else
     void* result = realloc(p, n);
 #endif
 
     ASSERT(result);  // We expect tcmalloc underneath, which would crash instead of getting here.
 
     return result;
 }
 
 void releaseFastMallocFreeMemory() { }
-    
+
 FastMallocStatistics fastMallocStatistics()
 {
     FastMallocStatistics statistics = { 0, 0, 0 };
     return statistics;
 }
 
 } // namespace WTF
 
 #if OS(DARWIN)
 // This symbol is present in the JavaScriptCore exports file even when FastMalloc is disabled.
@@ skipping 62 matching lines @@
 #define pthread_setspecific(key, val) _pthread_setspecific_direct(key, (val))
 #endif
 #endif
 
 #define DEFINE_VARIABLE(type, name, value, meaning) \
   namespace FLAG__namespace_do_not_use_directly_use_DECLARE_##type##_instead {  \
   type FLAGS_##name(value);                                \
   char FLAGS_no##name;                                                        \
   }                                                                           \
   using FLAG__namespace_do_not_use_directly_use_DECLARE_##type##_instead::FLAGS_##name
-  
+
 #define DEFINE_int64(name, value, meaning) \
   DEFINE_VARIABLE(int64_t, name, value, meaning)
-  
+
 #define DEFINE_double(name, value, meaning) \
   DEFINE_VARIABLE(double, name, value, meaning)
 
 namespace WTF {
 
 #define malloc fastMalloc
 #define calloc fastCalloc
 #define free fastFree
 #define realloc fastRealloc
 
@@ skipping 25 matching lines @@
  * To make it harder to exploit use-after free style exploits
  * we mask the addresses we put into our linked lists with the
  * address of kLLHardeningMask.  Due to ASLR the address of
  * kLLHardeningMask should be sufficiently randomized to make direct
  * freelist manipulation much more difficult.
  */
 enum {
     MaskKeyShift = 13
 };
 
-static ALWAYS_INLINE uintptr_t internalEntropyValue() 
+static ALWAYS_INLINE uintptr_t internalEntropyValue()
 {
     static uintptr_t value = EntropySource<sizeof(uintptr_t)>::value() | 1;
     ASSERT(value);
     return value;
 }
 
 #define HARDENING_ENTROPY internalEntropyValue()
 #define ROTATE_VALUE(value, amount) (((value) >> (amount)) | ((value) << (sizeof(value) * 8 - (amount))))
 #define XOR_MASK_PTR_WITH_KEY(ptr, key, entropy) (reinterpret_cast<typeof(ptr)>(reinterpret_cast<uintptr_t>(ptr)^(ROTATE_VALUE(reinterpret_cast<uintptr_t>(key), MaskKeyShift)^entropy)))
 
@@ skipping 976 matching lines @@
 // because sometimes the sizeclass is all the information we need.
 
 // Selector class -- general selector uses 3-level map
 template <int BITS> class MapSelector {
  public:
   typedef TCMalloc_PageMap3<BITS-kPageShift> Type;
   typedef PackedCache<BITS, uint64_t> CacheType;
 };
 
 #if CPU(X86_64)
-// On all known X86-64 platforms, the upper 16 bits are always unused and therefore 
+// On all known X86-64 platforms, the upper 16 bits are always unused and therefore
 // can be excluded from the PageMap key.
 // See http://en.wikipedia.org/wiki/X86-64#Virtual_address_space_details
 
 static const size_t kBitsUnusedOn64Bit = 16;
 #else
 static const size_t kBitsUnusedOn64Bit = 0;
 #endif
 
 // A three-level map for 64-bit machines
 template <> class MapSelector<64> {
@@ skipping 81 matching lines @@
   // Return the descriptor for the specified page.
   inline Span* GetDescriptor(PageID p) const {
     return reinterpret_cast<Span*>(pagemap_.get(p));
   }
 
   inline Span* GetDescriptorEnsureSafe(PageID p)
   {
       pagemap_.Ensure(p, 1);
       return GetDescriptor(p);
   }
-    
+
   size_t ReturnedBytes() const;
 
   // Return number of bytes allocated from system
   inline uint64_t SystemBytes() const { return system_bytes_; }
 
   // Return number of free bytes in heap
   uint64_t FreeBytes() const {
     return (static_cast<uint64_t>(free_pages_) << kPageShift);
   }
 
@@ skipping 63 matching lines @@
   //
   // "released" is true iff "span" was found on a "returned" list.
   void Carve(Span* span, Length n, bool released);
 
   void RecordSpan(Span* span) {
     pagemap_.set(span->start, span);
     if (span->length > 1) {
       pagemap_.set(span->start + span->length - 1, span);
     }
   }
-  
+
     // Allocate a large span of length == n.  If successful, returns a
   // span of exactly the specified length.  Else, returns NULL.
   Span* AllocLarge(Length n);
 
 #if !USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY
   // Incrementally release some memory to the system.
   // IncrementalScavenge(n) is called whenever n pages are freed.
   void IncrementalScavenge(Length n);
 #endif
 
   // Number of pages to deallocate before doing more scavenging
   int64_t scavenge_counter_;
 
   // Index of last free list we scavenged
   size_t scavenge_index_;
-  
+
 #if OS(DARWIN)
   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)
   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)
   static void CALLBACK scavengerTimerFired(void*, BOOLEAN);
   HANDLE m_scavengeQueueTimer;
-#else 
+#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;
 
   pthread_mutex_t m_scavengeMutex;
   pthread_cond_t m_scavengeCondition;
 #endif
@@ skipping 138 matching lines @@
 {
     static_cast<TCMalloc_PageHeap*>(context)->scavengerThread();
 #if COMPILER(MSVC)
     // Without this, Visual Studio will complain that this method does not return a value.
     return 0;
 #endif
 }
 
 ALWAYS_INLINE void TCMalloc_PageHeap::signalScavenger()
 {
-    // shouldScavenge() should be called only when the pageheap_lock spinlock is held, additionally, 
+    // shouldScavenge() should be called only when the pageheap_lock spinlock is held, additionally,
     // m_scavengeThreadActive is only set to false whilst pageheap_lock is held. The caller must ensure this is
     // taken prior to calling this method. If the scavenger thread is sleeping and shouldScavenge() indicates there
     // is memory to free the scavenger thread is signalled to start.
     ASSERT(pageheap_lock.IsHeld());
     if (!m_scavengeThreadActive && shouldScavenge())
         pthread_cond_signal(&m_scavengeCondition);
 }
 
 #endif
 
 void TCMalloc_PageHeap::scavenge()
 {
     size_t pagesToRelease = min_free_committed_pages_since_last_scavenge_ * kScavengePercentage;
     size_t targetPageCount = std::max<size_t>(kMinimumFreeCommittedPageCount, free_committed_pages_ - pagesToRelease);
 
     Length lastFreeCommittedPages = free_committed_pages_;
     while (free_committed_pages_ > targetPageCount) {
         ASSERT(Check());
         for (int i = kMaxPages; i > 0 && free_committed_pages_ >= targetPageCount; i--) {
             SpanList* slist = (static_cast<size_t>(i) == kMaxPages) ? &large_ : &free_[i];
-            // If the span size is bigger than kMinSpanListsWithSpans pages return all the spans in the list, else return all but 1 span.  
+            // If the span size is bigger than kMinSpanListsWithSpans pages return all the spans in the list, else return all but 1 span.
             // Return only 50% of a spanlist at a time so spans of size 1 are not the only ones left.
             size_t length = DLL_Length(&slist->normal, entropy_);
             size_t numSpansToReturn = (i > kMinSpanListsWithSpans) ? length : length / 2;
             for (int j = 0; static_cast<size_t>(j) < numSpansToReturn && !DLL_IsEmpty(&slist->normal, entropy_) && free_committed_pages_ > targetPageCount; j++) {
                 Span* s = slist->normal.prev(entropy_);
                 DLL_Remove(s, entropy_);
                 ASSERT(!s->decommitted);
                 if (!s->decommitted) {
                     TCMalloc_SystemRelease(reinterpret_cast<void*>(s->start << kPageShift),
                                            static_cast<size_t>(s->length << kPageShift));
                     ASSERT(free_committed_pages_ >= s->length);
                     free_committed_pages_ -= s->length;
                     s->decommitted = true;
                 }
                 DLL_Prepend(&slist->returned, s, entropy_);
             }
         }
 
         if (lastFreeCommittedPages == free_committed_pages_)
             break;
         lastFreeCommittedPages = free_committed_pages_;
     }
 
     min_free_committed_pages_since_last_scavenge_ = free_committed_pages_;
 }
 
-ALWAYS_INLINE bool TCMalloc_PageHeap::shouldScavenge() const 
+ALWAYS_INLINE bool TCMalloc_PageHeap::shouldScavenge() const
 {
-    return free_committed_pages_ > kMinimumFreeCommittedPageCount; 
+    return free_committed_pages_ > kMinimumFreeCommittedPageCount;
 }
 
 #endif  // USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY
 
 inline Span* TCMalloc_PageHeap::New(Length n) {
   ASSERT(Check());
   ASSERT(n > 0);
 
   // Find first size >= n that has a non-empty list
   for (Length s = n; s < kMaxPages; s++) {
@@ skipping 11 matching lines @@
       continue;
     }
 
     Span* result = ll->next(entropy_);
     Carve(result, n, released);
 #if USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY
     // The newly allocated memory is from a span that's in the normal span list (already committed).  Update the
     // free committed pages count.
     ASSERT(free_committed_pages_ >= n);
     free_committed_pages_ -= n;
-    if (free_committed_pages_ < min_free_committed_pages_since_last_scavenge_) 
+    if (free_committed_pages_ < min_free_committed_pages_since_last_scavenge_)
       min_free_committed_pages_since_last_scavenge_ = free_committed_pages_;
 #endif  // USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY
     ASSERT(Check());
     free_pages_ -= n;
     return result;
   }
 
   Span* result = AllocLarge(n);
   if (result != NULL) {
       ASSERT_SPAN_COMMITTED(result);
@@ skipping 85 matching lines @@
 
   if (released) {
     // If the span chosen to carve from is decommited, commit the entire span at once to avoid committing spans 1 page at a time.
     ASSERT(span->decommitted);
     TCMalloc_SystemCommit(reinterpret_cast<void*>(span->start << kPageShift), static_cast<size_t>(span->length << kPageShift));
     span->decommitted = false;
 #if USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY
     free_committed_pages_ += span->length;
 #endif
   }
-  
+
   const int extra = static_cast<int>(span->length - n);
   ASSERT(extra >= 0);
   if (extra > 0) {
     Span* leftover = NewSpan(span->start + n, extra);
     leftover->free = 1;
     leftover->decommitted = false;
     Event(leftover, 'S', extra);
     RecordSpan(leftover);
 
     // Place leftover span on appropriate free list
@@ skipping 154 matching lines @@
   // Associate span object with all interior pages as well
   ASSERT(!span->free);
   ASSERT(GetDescriptor(span->start) == span);
   ASSERT(GetDescriptor(span->start+span->length-1) == span);
   Event(span, 'C', sc);
   span->sizeclass = static_cast<unsigned int>(sc);
   for (Length i = 1; i < span->length-1; i++) {
     pagemap_.set(span->start+i, span);
   }
 }
-    
+
 size_t TCMalloc_PageHeap::ReturnedBytes() const {
     size_t result = 0;
     for (unsigned s = 0; s < kMaxPages; s++) {
         const int r_length = DLL_Length(&free_[s].returned, entropy_);
         unsigned r_pages = s * r_length;
         result += r_pages << kPageShift;
     }
-    
+
     for (Span* s = large_.returned.next(entropy_); s != &large_.returned; s = s->next(entropy_))
         result += s->length << kPageShift;
     return result;
 }
 
 bool TCMalloc_PageHeap::GrowHeap(Length n) {
   ASSERT(kMaxPages >= kMinSystemAlloc);
   if (n > kMaxValidPages) return false;
   Length ask = (n>kMinSystemAlloc) ? n : static_cast<Length>(kMinSystemAlloc);
   size_t actual_size;
@@ skipping 103 matching lines @@
     DLL_Prepend(returned, s, entropy_);
     TCMalloc_SystemRelease(reinterpret_cast<void*>(s->start << kPageShift),
                            static_cast<size_t>(s->length << kPageShift));
 #if USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY
     freePageReduction += s->length;
 #endif
   }
 
 #if USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY
     free_committed_pages_ -= freePageReduction;
-    if (free_committed_pages_ < min_free_committed_pages_since_last_scavenge_) 
+    if (free_committed_pages_ < min_free_committed_pages_since_last_scavenge_)
         min_free_committed_pages_since_last_scavenge_ = free_committed_pages_;
 #endif
 }
 
 void TCMalloc_PageHeap::ReleaseFreePages() {
   for (Length s = 0; s < kMaxPages; s++) {
     ReleaseFreeList(&free_[s].normal, &free_[s].returned);
   }
   ReleaseFreeList(&large_.normal, &large_.returned);
   ASSERT(Check());
@@ skipping 867 matching lines @@
   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)
   tlsIndex = TlsAlloc();
 #endif
   tsd_inited = true;
-    
+
 #if !OS(WINDOWS)
   // 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 (h->tid_ == 0) {
       h->tid_ = GetCurrentThreadId();
@@ skipping 371 matching lines @@
 #if ENABLE(WTF_MALLOC_VALIDATION)
     fastMallocValidate(result);
 #endif
     return result;
 }
 
 template <bool crashOnFailure>
 ALWAYS_INLINE
 void* calloc(size_t n, size_t elem_size) {
   size_t totalBytes = n * elem_size;
-    
+
   // Protect against overflow
   if (n > 1 && elem_size && (totalBytes / elem_size) != n)
     return 0;
 
 #if ENABLE(WTF_MALLOC_VALIDATION)
     void* result = malloc<crashOnFailure>(totalBytes);
     if (!result)
         return 0;
 
     memset(result, 0, totalBytes);
@@ skipping 467 matching lines @@
 void FastMallocZone::init()
 {
     static FastMallocZone zone(pageheap, &thread_heaps, static_cast<TCMalloc_Central_FreeListPadded*>(central_cache), &span_allocator, &threadheap_allocator);
 }
 
 #endif // OS(DARWIN)
 
 } // namespace WTF
 
 #endif // FORCE_SYSTEM_MALLOC