Removing a bunch of unused platform code.

Source/WTF/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 60 matching lines @@
 //
 // 9/28/2003 (new page-level allocator replaces ptmalloc2):
 // * malloc/free of small objects goes from ~300 ns to ~50 ns.
 // * allocation of a reasonably complicated struct
 //   goes from about 1100 ns to about 300 ns.
 
 #include "config.h"
 #include "FastMalloc.h"
 
 #include "Assertions.h"
-#include "CurrentTime.h"
 
 #include <limits>
 #if OS(WINDOWS)
 #include <windows.h>
 #else
 #include <pthread.h>
 #endif
 #include <string.h>
 #include <wtf/StdLibExtras.h>
 #include <wtf/UnusedParam.h>
 
 #ifndef NO_TCMALLOC_SAMPLES
 #ifdef WTF_CHANGES
 #define NO_TCMALLOC_SAMPLES
 #endif
 #endif
 
 #if !(defined(USE_SYSTEM_MALLOC) && 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) && !PLATFORM(QT)
+#if COMPILER(GCC)
 #define ENABLE_TCMALLOC_HARDENING 1
 #endif
 
 // Use a background thread to periodically scavenge memory to release back to the system
-#if PLATFORM(IOS)
-#define USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY 0
-#else
 #define USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY 1
-#endif
 
 #ifndef NDEBUG
 namespace WTF {
 
 #if OS(WINDOWS)
 
 // TLS_OUT_OF_INDEXES is not defined on WinCE.
 #ifndef TLS_OUT_OF_INDEXES
 #define TLS_OUT_OF_INDEXES 0xffffffff
 #endif
@@ skipping 527 matching lines @@
 
 // Maximum length we allow a per-thread free-list to have before we
 // move objects from it into the corresponding central free-list.  We
 // want this big to avoid locking the central free-list too often.  It
 // should not hurt to make this list somewhat big because the
 // scavenging code will shrink it down when its contents are not in use.
 static const int kMaxFreeListLength = 256;
 
 // Lower and upper bounds on the per-thread cache sizes
 static const size_t kMinThreadCacheSize = kMaxSize * 2;
-#if PLATFORM(IOS)
-static const size_t kMaxThreadCacheSize = 512 * 1024;
-#else
 static const size_t kMaxThreadCacheSize = 2 << 20;
-#endif
 
 // Default bound on the total amount of thread caches
 static const size_t kDefaultOverallThreadCacheSize = 16 << 20;
 
 // For all span-lengths < kMaxPages we keep an exact-size list.
 // REQUIRED: kMaxPages >= kMinSystemAlloc;
 static const size_t kMaxPages = kMinSystemAlloc;
 
 /* The smallest prime > 2^n */
 static int primes_list[] = {
@@ skipping 1607 matching lines @@
 
   ASSERT(Check());
 }
 
 #if !USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY
 void TCMalloc_PageHeap::IncrementalScavenge(Length n) {
   // Fast path; not yet time to release memory
   scavenge_counter_ -= n;
   if (scavenge_counter_ >= 0) return;  // Not yet time to scavenge
 
-#if PLATFORM(IOS)
-  static const size_t kDefaultReleaseDelay = 64;
-#else
   // If there is nothing to release, wait for so many pages before
   // scavenging again.  With 4K pages, this comes to 16MB of memory.
   static const size_t kDefaultReleaseDelay = 1 << 8;
-#endif
 
   // Find index of free list to scavenge
   size_t index = scavenge_index_ + 1;
   uintptr_t entropy = entropy_;
   for (size_t i = 0; i < kMaxPages+1; i++) {
     if (index > kMaxPages) index = 0;
     SpanList* slist = (index == kMaxPages) ? &large_ : &free_[index];
     if (!DLL_IsEmpty(&slist->normal, entropy)) {
       // Release the last span on the normal portion of this list
       Span* s = slist->normal.prev(entropy);
       DLL_Remove(s, entropy_);
       TCMalloc_SystemRelease(reinterpret_cast<void*>(s->start << kPageShift),
                              static_cast<size_t>(s->length << kPageShift));
       s->decommitted = true;
       DLL_Prepend(&slist->returned, s, entropy);
 
-#if PLATFORM(IOS)
-      scavenge_counter_ = std::max<size_t>(16UL, std::min<size_t>(kDefaultReleaseDelay, kDefaultReleaseDelay - (free_pages_ / kDefaultReleaseDelay)));
-#else
       scavenge_counter_ = std::max<size_t>(64UL, std::min<size_t>(kDefaultReleaseDelay, kDefaultReleaseDelay - (free_pages_ / kDefaultReleaseDelay)));
-#endif
 
       if (index == kMaxPages && !DLL_IsEmpty(&slist->normal, entropy))
         scavenge_index_ = index - 1;
       else
         scavenge_index_ = index;
       return;
     }
     index++;
   }
 
@@ skipping 2669 matching lines @@
 {
     static FastMallocZone zone(pageheap, &thread_heaps, static_cast<TCMalloc_Central_FreeListPadded*>(central_cache), &span_allocator, &threadheap_allocator);
 }
 
 #endif // OS(DARWIN)
 
 } // namespace WTF
 #endif // WTF_CHANGES
 
 #endif // FORCE_SYSTEM_MALLOC