Oilpan: Rename heap classes

Source/platform/heap/Heap.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 71 matching lines @@
 #if ENABLE(ASSERT) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
 #define FILL_ZERO_IF_PRODUCTION(address, size) do { } while (false)
 #define FILL_ZERO_IF_NOT_PRODUCTION(address, size) memset((address), 0, (size))
 #else
 #define FILL_ZERO_IF_PRODUCTION(address, size) memset((address), 0, (size))
 #define FILL_ZERO_IF_NOT_PRODUCTION(address, size) do { } while (false)
 #endif
 
 class CallbackStack;
 class PageMemory;
-class ThreadHeapForHeapPage;
+class NormalPageHeap;
 template<ThreadAffinity affinity> class ThreadLocalPersistents;
 template<typename T, typename RootsAccessor = ThreadLocalPersistents<ThreadingTrait<T>::Affinity>> class Persistent;
 
 #if ENABLE(GC_PROFILING)
 class TracedValue;
 #endif
 
 // HeapObjectHeader is 4 byte (32 bit) that has the following layout:
 //
 // | gcInfoIndex (15 bit) | size (14 bit) | dead bit (1 bit) | freed bit (1 bit) | mark bit (1 bit) |
 //
 // - For non-large objects, 14 bit is enough for |size| because the blink
 //   page size is 2^17 byte and each object is guaranteed to be aligned with
 //   2^3 byte.
 // - For large objects, |size| is 0. The actual size of a large object is
-//   stored in LargeObject::m_payloadSize.
+//   stored in LargeObjectPage::m_payloadSize.
 // - 15 bit is enough for gcInfoIndex because there are less than 2^15 types
 //   in Blink.
 const size_t headerGCInfoIndexShift = 17;
 const size_t headerGCInfoIndexMask = (static_cast<size_t>((1 << 15) - 1)) << headerGCInfoIndexShift;
 const size_t headerSizeMask = (static_cast<size_t>((1 << 14) - 1)) << 3;
 const size_t headerMarkBitMask = 1;
 const size_t headerFreedBitMask = 2;
 // The dead bit is used for objects that have gone through a GC marking, but did
 // not get swept before a new GC started. In that case we set the dead bit on
 // objects that were not marked in the previous GC to ensure we are not tracing
 // them via a conservatively found pointer. Tracing dead objects could lead to
 // tracing of already finalized objects in another thread's heap which is a
 // use-after-free situation.
 const size_t headerDeadBitMask = 4;
 // On free-list entries we reuse the dead bit to distinguish a normal free-list
 // entry from one that has been promptly freed.
 const size_t headerPromptlyFreedBitMask = headerFreedBitMask | headerDeadBitMask;
 const size_t largeObjectSizeInHeader = 0;
 const size_t gcInfoIndexForFreeListHeader = 0;
-const size_t nonLargeObjectSizeMax = 1 << 17;
+const size_t nonLargeObjectPageSizeMax = 1 << 17;
 
-static_assert(nonLargeObjectSizeMax >= blinkPageSize, "max size supported by HeapObjectHeader must at least be blinkPageSize");
+static_assert(nonLargeObjectPageSizeMax >= blinkPageSize, "max size supported by HeapObjectHeader must at least be blinkPageSize");
 
 class PLATFORM_EXPORT HeapObjectHeader {
 public:
     // If gcInfoIndex is 0, this header is interpreted as a free list header.
     NO_SANITIZE_ADDRESS
     HeapObjectHeader(size_t size, size_t gcInfoIndex)
     {
 #if ENABLE(ASSERT)
         m_magic = magic;
 #endif
 #if ENABLE(GC_PROFILING)
         m_age = 0;
 #endif
         // sizeof(HeapObjectHeader) must be equal to or smaller than
         // allocationGranurarity, because HeapObjectHeader is used as a header
         // for an freed entry.  Given that the smallest entry size is
         // allocationGranurarity, HeapObjectHeader must fit into the size.
         static_assert(sizeof(HeapObjectHeader) <= allocationGranularity, "size of HeapObjectHeader must be smaller than allocationGranularity");
 #if CPU(64BIT)
         static_assert(sizeof(HeapObjectHeader) == 8, "size of HeapObjectHeader must be 8 byte aligned");
 #endif
 
         ASSERT(gcInfoIndex < GCInfoTable::maxIndex);
-        ASSERT(size < nonLargeObjectSizeMax);
+        ASSERT(size < nonLargeObjectPageSizeMax);
         ASSERT(!(size & allocationMask));
         m_encoded = (gcInfoIndex << headerGCInfoIndexShift) | size | (gcInfoIndex ? 0 : headerFreedBitMask);
     }
 
     NO_SANITIZE_ADDRESS
     bool isFree() const { return m_encoded & headerFreedBitMask; }
     NO_SANITIZE_ADDRESS
     bool isPromptlyFreed() const { return (m_encoded & headerPromptlyFreedBitMask) == headerPromptlyFreedBitMask; }
     NO_SANITIZE_ADDRESS
     void markPromptlyFreed() { m_encoded |= headerPromptlyFreedBitMask; }
@@ skipping 178 matching lines @@
 // header should be OS page size away from being Blink page size
 // aligned.
 inline bool isPageHeaderAddress(Address address)
 {
     return !((reinterpret_cast<uintptr_t>(address) & blinkPageOffsetMask) - WTF::kSystemPageSize);
 }
 #endif
 
 // FIXME: Add a good comment about the heap layout once heap relayout work
 // is done.
-class BaseHeapPage {
+class BasePage {
 public:
-    BaseHeapPage(PageMemory*, ThreadHeap*);
-    virtual ~BaseHeapPage() { }
+    BasePage(PageMemory*, BaseHeap*);
+    virtual ~BasePage() { }
 
-    void link(BaseHeapPage** previousNext)
+    void link(BasePage** previousNext)
     {
         m_next = *previousNext;
         *previousNext = this;
     }
-    void unlink(BaseHeapPage** previousNext)
+    void unlink(BasePage** previousNext)
     {
         *previousNext = m_next;
         m_next = nullptr;
     }
-    BaseHeapPage* next() const { return m_next; }
+    BasePage* next() const { return m_next; }
 
     // virtual methods are slow. So performance-sensitive methods
-    // should be defined as non-virtual methods on HeapPage and LargeObject.
+    // should be defined as non-virtual methods on NormalPage and LargeObjectPage.
     // The following methods are not performance-sensitive.
     virtual size_t objectPayloadSizeForTesting() = 0;
     virtual bool isEmpty() = 0;
     virtual void removeFromHeap() = 0;
     virtual void sweep() = 0;
     virtual void markUnmarkedObjectsDead() = 0;
     // Check if the given address points to an object in this
     // heap page. If so, find the start of that object and mark it
     // using the given Visitor. Otherwise do nothing. The pointer must
     // be within the same aligned blinkPageSize as the this-pointer.
     //
     // This is used during conservative stack scanning to
     // conservatively mark all objects that could be referenced from
     // the stack.
     virtual void checkAndMarkPointer(Visitor*, Address) = 0;
     virtual void markOrphaned();
 #if ENABLE(GC_PROFILING)
     virtual const GCInfo* findGCInfo(Address) = 0;
     virtual void snapshot(TracedValue*, ThreadState::SnapshotInfo*) = 0;
 #endif
 #if ENABLE(ASSERT) || ENABLE(GC_PROFILING)
     virtual bool contains(Address) = 0;
 #endif
     virtual size_t size() = 0;
-    virtual bool isLargeObject() { return false; }
+    virtual bool isLargeObjectPage() { return false; }
 
     Address address() { return reinterpret_cast<Address>(this); }
     PageMemory* storage() const { return m_storage; }
-    ThreadHeap* heap() const { return m_heap; }
+    BaseHeap* heap() const { return m_heap; }
     bool orphaned() { return !m_heap; }
     bool terminating() { return m_terminating; }
     void setTerminating() { m_terminating = true; }
 
     // Returns true if this page has been swept by the ongoing lazy sweep.
     bool hasBeenSwept() const { return m_swept; }
 
     void markAsSwept()
     {
         ASSERT(!m_swept);
         m_swept = true;
     }
 
     void markAsUnswept()
     {
         ASSERT(m_swept);
         m_swept = false;
     }
 
 private:
     PageMemory* m_storage;
-    ThreadHeap* m_heap;
-    BaseHeapPage* m_next;
+    BaseHeap* m_heap;
+    BasePage* m_next;
     // Whether the page is part of a terminating thread or not.
     bool m_terminating;
 
     // Track the sweeping state of a page. Set to true once
     // the lazy sweep completes has processed it.
     //
     // Set to false at the start of a sweep, true  upon completion
     // of lazy sweeping.
     bool m_swept;
-    friend class ThreadHeap;
+    friend class BaseHeap;
 };
 
-class HeapPage final : public BaseHeapPage {
+class NormalPage final : public BasePage {
 public:
-    HeapPage(PageMemory*, ThreadHeap*);
+    NormalPage(PageMemory*, BaseHeap*);
 
     Address payload()
     {
-        return address() + sizeof(HeapPage) + headerPadding();
+        return address() + sizeof(NormalPage) + headerPadding();
     }
     size_t payloadSize()
     {
-        return (blinkPagePayloadSize() - sizeof(HeapPage) - headerPadding()) & ~allocationMask;
+        return (blinkPagePayloadSize() - sizeof(NormalPage) - headerPadding()) & ~allocationMask;
     }
     Address payloadEnd() { return payload() + payloadSize(); }
     bool containedInObjectPayload(Address address) { return payload() <= address && address < payloadEnd(); }
 
     virtual size_t objectPayloadSizeForTesting() override;
     virtual bool isEmpty() override;
     virtual void removeFromHeap() override;
     virtual void sweep() override;
     virtual void markUnmarkedObjectsDead() override;
     virtual void checkAndMarkPointer(Visitor*, Address) override;
     virtual void markOrphaned() override
     {
         // Zap the payload with a recognizable value to detect any incorrect
         // cross thread pointer usage.
 #if defined(ADDRESS_SANITIZER)
         // This needs to zap poisoned memory as well.
         // Force unpoison memory before memset.
         ASAN_UNPOISON_MEMORY_REGION(payload(), payloadSize());
 #endif
         memset(payload(), orphanedZapValue, payloadSize());
-        BaseHeapPage::markOrphaned();
+        BasePage::markOrphaned();
     }
 #if ENABLE(GC_PROFILING)
     const GCInfo* findGCInfo(Address) override;
     virtual void snapshot(TracedValue*, ThreadState::SnapshotInfo*);
     void incrementMarkedObjectsAge();
     void countMarkedObjects(ClassAgeCountsMap&);
     void countObjectsToSweep(ClassAgeCountsMap&);
 #endif
 #if ENABLE(ASSERT) || ENABLE(GC_PROFILING)
     // Returns true for the whole blinkPageSize page that the page is on, even
     // for the header, and the unmapped guard page at the start. That ensures
     // the result can be used to populate the negative page cache.
     virtual bool contains(Address addr) override
     {
         Address blinkPageStart = roundToBlinkPageStart(address());
         ASSERT(blinkPageStart == address() - WTF::kSystemPageSize); // Page is at aligned address plus guard page size.
         return blinkPageStart <= addr && addr < blinkPageStart + blinkPageSize;
     }
 #endif
     virtual size_t size() override { return blinkPageSize; }
     // Compute the amount of padding we have to add to a header to make
     // the size of the header plus the padding a multiple of 8 bytes.
     static size_t headerPadding()
     {
-        return (sizeof(HeapPage) + allocationGranularity - (sizeof(HeapObjectHeader) % allocationGranularity)) % allocationGranularity;
+        return (sizeof(NormalPage) + allocationGranularity - (sizeof(HeapObjectHeader) % allocationGranularity)) % allocationGranularity;
     }
 
 
-    ThreadHeapForHeapPage* heapForHeapPage();
+    NormalPageHeap* heapForNormalPage();
     void clearObjectStartBitMap();
 
 #if defined(ADDRESS_SANITIZER)
     void poisonUnmarkedObjects();
 #endif
 
 private:
     HeapObjectHeader* findHeaderFromAddress(Address);
     void populateObjectStartBitMap();
     bool isObjectStartBitMapComputed() { return m_objectStartBitMapComputed; }
 
     bool m_objectStartBitMapComputed;
     uint8_t m_objectStartBitMap[reservedForObjectBitMap];
 };
 
 // Large allocations are allocated as separate objects and linked in a list.
 //
 // In order to use the same memory allocation routines for everything allocated
 // in the heap, large objects are considered heap pages containing only one
 // object.
-class LargeObject final : public BaseHeapPage {
+class LargeObjectPage final : public BasePage {
 public:
-    LargeObject(PageMemory* storage, ThreadHeap* heap, size_t payloadSize)
-        : BaseHeapPage(storage, heap)
+    LargeObjectPage(PageMemory* storage, BaseHeap* heap, size_t payloadSize)
+        : BasePage(storage, heap)
         , m_payloadSize(payloadSize)
     {
     }
 
     Address payload() { return heapObjectHeader()->payload(); }
     size_t payloadSize() { return m_payloadSize; }
     Address payloadEnd() { return payload() + payloadSize(); }
     bool containedInObjectPayload(Address address) { return payload() <= address && address < payloadEnd(); }
 
     virtual size_t objectPayloadSizeForTesting() override;
     virtual bool isEmpty() override;
     virtual void removeFromHeap() override;
     virtual void sweep() override;
     virtual void markUnmarkedObjectsDead() override;
     virtual void checkAndMarkPointer(Visitor*, Address) override;
     virtual void markOrphaned() override
     {
         // Zap the payload with a recognizable value to detect any incorrect
         // cross thread pointer usage.
         memset(payload(), orphanedZapValue, payloadSize());
-        BaseHeapPage::markOrphaned();
+        BasePage::markOrphaned();
     }
 
 #if ENABLE(GC_PROFILING)
     virtual const GCInfo* findGCInfo(Address) override;
     virtual void snapshot(TracedValue*, ThreadState::SnapshotInfo*) override;
     void incrementMarkedObjectsAge();
     void countMarkedObjects(ClassAgeCountsMap&);
     void countObjectsToSweep(ClassAgeCountsMap&);
 #endif
 
 #if ENABLE(ASSERT) || ENABLE(GC_PROFILING)
     // Returns true for any address that is on one of the pages that this
     // large object uses. That ensures that we can use a negative result to
     // populate the negative page cache.
     virtual bool contains(Address object) override
     {
         return roundToBlinkPageStart(address()) <= object && object < roundToBlinkPageEnd(address() + size());
     }
 #endif
     virtual size_t size()
     {
-        return sizeof(LargeObject) + headerPadding() +  sizeof(HeapObjectHeader) + m_payloadSize;
+        return sizeof(LargeObjectPage) + headerPadding() +  sizeof(HeapObjectHeader) + m_payloadSize;
     }
     // Compute the amount of padding we have to add to a header to make
     // the size of the header plus the padding a multiple of 8 bytes.
     static size_t headerPadding()
     {
-        return (sizeof(LargeObject) + allocationGranularity - (sizeof(HeapObjectHeader) % allocationGranularity)) % allocationGranularity;
+        return (sizeof(LargeObjectPage) + allocationGranularity - (sizeof(HeapObjectHeader) % allocationGranularity)) % allocationGranularity;
     }
-    virtual bool isLargeObject() override { return true; }
+    virtual bool isLargeObjectPage() override { return true; }
 
     HeapObjectHeader* heapObjectHeader()
     {
-        Address headerAddress = address() + sizeof(LargeObject) + headerPadding();
+        Address headerAddress = address() + sizeof(LargeObjectPage) + headerPadding();
         return reinterpret_cast<HeapObjectHeader*>(headerAddress);
     }
 
 private:
 
     size_t m_payloadSize;
 };
 
 // A HeapDoesNotContainCache provides a fast way of taking an arbitrary
 // pointer-sized word, and determining whether it cannot be interpreted as a
@@ skipping 74 matching lines @@
 class FreePagePool : public PagePool<PageMemory> {
 public:
     ~FreePagePool();
     void addFreePage(int, PageMemory*);
     PageMemory* takeFreePage(int);
 
 private:
     Mutex m_mutex[NumberOfHeaps];
 };
 
-class OrphanedPagePool : public PagePool<BaseHeapPage> {
+class OrphanedPagePool : public PagePool<BasePage> {
 public:
     ~OrphanedPagePool();
-    void addOrphanedPage(int, BaseHeapPage*);
+    void addOrphanedPage(int, BasePage*);
     void decommitOrphanedPages();
 #if ENABLE(ASSERT)
     bool contains(void*);
 #endif
 private:
     void clearMemory(PageMemory*);
 };
 
 class FreeList {
 public:
@@ skipping 16 matching lines @@
 
     void getFreeSizeStats(PerBucketFreeListStats bucketStats[], size_t& totalSize) const;
 #endif
 
 private:
     int m_biggestFreeListIndex;
 
     // All FreeListEntries in the nth list have size >= 2^n.
     FreeListEntry* m_freeLists[blinkPageSizeLog2];
 
-    friend class ThreadHeapForHeapPage;
+    friend class NormalPageHeap;
 };
 
 // Thread heaps represent a part of the per-thread Blink heap.
 //
 // Each Blink thread has a number of thread heaps: one general heap
 // that contains any type of object and a number of heaps specialized
 // for specific object types (such as Node).
 //
 // Each thread heap contains the functionality to allocate new objects
 // (potentially adding new pages to the heap), to find and mark
 // objects during conservative stack scanning and to sweep the set of
 // pages after a GC.
-class PLATFORM_EXPORT ThreadHeap {
+class PLATFORM_EXPORT BaseHeap {
 public:
-    ThreadHeap(ThreadState*, int);
-    virtual ~ThreadHeap();
+    BaseHeap(ThreadState*, int);
+    virtual ~BaseHeap();
     void cleanupPages();
 
 #if ENABLE(ASSERT) || ENABLE(GC_PROFILING)
-    BaseHeapPage* findPageFromAddress(Address);
+    BasePage* findPageFromAddress(Address);
 #endif
 #if ENABLE(GC_PROFILING)
     void snapshot(TracedValue*, ThreadState::SnapshotInfo*);
     void incrementMarkedObjectsAge();
 #endif
 
     virtual void clearFreeLists() { }
     void makeConsistentForSweeping();
 #if ENABLE(ASSERT)
     virtual bool isConsistentForSweeping() = 0;
 #endif
     size_t objectPayloadSizeForTesting();
     void prepareHeapForTermination();
     void prepareForSweep();
     Address lazySweep(size_t, size_t gcInfoIndex);
     void completeSweep();
 
     ThreadState* threadState() { return m_threadState; }
     int heapIndex() const { return m_index; }
     inline static size_t allocationSizeFromSize(size_t);
     inline static size_t roundedAllocationSize(size_t size)
     {
         return allocationSizeFromSize(size) - sizeof(HeapObjectHeader);
     }
 
 protected:
-    BaseHeapPage* m_firstPage;
-    BaseHeapPage* m_firstUnsweptPage;
+    BasePage* m_firstPage;
+    BasePage* m_firstUnsweptPage;
 
 private:
     virtual Address lazySweepPages(size_t, size_t gcInfoIndex) = 0;
 
     ThreadState* m_threadState;
 
     // Index into the page pools.  This is used to ensure that the pages of the
     // same type go into the correct page pool and thus avoid type confusion.
     int m_index;
 };
 
-class PLATFORM_EXPORT ThreadHeapForHeapPage final : public ThreadHeap {
+class PLATFORM_EXPORT NormalPageHeap final : public BaseHeap {
 public:
-    ThreadHeapForHeapPage(ThreadState*, int);
+    NormalPageHeap(ThreadState*, int);
     void addToFreeList(Address address, size_t size)
     {
         ASSERT(findPageFromAddress(address));
         ASSERT(findPageFromAddress(address + size - 1));
         m_freeList.addToFreeList(address, size);
     }
     virtual void clearFreeLists() override;
 #if ENABLE(ASSERT)
     virtual bool isConsistentForSweeping() override;
     bool pagesToBeSweptContains(Address);
 #endif
 
     inline Address allocate(size_t payloadSize, size_t gcInfoIndex);
     inline Address allocateObject(size_t allocationSize, size_t gcInfoIndex);
 
-    void freePage(HeapPage*);
+    void freePage(NormalPage*);
 
     bool coalesce();
     void promptlyFreeObject(HeapObjectHeader*);
     bool expandObject(HeapObjectHeader*, size_t);
     void shrinkObject(HeapObjectHeader*, size_t);
     void decreasePromptlyFreedSize(size_t size) { m_promptlyFreedSize -= size; }
 
 #if ENABLE(GC_PROFILING)
     void snapshotFreeList(TracedValue&);
 
@@ skipping 20 matching lines @@
     // The size of promptly freed objects in the heap.
     size_t m_promptlyFreedSize;
 
 #if ENABLE(GC_PROFILING)
     size_t m_cumulativeAllocationSize;
     size_t m_allocationCount;
     size_t m_inlineAllocationCount;
 #endif
 };
 
-class ThreadHeapForLargeObject final : public ThreadHeap {
+class LargeObjectHeap final : public BaseHeap {
 public:
-    ThreadHeapForLargeObject(ThreadState*, int);
-    Address allocateLargeObject(size_t, size_t gcInfoIndex);
-    void freeLargeObject(LargeObject*);
+    LargeObjectHeap(ThreadState*, int);
+    Address allocateLargeObjectPage(size_t, size_t gcInfoIndex);
+    void freeLargeObjectPage(LargeObjectPage*);
 #if ENABLE(ASSERT)
     virtual bool isConsistentForSweeping() override { return true; }
 #endif
 private:
-    Address doAllocateLargeObject(size_t, size_t gcInfoIndex);
+    Address doAllocateLargeObjectPage(size_t, size_t gcInfoIndex);
     virtual Address lazySweepPages(size_t, size_t gcInfoIndex) override;
 };
 
 // Mask an address down to the enclosing oilpan heap base page.  All oilpan heap
 // pages are aligned at blinkPageBase plus an OS page size.
 // FIXME: Remove PLATFORM_EXPORT once we get a proper public interface to our
 // typed heaps.  This is only exported to enable tests in HeapTest.cpp.
-PLATFORM_EXPORT inline BaseHeapPage* pageFromObject(const void* object)
+PLATFORM_EXPORT inline BasePage* pageFromObject(const void* object)
 {
     Address address = reinterpret_cast<Address>(const_cast<void*>(object));
-    BaseHeapPage* page = reinterpret_cast<BaseHeapPage*>(blinkPageAddress(address) + WTF::kSystemPageSize);
+    BasePage* page = reinterpret_cast<BasePage*>(blinkPageAddress(address) + WTF::kSystemPageSize);
     ASSERT(page->contains(address));
     return page;
 }
 
 class PLATFORM_EXPORT Heap {
 public:
     static void init();
     static void shutdown();
     static void doShutdown();
 
 #if ENABLE(ASSERT) || ENABLE(GC_PROFILING)
-    static BaseHeapPage* findPageFromAddress(Address);
-    static BaseHeapPage* findPageFromAddress(void* pointer) { return findPageFromAddress(reinterpret_cast<Address>(pointer)); }
+    static BasePage* findPageFromAddress(Address);
+    static BasePage* findPageFromAddress(void* pointer) { return findPageFromAddress(reinterpret_cast<Address>(pointer)); }
     static bool containedInHeapOrOrphanedPage(void*);
 #endif
 
     // Is the finalizable GC object still alive, but slated for lazy sweeping?
     // If a lazy sweep is in progress, returns true if the object was found
     // to be not reachable during the marking phase, but it has yet to be swept
     // and finalized. The predicate returns false in all other cases.
     //
     // Holding a reference to an already-dead object is not a valid state
     // to be in; willObjectBeLazilySwept() has undefined behavior if passed
     // such a reference.
     template<typename T>
     static bool willObjectBeLazilySwept(const T* objectPointer)
     {
         static_assert(IsGarbageCollectedType<T>::value, "only objects deriving from GarbageCollected can be used.");
 #if ENABLE(OILPAN)
-        BaseHeapPage* page = pageFromObject(objectPointer);
+        BasePage* page = pageFromObject(objectPointer);
         if (page->hasBeenSwept())
             return false;
         ASSERT(page->heap()->threadState()->isSweepingInProgress());
 
         return !ObjectAliveTrait<T>::isHeapObjectAlive(s_markingVisitor, const_cast<T*>(objectPointer));
 #else
         // FIXME: remove when lazy sweeping is always on
         // (cf. ThreadState::postGCProcessing()).
         return false;
 #endif
@@ skipping 82 matching lines @@
     // Return true if the last GC found a pointer into a heap page
     // during conservative scanning.
     static bool lastGCWasConservative() { return s_lastGCWasConservative; }
 
     static FreePagePool* freePagePool() { return s_freePagePool; }
     static OrphanedPagePool* orphanedPagePool() { return s_orphanedPagePool; }
 
     // This look-up uses the region search tree and a negative contains cache to
     // provide an efficient mapping from arbitrary addresses to the containing
     // heap-page if one exists.
-    static BaseHeapPage* lookup(Address);
+    static BasePage* lookup(Address);
     static void addPageMemoryRegion(PageMemoryRegion*);
     static void removePageMemoryRegion(PageMemoryRegion*);
 
     static const GCInfo* gcInfo(size_t gcInfoIndex)
     {
         ASSERT(gcInfoIndex >= 1);
         ASSERT(gcInfoIndex < GCInfoTable::maxIndex);
         ASSERT(s_gcInfoTable);
         const GCInfo* info = s_gcInfoTable[gcInfoIndex];
         ASSERT(info);
@@ skipping 268 matching lines @@
 #define STACK_ALLOCATED() DISALLOW_ALLOCATION()
 #define GC_PLUGIN_IGNORE(bug)
 #endif
 
 NO_SANITIZE_ADDRESS inline
 size_t HeapObjectHeader::size() const
 {
     size_t result = m_encoded & headerSizeMask;
     // Large objects should not refer to header->size().
     // The actual size of a large object is stored in
-    // LargeObject::m_payloadSize.
+    // LargeObjectPage::m_payloadSize.
     ASSERT(result != largeObjectSizeInHeader);
-    ASSERT(!pageFromObject(this)->isLargeObject());
+    ASSERT(!pageFromObject(this)->isLargeObjectPage());
     return result;
 }
 
 NO_SANITIZE_ADDRESS
 void HeapObjectHeader::checkHeader() const
 {
     ASSERT(pageFromObject(this)->orphaned() || m_magic == magic);
 }
 
 Address HeapObjectHeader::payload()
 {
     return reinterpret_cast<Address>(this) + sizeof(HeapObjectHeader);
 }
 
 Address HeapObjectHeader::payloadEnd()
 {
     return reinterpret_cast<Address>(this) + size();
 }
 
 NO_SANITIZE_ADDRESS inline
 size_t HeapObjectHeader::payloadSize()
 {
     size_t size = m_encoded & headerSizeMask;
     if (UNLIKELY(size == largeObjectSizeInHeader)) {
-        ASSERT(pageFromObject(this)->isLargeObject());
-        return static_cast<LargeObject*>(pageFromObject(this))->payloadSize();
+        ASSERT(pageFromObject(this)->isLargeObjectPage());
+        return static_cast<LargeObjectPage*>(pageFromObject(this))->payloadSize();
     }
-    ASSERT(!pageFromObject(this)->isLargeObject());
+    ASSERT(!pageFromObject(this)->isLargeObjectPage());
     return size - sizeof(HeapObjectHeader);
 }
 
 NO_SANITIZE_ADDRESS inline
 bool HeapObjectHeader::isMarked() const
 {
     checkHeader();
     return m_encoded & headerMarkBitMask;
 }
 
@@ skipping 21 matching lines @@
 }
 
 NO_SANITIZE_ADDRESS inline
 void HeapObjectHeader::markDead()
 {
     checkHeader();
     ASSERT(!isMarked());
     m_encoded |= headerDeadBitMask;
 }
 
-size_t ThreadHeap::allocationSizeFromSize(size_t size)
+size_t BaseHeap::allocationSizeFromSize(size_t size)
 {
     // Check the size before computing the actual allocation size.  The
     // allocation size calculation can overflow for large sizes and the check
     // therefore has to happen before any calculation on the size.
     RELEASE_ASSERT(size < maxHeapObjectSize);
 
     // Add space for header.
     size_t allocationSize = size + sizeof(HeapObjectHeader);
     // Align size with allocation granularity.
     allocationSize = (allocationSize + allocationMask) & ~allocationMask;
     return allocationSize;
 }
 
-Address ThreadHeapForHeapPage::allocateObject(size_t allocationSize, size_t gcInfoIndex)
+Address NormalPageHeap::allocateObject(size_t allocationSize, size_t gcInfoIndex)
 {
 #if ENABLE(GC_PROFILING)
     m_cumulativeAllocationSize += allocationSize;
     ++m_allocationCount;
 #endif
 
     if (LIKELY(allocationSize <= m_remainingAllocationSize)) {
 #if ENABLE(GC_PROFILING)
         ++m_inlineAllocationCount;
 #endif
         Address headerAddress = m_currentAllocationPoint;
         m_currentAllocationPoint += allocationSize;
         m_remainingAllocationSize -= allocationSize;
         ASSERT(gcInfoIndex > 0);
         new (NotNull, headerAddress) HeapObjectHeader(allocationSize, gcInfoIndex);
         Address result = headerAddress + sizeof(HeapObjectHeader);
         ASSERT(!(reinterpret_cast<uintptr_t>(result) & allocationMask));
 
         // Unpoison the memory used for the object (payload).
         ASAN_UNPOISON_MEMORY_REGION(result, allocationSize - sizeof(HeapObjectHeader));
         FILL_ZERO_IF_NOT_PRODUCTION(result, allocationSize - sizeof(HeapObjectHeader));
         ASSERT(findPageFromAddress(headerAddress + allocationSize - 1));
         return result;
     }
     return outOfLineAllocate(allocationSize, gcInfoIndex);
 }
 
-Address ThreadHeapForHeapPage::allocate(size_t size, size_t gcInfoIndex)
+Address NormalPageHeap::allocate(size_t size, size_t gcInfoIndex)
 {
     return allocateObject(allocationSizeFromSize(size), gcInfoIndex);
 }
 
 template<typename T>
 struct HeapIndexTrait {
-    static int index() { return GeneralHeap; };
+    static int index() { return NormalPageHeapIndex; };
 };
 
 // FIXME: The forward declaration is layering violation.
 #define DEFINE_TYPED_HEAP_TRAIT(Type)                \
     class Type;                                      \
     template<>                                       \
     struct HeapIndexTrait<class Type> {              \
     static int index() { return Type##Heap; }; \
     };
 FOR_EACH_TYPED_HEAP(DEFINE_TYPED_HEAP_TRAIT)
 #undef DEFINE_TYPED_HEAP_TRAIT
 
 template<typename T>
 Address Heap::allocateOnHeapIndex(size_t size, int heapIndex, size_t gcInfoIndex)
 {
     ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
     ASSERT(state->isAllocationAllowed());
-    return static_cast<ThreadHeapForHeapPage*>(state->heap(heapIndex))->allocate(size, gcInfoIndex);
+    return static_cast<NormalPageHeap*>(state->heap(heapIndex))->allocate(size, gcInfoIndex);
 }
 
 template<typename T>
 Address Heap::allocate(size_t size)
 {
     return allocateOnHeapIndex<T>(size, HeapIndexTrait<T>::index(), GCInfoTrait<T>::index());
 }
 
 template<typename T>
 Address Heap::reallocate(void* previous, size_t size)
@@ skipping 18 matching lines @@
     memcpy(address, previous, copySize);
     return address;
 }
 
 class HeapAllocatorQuantizer {
 public:
     template<typename T>
     static size_t quantizedSize(size_t count)
     {
         RELEASE_ASSERT(count <= kMaxUnquantizedAllocation / sizeof(T));
-        return ThreadHeap::roundedAllocationSize(count * sizeof(T));
+        return BaseHeap::roundedAllocationSize(count * sizeof(T));
     }
     static const size_t kMaxUnquantizedAllocation = maxHeapObjectSize;
 };
 
 // This is a static-only class used as a trait on collections to make them heap
 // allocated.  However see also HeapListHashSetAllocator.
 class HeapAllocator {
 public:
     using Quantizer = HeapAllocatorQuantizer;
     using Visitor = blink::Visitor;
     static const bool isGarbageCollected = true;
 
     template <typename T>
     static T* allocateVectorBacking(size_t size)
     {
         size_t gcInfoIndex = GCInfoTrait<HeapVectorBacking<T, VectorTraits<T>>>::index();
-        return reinterpret_cast<T*>(Heap::allocateOnHeapIndex<T>(size, VectorBackingHeap, gcInfoIndex));
+        return reinterpret_cast<T*>(Heap::allocateOnHeapIndex<T>(size, VectorHeapIndex, gcInfoIndex));
     }
     PLATFORM_EXPORT static void freeVectorBacking(void* address);
     PLATFORM_EXPORT static bool expandVectorBacking(void*, size_t);
     static inline bool shrinkVectorBacking(void* address, size_t quantizedCurrentSize, size_t quantizedShrunkSize)
     {
         shrinkVectorBackingInternal(address, quantizedCurrentSize, quantizedShrunkSize);
         return true;
     }
     template <typename T>
     static T* allocateInlineVectorBacking(size_t size)
     {
         size_t gcInfoIndex = GCInfoTrait<HeapVectorBacking<T, VectorTraits<T>>>::index();
-        return reinterpret_cast<T*>(Heap::allocateOnHeapIndex<T>(size, InlineVectorBackingHeap, gcInfoIndex));
+        return reinterpret_cast<T*>(Heap::allocateOnHeapIndex<T>(size, InlineVectorHeapIndex, gcInfoIndex));
     }
     PLATFORM_EXPORT static void freeInlineVectorBacking(void* address);
     PLATFORM_EXPORT static bool expandInlineVectorBacking(void*, size_t);
     static inline bool shrinkInlineVectorBacking(void* address, size_t quantizedCurrentSize, size_t quantizedShrinkedSize)
     {
         shrinkInlineVectorBackingInternal(address, quantizedCurrentSize, quantizedShrinkedSize);
         return true;
     }
 
 
     template <typename T, typename HashTable>
     static T* allocateHashTableBacking(size_t size)
     {
         size_t gcInfoIndex = GCInfoTrait<HeapHashTableBacking<HashTable>>::index();
-        return reinterpret_cast<T*>(Heap::allocateOnHeapIndex<T>(size, HashTableBackingHeap, gcInfoIndex));
+        return reinterpret_cast<T*>(Heap::allocateOnHeapIndex<T>(size, HashTableHeapIndex, gcInfoIndex));
     }
     template <typename T, typename HashTable>
     static T* allocateZeroedHashTableBacking(size_t size)
     {
         return allocateHashTableBacking<T, HashTable>(size);
     }
     PLATFORM_EXPORT static void freeHashTableBacking(void* address);
     PLATFORM_EXPORT static bool expandHashTableBacking(void*, size_t);
 
     template <typename Return, typename Metadata>
@@ skipping 949 matching lines @@
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapVector<T, inlineCapacity>> : public GCInfoTrait<Vector<T, inlineCapacity, HeapAllocator>> { };
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapDeque<T, inlineCapacity>> : public GCInfoTrait<Deque<T, inlineCapacity, HeapAllocator>> { };
 template<typename T, typename U, typename V>
 struct GCInfoTrait<HeapHashCountedSet<T, U, V>> : public GCInfoTrait<HashCountedSet<T, U, V, HeapAllocator>> { };
 
 } // namespace blink
 
 #endif // Heap_h