Remove ENABLE(OILPAN) uses in wtf/

third_party/WebKit/Source/wtf/Partitions.cpp

 /*
  * Copyright (C) 2013 Google 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
@@ skipping 24 matching lines @@
 
 namespace WTF {
 
 const char* const Partitions::kAllocatedObjectPoolName = "partition_alloc/allocated_objects";
 
 SpinLock Partitions::s_initializationLock;
 bool Partitions::s_initialized = false;
 
 PartitionAllocatorGeneric Partitions::m_fastMallocAllocator;
 PartitionAllocatorGeneric Partitions::m_bufferAllocator;
-#if !ENABLE(OILPAN)
-SizeSpecificPartitionAllocator<3328> Partitions::m_nodeAllocator;
-#endif
 SizeSpecificPartitionAllocator<1024> Partitions::m_layoutAllocator;
 Partitions::ReportPartitionAllocSizeFunction Partitions::m_reportSizeFunction = nullptr;
 
 void Partitions::initialize(ReportPartitionAllocSizeFunction reportSizeFunction)
 {
     SpinLock::Guard guard(s_initializationLock);
 
     if (!s_initialized) {
         partitionAllocGlobalInit(&Partitions::handleOutOfMemory);
         m_fastMallocAllocator.init();
         m_bufferAllocator.init();
-#if !ENABLE(OILPAN)
-        m_nodeAllocator.init();
-#endif
         m_layoutAllocator.init();
         m_reportSizeFunction = reportSizeFunction;
         s_initialized = true;
     }
 }
 
 void Partitions::shutdown()
 {
     SpinLock::Guard guard(s_initializationLock);
 
     // We could ASSERT here for a memory leak within the partition, but it leads
     // to very hard to diagnose ASSERTs, so it's best to leave leak checking for
     // the valgrind and heapcheck bots, which run without partitions.
     if (s_initialized) {
         (void) m_layoutAllocator.shutdown();
-#if !ENABLE(OILPAN)
-        (void) m_nodeAllocator.shutdown();
-#endif
         (void) m_bufferAllocator.shutdown();
         (void) m_fastMallocAllocator.shutdown();
     }
 }
 
 void Partitions::decommitFreeableMemory()
 {
     RELEASE_ASSERT(isMainThread());
     if (!s_initialized)
         return;
 
     partitionPurgeMemoryGeneric(bufferPartition(), PartitionPurgeDecommitEmptyPages);
     partitionPurgeMemoryGeneric(fastMallocPartition(), PartitionPurgeDecommitEmptyPages);
-#if !ENABLE(OILPAN)
-    partitionPurgeMemory(nodePartition(), PartitionPurgeDecommitEmptyPages);
-#endif
     partitionPurgeMemory(layoutPartition(), PartitionPurgeDecommitEmptyPages);
 }
 
 void Partitions::reportMemoryUsageHistogram()
 {
     static size_t observedMaxSizeInMB = 0;
 
     if (!m_reportSizeFunction)
         return;
     // We only report the memory in the main thread.
     if (!isMainThread())
         return;
     // +1 is for rounding up the sizeInMB.
     size_t sizeInMB = Partitions::totalSizeOfCommittedPages() / 1024 / 1024 + 1;
     if (sizeInMB > observedMaxSizeInMB) {
         m_reportSizeFunction(sizeInMB);
         observedMaxSizeInMB = sizeInMB;
     }
 }
 
 void Partitions::dumpMemoryStats(bool isLightDump, PartitionStatsDumper* partitionStatsDumper)
 {
     // Object model and rendering partitions are not thread safe and can be
     // accessed only on the main thread.
     ASSERT(isMainThread());
 
     decommitFreeableMemory();
     partitionDumpStatsGeneric(fastMallocPartition(), "fast_malloc", isLightDump, partitionStatsDumper);
     partitionDumpStatsGeneric(bufferPartition(), "buffer", isLightDump, partitionStatsDumper);
-#if !ENABLE(OILPAN)
-    partitionDumpStats(nodePartition(), "node", isLightDump, partitionStatsDumper);
-#endif
     partitionDumpStats(layoutPartition(), "layout", isLightDump, partitionStatsDumper);
 }
 
 static NEVER_INLINE void partitionsOutOfMemoryUsing2G()
 {
     size_t signature = 2UL * 1024 * 1024 * 1024;
     base::debug::Alias(&signature);
     IMMEDIATE_CRASH();
 }
 
@@ skipping 72 matching lines @@
     if (totalUsage >= 64 * 1024 * 1024)
         partitionsOutOfMemoryUsing64M();
     if (totalUsage >= 32 * 1024 * 1024)
         partitionsOutOfMemoryUsing32M();
     if (totalUsage >= 16 * 1024 * 1024)
         partitionsOutOfMemoryUsing16M();
     partitionsOutOfMemoryUsingLessThan16M();
 }
 
 } // namespace WTF