Move Partition Allocator into Chromium base.

third_party/WebKit/Source/wtf/allocator/Partitions.h

 /*
  * 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 13 matching lines @@
  * 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
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef Partitions_h
 #define Partitions_h
 
+#include "base/allocator/partition_allocator/partition_alloc.h"
+#include "base/synchronization/spin_lock.h"
+#include "wtf/Assertions.h"
 #include "wtf/WTF.h"
 #include "wtf/WTFExport.h"
-#include "wtf/allocator/PartitionAlloc.h"
 #include <string.h>
 
 namespace WTF {
 
 class WTF_EXPORT Partitions {
  public:
   typedef void (*ReportPartitionAllocSizeFunction)(size_t);
 
   // Name of allocator used by tracing for marking sub-allocations while take
   // memory snapshots.
   static const char* const kAllocatedObjectPoolName;
 
   static void initialize(ReportPartitionAllocSizeFunction);
   static void shutdown();
-  ALWAYS_INLINE static PartitionRootGeneric* bufferPartition() {
+  ALWAYS_INLINE static base::PartitionRootGeneric* bufferPartition() {
     ASSERT(s_initialized);
     return m_bufferAllocator.root();
   }
 
-  ALWAYS_INLINE static PartitionRootGeneric* fastMallocPartition() {
+  ALWAYS_INLINE static base::PartitionRootGeneric* fastMallocPartition() {
     ASSERT(s_initialized);
     return m_fastMallocAllocator.root();
   }
 
-  ALWAYS_INLINE static PartitionRoot* nodePartition() {
+  ALWAYS_INLINE static base::PartitionRoot* nodePartition() {
     ASSERT_NOT_REACHED();
     return nullptr;
   }
-  ALWAYS_INLINE static PartitionRoot* layoutPartition() {
+  ALWAYS_INLINE static base::PartitionRoot* layoutPartition() {
     ASSERT(s_initialized);
     return m_layoutAllocator.root();
   }
 
   static size_t currentDOMMemoryUsage() {
     ASSERT(s_initialized);
     ASSERT_NOT_REACHED();
     return 0;
   }
 
   static size_t totalSizeOfCommittedPages() {
     size_t totalSize = 0;
     totalSize += m_fastMallocAllocator.root()->totalSizeOfCommittedPages;
     totalSize += m_bufferAllocator.root()->totalSizeOfCommittedPages;
     totalSize += m_layoutAllocator.root()->totalSizeOfCommittedPages;
     return totalSize;
   }
 
   static void decommitFreeableMemory();
 
   static void reportMemoryUsageHistogram();
 
-  static void dumpMemoryStats(bool isLightDump, PartitionStatsDumper*);
+  static void dumpMemoryStats(bool isLightDump, base::PartitionStatsDumper*);
 
   ALWAYS_INLINE static void* bufferMalloc(size_t n, const char* typeName) {
     return partitionAllocGeneric(bufferPartition(), n, typeName);
   }
   ALWAYS_INLINE static void* bufferRealloc(void* p,
                                            size_t n,
                                            const char* typeName) {
     return partitionReallocGeneric(bufferPartition(), p, n, typeName);
   }
   ALWAYS_INLINE static void bufferFree(void* p) {
@@ skipping 15 matching lines @@
     return partitionReallocGeneric(Partitions::fastMallocPartition(), p, n,
                                    typeName);
   }
   static void fastFree(void* p) {
     partitionFreeGeneric(Partitions::fastMallocPartition(), p);
   }
 
   static void handleOutOfMemory();
 
  private:
-  static SpinLock s_initializationLock;
+  static base::subtle::SpinLock s_initializationLock;
   static bool s_initialized;
 
   // We have the following four partitions.
   //   - LayoutObject partition: A partition to allocate LayoutObjects.
   //     We prepare a dedicated partition for LayoutObjects because they
   //     are likely to be a source of use-after-frees. Another reason
   //     is for performance: As LayoutObjects are guaranteed to only be used
   //     by the main thread, we can bypass acquiring a lock. Also we can
   //     improve memory locality by putting LayoutObjects together.
   //   - Buffer partition: A partition to allocate objects that have a strong
   //     risk where the length and/or the contents are exploited from user
   //     scripts. Vectors, HashTables, ArrayBufferContents and Strings are
   //     allocated in the buffer partition.
   //   - Fast malloc partition: A partition to allocate all other objects.
-  static PartitionAllocatorGeneric m_fastMallocAllocator;
-  static PartitionAllocatorGeneric m_bufferAllocator;
-  static SizeSpecificPartitionAllocator<1024> m_layoutAllocator;
+  static base::PartitionAllocatorGeneric m_fastMallocAllocator;
+  static base::PartitionAllocatorGeneric m_bufferAllocator;
+  static base::SizeSpecificPartitionAllocator<1024> m_layoutAllocator;
   static ReportPartitionAllocSizeFunction m_reportSizeFunction;
 };
 
+using base::kGenericMaxDirectMapped;

[haraken, 2016/12/08 08:43:55]

Hmm, these using statements look nasty. I'd prefer just removing the using
statements and start using base:: things in core/ and modules/, but this needs
to be discussed in platform-architecture-dev@. I'll do that.

In any case, this CL is fine. Let's address it in a follow up.

[palmer, 2016/12/08 22:29:58]

They are not good. :)
SGTM.

+using base::kPageAllocationGranularity;
+using base::kPageAllocationGranularityBaseMask;
+using base::kPageAllocationGranularityOffsetMask;
+using base::kSystemPageSize;
+
+using base::allocPages;
+using base::decommitSystemPages;
+using base::discardSystemPages;
+using base::partitionFree;
+using base::freePages;
+using base::getAllocPageErrorCode;
+using base::recommitSystemPages;
+using base::roundDownToSystemPage;
+using base::roundUpToSystemPage;
+using base::setSystemPagesAccessible;
+using base::setSystemPagesInaccessible;
+
+using base::PageAccessible;
+using base::PageInaccessible;
+using base::PartitionStatsDumper;
+using base::PartitionMemoryStats;
+using base::PartitionBucketMemoryStats;
+using base::PartitionAllocHooks;
+
 }  // namespace WTF
 
 #endif  // Partitions_h