Oilpan: Rename heap classes

Source/platform/heap/Heap.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 171 matching lines @@
     static PageMemoryRegion* allocateLargePage(size_t size)
     {
         return allocate(size, 1);
     }
 
     static PageMemoryRegion* allocateNormalPages()
     {
         return allocate(blinkPageSize * blinkPagesPerRegion, blinkPagesPerRegion);
     }
 
-    BaseHeapPage* pageFromAddress(Address address)
+    BasePage* pageFromAddress(Address address)
     {
         ASSERT(contains(address));
         if (!m_inUse[index(address)])
             return nullptr;
         if (m_isLargePage)
             return pageFromObject(base());
         return pageFromObject(address);
     }
 
 private:
@@ skipping 267 matching lines @@
     // Zap the primary vTable entry (secondary vTable entries are not zapped).
     if (gcInfo->hasVTable()) {
         *(reinterpret_cast<uintptr_t*>(object)) = zappedVTable;
     }
 #endif
     // In Release builds, the entire object is zeroed out when it is added to
     // the free list.  This happens right after sweeping the page and before the
     // thread commences execution.
 }
 
-void LargeObject::sweep()
+void LargeObjectPage::sweep()
 {
     Heap::increaseMarkedObjectSize(size());
     heapObjectHeader()->unmark();
 }
 
-bool LargeObject::isEmpty()
+bool LargeObjectPage::isEmpty()
 {
     return !heapObjectHeader()->isMarked();
 }
 
 #if ENABLE(ASSERT)
 static bool isUninitializedMemory(void* objectPointer, size_t objectSize)
 {
     // Scan through the object's fields and check that they are all zero.
     Address* objectFields = reinterpret_cast<Address*>(objectPointer);
     for (size_t i = 0; i < objectSize / sizeof(Address); ++i) {
         if (objectFields[i] != 0)
             return false;
     }
     return true;
 }
 #endif
 
 static void markPointer(Visitor* visitor, HeapObjectHeader* header)
 {
     const GCInfo* gcInfo = Heap::gcInfo(header->gcInfoIndex());
     if (gcInfo->hasVTable() && !vTableInitialized(header->payload())) {
         visitor->markHeaderNoTracing(header);
         ASSERT(isUninitializedMemory(header->payload(), header->payloadSize()));
     } else {
         visitor->markHeader(header, gcInfo->m_trace);
     }
 }
 
-void LargeObject::checkAndMarkPointer(Visitor* visitor, Address address)
+void LargeObjectPage::checkAndMarkPointer(Visitor* visitor, Address address)
 {
     ASSERT(contains(address));
     if (!containedInObjectPayload(address) || heapObjectHeader()->isDead())
         return;
 #if ENABLE(GC_PROFILING)
     visitor->setHostInfo(&address, "stack");
 #endif
     markPointer(visitor, heapObjectHeader());
 }
 
-void LargeObject::markUnmarkedObjectsDead()
+void LargeObjectPage::markUnmarkedObjectsDead()
 {
     HeapObjectHeader* header = heapObjectHeader();
     if (header->isMarked())
         header->unmark();
     else
         header->markDead();
 }
 
-void LargeObject::removeFromHeap()
+void LargeObjectPage::removeFromHeap()
 {
-    static_cast<ThreadHeapForLargeObject*>(heap())->freeLargeObject(this);
+    static_cast<LargeObjectHeap*>(heap())->freeLargeObjectPage(this);
 }
 
 FreeList::FreeList()
     : m_biggestFreeListIndex(0)
 {
 }
 
-ThreadHeap::ThreadHeap(ThreadState* state, int index)
+BaseHeap::BaseHeap(ThreadState* state, int index)
     : m_firstPage(nullptr)
     , m_firstUnsweptPage(nullptr)
     , m_threadState(state)
     , m_index(index)
 #if ENABLE(GC_PROFILING)
     , m_cumulativeAllocationSize(0)
     , m_allocationCount(0)
     , m_inlineAllocationCount(0)
 #endif
 {
 }
 
-ThreadHeapForHeapPage::ThreadHeapForHeapPage(ThreadState* state, int index)
-    : ThreadHeap(state, index)
+NormalPageHeap::NormalPageHeap(ThreadState* state, int index)
+    : BaseHeap(state, index)
     , m_currentAllocationPoint(nullptr)
     , m_remainingAllocationSize(0)
     , m_lastRemainingAllocationSize(0)
     , m_promptlyFreedSize(0)
 {
     clearFreeLists();
 }
 
-ThreadHeapForLargeObject::ThreadHeapForLargeObject(ThreadState* state, int index)
-    : ThreadHeap(state, index)
+LargeObjectHeap::LargeObjectHeap(ThreadState* state, int index)
+    : BaseHeap(state, index)
 {
 }
 
-ThreadHeap::~ThreadHeap()
+BaseHeap::~BaseHeap()
 {
     ASSERT(!m_firstPage);
     ASSERT(!m_firstUnsweptPage);
 }
 
-void ThreadHeap::cleanupPages()
+void BaseHeap::cleanupPages()
 {
     clearFreeLists();
 
     ASSERT(!m_firstUnsweptPage);
-    // Add the ThreadHeap's pages to the orphanedPagePool.
-    for (BaseHeapPage* page = m_firstPage; page; page = page->next()) {
+    // Add the BaseHeap's pages to the orphanedPagePool.
+    for (BasePage* page = m_firstPage; page; page = page->next()) {
         Heap::decreaseAllocatedSpace(page->size());
         Heap::orphanedPagePool()->addOrphanedPage(heapIndex(), page);
     }
     m_firstPage = nullptr;
 }
 
-void ThreadHeapForHeapPage::updateRemainingAllocationSize()
+void NormalPageHeap::updateRemainingAllocationSize()
 {
     if (m_lastRemainingAllocationSize > remainingAllocationSize()) {
         Heap::increaseAllocatedObjectSize(m_lastRemainingAllocationSize - remainingAllocationSize());
         m_lastRemainingAllocationSize = remainingAllocationSize();
     }
     ASSERT(m_lastRemainingAllocationSize == remainingAllocationSize());
 }
 
-void ThreadHeapForHeapPage::setAllocationPoint(Address point, size_t size)
+void NormalPageHeap::setAllocationPoint(Address point, size_t size)
 {
 #if ENABLE(ASSERT)
     if (point) {
         ASSERT(size);
-        BaseHeapPage* page = pageFromObject(point);
-        ASSERT(!page->isLargeObject());
-        ASSERT(size <= static_cast<HeapPage*>(page)->payloadSize());
+        BasePage* page = pageFromObject(point);
+        ASSERT(!page->isLargeObjectPage());
+        ASSERT(size <= static_cast<NormalPage*>(page)->payloadSize());
     }
 #endif
     if (hasCurrentAllocationArea()) {
         addToFreeList(currentAllocationPoint(), remainingAllocationSize());
     }
     updateRemainingAllocationSize();
     m_currentAllocationPoint = point;
     m_lastRemainingAllocationSize = m_remainingAllocationSize = size;
 }
 
-Address ThreadHeapForHeapPage::outOfLineAllocate(size_t allocationSize, size_t gcInfoIndex)
+Address NormalPageHeap::outOfLineAllocate(size_t allocationSize, size_t gcInfoIndex)
 {
     ASSERT(allocationSize > remainingAllocationSize());
     ASSERT(allocationSize >= allocationGranularity);
 
 #if ENABLE(GC_PROFILING)
     m_threadState->snapshotFreeListIfNecessary();
 #endif
 
     // 1. If this allocation is big enough, allocate a large object.
     if (allocationSize >= largeObjectSizeThreshold)
-        return static_cast<ThreadHeapForLargeObject*>(threadState()->heap(LargeObjectHeap))->allocateLargeObject(allocationSize, gcInfoIndex);
+        return static_cast<LargeObjectHeap*>(threadState()->heap(LargeObjectHeapIndex))->allocateLargeObjectPage(allocationSize, gcInfoIndex);
 
     // 2. Check if we should trigger a GC.
     updateRemainingAllocationSize();
     threadState()->scheduleGCIfNeeded();
 
     // 3. Try to allocate from a free list.
     Address result = allocateFromFreeList(allocationSize, gcInfoIndex);
     if (result)
         return result;
 
@@ skipping 19 matching lines @@
 
     // 8. Add a new page to this heap.
     allocatePage();
 
     // 9. Try to allocate from a free list. This allocation must succeed.
     result = allocateFromFreeList(allocationSize, gcInfoIndex);
     RELEASE_ASSERT(result);
     return result;
 }
 
-Address ThreadHeapForHeapPage::allocateFromFreeList(size_t allocationSize, size_t gcInfoIndex)
+Address NormalPageHeap::allocateFromFreeList(size_t allocationSize, size_t gcInfoIndex)
 {
     // Try reusing a block from the largest bin. The underlying reasoning
     // being that we want to amortize this slow allocation call by carving
     // off as a large a free block as possible in one go; a block that will
     // service this block and let following allocations be serviced quickly
     // by bump allocation.
     size_t bucketSize = 1 << m_freeList.m_biggestFreeListIndex;
     int index = m_freeList.m_biggestFreeListIndex;
     for (; index > 0; --index, bucketSize >>= 1) {
         FreeListEntry* entry = m_freeList.m_freeLists[index];
@@ skipping 10 matching lines @@
             ASSERT(hasCurrentAllocationArea());
             ASSERT(remainingAllocationSize() >= allocationSize);
             m_freeList.m_biggestFreeListIndex = index;
             return allocateObject(allocationSize, gcInfoIndex);
         }
     }
     m_freeList.m_biggestFreeListIndex = index;
     return nullptr;
 }
 
-void ThreadHeap::prepareForSweep()
+void BaseHeap::prepareForSweep()
 {
     ASSERT(!threadState()->isInGC());
     ASSERT(!m_firstUnsweptPage);
 
     // Move all pages to a list of unswept pages.
     m_firstUnsweptPage = m_firstPage;
     m_firstPage = nullptr;
 }
 
-Address ThreadHeap::lazySweep(size_t allocationSize, size_t gcInfoIndex)
+Address BaseHeap::lazySweep(size_t allocationSize, size_t gcInfoIndex)
 {
     // If there are no pages to be swept, return immediately.
     if (!m_firstUnsweptPage)
         return nullptr;
 
     RELEASE_ASSERT(threadState()->isSweepingInProgress());
 
     // lazySweepPages() can be called recursively if finalizers invoked in
     // page->sweep() allocate memory and the allocation triggers
     // lazySweepPages(). This check prevents the sweeping from being executed
     // recursively.
     if (threadState()->sweepForbidden())
         return nullptr;
 
-    TRACE_EVENT0("blink_gc", "ThreadHeap::lazySweepPages");
+    TRACE_EVENT0("blink_gc", "BaseHeap::lazySweepPages");
     ThreadState::SweepForbiddenScope scope(threadState());
 
     if (threadState()->isMainThread())
         ScriptForbiddenScope::enter();
 
     Address result = lazySweepPages(allocationSize, gcInfoIndex);
 
     if (threadState()->isMainThread())
         ScriptForbiddenScope::exit();
     return result;
 }
 
-Address ThreadHeapForHeapPage::lazySweepPages(size_t allocationSize, size_t gcInfoIndex)
+Address NormalPageHeap::lazySweepPages(size_t allocationSize, size_t gcInfoIndex)
 {
     ASSERT(!hasCurrentAllocationArea());
     Address result = nullptr;
     while (m_firstUnsweptPage) {
-        BaseHeapPage* page = m_firstUnsweptPage;
+        BasePage* page = m_firstUnsweptPage;
         if (page->isEmpty()) {
             page->unlink(&m_firstUnsweptPage);
             page->removeFromHeap();
         } else {
             // Sweep a page and move the page from m_firstUnsweptPages to
             // m_firstPages.
             page->sweep();
             page->unlink(&m_firstUnsweptPage);
             page->link(&m_firstPage);
             page->markAsSwept();
 
-            // For HeapPage, stop lazy sweeping once we find a slot to
+            // For NormalPage, stop lazy sweeping once we find a slot to
             // allocate a new object.
             result = allocateFromFreeList(allocationSize, gcInfoIndex);
             if (result)
                 break;
         }
     }
     return result;
 }
 
-Address ThreadHeapForLargeObject::lazySweepPages(size_t allocationSize, size_t gcInfoIndex)
+Address LargeObjectHeap::lazySweepPages(size_t allocationSize, size_t gcInfoIndex)
 {
     Address result = nullptr;
     size_t sweptSize = 0;
     while (m_firstUnsweptPage) {
-        BaseHeapPage* page = m_firstUnsweptPage;
+        BasePage* page = m_firstUnsweptPage;
         if (page->isEmpty()) {
-            sweptSize += static_cast<LargeObject*>(page)->payloadSize() + sizeof(HeapObjectHeader);
+            sweptSize += static_cast<LargeObjectPage*>(page)->payloadSize() + sizeof(HeapObjectHeader);
             page->unlink(&m_firstUnsweptPage);
             page->removeFromHeap();
-            // For LargeObject, stop lazy sweeping once we have swept
+            // For LargeObjectPage, stop lazy sweeping once we have swept
             // more than allocationSize bytes.
             if (sweptSize >= allocationSize) {
-                result = doAllocateLargeObject(allocationSize, gcInfoIndex);
+                result = doAllocateLargeObjectPage(allocationSize, gcInfoIndex);
                 ASSERT(result);
                 break;
             }
         } else {
             // Sweep a page and move the page from m_firstUnsweptPages to
             // m_firstPages.
             page->sweep();
             page->unlink(&m_firstUnsweptPage);
             page->link(&m_firstPage);
             page->markAsSwept();
         }
     }
     return result;
 }
 
-void ThreadHeap::completeSweep()
+void BaseHeap::completeSweep()
 {
     RELEASE_ASSERT(threadState()->isSweepingInProgress());
     ASSERT(threadState()->sweepForbidden());
 
     if (threadState()->isMainThread())
         ScriptForbiddenScope::enter();
 
     while (m_firstUnsweptPage) {
-        BaseHeapPage* page = m_firstUnsweptPage;
+        BasePage* page = m_firstUnsweptPage;
         if (page->isEmpty()) {
             page->unlink(&m_firstUnsweptPage);
             page->removeFromHeap();
         } else {
             // Sweep a page and move the page from m_firstUnsweptPages to
             // m_firstPages.
             page->sweep();
             page->unlink(&m_firstUnsweptPage);
             page->link(&m_firstPage);
             page->markAsSwept();
         }
     }
 
     if (threadState()->isMainThread())
         ScriptForbiddenScope::exit();
 }
 
 #if ENABLE(ASSERT)
-BaseHeapPage* ThreadHeap::findPageFromAddress(Address address)
+BasePage* BaseHeap::findPageFromAddress(Address address)
 {
-    for (BaseHeapPage* page = m_firstPage; page; page = page->next()) {
+    for (BasePage* page = m_firstPage; page; page = page->next()) {
         if (page->contains(address))
             return page;
     }
-    for (BaseHeapPage* page = m_firstUnsweptPage; page; page = page->next()) {
+    for (BasePage* page = m_firstUnsweptPage; page; page = page->next()) {
         if (page->contains(address))
             return page;
     }
     return nullptr;
 }
 #endif
 
 #if ENABLE(GC_PROFILING)
 #define GC_PROFILE_HEAP_PAGE_SNAPSHOT_THRESHOLD 0
-void ThreadHeap::snapshot(TracedValue* json, ThreadState::SnapshotInfo* info)
+void BaseHeap::snapshot(TracedValue* json, ThreadState::SnapshotInfo* info)
 {
     ASSERT(isConsistentForSweeping());
     size_t previousPageCount = info->pageCount;
 
     json->beginArray("pages");
-    for (BaseHeapPage* page = m_firstPage; page; page = page->next(), ++info->pageCount) {
+    for (BasePage* page = m_firstPage; page; page = page->next(), ++info->pageCount) {
         // FIXME: To limit the size of the snapshot we only output "threshold" many page snapshots.
         if (info->pageCount < GC_PROFILE_HEAP_PAGE_SNAPSHOT_THRESHOLD) {
             json->beginArray();
             json->pushInteger(reinterpret_cast<intptr_t>(page));
             page->snapshot(json, info);
             json->endArray();
         } else {
             page->snapshot(0, info);
         }
     }
     json->endArray();
 
     json->setInteger("pageCount", info->pageCount - previousPageCount);
 }
 
-void ThreadHeap::incrementMarkedObjectsAge()
+void BaseHeap::incrementMarkedObjectsAge()
 {
-    for (HeapPage* page = m_firstPage; page; page = page->next())
+    for (NormalPage* page = m_firstPage; page; page = page->next())
         page->incrementMarkedObjectsAge();
-    for (LargeObject* largeObject = m_firstLargeObject; largeObject; largeObject = largeObject->next())
+    for (LargeObjectPage* largeObject = m_firstLargeObjectPage; largeObject; largeObject = largeObject->next())
         largeObject->incrementMarkedObjectsAge();
 }
 #endif
 
 void FreeList::addToFreeList(Address address, size_t size)
 {
     ASSERT(size < blinkPagePayloadSize());
     // The free list entries are only pointer aligned (but when we allocate
     // from them we are 8 byte aligned due to the header size).
     ASSERT(!((reinterpret_cast<uintptr_t>(address) + sizeof(HeapObjectHeader)) & allocationMask));
     ASSERT(!(size & allocationMask));
     ASAN_POISON_MEMORY_REGION(address, size);
     FreeListEntry* entry;
     if (size < sizeof(*entry)) {
         // Create a dummy header with only a size and freelist bit set.
         ASSERT(size >= sizeof(HeapObjectHeader));
         // Free list encode the size to mark the lost memory as freelist memory.
         new (NotNull, address) HeapObjectHeader(size, gcInfoIndexForFreeListHeader);
         // This memory gets lost. Sweeping can reclaim it.
         return;
     }
     entry = new (NotNull, address) FreeListEntry(size);
 #if defined(ADDRESS_SANITIZER)
-    BaseHeapPage* page = pageFromObject(address);
-    ASSERT(!page->isLargeObject());
+    BasePage* page = pageFromObject(address);
+    ASSERT(!page->isLargeObjectPage());
     // For ASan we don't add the entry to the free lists until the
     // asanDeferMemoryReuseCount reaches zero.  However we always add entire
     // pages to ensure that adding a new page will increase the allocation
     // space.
-    if (static_cast<HeapPage*>(page)->payloadSize() != size && !entry->shouldAddToFreeList())
+    if (static_cast<NormalPage*>(page)->payloadSize() != size && !entry->shouldAddToFreeList())
         return;
 #endif
     int index = bucketIndexForSize(size);
     entry->link(&m_freeLists[index]);
     if (index > m_biggestFreeListIndex)
         m_biggestFreeListIndex = index;
 }
 
-bool ThreadHeapForHeapPage::expandObject(HeapObjectHeader* header, size_t newSize)
+bool NormalPageHeap::expandObject(HeapObjectHeader* header, size_t newSize)
 {
     // It's possible that Vector requests a smaller expanded size because
     // Vector::shrinkCapacity can set a capacity smaller than the actual payload
     // size.
     if (header->payloadSize() >= newSize)
         return true;
     size_t allocationSize = allocationSizeFromSize(newSize);
     ASSERT(allocationSize > header->size());
     size_t expandSize = allocationSize - header->size();
     if (header->payloadEnd() == m_currentAllocationPoint && expandSize <= m_remainingAllocationSize) {
         m_currentAllocationPoint += expandSize;
         m_remainingAllocationSize -= expandSize;
 
         // Unpoison the memory used for the object (payload).
         ASAN_UNPOISON_MEMORY_REGION(header->payloadEnd(), expandSize);
         FILL_ZERO_IF_NOT_PRODUCTION(header->payloadEnd(), expandSize);
         header->setSize(allocationSize);
         ASSERT(findPageFromAddress(header->payloadEnd() - 1));
         return true;
     }
     return false;
 }
 
-void ThreadHeapForHeapPage::shrinkObject(HeapObjectHeader* header, size_t newSize)
+void NormalPageHeap::shrinkObject(HeapObjectHeader* header, size_t newSize)
 {
     ASSERT(header->payloadSize() > newSize);
     size_t allocationSize = allocationSizeFromSize(newSize);
     ASSERT(header->size() > allocationSize);
     size_t shrinkSize = header->size() - allocationSize;
     if (header->payloadEnd() == m_currentAllocationPoint) {
         m_currentAllocationPoint -= shrinkSize;
         m_remainingAllocationSize += shrinkSize;
         FILL_ZERO_IF_PRODUCTION(m_currentAllocationPoint, shrinkSize);
         ASAN_POISON_MEMORY_REGION(m_currentAllocationPoint, shrinkSize);
         header->setSize(allocationSize);
     } else {
         ASSERT(shrinkSize >= sizeof(HeapObjectHeader));
         ASSERT(header->gcInfoIndex() > 0);
         HeapObjectHeader* freedHeader = new (NotNull, header->payloadEnd() - shrinkSize) HeapObjectHeader(shrinkSize, header->gcInfoIndex());
         freedHeader->markPromptlyFreed();
         ASSERT(pageFromObject(reinterpret_cast<Address>(header)) == findPageFromAddress(reinterpret_cast<Address>(header)));
         m_promptlyFreedSize += shrinkSize;
         header->setSize(allocationSize);
     }
 }
 
-void ThreadHeapForHeapPage::promptlyFreeObject(HeapObjectHeader* header)
+void NormalPageHeap::promptlyFreeObject(HeapObjectHeader* header)
 {
     ASSERT(!threadState()->sweepForbidden());
     header->checkHeader();
     Address address = reinterpret_cast<Address>(header);
     Address payload = header->payload();
     size_t size = header->size();
     size_t payloadSize = header->payloadSize();
     ASSERT(size > 0);
     ASSERT(pageFromObject(address) == findPageFromAddress(address));
 
@@ skipping 11 matching lines @@
             ASAN_POISON_MEMORY_REGION(address, size);
             return;
         }
         FILL_ZERO_IF_PRODUCTION(payload, payloadSize);
         header->markPromptlyFreed();
     }
 
     m_promptlyFreedSize += size;
 }
 
-bool ThreadHeapForHeapPage::coalesce()
+bool NormalPageHeap::coalesce()
 {
     // Don't coalesce heaps if there are not enough promptly freed entries
     // to be coalesced.
     //
     // FIXME: This threshold is determined just to optimize blink_perf
     // benchmarks. Coalescing is very sensitive to the threashold and
     // we need further investigations on the coalescing scheme.
     if (m_promptlyFreedSize < 1024 * 1024)
         return false;
 
     if (threadState()->sweepForbidden())
         return false;
 
     ASSERT(!hasCurrentAllocationArea());
-    TRACE_EVENT0("blink_gc", "ThreadHeap::coalesce");
+    TRACE_EVENT0("blink_gc", "BaseHeap::coalesce");
 
     // Rebuild free lists.
     m_freeList.clear();
     size_t freedSize = 0;
-    for (HeapPage* page = static_cast<HeapPage*>(m_firstPage); page; page = static_cast<HeapPage*>(page->next())) {
+    for (NormalPage* page = static_cast<NormalPage*>(m_firstPage); page; page = static_cast<NormalPage*>(page->next())) {
         page->clearObjectStartBitMap();
         Address startOfGap = page->payload();
         for (Address headerAddress = startOfGap; headerAddress < page->payloadEnd(); ) {
             HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(headerAddress);
             size_t size = header->size();
             ASSERT(size > 0);
             ASSERT(size < blinkPagePayloadSize());
 
             if (header->isPromptlyFreed()) {
                 ASSERT(size >= sizeof(HeapObjectHeader));
@@ skipping 20 matching lines @@
 
         if (startOfGap != page->payloadEnd())
             addToFreeList(startOfGap, page->payloadEnd() - startOfGap);
     }
     Heap::decreaseAllocatedObjectSize(freedSize);
     ASSERT(m_promptlyFreedSize == freedSize);
     m_promptlyFreedSize = 0;
     return true;
 }
 
-Address ThreadHeapForLargeObject::allocateLargeObject(size_t allocationSize, size_t gcInfoIndex)
+Address LargeObjectHeap::allocateLargeObjectPage(size_t allocationSize, size_t gcInfoIndex)
 {
     // Caller already added space for object header and rounded up to allocation
     // alignment
     ASSERT(!(allocationSize & allocationMask));
 
     // 1. Check if we should trigger a GC.
     threadState()->scheduleGCIfNeeded();
 
     // 2. Try to sweep large objects more than allocationSize bytes
     // before allocating a new large object.
     Address result = lazySweep(allocationSize, gcInfoIndex);
     if (result)
         return result;
 
     // 3. If we have failed in sweeping allocationSize bytes,
     // we complete sweeping before allocating this large object.
     threadState()->completeSweep();
-    return doAllocateLargeObject(allocationSize, gcInfoIndex);
+    return doAllocateLargeObjectPage(allocationSize, gcInfoIndex);
 }
 
-Address ThreadHeapForLargeObject::doAllocateLargeObject(size_t allocationSize, size_t gcInfoIndex)
+Address LargeObjectHeap::doAllocateLargeObjectPage(size_t allocationSize, size_t gcInfoIndex)
 {
-    size_t largeObjectSize = sizeof(LargeObject) + LargeObject::headerPadding() + allocationSize;
+    size_t largeObjectSize = sizeof(LargeObjectPage) + LargeObjectPage::headerPadding() + allocationSize;
     // If ASan is supported we add allocationGranularity bytes to the allocated
     // space and poison that to detect overflows
 #if defined(ADDRESS_SANITIZER)
     largeObjectSize += allocationGranularity;
 #endif
 
     threadState()->shouldFlushHeapDoesNotContainCache();
     PageMemory* pageMemory = PageMemory::allocate(largeObjectSize);
     threadState()->allocatedRegionsSinceLastGC().append(pageMemory->region());
     Address largeObjectAddress = pageMemory->writableStart();
-    Address headerAddress = largeObjectAddress + sizeof(LargeObject) + LargeObject::headerPadding();
+    Address headerAddress = largeObjectAddress + sizeof(LargeObjectPage) + LargeObjectPage::headerPadding();
 #if ENABLE(ASSERT)
     // Verify that the allocated PageMemory is expectedly zeroed.
     for (size_t i = 0; i < largeObjectSize; ++i)
         ASSERT(!headerAddress[i]);
 #endif
     ASSERT(gcInfoIndex > 0);
     HeapObjectHeader* header = new (NotNull, headerAddress) HeapObjectHeader(largeObjectSizeInHeader, gcInfoIndex);
     Address result = headerAddress + sizeof(*header);
     ASSERT(!(reinterpret_cast<uintptr_t>(result) & allocationMask));
-    LargeObject* largeObject = new (largeObjectAddress) LargeObject(pageMemory, this, allocationSize);
+    LargeObjectPage* largeObject = new (largeObjectAddress) LargeObjectPage(pageMemory, this, allocationSize);
     header->checkHeader();
 
     // Poison the object header and allocationGranularity bytes after the object
     ASAN_POISON_MEMORY_REGION(header, sizeof(*header));
     ASAN_POISON_MEMORY_REGION(largeObject->address() + largeObject->size(), allocationGranularity);
 
     largeObject->link(&m_firstPage);
 
     Heap::increaseAllocatedSpace(largeObject->size());
     Heap::increaseAllocatedObjectSize(largeObject->size());
     return result;
 }
 
-void ThreadHeapForLargeObject::freeLargeObject(LargeObject* object)
+void LargeObjectHeap::freeLargeObjectPage(LargeObjectPage* object)
 {
     object->heapObjectHeader()->finalize(object->payload(), object->payloadSize());
     Heap::decreaseAllocatedSpace(object->size());
 
     // Unpoison the object header and allocationGranularity bytes after the
     // object before freeing.
     ASAN_UNPOISON_MEMORY_REGION(object->heapObjectHeader(), sizeof(HeapObjectHeader));
     ASAN_UNPOISON_MEMORY_REGION(object->address() + object->size(), allocationGranularity);
 
     if (object->terminating()) {
         ASSERT(ThreadState::current()->isTerminating());
         // The thread is shutting down and this page is being removed as a part
         // of the thread local GC.  In that case the object could be traced in
         // the next global GC if there is a dangling pointer from a live thread
         // heap to this dead thread heap.  To guard against this, we put the
         // page into the orphaned page pool and zap the page memory.  This
         // ensures that tracing the dangling pointer in the next global GC just
         // crashes instead of causing use-after-frees.  After the next global
         // GC, the orphaned pages are removed.
         Heap::orphanedPagePool()->addOrphanedPage(heapIndex(), object);
     } else {
         ASSERT(!ThreadState::current()->isTerminating());
         PageMemory* memory = object->storage();
-        object->~LargeObject();
+        object->~LargeObjectPage();
         delete memory;
     }
 }
 
 template<typename DataType>
 PagePool<DataType>::PagePool()
 {
     for (int i = 0; i < NumberOfHeaps; ++i) {
         m_pool[i] = nullptr;
     }
@@ skipping 33 matching lines @@
         delete entry;
         if (memory->commit())
             return memory;
 
         // We got some memory, but failed to commit it, try again.
         delete memory;
     }
     return nullptr;
 }
 
-BaseHeapPage::BaseHeapPage(PageMemory* storage, ThreadHeap* heap)
+BasePage::BasePage(PageMemory* storage, BaseHeap* heap)
     : m_storage(storage)
     , m_heap(heap)
     , m_next(nullptr)
     , m_terminating(false)
     , m_swept(true)
 {
     ASSERT(isPageHeaderAddress(reinterpret_cast<Address>(this)));
 }
 
-void BaseHeapPage::markOrphaned()
+void BasePage::markOrphaned()
 {
     m_heap = nullptr;
     m_terminating = false;
     // Since we zap the page payload for orphaned pages we need to mark it as
     // unused so a conservative pointer won't interpret the object headers.
     storage()->markUnused();
 }
 
 OrphanedPagePool::~OrphanedPagePool()
 {
     for (int index = 0; index < NumberOfHeaps; ++index) {
         while (PoolEntry* entry = m_pool[index]) {
             m_pool[index] = entry->next;
-            BaseHeapPage* page = entry->data;
+            BasePage* page = entry->data;
             delete entry;
             PageMemory* memory = page->storage();
             ASSERT(memory);
-            page->~BaseHeapPage();
+            page->~BasePage();
             delete memory;
         }
     }
 }
 
-void OrphanedPagePool::addOrphanedPage(int index, BaseHeapPage* page)
+void OrphanedPagePool::addOrphanedPage(int index, BasePage* page)
 {
     page->markOrphaned();
     PoolEntry* entry = new PoolEntry(page, m_pool[index]);
     m_pool[index] = entry;
 }
 
 NO_SANITIZE_ADDRESS
 void OrphanedPagePool::decommitOrphanedPages()
 {
     ASSERT(ThreadState::current()->isInGC());
 
 #if ENABLE(ASSERT)
     // No locking needed as all threads are at safepoints at this point in time.
     for (ThreadState* state : ThreadState::attachedThreads())
         ASSERT(state->isAtSafePoint());
 #endif
 
     for (int index = 0; index < NumberOfHeaps; ++index) {
         PoolEntry* entry = m_pool[index];
         PoolEntry** prevNext = &m_pool[index];
         while (entry) {
-            BaseHeapPage* page = entry->data;
+            BasePage* page = entry->data;
             // Check if we should reuse the memory or just free it.
             // Large object memory is not reused but freed, normal blink heap
             // pages are reused.
             // NOTE: We call the destructor before freeing or adding to the
             // free page pool.
             PageMemory* memory = page->storage();
-            if (page->isLargeObject()) {
-                page->~BaseHeapPage();
+            if (page->isLargeObjectPage()) {
+                page->~BasePage();
                 delete memory;
             } else {
-                page->~BaseHeapPage();
+                page->~BasePage();
                 clearMemory(memory);
                 Heap::freePagePool()->addFreePage(index, memory);
             }
 
             PoolEntry* deadEntry = entry;
             entry = entry->next;
             *prevNext = entry;
             delete deadEntry;
         }
     }
@@ skipping 12 matching lines @@
 #else
     memset(memory->writableStart(), 0, blinkPagePayloadSize());
 #endif
 }
 
 #if ENABLE(ASSERT)
 bool OrphanedPagePool::contains(void* object)
 {
     for (int index = 0; index < NumberOfHeaps; ++index) {
         for (PoolEntry* entry = m_pool[index]; entry; entry = entry->next) {
-            BaseHeapPage* page = entry->data;
+            BasePage* page = entry->data;
             if (page->contains(reinterpret_cast<Address>(object)))
                 return true;
         }
     }
     return false;
 }
 #endif
 
-void ThreadHeapForHeapPage::freePage(HeapPage* page)
+void NormalPageHeap::freePage(NormalPage* page)
 {
     Heap::decreaseAllocatedSpace(page->size());
 
     if (page->terminating()) {
         // The thread is shutting down and this page is being removed as a part
         // of the thread local GC.  In that case the object could be traced in
         // the next global GC if there is a dangling pointer from a live thread
         // heap to this dead thread heap.  To guard against this, we put the
         // page into the orphaned page pool and zap the page memory.  This
         // ensures that tracing the dangling pointer in the next global GC just
         // crashes instead of causing use-after-frees.  After the next global
         // GC, the orphaned pages are removed.
         Heap::orphanedPagePool()->addOrphanedPage(heapIndex(), page);
     } else {
         PageMemory* memory = page->storage();
-        page->~HeapPage();
+        page->~NormalPage();
         Heap::freePagePool()->addFreePage(heapIndex(), memory);
     }
 }
 
-void ThreadHeapForHeapPage::allocatePage()
+void NormalPageHeap::allocatePage()
 {
     threadState()->shouldFlushHeapDoesNotContainCache();
     PageMemory* pageMemory = Heap::freePagePool()->takeFreePage(heapIndex());
     // We continue allocating page memory until we succeed in committing one.
     while (!pageMemory) {
         // Allocate a memory region for blinkPagesPerRegion pages that
         // will each have the following layout.
         //
         //    [ guard os page | ... payload ... | guard os page ]
         //    ^---{ aligned to blink page size }
@@ skipping 10 matching lines @@
                 if (memory->commit())
                     pageMemory = memory;
                 else
                     delete memory;
             } else {
                 Heap::freePagePool()->addFreePage(heapIndex(), memory);
             }
             offset += blinkPageSize;
         }
     }
-    HeapPage* page = new (pageMemory->writableStart()) HeapPage(pageMemory, this);
+    NormalPage* page = new (pageMemory->writableStart()) NormalPage(pageMemory, this);
     page->link(&m_firstPage);
 
     Heap::increaseAllocatedSpace(page->size());
     addToFreeList(page->payload(), page->payloadSize());
 }
 
 #if ENABLE(ASSERT)
-bool ThreadHeapForHeapPage::pagesToBeSweptContains(Address address)
+bool NormalPageHeap::pagesToBeSweptContains(Address address)
 {
-    for (BaseHeapPage* page = m_firstUnsweptPage; page; page = page->next()) {
+    for (BasePage* page = m_firstUnsweptPage; page; page = page->next()) {
         if (page->contains(address))
             return true;
     }
     return false;
 }
 #endif
 
-size_t ThreadHeap::objectPayloadSizeForTesting()
+size_t BaseHeap::objectPayloadSizeForTesting()
 {
     ASSERT(isConsistentForSweeping());
     ASSERT(!m_firstUnsweptPage);
 
     size_t objectPayloadSize = 0;
-    for (BaseHeapPage* page = m_firstPage; page; page = page->next())
+    for (BasePage* page = m_firstPage; page; page = page->next())
         objectPayloadSize += page->objectPayloadSizeForTesting();
     return objectPayloadSize;
 }
 
 #if ENABLE(ASSERT)
-bool ThreadHeapForHeapPage::isConsistentForSweeping()
+bool NormalPageHeap::isConsistentForSweeping()
 {
     // A thread heap is consistent for sweeping if none of the pages to be swept
     // contain a freelist block or the current allocation point.
     for (size_t i = 0; i < blinkPageSizeLog2; ++i) {
         for (FreeListEntry* freeListEntry = m_freeList.m_freeLists[i]; freeListEntry; freeListEntry = freeListEntry->next()) {
             if (pagesToBeSweptContains(freeListEntry->address()))
                 return false;
         }
     }
     if (hasCurrentAllocationArea()) {
         if (pagesToBeSweptContains(currentAllocationPoint()))
             return false;
     }
     return true;
 }
 #endif
 
-void ThreadHeap::makeConsistentForSweeping()
+void BaseHeap::makeConsistentForSweeping()
 {
     clearFreeLists();
     ASSERT(isConsistentForSweeping());
-    for (BaseHeapPage* page = m_firstPage; page; page = page->next())
+    for (BasePage* page = m_firstPage; page; page = page->next())
         page->markAsUnswept();
 
     // If a new GC is requested before this thread got around to sweep,
     // ie. due to the thread doing a long running operation, we clear
     // the mark bits and mark any of the dead objects as dead. The latter
     // is used to ensure the next GC marking does not trace already dead
     // objects. If we trace a dead object we could end up tracing into
     // garbage or the middle of another object via the newly conservatively
     // found object.
-    BaseHeapPage* previousPage = nullptr;
-    for (BaseHeapPage* page = m_firstUnsweptPage; page; previousPage = page, page = page->next()) {
+    BasePage* previousPage = nullptr;
+    for (BasePage* page = m_firstUnsweptPage; page; previousPage = page, page = page->next()) {
         page->markUnmarkedObjectsDead();
         ASSERT(!page->hasBeenSwept());
     }
     if (previousPage) {
         ASSERT(m_firstUnsweptPage);
         previousPage->m_next = m_firstPage;
         m_firstPage = m_firstUnsweptPage;
         m_firstUnsweptPage = nullptr;
     }
     ASSERT(!m_firstUnsweptPage);
 }
 
-void ThreadHeapForHeapPage::clearFreeLists()
+void NormalPageHeap::clearFreeLists()
 {
     setAllocationPoint(nullptr, 0);
     m_freeList.clear();
 }
 
 #if ENABLE(GC_PROFILING)
-void ThreadHeap::snapshotFreeList(TracedValue& json)
+void BaseHeap::snapshotFreeList(TracedValue& json)
 {
     json.setInteger("cumulativeAllocationSize", m_cumulativeAllocationSize);
     json.setDouble("inlineAllocationRate", static_cast<double>(m_inlineAllocationCount) / m_allocationCount);
     json.setInteger("inlineAllocationCount", m_inlineAllocationCount);
     json.setInteger("allocationCount", m_allocationCount);
     size_t pageCount = 0;
     size_t totalPageSize = 0;
-    for (HeapPage* page = m_firstPage; page; page = page->next()) {
+    for (NormalPage* page = m_firstPage; page; page = page->next()) {
         ++pageCount;
         totalPageSize += page->payloadSize();
     }
     json.setInteger("pageCount", pageCount);
     json.setInteger("totalPageSize", totalPageSize);
 
     FreeList::PerBucketFreeListStats bucketStats[blinkPageSizeLog2];
     size_t totalFreeSize;
     m_freeList.getFreeSizeStats(bucketStats, totalFreeSize);
     json.setInteger("totalFreeSize", totalFreeSize);
 
     json.beginArray("perBucketEntryCount");
     for (size_t i = 0; i < blinkPageSizeLog2; ++i)
         json.pushInteger(bucketStats[i].entryCount);
     json.endArray();
 
     json.beginArray("perBucketFreeSize");
     for (size_t i = 0; i < blinkPageSizeLog2; ++i)
         json.pushInteger(bucketStats[i].freeSize);
     json.endArray();
 }
 
-void ThreadHeap::countMarkedObjects(ClassAgeCountsMap& classAgeCounts) const
+void BaseHeap::countMarkedObjects(ClassAgeCountsMap& classAgeCounts) const
 {
-    for (HeapPage* page = m_firstPage; page; page = page->next())
+    for (NormalPage* page = m_firstPage; page; page = page->next())
         page->countMarkedObjects(classAgeCounts);
-    for (LargeObject* largeObject = m_firstLargeObject; largeObject; largeObject = largeObject->next())
+    for (LargeObjectPage* largeObject = m_firstLargeObjectPage; largeObject; largeObject = largeObject->next())
         largeObject->countMarkedObjects(classAgeCounts);
 }
 
-void ThreadHeap::countObjectsToSweep(ClassAgeCountsMap& classAgeCounts) const
+void BaseHeap::countObjectsToSweep(ClassAgeCountsMap& classAgeCounts) const
 {
-    for (HeapPage* page = m_firstPage; page; page = page->next())
+    for (NormalPage* page = m_firstPage; page; page = page->next())
         page->countObjectsToSweep(classAgeCounts);
-    for (LargeObject* largeObject = m_firstLargeObject; largeObject; largeObject = largeObject->next())
+    for (LargeObjectPage* largeObject = m_firstLargeObjectPage; largeObject; largeObject = largeObject->next())
         largeObject->countObjectsToSweep(classAgeCounts);
 }
 #endif
 
 void FreeList::clear()
 {
     m_biggestFreeListIndex = 0;
     for (size_t i = 0; i < blinkPageSizeLog2; ++i)
         m_freeLists[i] = nullptr;
 }
@@ skipping 18 matching lines @@
         size_t& freeSize = bucketStats[i].freeSize;
         for (FreeListEntry* entry = m_freeLists[i]; entry; entry = entry->next()) {
             ++entryCount;
             freeSize += entry->size();
         }
         totalFreeSize += freeSize;
     }
 }
 #endif
 
-HeapPage::HeapPage(PageMemory* storage, ThreadHeap* heap)
-    : BaseHeapPage(storage, heap)
+NormalPage::NormalPage(PageMemory* storage, BaseHeap* heap)
+    : BasePage(storage, heap)
 {
     m_objectStartBitMapComputed = false;
     ASSERT(isPageHeaderAddress(reinterpret_cast<Address>(this)));
 }
 
-size_t HeapPage::objectPayloadSizeForTesting()
+size_t NormalPage::objectPayloadSizeForTesting()
 {
     size_t objectPayloadSize = 0;
     Address headerAddress = payload();
     markAsSwept();
     ASSERT(headerAddress != payloadEnd());
     do {
         HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(headerAddress);
         if (!header->isFree()) {
             header->checkHeader();
             objectPayloadSize += header->payloadSize();
         }
         ASSERT(header->size() < blinkPagePayloadSize());
         headerAddress += header->size();
         ASSERT(headerAddress <= payloadEnd());
     } while (headerAddress < payloadEnd());
     return objectPayloadSize;
 }
 
-bool HeapPage::isEmpty()
+bool NormalPage::isEmpty()
 {
     HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(payload());
     return header->isFree() && header->size() == payloadSize();
 }
 
-void HeapPage::sweep()
+void NormalPage::sweep()
 {
     clearObjectStartBitMap();
 
     size_t markedObjectSize = 0;
     Address startOfGap = payload();
     for (Address headerAddress = startOfGap; headerAddress < payloadEnd(); ) {
         HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(headerAddress);
         ASSERT(header->size() > 0);
         ASSERT(header->size() < blinkPagePayloadSize());
 
         if (header->isPromptlyFreed())
-            heapForHeapPage()->decreasePromptlyFreedSize(header->size());
+            heapForNormalPage()->decreasePromptlyFreedSize(header->size());
         if (header->isFree()) {
             size_t size = header->size();
             // Zero the memory in the free list header to maintain the
             // invariant that memory on the free list is zero filled.
             // The rest of the memory is already on the free list and is
             // therefore already zero filled.
             FILL_ZERO_IF_PRODUCTION(headerAddress, size < sizeof(FreeListEntry) ? size : sizeof(FreeListEntry));
             headerAddress += size;
             continue;
         }
@@ skipping 12 matching lines @@
             header->finalize(payload, payloadSize);
             // This memory will be added to the freelist. Maintain the invariant
             // that memory on the freelist is zero filled.
             FILL_ZERO_IF_PRODUCTION(headerAddress, size);
             ASAN_POISON_MEMORY_REGION(payload, payloadSize);
             headerAddress += size;
             continue;
         }
 
         if (startOfGap != headerAddress)
-            heapForHeapPage()->addToFreeList(startOfGap, headerAddress - startOfGap);
+            heapForNormalPage()->addToFreeList(startOfGap, headerAddress - startOfGap);
         header->unmark();
         headerAddress += header->size();
         markedObjectSize += header->size();
         startOfGap = headerAddress;
     }
     if (startOfGap != payloadEnd())
-        heapForHeapPage()->addToFreeList(startOfGap, payloadEnd() - startOfGap);
+        heapForNormalPage()->addToFreeList(startOfGap, payloadEnd() - startOfGap);
 
     if (markedObjectSize)
         Heap::increaseMarkedObjectSize(markedObjectSize);
 }
 
-void HeapPage::markUnmarkedObjectsDead()
+void NormalPage::markUnmarkedObjectsDead()
 {
     for (Address headerAddress = payload(); headerAddress < payloadEnd();) {
         HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(headerAddress);
         ASSERT(header->size() < blinkPagePayloadSize());
         // Check if a free list entry first since we cannot call
         // isMarked on a free list entry.
         if (header->isFree()) {
             headerAddress += header->size();
             continue;
         }
         header->checkHeader();
         if (header->isMarked())
             header->unmark();
         else
             header->markDead();
         headerAddress += header->size();
     }
 }
 
-void HeapPage::removeFromHeap()
+void NormalPage::removeFromHeap()
 {
-    heapForHeapPage()->freePage(this);
+    heapForNormalPage()->freePage(this);
 }
 
-ThreadHeapForHeapPage* HeapPage::heapForHeapPage()
+NormalPageHeap* NormalPage::heapForNormalPage()
 {
-    return static_cast<ThreadHeapForHeapPage*>(heap());
+    return static_cast<NormalPageHeap*>(heap());
 }
 
-void HeapPage::populateObjectStartBitMap()
+void NormalPage::populateObjectStartBitMap()
 {
     memset(&m_objectStartBitMap, 0, objectStartBitMapSize);
     Address start = payload();
     for (Address headerAddress = start; headerAddress < payloadEnd();) {
         HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(headerAddress);
         size_t objectOffset = headerAddress - start;
         ASSERT(!(objectOffset & allocationMask));
         size_t objectStartNumber = objectOffset / allocationGranularity;
         size_t mapIndex = objectStartNumber / 8;
         ASSERT(mapIndex < objectStartBitMapSize);
         m_objectStartBitMap[mapIndex] |= (1 << (objectStartNumber & 7));
         headerAddress += header->size();
         ASSERT(headerAddress <= payloadEnd());
     }
     m_objectStartBitMapComputed = true;
 }
 
-void HeapPage::clearObjectStartBitMap()
+void NormalPage::clearObjectStartBitMap()
 {
     m_objectStartBitMapComputed = false;
 }
 
 static int numberOfLeadingZeroes(uint8_t byte)
 {
     if (!byte)
         return 8;
     int result = 0;
     if (byte <= 0x0F) {
         result += 4;
         byte = byte << 4;
     }
     if (byte <= 0x3F) {
         result += 2;
         byte = byte << 2;
     }
     if (byte <= 0x7F)
         result++;
     return result;
 }
 
-HeapObjectHeader* HeapPage::findHeaderFromAddress(Address address)
+HeapObjectHeader* NormalPage::findHeaderFromAddress(Address address)
 {
     if (address < payload())
         return nullptr;
     if (!isObjectStartBitMapComputed())
         populateObjectStartBitMap();
     size_t objectOffset = address - payload();
     size_t objectStartNumber = objectOffset / allocationGranularity;
     size_t mapIndex = objectStartNumber / 8;
     ASSERT(mapIndex < objectStartBitMapSize);
     size_t bit = objectStartNumber & 7;
     uint8_t byte = m_objectStartBitMap[mapIndex] & ((1 << (bit + 1)) - 1);
     while (!byte) {
         ASSERT(mapIndex > 0);
         byte = m_objectStartBitMap[--mapIndex];
     }
     int leadingZeroes = numberOfLeadingZeroes(byte);
     objectStartNumber = (mapIndex * 8) + 7 - leadingZeroes;
     objectOffset = objectStartNumber * allocationGranularity;
     Address objectAddress = objectOffset + payload();
     HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(objectAddress);
     if (header->isFree())
         return nullptr;
     header->checkHeader();
     return header;
 }
 
-void HeapPage::checkAndMarkPointer(Visitor* visitor, Address address)
+void NormalPage::checkAndMarkPointer(Visitor* visitor, Address address)
 {
     ASSERT(contains(address));
     HeapObjectHeader* header = findHeaderFromAddress(address);
     if (!header || header->isDead())
         return;
 #if ENABLE(GC_PROFILING)
     visitor->setHostInfo(&address, "stack");
 #endif
     markPointer(visitor, header);
 }
 
 #if ENABLE(GC_PROFILING)
-const GCInfo* HeapPage::findGCInfo(Address address)
+const GCInfo* NormalPage::findGCInfo(Address address)
 {
     if (address < payload())
         return nullptr;
 
     HeapObjectHeader* header = findHeaderFromAddress(address);
     if (!header)
         return nullptr;
 
     return Heap::gcInfo(header->gcInfoIndex());
 }
 #endif
 
 #if ENABLE(GC_PROFILING)
-void HeapPage::snapshot(TracedValue* json, ThreadState::SnapshotInfo* info)
+void NormalPage::snapshot(TracedValue* json, ThreadState::SnapshotInfo* info)
 {
     HeapObjectHeader* header = nullptr;
     for (Address addr = payload(); addr < payloadEnd(); addr += header->size()) {
         header = reinterpret_cast<HeapObjectHeader*>(addr);
         if (json)
             json->pushInteger(header->encodedSize());
         if (header->isFree()) {
             info->freeSize += header->size();
             continue;
         }
@@ skipping 11 matching lines @@
         } else {
             info->deadCount[tag] += 1;
             info->deadSize[tag] += header->size();
             // Count objects that are dead before the final generation.
             if (age < maxHeapObjectAge)
                 info->generations[tag][age] += 1;
         }
     }
 }
 
-void HeapPage::incrementMarkedObjectsAge()
+void NormalPage::incrementMarkedObjectsAge()
 {
     HeapObjectHeader* header = nullptr;
     for (Address address = payload(); address < payloadEnd(); address += header->size()) {
         header = reinterpret_cast<HeapObjectHeader*>(address);
         if (header->isMarked())
             header->incrementAge();
     }
 }
 
-void HeapPage::countMarkedObjects(ClassAgeCountsMap& classAgeCounts)
+void NormalPage::countMarkedObjects(ClassAgeCountsMap& classAgeCounts)
 {
     HeapObjectHeader* header = nullptr;
     for (Address address = payload(); address < payloadEnd(); address += header->size()) {
         header = reinterpret_cast<HeapObjectHeader*>(address);
         if (header->isMarked()) {
             String className(classOf(header->payload()));
             ++(classAgeCounts.add(className, AgeCounts()).storedValue->value.ages[header->age()]);
         }
     }
 }
 
-void HeapPage::countObjectsToSweep(ClassAgeCountsMap& classAgeCounts)
+void NormalPage::countObjectsToSweep(ClassAgeCountsMap& classAgeCounts)
 {
     HeapObjectHeader* header = nullptr;
     for (Address address = payload(); address < payloadEnd(); address += header->size()) {
         header = reinterpret_cast<HeapObjectHeader*>(address);
         if (!header->isFree() && !header->isMarked()) {
             String className(classOf(header->payload()));
             ++(classAgeCounts.add(className, AgeCounts()).storedValue->value.ages[header->age()]);
         }
     }
 }
 #endif
 
-size_t LargeObject::objectPayloadSizeForTesting()
+size_t LargeObjectPage::objectPayloadSizeForTesting()
 {
     markAsSwept();
     return payloadSize();
 }
 
 #if ENABLE(GC_PROFILING)
-const GCInfo* LargeObject::findGCInfo(Address address)
+const GCInfo* LargeObjectPage::findGCInfo(Address address)
 {
     if (!containedInObjectPayload(address))
         return nullptr;
     HeapObjectHeader* header = heapObjectHeader();
     return Heap::gcInfo(header->gcInfoIndex());
 }
 
-void LargeObject::snapshot(TracedValue* json, ThreadState::SnapshotInfo* info)
+void LargeObjectPage::snapshot(TracedValue* json, ThreadState::SnapshotInfo* info)
 {
     HeapObjectHeader* header = heapObjectHeader();
     size_t tag = info->getClassTag(Heap::gcInfo(header->gcInfoIndex()));
     size_t age = header->age();
     if (header->isMarked()) {
         info->liveCount[tag] += 1;
         info->liveSize[tag] += header->size();
         // Count objects that are live when promoted to the final generation.
         if (age == maxHeapObjectAge - 1)
             info->generations[tag][maxHeapObjectAge] += 1;
     } else {
         info->deadCount[tag] += 1;
         info->deadSize[tag] += header->size();
         // Count objects that are dead before the final generation.
         if (age < maxHeapObjectAge)
             info->generations[tag][age] += 1;
     }
 
     if (json) {
         json->setInteger("class", tag);
         json->setInteger("size", header->size());
         json->setInteger("isMarked", header->isMarked());
     }
 }
 
-void LargeObject::incrementMarkedObjectsAge()
+void LargeObjectPage::incrementMarkedObjectsAge()
 {
     HeapObjectHeader* header = heapObjectHeader();
     if (header->isMarked())
         header->incrementAge();
 }
 
-void LargeObject::countMarkedObjects(ClassAgeCountsMap& classAgeCounts)
+void LargeObjectPage::countMarkedObjects(ClassAgeCountsMap& classAgeCounts)
 {
     HeapObjectHeader* header = heapObjectHeader();
     if (header->isMarked()) {
         String className(classOf(header->payload()));
         ++(classAgeCounts.add(className, AgeCounts()).storedValue->value.ages[header->age()]);
     }
 }
 
-void LargeObject::countObjectsToSweep(ClassAgeCountsMap& classAgeCounts)
+void LargeObjectPage::countObjectsToSweep(ClassAgeCountsMap& classAgeCounts)
 {
     HeapObjectHeader* header = heapObjectHeader();
     if (!header->isFree() && !header->isMarked()) {
         String className(classOf(header->payload()));
         ++(classAgeCounts.add(className, AgeCounts()).storedValue->value.ages[header->age()]);
     }
 }
 #endif
 
 void HeapDoesNotContainCache::flush()
@@ skipping 222 matching lines @@
     virtual void registerWeakCellWithCallback(void** cell, WeakPointerCallback callback) override
     {
         Impl::registerWeakCellWithCallback(cell, callback);
     }
 
     inline bool shouldMarkObject(const void* objectPointer)
     {
         if (Mode != ThreadLocalMarking)
             return true;
 
-        BaseHeapPage* page = pageFromObject(objectPointer);
+        BasePage* page = pageFromObject(objectPointer);
         ASSERT(!page->orphaned());
         // When doing a thread local GC, the marker checks if
         // the object resides in another thread's heap. If it
         // does, the object should not be marked & traced.
         return page->terminating();
     }
 
 #if ENABLE(ASSERT)
     virtual void checkMarkingAllowed() override
     {
@@ skipping 50 matching lines @@
     delete s_ephemeronStack;
     s_ephemeronStack = nullptr;
     delete s_regionTree;
     s_regionTree = nullptr;
     GCInfoTable::shutdown();
     ThreadState::shutdown();
     ASSERT(Heap::allocatedSpace() == 0);
 }
 
 #if ENABLE(ASSERT)
-BaseHeapPage* Heap::findPageFromAddress(Address address)
+BasePage* Heap::findPageFromAddress(Address address)
 {
     ASSERT(ThreadState::current()->isInGC());
     for (ThreadState* state : ThreadState::attachedThreads()) {
-        if (BaseHeapPage* page = state->findPageFromAddress(address))
+        if (BasePage* page = state->findPageFromAddress(address))
             return page;
     }
     return nullptr;
 }
 
 bool Heap::containedInHeapOrOrphanedPage(void* object)
 {
     return findPageFromAddress(object) || orphanedPagePool()->contains(object);
 }
 #endif
 
 Address Heap::checkAndMarkPointer(Visitor* visitor, Address address)
 {
     ASSERT(ThreadState::current()->isInGC());
 
 #if !ENABLE(ASSERT)
     if (s_heapDoesNotContainCache->lookup(address))
         return nullptr;
 #endif
 
-    if (BaseHeapPage* page = lookup(address)) {
+    if (BasePage* page = lookup(address)) {
         ASSERT(page->contains(address));
         ASSERT(!page->orphaned());
         ASSERT(!s_heapDoesNotContainCache->lookup(address));
         page->checkAndMarkPointer(visitor, address);
         // FIXME: We only need to set the conservative flag if
         // checkAndMarkPointer actually marked the pointer.
         s_lastGCWasConservative = true;
         return address;
     }
 
@@ skipping 93 matching lines @@
 
 void Heap::pushWeakCellPointerCallback(void** cell, WeakPointerCallback callback)
 {
     ASSERT(!Heap::orphanedPagePool()->contains(cell));
     CallbackStack::Item* slot = s_weakCallbackStack->allocateEntry();
     *slot = CallbackStack::Item(cell, callback);
 }
 
 void Heap::pushWeakPointerCallback(void* closure, void* object, WeakPointerCallback callback)
 {
-    BaseHeapPage* page = pageFromObject(object);
+    BasePage* page = pageFromObject(object);
     ASSERT(!page->orphaned());
     ThreadState* state = page->heap()->threadState();
     state->pushWeakPointerCallback(closure, callback);
 }
 
 bool Heap::popAndInvokeWeakPointerCallback(Visitor* visitor)
 {
     // For weak processing we should never reach orphaned pages since orphaned
     // pages are not traced and thus objects on those pages are never be
     // registered as objects on orphaned pages.  We cannot assert this here
@@ skipping 222 matching lines @@
     for (int i = 0; i < 5; ++i)
         collectGarbage(ThreadState::NoHeapPointersOnStack);
 }
 
 double Heap::estimatedMarkingTime()
 {
     // FIXME: Implement heuristics
     return 0.0;
 }
 
-void ThreadHeap::prepareHeapForTermination()
+void BaseHeap::prepareHeapForTermination()
 {
     ASSERT(!m_firstUnsweptPage);
-    for (BaseHeapPage* page = m_firstPage; page; page = page->next()) {
+    for (BasePage* page = m_firstPage; page; page = page->next()) {
         page->setTerminating();
     }
 }
 
 size_t Heap::objectPayloadSizeForTesting()
 {
     size_t objectPayloadSize = 0;
     for (ThreadState* state : ThreadState::attachedThreads()) {
         state->setGCState(ThreadState::GCRunning);
         state->makeConsistentForSweeping();
@@ skipping 10 matching lines @@
     if (!address)
         return;
 
     ThreadState* state = ThreadState::current();
     if (state->sweepForbidden())
         return;
     ASSERT(!state->isInGC());
 
     // Don't promptly free large objects because their page is never reused.
     // Don't free backings allocated on other threads.
-    BaseHeapPage* page = pageFromObject(address);
-    if (page->isLargeObject() || page->heap()->threadState() != state)
+    BasePage* page = pageFromObject(address);
+    if (page->isLargeObjectPage() || page->heap()->threadState() != state)
         return;
 
     HeapObjectHeader* header = HeapObjectHeader::fromPayload(address);
     header->checkHeader();
-    static_cast<HeapPage*>(page)->heapForHeapPage()->promptlyFreeObject(header);
+    static_cast<NormalPage*>(page)->heapForNormalPage()->promptlyFreeObject(header);
 }
 
 void HeapAllocator::freeVectorBacking(void* address)
 {
     backingFree(address);
 }
 
 void HeapAllocator::freeInlineVectorBacking(void* address)
 {
     backingFree(address);
@@ skipping 10 matching lines @@
         return false;
 
     ThreadState* state = ThreadState::current();
     if (state->sweepForbidden())
         return false;
     ASSERT(!state->isInGC());
     ASSERT(state->isAllocationAllowed());
 
     // FIXME: Support expand for large objects.
     // Don't expand backings allocated on other threads.
-    BaseHeapPage* page = pageFromObject(address);
-    if (page->isLargeObject() || page->heap()->threadState() != state)
+    BasePage* page = pageFromObject(address);
+    if (page->isLargeObjectPage() || page->heap()->threadState() != state)
         return false;
 
     HeapObjectHeader* header = HeapObjectHeader::fromPayload(address);
     header->checkHeader();
-    return static_cast<HeapPage*>(page)->heapForHeapPage()->expandObject(header, newSize);
+    return static_cast<NormalPage*>(page)->heapForNormalPage()->expandObject(header, newSize);
 }
 
 bool HeapAllocator::expandVectorBacking(void* address, size_t newSize)
 {
     return backingExpand(address, newSize);
 }
 
 bool HeapAllocator::expandInlineVectorBacking(void* address, size_t newSize)
 {
     return backingExpand(address, newSize);
@@ skipping 16 matching lines @@
         return;
 
     ThreadState* state = ThreadState::current();
     if (state->sweepForbidden())
         return;
     ASSERT(!state->isInGC());
     ASSERT(state->isAllocationAllowed());
 
     // FIXME: Support shrink for large objects.
     // Don't shrink backings allocated on other threads.
-    BaseHeapPage* page = pageFromObject(address);
-    if (page->isLargeObject() || page->heap()->threadState() != state)
+    BasePage* page = pageFromObject(address);
+    if (page->isLargeObjectPage() || page->heap()->threadState() != state)
         return;
 
     HeapObjectHeader* header = HeapObjectHeader::fromPayload(address);
     header->checkHeader();
-    static_cast<HeapPage*>(page)->heapForHeapPage()->shrinkObject(header, quantizedShrunkSize);
+    static_cast<NormalPage*>(page)->heapForNormalPage()->shrinkObject(header, quantizedShrunkSize);
 }
 
 void HeapAllocator::shrinkVectorBackingInternal(void* address, size_t quantizedCurrentSize, size_t quantizedShrunkSize)
 {
     backingShrink(address, quantizedCurrentSize, quantizedShrunkSize);
 }
 
 void HeapAllocator::shrinkInlineVectorBackingInternal(void* address, size_t quantizedCurrentSize, size_t quantizedShrunkSize)
 {
     backingShrink(address, quantizedCurrentSize, quantizedShrunkSize);
 }
 
-BaseHeapPage* Heap::lookup(Address address)
+BasePage* Heap::lookup(Address address)
 {
     ASSERT(ThreadState::current()->isInGC());
     if (!s_regionTree)
         return nullptr;
     if (PageMemoryRegion* region = s_regionTree->lookup(address)) {
-        BaseHeapPage* page = region->pageFromAddress(address);
+        BasePage* page = region->pageFromAddress(address);
         return page && !page->orphaned() ? page : nullptr;
     }
     return nullptr;
 }
 
 static Mutex& regionTreeMutex()
 {
     AtomicallyInitializedStaticReference(Mutex, mutex, new Mutex);
     return mutex;
 }
@@ skipping 80 matching lines @@
 bool Heap::s_shutdownCalled = false;
 bool Heap::s_lastGCWasConservative = false;
 FreePagePool* Heap::s_freePagePool;
 OrphanedPagePool* Heap::s_orphanedPagePool;
 Heap::RegionTree* Heap::s_regionTree = nullptr;
 size_t Heap::s_allocatedObjectSize = 0;
 size_t Heap::s_allocatedSpace = 0;
 size_t Heap::s_markedObjectSize = 0;
 
 } // namespace blink