Move Partition Allocator into Chromium base.

base/allocator/partition_allocator/partition_alloc.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
- * 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
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
 
-#ifndef WTF_PartitionAlloc_h
-#define WTF_PartitionAlloc_h
+#ifndef BASE_ALLOCATOR_PARTITION_ALLOCATOR_PARTITION_ALLOC_H
+#define BASE_ALLOCATOR_PARTITION_ALLOCATOR_PARTITION_ALLOC_H
 
 // DESCRIPTION
 // partitionAlloc() / partitionAllocGeneric() and partitionFree() /
 // partitionFreeGeneric() are approximately analagous to malloc() and free().
 //
 // The main difference is that a PartitionRoot / PartitionRootGeneric object
 // must be supplied to these functions, representing a specific "heap partition"
 // that will be used to satisfy the allocation. Different partitions are
 // guaranteed to exist in separate address spaces, including being separate from
 // the main system heap. If the contained objects are all freed, physical memory
@@ skipping 35 matching lines @@
 //   pages, enabling various simple tricks to try and minimize fragmentation.
 // - Fine-grained bucket sizes leading to less waste and better packing.
 //
 // The following security properties could be investigated in the future:
 // - Per-object bucketing (instead of per-size) is mostly available at the API,
 // but not used yet.
 // - No randomness of freelist entries or bucket position.
 // - Better checking for wild pointers in free().
 // - Better freelist masking function to guarantee fault on 32-bit.
 
-#include "wtf/Assertions.h"
-#include "wtf/BitwiseOperations.h"
-#include "wtf/ByteSwap.h"
-#include "wtf/CPU.h"
-#include "wtf/SpinLock.h"
-#include "wtf/TypeTraits.h"
-#include "wtf/allocator/PageAllocator.h"
+#include <limits.h>
 
-#include <limits.h>
+#include "base/allocator/partition_allocator/page_allocator.h"
+#include "base/bits.h"
+#include "base/compiler_specific.h"
+#include "base/synchronization/spin_lock.h"

[Primiano Tucci (use gerrit), 2016/11/22 14:28:33]

IWYU: +base/logging.h for DCHECK_IS_ON
+build/build_config for defined(OS_...

[palmer, 2016/11/24 01:05:56]

Done.

 
 #if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
 #include <stdlib.h>
 #endif
 
-#if ENABLE(ASSERT)
-#include <string.h>
-#endif
-
-namespace WTF {
+namespace base {
 
 // Allocation granularity of sizeof(void*) bytes.
 static const size_t kAllocationGranularity = sizeof(void*);

[Primiano Tucci (use gerrit), 2016/11/22 14:28:33]

it feels like a lot of this stuff should be in base::internal 

[palmer, 2016/11/24 01:05:56]

I am thinking of putting the public interfaces in base::partition_allocator and
the internals in base::partition_allocator::internal. What do you think?

 static const size_t kAllocationGranularityMask = kAllocationGranularity - 1;
 static const size_t kBucketShift = (kAllocationGranularity == 8) ? 3 : 2;
 
 // Underlying partition storage pages are a power-of-two size. It is typical
 // for a partition page to be based on multiple system pages. Most references to
 // "page" refer to partition pages.
 // We also have the concept of "super pages" -- these are the underlying system
 // allocations we make. Super pages contain multiple partition pages inside them
 // and include space for a small amount of metadata per partition page.
 // Inside super pages, we store "slot spans". A slot span is a continguous range
@@ skipping 114 matching lines @@
 // Constants for the memory reclaim logic.
 static const size_t kMaxFreeableSpans = 16;
 
 // If the total size in bytes of allocated but not committed pages exceeds this
 // value (probably it is a "out of virtual address space" crash),
 // a special crash stack trace is generated at |partitionOutOfMemory|.
 // This is to distinguish "out of virtual address space" from
 // "out of physical memory" in crash reports.
 static const size_t kReasonableSizeOfUnusedPages = 1024 * 1024 * 1024;  // 1GiB
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 // These two byte values match tcmalloc.
 static const unsigned char kUninitializedByte = 0xAB;
 static const unsigned char kFreedByte = 0xCD;
 static const size_t kCookieSize =
     16;  // Handles alignment up to XMM instructions on Intel.
 static const unsigned char kCookieValue[kCookieSize] = {
     0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xD0, 0x0D,
     0x13, 0x37, 0xF0, 0x05, 0xBA, 0x11, 0xAB, 0x1E};
 #endif
 
@@ skipping 59 matching lines @@
   PartitionSuperPageExtentEntry* next;
 };
 
 struct PartitionDirectMapExtent {
   PartitionDirectMapExtent* nextExtent;
   PartitionDirectMapExtent* prevExtent;
   PartitionBucket* bucket;
   size_t mapSize;  // Mapped size, not including guard pages and meta-data.
 };
 
-struct WTF_EXPORT PartitionRootBase {
+struct BASE_EXPORT PartitionRootBase {
   size_t totalSizeOfCommittedPages;
   size_t totalSizeOfSuperPages;
   size_t totalSizeOfDirectMappedPages;
   // Invariant: totalSizeOfCommittedPages <=
   //                totalSizeOfSuperPages + totalSizeOfDirectMappedPages.
   unsigned numBuckets;
   unsigned maxAllocation;
   bool initialized;
   char* nextSuperPage;
   char* nextPartitionPage;
   char* nextPartitionPageEnd;
   PartitionSuperPageExtentEntry* currentExtent;
   PartitionSuperPageExtentEntry* firstExtent;
   PartitionDirectMapExtent* directMapList;
   PartitionPage* globalEmptyPageRing[kMaxFreeableSpans];
   int16_t globalEmptyPageRingIndex;
   uintptr_t invertedSelf;
 
-  static SpinLock gInitializedLock;
+  static subtle::SpinLock gInitializedLock;
   static bool gInitialized;
   // gSeedPage is used as a sentinel to indicate that there is no page
   // in the active page list. We can use nullptr, but in that case we need
   // to add a null-check branch to the hot allocation path. We want to avoid
   // that.
   static PartitionPage gSeedPage;
   static PartitionBucket gPagedBucket;
   // gOomHandlingFunction is invoked when ParitionAlloc hits OutOfMemory.
   static void (*gOomHandlingFunction)();
 };
 
 // Never instantiate a PartitionRoot directly, instead use PartitionAlloc.
 struct PartitionRoot : public PartitionRootBase {
   // The PartitionAlloc templated class ensures the following is correct.
   ALWAYS_INLINE PartitionBucket* buckets() {
     return reinterpret_cast<PartitionBucket*>(this + 1);
   }
   ALWAYS_INLINE const PartitionBucket* buckets() const {
     return reinterpret_cast<const PartitionBucket*>(this + 1);
   }
 };
 
 // Never instantiate a PartitionRootGeneric directly, instead use
 // PartitionAllocatorGeneric.
 struct PartitionRootGeneric : public PartitionRootBase {
-  SpinLock lock;
+  subtle::SpinLock lock;
   // Some pre-computed constants.
   size_t orderIndexShifts[kBitsPerSizet + 1];
   size_t orderSubIndexMasks[kBitsPerSizet + 1];
   // The bucket lookup table lets us map a size_t to a bucket quickly.
   // The trailing +1 caters for the overflow case for very large allocation
   // sizes.  It is one flat array instead of a 2D array because in the 2D
   // world, we'd need to index array[blah][max+1] which risks undefined
   // behavior.
   PartitionBucket*
       bucketLookups[((kBitsPerSizet + 1) * kGenericNumBucketsPerOrder) + 1];
@@ skipping 33 matching lines @@
   uint32_t numActivePages;       // Number of pages that have at least one
                                  // provisioned slot.
   uint32_t numEmptyPages;        // Number of pages that are empty
                                  // but not decommitted.
   uint32_t numDecommittedPages;  // Number of pages that are empty
                                  // and decommitted.
 };
 
 // Interface that is passed to partitionDumpStats and
 // partitionDumpStatsGeneric for using the memory statistics.
-class WTF_EXPORT PartitionStatsDumper {
+class BASE_EXPORT PartitionStatsDumper {
  public:
   // Called to dump total memory used by partition, once per partition.
   virtual void partitionDumpTotals(const char* partitionName,
                                    const PartitionMemoryStats*) = 0;
 
   // Called to dump stats about buckets, for each bucket.
   virtual void partitionsDumpBucketStats(const char* partitionName,
                                          const PartitionBucketMemoryStats*) = 0;
 };
 
-WTF_EXPORT void partitionAllocGlobalInit(void (*oomHandlingFunction)());
-WTF_EXPORT void partitionAllocInit(PartitionRoot*,
-                                   size_t numBuckets,
-                                   size_t maxAllocation);
-WTF_EXPORT bool partitionAllocShutdown(PartitionRoot*);
-WTF_EXPORT void partitionAllocGenericInit(PartitionRootGeneric*);
-WTF_EXPORT bool partitionAllocGenericShutdown(PartitionRootGeneric*);
+BASE_EXPORT void partitionAllocGlobalInit(void (*oomHandlingFunction)());
+BASE_EXPORT void partitionAllocInit(PartitionRoot*,
+                                    size_t numBuckets,
+                                    size_t maxAllocation);
+BASE_EXPORT bool partitionAllocShutdown(PartitionRoot*);
+BASE_EXPORT void partitionAllocGenericInit(PartitionRootGeneric*);
+BASE_EXPORT bool partitionAllocGenericShutdown(PartitionRootGeneric*);
 
 enum PartitionPurgeFlags {
   // Decommitting the ring list of empty pages is reasonably fast.
   PartitionPurgeDecommitEmptyPages = 1 << 0,
   // Discarding unused system pages is slower, because it involves walking all
   // freelists in all active partition pages of all buckets >= system page
   // size. It often frees a similar amount of memory to decommitting the empty
   // pages, though.
   PartitionPurgeDiscardUnusedSystemPages = 1 << 1,
 };
 
-WTF_EXPORT void partitionPurgeMemory(PartitionRoot*, int);
-WTF_EXPORT void partitionPurgeMemoryGeneric(PartitionRootGeneric*, int);
+BASE_EXPORT void partitionPurgeMemory(PartitionRoot*, int);
+BASE_EXPORT void partitionPurgeMemoryGeneric(PartitionRootGeneric*, int);
 
-WTF_EXPORT NEVER_INLINE void* partitionAllocSlowPath(PartitionRootBase*,
-                                                     int,
-                                                     size_t,
-                                                     PartitionBucket*);
-WTF_EXPORT NEVER_INLINE void partitionFreeSlowPath(PartitionPage*);
-WTF_EXPORT NEVER_INLINE void* partitionReallocGeneric(PartitionRootGeneric*,
-                                                      void*,
-                                                      size_t,
-                                                      const char* typeName);
+BASE_EXPORT NOINLINE void* partitionAllocSlowPath(PartitionRootBase*,
+                                                  int,
+                                                  size_t,
+                                                  PartitionBucket*);
+BASE_EXPORT NOINLINE void partitionFreeSlowPath(PartitionPage*);
+BASE_EXPORT NOINLINE void* partitionReallocGeneric(PartitionRootGeneric*,
+                                                   void*,
+                                                   size_t,
+                                                   const char* typeName);
 
-WTF_EXPORT void partitionDumpStats(PartitionRoot*,
-                                   const char* partitionName,
-                                   bool isLightDump,
-                                   PartitionStatsDumper*);
-WTF_EXPORT void partitionDumpStatsGeneric(PartitionRootGeneric*,
-                                          const char* partitionName,
-                                          bool isLightDump,
-                                          PartitionStatsDumper*);
+BASE_EXPORT void partitionDumpStats(PartitionRoot*,
+                                    const char* partitionName,
+                                    bool isLightDump,
+                                    PartitionStatsDumper*);
+BASE_EXPORT void partitionDumpStatsGeneric(PartitionRootGeneric*,
+                                           const char* partitionName,
+                                           bool isLightDump,
+                                           PartitionStatsDumper*);
 
-class WTF_EXPORT PartitionAllocHooks {
+class BASE_EXPORT PartitionAllocHooks {
  public:
   typedef void AllocationHook(void* address, size_t, const char* typeName);
   typedef void FreeHook(void* address);
 
   static void setAllocationHook(AllocationHook* hook) {
     m_allocationHook = hook;
   }
   static void setFreeHook(FreeHook* hook) { m_freeHook = hook; }
 
   static void allocationHookIfEnabled(void* address,
@@ skipping 26 matching lines @@
  private:
   // Pointers to hook functions that PartitionAlloc will call on allocation and
   // free if the pointers are non-null.
   static AllocationHook* m_allocationHook;
   static FreeHook* m_freeHook;
 };
 
 // In official builds, do not include type info string literals to avoid
 // bloating the binary.
 #if defined(OFFICIAL_BUILD)
-#define WTF_HEAP_PROFILER_TYPE_NAME(T) nullptr
+#define PARTITION_HEAP_PROFILER_TYPE_NAME(T) nullptr
 #else
-#define WTF_HEAP_PROFILER_TYPE_NAME(T) ::WTF::getStringWithTypeName<T>()
+#define PARTITION_HEAP_PROFILER_TYPE_NAME(T) GetStringWithTypeName<T>()
 #endif
 
 ALWAYS_INLINE PartitionFreelistEntry* partitionFreelistMask(
     PartitionFreelistEntry* ptr) {
 // We use bswap on little endian as a fast mask for two reasons:
 // 1) If an object is freed and its vtable used where the attacker doesn't
 // get the chance to run allocations between the free and use, the vtable
 // dereference is likely to fault.
 // 2) If the attacker has a linear buffer overflow and elects to try and
 // corrupt a freelist pointer, partial pointer overwrite attacks are
 // thwarted.
 // For big endian, similar guarantees are arrived at with a negation.
 #if CPU(BIG_ENDIAN)
   uintptr_t masked = ~reinterpret_cast<uintptr_t>(ptr);
 #else
   uintptr_t masked = bswapuintptrt(reinterpret_cast<uintptr_t>(ptr));
 #endif
   return reinterpret_cast<PartitionFreelistEntry*>(masked);
 }
 
 ALWAYS_INLINE size_t partitionCookieSizeAdjustAdd(size_t size) {
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   // Add space for cookies, checking for integer overflow.
-  ASSERT(size + (2 * kCookieSize) > size);
+  DCHECK(size + (2 * kCookieSize) > size);
   size += 2 * kCookieSize;
 #endif
   return size;
 }
 
 ALWAYS_INLINE size_t partitionCookieSizeAdjustSubtract(size_t size) {
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   // Remove space for cookies.
-  ASSERT(size >= 2 * kCookieSize);
+  DCHECK(size >= 2 * kCookieSize);
   size -= 2 * kCookieSize;
 #endif
   return size;
 }
 
 ALWAYS_INLINE void* partitionCookieFreePointerAdjust(void* ptr) {
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   // The value given to the application is actually just after the cookie.
   ptr = static_cast<char*>(ptr) - kCookieSize;
 #endif
   return ptr;
 }
 
 ALWAYS_INLINE void partitionCookieWriteValue(void* ptr) {
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   unsigned char* cookiePtr = reinterpret_cast<unsigned char*>(ptr);
   for (size_t i = 0; i < kCookieSize; ++i, ++cookiePtr)
     *cookiePtr = kCookieValue[i];
 #endif
 }
 
 ALWAYS_INLINE void partitionCookieCheckValue(void* ptr) {
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   unsigned char* cookiePtr = reinterpret_cast<unsigned char*>(ptr);
   for (size_t i = 0; i < kCookieSize; ++i, ++cookiePtr)
-    ASSERT(*cookiePtr == kCookieValue[i]);
+    DCHECK(*cookiePtr == kCookieValue[i]);
 #endif
 }
 
 ALWAYS_INLINE char* partitionSuperPageToMetadataArea(char* ptr) {
   uintptr_t pointerAsUint = reinterpret_cast<uintptr_t>(ptr);
-  ASSERT(!(pointerAsUint & kSuperPageOffsetMask));
+  DCHECK(!(pointerAsUint & kSuperPageOffsetMask));
   // The metadata area is exactly one system page (the guard page) into the
   // super page.
   return reinterpret_cast<char*>(pointerAsUint + kSystemPageSize);
 }
 
 ALWAYS_INLINE PartitionPage* partitionPointerToPageNoAlignmentCheck(void* ptr) {
   uintptr_t pointerAsUint = reinterpret_cast<uintptr_t>(ptr);
   char* superPagePtr =
       reinterpret_cast<char*>(pointerAsUint & kSuperPageBaseMask);
   uintptr_t partitionPageIndex =
       (pointerAsUint & kSuperPageOffsetMask) >> kPartitionPageShift;
   // Index 0 is invalid because it is the metadata and guard area and
   // the last index is invalid because it is a guard page.
-  ASSERT(partitionPageIndex);
-  ASSERT(partitionPageIndex < kNumPartitionPagesPerSuperPage - 1);
+  DCHECK(partitionPageIndex);
+  DCHECK(partitionPageIndex < kNumPartitionPagesPerSuperPage - 1);
   PartitionPage* page = reinterpret_cast<PartitionPage*>(
       partitionSuperPageToMetadataArea(superPagePtr) +
       (partitionPageIndex << kPageMetadataShift));
   // Partition pages in the same slot span can share the same page object.
   // Adjust for that.
   size_t delta = page->pageOffset << kPageMetadataShift;
   page =
       reinterpret_cast<PartitionPage*>(reinterpret_cast<char*>(page) - delta);
   return page;
 }
 
 ALWAYS_INLINE void* partitionPageToPointer(const PartitionPage* page) {
   uintptr_t pointerAsUint = reinterpret_cast<uintptr_t>(page);
   uintptr_t superPageOffset = (pointerAsUint & kSuperPageOffsetMask);
-  ASSERT(superPageOffset > kSystemPageSize);
-  ASSERT(superPageOffset < kSystemPageSize + (kNumPartitionPagesPerSuperPage *
+  DCHECK(superPageOffset > kSystemPageSize);
+  DCHECK(superPageOffset < kSystemPageSize + (kNumPartitionPagesPerSuperPage *
                                               kPageMetadataSize));
   uintptr_t partitionPageIndex =
       (superPageOffset - kSystemPageSize) >> kPageMetadataShift;
   // Index 0 is invalid because it is the metadata area and the last index is
   // invalid because it is a guard page.
-  ASSERT(partitionPageIndex);
-  ASSERT(partitionPageIndex < kNumPartitionPagesPerSuperPage - 1);
+  DCHECK(partitionPageIndex);
+  DCHECK(partitionPageIndex < kNumPartitionPagesPerSuperPage - 1);
   uintptr_t superPageBase = (pointerAsUint & kSuperPageBaseMask);
   void* ret = reinterpret_cast<void*>(
       superPageBase + (partitionPageIndex << kPartitionPageShift));
   return ret;
 }
 
 ALWAYS_INLINE PartitionPage* partitionPointerToPage(void* ptr) {
   PartitionPage* page = partitionPointerToPageNoAlignmentCheck(ptr);
   // Checks that the pointer is a multiple of bucket size.
-  ASSERT(!((reinterpret_cast<uintptr_t>(ptr) -
+  DCHECK(!((reinterpret_cast<uintptr_t>(ptr) -
             reinterpret_cast<uintptr_t>(partitionPageToPointer(page))) %
            page->bucket->slotSize));
   return page;
 }
 
 ALWAYS_INLINE bool partitionBucketIsDirectMapped(
     const PartitionBucket* bucket) {
   return !bucket->numSystemPagesPerSlotSpan;
 }
 
 ALWAYS_INLINE size_t partitionBucketBytes(const PartitionBucket* bucket) {
   return bucket->numSystemPagesPerSlotSpan * kSystemPageSize;
 }
 
 ALWAYS_INLINE uint16_t partitionBucketSlots(const PartitionBucket* bucket) {
   return static_cast<uint16_t>(partitionBucketBytes(bucket) / bucket->slotSize);
 }
 
 ALWAYS_INLINE size_t* partitionPageGetRawSizePtr(PartitionPage* page) {
   // For single-slot buckets which span more than one partition page, we
   // have some spare metadata space to store the raw allocation size. We
   // can use this to report better statistics.
   PartitionBucket* bucket = page->bucket;
   if (bucket->slotSize <= kMaxSystemPagesPerSlotSpan * kSystemPageSize)
     return nullptr;
 
-  ASSERT((bucket->slotSize % kSystemPageSize) == 0);
-  ASSERT(partitionBucketIsDirectMapped(bucket) ||
+  DCHECK((bucket->slotSize % kSystemPageSize) == 0);
+  DCHECK(partitionBucketIsDirectMapped(bucket) ||
          partitionBucketSlots(bucket) == 1);
   page++;
   return reinterpret_cast<size_t*>(&page->freelistHead);
 }
 
 ALWAYS_INLINE size_t partitionPageGetRawSize(PartitionPage* page) {
   size_t* rawSizePtr = partitionPageGetRawSizePtr(page);
   if (UNLIKELY(rawSizePtr != nullptr))
     return *rawSizePtr;
   return 0;
@@ skipping 11 matching lines @@
   PartitionRootBase* root = partitionPageToRoot(page);
   return root->invertedSelf == ~reinterpret_cast<uintptr_t>(root);
 }
 
 ALWAYS_INLINE void* partitionBucketAlloc(PartitionRootBase* root,
                                          int flags,
                                          size_t size,
                                          PartitionBucket* bucket) {
   PartitionPage* page = bucket->activePagesHead;
   // Check that this page is neither full nor freed.
-  ASSERT(page->numAllocatedSlots >= 0);
+  DCHECK(page->numAllocatedSlots >= 0);
   void* ret = page->freelistHead;
   if (LIKELY(ret != 0)) {
     // If these asserts fire, you probably corrupted memory.
-    ASSERT(partitionPointerIsValid(ret));
+    DCHECK(partitionPointerIsValid(ret));
     // All large allocations must go through the slow path to correctly
     // update the size metadata.
-    ASSERT(partitionPageGetRawSize(page) == 0);
+    DCHECK(partitionPageGetRawSize(page) == 0);
     PartitionFreelistEntry* newHead =
         partitionFreelistMask(static_cast<PartitionFreelistEntry*>(ret)->next);
     page->freelistHead = newHead;
     page->numAllocatedSlots++;
   } else {
     ret = partitionAllocSlowPath(root, flags, size, bucket);
-    ASSERT(!ret || partitionPointerIsValid(ret));
+    DCHECK(!ret || partitionPointerIsValid(ret));
   }
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   if (!ret)
     return 0;
   // Fill the uninitialized pattern, and write the cookies.
   page = partitionPointerToPage(ret);
   size_t slotSize = page->bucket->slotSize;
   size_t rawSize = partitionPageGetRawSize(page);
   if (rawSize) {
-    ASSERT(rawSize == size);
+    DCHECK(rawSize == size);
     slotSize = rawSize;
   }
   size_t noCookieSize = partitionCookieSizeAdjustSubtract(slotSize);
   char* charRet = static_cast<char*>(ret);
   // The value given to the application is actually just after the cookie.
   ret = charRet + kCookieSize;
   memset(ret, kUninitializedByte, noCookieSize);
   partitionCookieWriteValue(charRet);
   partitionCookieWriteValue(charRet + kCookieSize + noCookieSize);
 #endif
   return ret;
 }
 
 ALWAYS_INLINE void* partitionAlloc(PartitionRoot* root,
                                    size_t size,
                                    const char* typeName) {
 #if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
   void* result = malloc(size);
-  RELEASE_ASSERT(result);
+  CHECK(result);
   return result;
 #else
   size_t requestedSize = size;
   size = partitionCookieSizeAdjustAdd(size);
-  ASSERT(root->initialized);
+  DCHECK(root->initialized);
   size_t index = size >> kBucketShift;
-  ASSERT(index < root->numBuckets);
-  ASSERT(size == index << kBucketShift);
+  DCHECK(index < root->numBuckets);
+  DCHECK(size == index << kBucketShift);
   PartitionBucket* bucket = &root->buckets()[index];
   void* result = partitionBucketAlloc(root, 0, size, bucket);
   PartitionAllocHooks::allocationHookIfEnabled(result, requestedSize, typeName);
   return result;
 #endif  // defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
 }
 
 ALWAYS_INLINE void partitionFreeWithPage(void* ptr, PartitionPage* page) {
 // If these asserts fire, you probably corrupted memory.
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   size_t slotSize = page->bucket->slotSize;
   size_t rawSize = partitionPageGetRawSize(page);
   if (rawSize)
     slotSize = rawSize;
   partitionCookieCheckValue(ptr);
   partitionCookieCheckValue(reinterpret_cast<char*>(ptr) + slotSize -
                             kCookieSize);
   memset(ptr, kFreedByte, slotSize);
 #endif
-  ASSERT(page->numAllocatedSlots);
+  DCHECK(page->numAllocatedSlots);
   PartitionFreelistEntry* freelistHead = page->freelistHead;
-  ASSERT(!freelistHead || partitionPointerIsValid(freelistHead));
+  DCHECK(!freelistHead || partitionPointerIsValid(freelistHead));
   SECURITY_CHECK(ptr != freelistHead);  // Catches an immediate double free.
   // Look for double free one level deeper in debug.
   SECURITY_DCHECK(!freelistHead ||
                   ptr != partitionFreelistMask(freelistHead->next));
   PartitionFreelistEntry* entry = static_cast<PartitionFreelistEntry*>(ptr);
   entry->next = partitionFreelistMask(freelistHead);
   page->freelistHead = entry;
   --page->numAllocatedSlots;
   if (UNLIKELY(page->numAllocatedSlots <= 0)) {
     partitionFreeSlowPath(page);
   } else {
     // All single-slot allocations must go through the slow path to
     // correctly update the size metadata.
-    ASSERT(partitionPageGetRawSize(page) == 0);
+    DCHECK(partitionPageGetRawSize(page) == 0);
   }
 }
 
 ALWAYS_INLINE void partitionFree(void* ptr) {
 #if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
   free(ptr);
 #else
   PartitionAllocHooks::freeHookIfEnabled(ptr);
   ptr = partitionCookieFreePointerAdjust(ptr);
-  ASSERT(partitionPointerIsValid(ptr));
+  DCHECK(partitionPointerIsValid(ptr));
   PartitionPage* page = partitionPointerToPage(ptr);
   partitionFreeWithPage(ptr, page);
 #endif
 }
 
 ALWAYS_INLINE PartitionBucket* partitionGenericSizeToBucket(
     PartitionRootGeneric* root,
     size_t size) {
-  size_t order = kBitsPerSizet - CountLeadingZeroBitsSizeT(size);
+  size_t order = kBitsPerSizet - bits::CountLeadingZeroBitsSizeT(size);
   // The order index is simply the next few bits after the most significant bit.
   size_t orderIndex = (size >> root->orderIndexShifts[order]) &
                       (kGenericNumBucketsPerOrder - 1);
   // And if the remaining bits are non-zero we must bump the bucket up.
   size_t subOrderIndex = size & root->orderSubIndexMasks[order];
   PartitionBucket* bucket =
       root->bucketLookups[(order << kGenericNumBucketsPerOrderBits) +
                           orderIndex + !!subOrderIndex];
-  ASSERT(!bucket->slotSize || bucket->slotSize >= size);
-  ASSERT(!(bucket->slotSize % kGenericSmallestBucket));
+  DCHECK(!bucket->slotSize || bucket->slotSize >= size);
+  DCHECK(!(bucket->slotSize % kGenericSmallestBucket));
   return bucket;
 }
 
 ALWAYS_INLINE void* partitionAllocGenericFlags(PartitionRootGeneric* root,
                                                int flags,
                                                size_t size,
                                                const char* typeName) {
 #if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
   void* result = malloc(size);
-  RELEASE_ASSERT(result || flags & PartitionAllocReturnNull);
+  CHECK(result || flags & PartitionAllocReturnNull);
   return result;
 #else
-  ASSERT(root->initialized);
+  DCHECK(root->initialized);
   size_t requestedSize = size;
   size = partitionCookieSizeAdjustAdd(size);
   PartitionBucket* bucket = partitionGenericSizeToBucket(root, size);
   void* ret = nullptr;
   {
-    SpinLock::Guard guard(root->lock);
+    subtle::SpinLock::Guard guard(root->lock);
     ret = partitionBucketAlloc(root, flags, size, bucket);
   }
   PartitionAllocHooks::allocationHookIfEnabled(ret, requestedSize, typeName);
   return ret;
 #endif
 }
 
 ALWAYS_INLINE void* partitionAllocGeneric(PartitionRootGeneric* root,
                                           size_t size,
                                           const char* typeName) {
   return partitionAllocGenericFlags(root, 0, size, typeName);
 }
 
 ALWAYS_INLINE void partitionFreeGeneric(PartitionRootGeneric* root, void* ptr) {
 #if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
   free(ptr);
 #else
-  ASSERT(root->initialized);
+  DCHECK(root->initialized);
 
   if (UNLIKELY(!ptr))
     return;
 
   PartitionAllocHooks::freeHookIfEnabled(ptr);
   ptr = partitionCookieFreePointerAdjust(ptr);
-  ASSERT(partitionPointerIsValid(ptr));
+  DCHECK(partitionPointerIsValid(ptr));
   PartitionPage* page = partitionPointerToPage(ptr);
   {
-    SpinLock::Guard guard(root->lock);
+    subtle::SpinLock::Guard guard(root->lock);
     partitionFreeWithPage(ptr, page);
   }
 #endif
 }
 
 ALWAYS_INLINE size_t partitionDirectMapSize(size_t size) {
   // Caller must check that the size is not above the kGenericMaxDirectMapped
   // limit before calling. This also guards against integer overflow in the
   // calculation here.
-  ASSERT(size <= kGenericMaxDirectMapped);
+  DCHECK(size <= kGenericMaxDirectMapped);
   return (size + kSystemPageOffsetMask) & kSystemPageBaseMask;
 }
 
 ALWAYS_INLINE size_t partitionAllocActualSize(PartitionRootGeneric* root,
                                               size_t size) {
 #if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
   return size;
 #else
-  ASSERT(root->initialized);
+  DCHECK(root->initialized);
   size = partitionCookieSizeAdjustAdd(size);
   PartitionBucket* bucket = partitionGenericSizeToBucket(root, size);
   if (LIKELY(!partitionBucketIsDirectMapped(bucket))) {
     size = bucket->slotSize;
   } else if (size > kGenericMaxDirectMapped) {
     // Too large to allocate => return the size unchanged.
   } else {
-    ASSERT(bucket == &PartitionRootBase::gPagedBucket);
+    DCHECK(bucket == &PartitionRootBase::gPagedBucket);
     size = partitionDirectMapSize(size);
   }
   return partitionCookieSizeAdjustSubtract(size);
 #endif
 }
 
 ALWAYS_INLINE bool partitionAllocSupportsGetSize() {
 #if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
   return false;
 #else
   return true;
 #endif
 }
 
 ALWAYS_INLINE size_t partitionAllocGetSize(void* ptr) {
   // No need to lock here. Only 'ptr' being freed by another thread could
   // cause trouble, and the caller is responsible for that not happening.
-  ASSERT(partitionAllocSupportsGetSize());
+  DCHECK(partitionAllocSupportsGetSize());
   ptr = partitionCookieFreePointerAdjust(ptr);
-  ASSERT(partitionPointerIsValid(ptr));
+  DCHECK(partitionPointerIsValid(ptr));
   PartitionPage* page = partitionPointerToPage(ptr);
   size_t size = page->bucket->slotSize;
   return partitionCookieSizeAdjustSubtract(size);
 }
 
 // N (or more accurately, N - sizeof(void*)) represents the largest size in
 // bytes that will be handled by a SizeSpecificPartitionAllocator.
 // Attempts to partitionAlloc() more than this amount will fail.
 template <size_t N>
 class SizeSpecificPartitionAllocator {
@@ skipping 14 matching lines @@
 class PartitionAllocatorGeneric {
  public:
   void init() { partitionAllocGenericInit(&m_partitionRoot); }
   bool shutdown() { return partitionAllocGenericShutdown(&m_partitionRoot); }
   ALWAYS_INLINE PartitionRootGeneric* root() { return &m_partitionRoot; }
 
  private:
   PartitionRootGeneric m_partitionRoot;
 };
 
-}  // namespace WTF
+}  // namespace base
 
-using WTF::SizeSpecificPartitionAllocator;
-using WTF::PartitionAllocatorGeneric;
-using WTF::PartitionRoot;
-using WTF::partitionAllocInit;
-using WTF::partitionAllocShutdown;
-using WTF::partitionAlloc;
-using WTF::partitionFree;
-using WTF::partitionAllocGeneric;
-using WTF::partitionFreeGeneric;
-using WTF::partitionReallocGeneric;
-using WTF::partitionAllocActualSize;
-using WTF::partitionAllocSupportsGetSize;
-using WTF::partitionAllocGetSize;
+using base::SizeSpecificPartitionAllocator;
+using base::PartitionAllocatorGeneric;

[Primiano Tucci (use gerrit), 2016/11/22 14:28:33]

Can't figure out what these are for. The .cc file is in the right namespace, so
it looks like the only one benefitting of this is the test.cc. Probably should
be moved there?

[palmer, 2016/11/24 01:05:56]

Done.

+using base::PartitionRoot;
+using base::partitionAllocInit;
+using base::partitionAllocShutdown;
+using base::partitionAlloc;
+using base::partitionFree;
+using base::partitionAllocGeneric;
+using base::partitionFreeGeneric;
+using base::partitionReallocGeneric;
+using base::partitionAllocActualSize;
+using base::partitionAllocSupportsGetSize;
+using base::partitionAllocGetSize;
 
-#endif  // WTF_PartitionAlloc_h
+#endif  // BASE_ALLOCATOR_PARTITION_ALLOCATOR_PARTITION_ALLOC_H