Rename BaseHeap to BaseArena

third_party/WebKit/Source/platform/heap/HeapPage.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 45 matching lines @@
 // FIXME: have ContainerAnnotations.h define an ENABLE_-style name instead.
 #define ENABLE_ASAN_CONTAINER_ANNOTATIONS 1
 
 // When finalizing a non-inlined vector backing store/container, remove
 // its contiguous container annotation. Required as it will not be destructed
 // from its Vector.
 #define ASAN_RETIRE_CONTAINER_ANNOTATION(object, objectSize)                          \
     do {                                                                              \
         BasePage* page = pageFromObject(object);                                      \
         ASSERT(page);                                                                 \
-        bool isContainer = ThreadState::isVectorHeapIndex(page->heap()->heapIndex()); \
+        bool isContainer = ThreadState::isVectorArenaIndex(page->arena()->arenaIndex()); \
         if (!isContainer && page->isLargeObjectPage())                                \
             isContainer = static_cast<LargeObjectPage*>(page)->isVectorBackingPage(); \
         if (isContainer)                                                              \
             ANNOTATE_DELETE_BUFFER(object, objectSize, 0);                            \
     } while (0)
 
 // A vector backing store represented by a large object is marked
 // so that when it is finalized, its ASan annotation will be
 // correctly retired.
-#define ASAN_MARK_LARGE_VECTOR_CONTAINER(heap, largeObject)                 \
-    if (ThreadState::isVectorHeapIndex(heap->heapIndex())) {                \
+#define ASAN_MARK_LARGE_VECTOR_CONTAINER(arena, largeObject)                 \
+    if (ThreadState::isVectorArenaIndex(arena->arenaIndex())) {                \
         BasePage* largePage = pageFromObject(largeObject);                  \
         ASSERT(largePage->isLargeObjectPage());                             \
         static_cast<LargeObjectPage*>(largePage)->setIsVectorBackingPage(); \
     }
 #else
 #define ENABLE_ASAN_CONTAINER_ANNOTATIONS 0
 #define ASAN_RETIRE_CONTAINER_ANNOTATION(payload, payloadSize)
-#define ASAN_MARK_LARGE_VECTOR_CONTAINER(heap, largeObject)
+#define ASAN_MARK_LARGE_VECTOR_CONTAINER(arena, largeObject)
 #endif
 
 namespace blink {
 
 #if ENABLE(ASSERT)
 NO_SANITIZE_ADDRESS
 void HeapObjectHeader::zapMagic()
 {
     ASSERT(checkHeader());
     m_magic = zappedMagic;
 }
 #endif
 
 void HeapObjectHeader::finalize(Address object, size_t objectSize)
 {
     HeapAllocHooks::freeHookIfEnabled(object);
     const GCInfo* gcInfo = Heap::gcInfo(gcInfoIndex());
     if (gcInfo->hasFinalizer())
         gcInfo->m_finalize(object);
 
     ASAN_RETIRE_CONTAINER_ANNOTATION(object, objectSize);
 }
 
-BaseHeap::BaseHeap(ThreadState* state, int index)
+BaseArena::BaseArena(ThreadState* state, int index)
     : m_firstPage(nullptr)
     , m_firstUnsweptPage(nullptr)
     , m_threadState(state)
     , m_index(index)
 {
 }
 
-BaseHeap::~BaseHeap()
+BaseArena::~BaseArena()
 {
     ASSERT(!m_firstPage);
     ASSERT(!m_firstUnsweptPage);
 }
 
-void BaseHeap::cleanupPages()
+void BaseArena::cleanupPages()
 {
     clearFreeLists();
 
     ASSERT(!m_firstUnsweptPage);
-    // Add the BaseHeap's pages to the orphanedPagePool.
+    // Add the BaseArena's pages to the orphanedPagePool.
     for (BasePage* page = m_firstPage; page; page = page->next()) {
         Heap::decreaseAllocatedSpace(page->size());
-        Heap::orphanedPagePool()->addOrphanedPage(heapIndex(), page);
+        Heap::orphanedPagePool()->addOrphanedPage(arenaIndex(), page);
     }
     m_firstPage = nullptr;
 }
 
-void BaseHeap::takeSnapshot(const String& dumpBaseName, ThreadState::GCSnapshotInfo& info)
+void BaseArena::takeSnapshot(const String& dumpBaseName, ThreadState::GCSnapshotInfo& info)
 {
     // |dumpBaseName| at this point is "blink_gc/thread_X/heaps/HeapName"
     WebMemoryAllocatorDump* allocatorDump = BlinkGCMemoryDumpProvider::instance()->createMemoryAllocatorDumpForCurrentGC(dumpBaseName);
     size_t pageCount = 0;
     BasePage::HeapSnapshotInfo heapInfo;
     for (BasePage* page = m_firstUnsweptPage; page; page = page->next()) {
         String dumpName = dumpBaseName + String::format("/pages/page_%lu", static_cast<unsigned long>(pageCount++));
         WebMemoryAllocatorDump* pageDump = BlinkGCMemoryDumpProvider::instance()->createMemoryAllocatorDumpForCurrentGC(dumpName);
 
         page->takeSnapshot(pageDump, info, heapInfo);
     }
     allocatorDump->addScalar("blink_page_count", "objects", pageCount);
 
     // When taking a full dump (w/ freelist), both the /buckets and /pages
     // report their free size but they are not meant to be added together.
     // Therefore, here we override the free_size of the parent heap to be
     // equal to the free_size of the sum of its heap pages.
     allocatorDump->addScalar("free_size", "bytes", heapInfo.freeSize);
     allocatorDump->addScalar("free_count", "objects", heapInfo.freeCount);
 }
 
 #if ENABLE(ASSERT)
-BasePage* BaseHeap::findPageFromAddress(Address address)
+BasePage* BaseArena::findPageFromAddress(Address address)
 {
     for (BasePage* page = m_firstPage; page; page = page->next()) {
         if (page->contains(address))
             return page;
     }
     for (BasePage* page = m_firstUnsweptPage; page; page = page->next()) {
         if (page->contains(address))
             return page;
     }
     return nullptr;
 }
 #endif
 
-void BaseHeap::makeConsistentForGC()
+void BaseArena::makeConsistentForGC()
 {
     clearFreeLists();
     ASSERT(isConsistentForGC());
     for (BasePage* page = m_firstPage; page; page = page->next()) {
         page->markAsUnswept();
         page->invalidateObjectStartBitmap();
     }
 
     // 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
@@ skipping 10 matching lines @@
     }
     if (previousPage) {
         ASSERT(m_firstUnsweptPage);
         previousPage->m_next = m_firstPage;
         m_firstPage = m_firstUnsweptPage;
         m_firstUnsweptPage = nullptr;
     }
     ASSERT(!m_firstUnsweptPage);
 }
 
-void BaseHeap::makeConsistentForMutator()
+void BaseArena::makeConsistentForMutator()
 {
     clearFreeLists();
     ASSERT(isConsistentForGC());
     ASSERT(!m_firstPage);
 
     // Drop marks from marked objects and rebuild free lists in preparation for
     // resuming the executions of mutators.
     BasePage* previousPage = nullptr;
     for (BasePage* page = m_firstUnsweptPage; page; previousPage = page, page = page->next()) {
         page->makeConsistentForMutator();
         page->markAsSwept();
         page->invalidateObjectStartBitmap();
     }
     if (previousPage) {
         ASSERT(m_firstUnsweptPage);
         previousPage->m_next = m_firstPage;
         m_firstPage = m_firstUnsweptPage;
         m_firstUnsweptPage = nullptr;
     }
     ASSERT(!m_firstUnsweptPage);
 }
 
-size_t BaseHeap::objectPayloadSizeForTesting()
+size_t BaseArena::objectPayloadSizeForTesting()
 {
     ASSERT(isConsistentForGC());
     ASSERT(!m_firstUnsweptPage);
 
     size_t objectPayloadSize = 0;
     for (BasePage* page = m_firstPage; page; page = page->next())
         objectPayloadSize += page->objectPayloadSizeForTesting();
     return objectPayloadSize;
 }
 
-void BaseHeap::prepareHeapForTermination()
+void BaseArena::prepareHeapForTermination()
 {
     ASSERT(!m_firstUnsweptPage);
     for (BasePage* page = m_firstPage; page; page = page->next()) {
         page->setTerminating();
     }
 }
 
-void BaseHeap::prepareForSweep()
+void BaseArena::prepareForSweep()
 {
     ASSERT(threadState()->isInGC());
     ASSERT(!m_firstUnsweptPage);
 
     // Move all pages to a list of unswept pages.
     m_firstUnsweptPage = m_firstPage;
     m_firstPage = nullptr;
 }
 
 #if defined(ADDRESS_SANITIZER)
-void BaseHeap::poisonHeap(BlinkGC::ObjectsToPoison objectsToPoison, BlinkGC::Poisoning poisoning)
+void BaseArena::poisonHeap(BlinkGC::ObjectsToPoison objectsToPoison, BlinkGC::Poisoning poisoning)
 {
-    // TODO(sof): support complete poisoning of all heaps.
-    ASSERT(objectsToPoison != BlinkGC::MarkedAndUnmarked || heapIndex() == BlinkGC::EagerSweepHeapIndex);
+    // TODO(sof): support complete poisoning of all arenas.
+    ASSERT(objectsToPoison != BlinkGC::MarkedAndUnmarked || arenaIndex() == BlinkGC::EagerSweepArenaIndex);
 
     // This method may either be called to poison (SetPoison) heap
     // object payloads prior to sweeping, or it may be called at
     // the completion of a sweep to unpoison (ClearPoison) the
     // objects remaining in the heap. Those will all be live and unmarked.
     //
     // Poisoning may be limited to unmarked objects only, or apply to all.
     if (poisoning == BlinkGC::SetPoison) {
         for (BasePage* page = m_firstUnsweptPage; page; page = page->next())
             page->poisonObjects(objectsToPoison, poisoning);
         return;
     }
     // Support clearing of poisoning after sweeping has completed,
     // in which case the pages of the live objects are reachable
     // via m_firstPage.
     ASSERT(!m_firstUnsweptPage);
     for (BasePage* page = m_firstPage; page; page = page->next())
         page->poisonObjects(objectsToPoison, poisoning);
 }
 #endif
 
-Address BaseHeap::lazySweep(size_t allocationSize, size_t gcInfoIndex)
+Address BaseArena::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", "BaseHeap::lazySweepPages");
+    TRACE_EVENT0("blink_gc", "BaseArena::lazySweepPages");
     ThreadState::SweepForbiddenScope sweepForbidden(threadState());
     ScriptForbiddenIfMainThreadScope scriptForbidden;
 
     double startTime = WTF::currentTimeMS();
     Address result = lazySweepPages(allocationSize, gcInfoIndex);
     threadState()->accumulateSweepingTime(WTF::currentTimeMS() - startTime);
     Heap::reportMemoryUsageForTracing();
 
     return result;
 }
 
-void BaseHeap::sweepUnsweptPage()
+void BaseArena::sweepUnsweptPage()
 {
     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();
     }
 }
 
-bool BaseHeap::lazySweepWithDeadline(double deadlineSeconds)
+bool BaseArena::lazySweepWithDeadline(double deadlineSeconds)
 {
     // It might be heavy to call Platform::current()->monotonicallyIncreasingTimeSeconds()
     // per page (i.e., 128 KB sweep or one LargeObject sweep), so we check
     // the deadline per 10 pages.
     static const int deadlineCheckInterval = 10;
 
     RELEASE_ASSERT(threadState()->isSweepingInProgress());
     ASSERT(threadState()->sweepForbidden());
     ASSERT(!threadState()->isMainThread() || ScriptForbiddenScope::isScriptForbidden());
 
     int pageCount = 1;
     while (m_firstUnsweptPage) {
         sweepUnsweptPage();
         if (pageCount % deadlineCheckInterval == 0) {
             if (deadlineSeconds <= monotonicallyIncreasingTime()) {
                 // Deadline has come.
                 Heap::reportMemoryUsageForTracing();
                 return !m_firstUnsweptPage;
             }
         }
         pageCount++;
     }
     Heap::reportMemoryUsageForTracing();
     return true;
 }
 
-void BaseHeap::completeSweep()
+void BaseArena::completeSweep()
 {
     RELEASE_ASSERT(threadState()->isSweepingInProgress());
     ASSERT(threadState()->sweepForbidden());
     ASSERT(!threadState()->isMainThread() || ScriptForbiddenScope::isScriptForbidden());
 
     while (m_firstUnsweptPage) {
         sweepUnsweptPage();
     }
     Heap::reportMemoryUsageForTracing();
 }
 
 NormalPageHeap::NormalPageHeap(ThreadState* state, int index)
-    : BaseHeap(state, index)
+    : BaseArena(state, index)
     , m_currentAllocationPoint(nullptr)
     , m_remainingAllocationSize(0)
     , m_lastRemainingAllocationSize(0)
     , m_promptlyFreedSize(0)
 {
     clearFreeLists();
 }
 
 void NormalPageHeap::clearFreeLists()
 {
@@ skipping 34 matching lines @@
     if (m_freeList.takeSnapshot(dumpName)) {
         WebMemoryAllocatorDump* bucketsDump = BlinkGCMemoryDumpProvider::instance()->createMemoryAllocatorDumpForCurrentGC(dumpName + "/buckets");
         WebMemoryAllocatorDump* pagesDump = BlinkGCMemoryDumpProvider::instance()->createMemoryAllocatorDumpForCurrentGC(dumpName + "/pages");
         BlinkGCMemoryDumpProvider::instance()->currentProcessMemoryDump()->addOwnershipEdge(pagesDump->guid(), bucketsDump->guid());
     }
 }
 
 void NormalPageHeap::allocatePage()
 {
     threadState()->shouldFlushHeapDoesNotContainCache();
-    PageMemory* pageMemory = Heap::freePagePool()->takeFreePage(heapIndex());
+    PageMemory* pageMemory = Heap::freePagePool()->takeFreePage(arenaIndex());
 
     if (!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 }
         PageMemoryRegion* region = PageMemoryRegion::allocateNormalPages();
 
         // Setup the PageMemory object for each of the pages in the region.
         for (size_t i = 0; i < blinkPagesPerRegion; ++i) {
             PageMemory* memory = PageMemory::setupPageMemoryInRegion(region, i * blinkPageSize, blinkPagePayloadSize());
             // Take the first possible page ensuring that this thread actually
             // gets a page and add the rest to the page pool.
             if (!pageMemory) {
                 bool result = memory->commit();
                 // If you hit the ASSERT, it will mean that you're hitting
                 // the limit of the number of mmapped regions OS can support
                 // (e.g., /proc/sys/vm/max_map_count in Linux).
                 RELEASE_ASSERT(result);
                 pageMemory = memory;
             } else {
-                Heap::freePagePool()->addFreePage(heapIndex(), memory);
+                Heap::freePagePool()->addFreePage(arenaIndex(), memory);
             }
         }
     }
 
     NormalPage* page = new (pageMemory->writableStart()) NormalPage(pageMemory, this);
     page->link(&m_firstPage);
 
     Heap::increaseAllocatedSpace(page->size());
 #if ENABLE(ASSERT) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
     // Allow the following addToFreeList() to add the newly allocated memory
@@ skipping 13 matching lines @@
 
     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);
+        Heap::orphanedPagePool()->addOrphanedPage(arenaIndex(), page);
     } else {
         PageMemory* memory = page->storage();
         page->~NormalPage();
-        Heap::freePagePool()->addFreePage(heapIndex(), memory);
+        Heap::freePagePool()->addFreePage(arenaIndex(), memory);
     }
 }
 
 bool NormalPageHeap::coalesce()
 {
-    // Don't coalesce heaps if there are not enough promptly freed entries
+    // Don't coalesce arenas 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", "BaseHeap::coalesce");
+    TRACE_EVENT0("blink_gc", "BaseArena::coalesce");
 
     // Rebuild free lists.
     m_freeList.clear();
     size_t freedSize = 0;
     for (NormalPage* page = static_cast<NormalPage*>(m_firstPage); page; page = static_cast<NormalPage*>(page->next())) {
         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);
@@ skipping 184 matching lines @@
 }
 
 Address NormalPageHeap::outOfLineAllocate(size_t allocationSize, size_t gcInfoIndex)
 {
     ASSERT(allocationSize > remainingAllocationSize());
     ASSERT(allocationSize >= allocationGranularity);
 
     // 1. If this allocation is big enough, allocate a large object.
     if (allocationSize >= largeObjectSizeThreshold) {
         // TODO(sof): support eagerly finalized large objects, if ever needed.
-        RELEASE_ASSERT(heapIndex() != BlinkGC::EagerSweepHeapIndex);
-        LargeObjectHeap* largeObjectHeap = static_cast<LargeObjectHeap*>(threadState()->heap(BlinkGC::LargeObjectHeapIndex));
+        RELEASE_ASSERT(arenaIndex() != BlinkGC::EagerSweepArenaIndex);
+        LargeObjectHeap* largeObjectHeap = static_cast<LargeObjectHeap*>(threadState()->arena(BlinkGC::LargeObjectArenaIndex));
         Address largeObject = largeObjectHeap->allocateLargeObjectPage(allocationSize, gcInfoIndex);
         ASAN_MARK_LARGE_VECTOR_CONTAINER(this, largeObject);
         return largeObject;
     }
 
     // 2. Try to allocate from a free list.
     updateRemainingAllocationSize();
     Address result = allocateFromFreeList(allocationSize, gcInfoIndex);
     if (result)
         return result;
@@ skipping 55 matching lines @@
             ASSERT(remainingAllocationSize() >= allocationSize);
             m_freeList.m_biggestFreeListIndex = index;
             return allocateObject(allocationSize, gcInfoIndex);
         }
     }
     m_freeList.m_biggestFreeListIndex = index;
     return nullptr;
 }
 
 LargeObjectHeap::LargeObjectHeap(ThreadState* state, int index)
-    : BaseHeap(state, index)
+    : BaseArena(state, index)
 {
 }
 
 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. Try to sweep large objects more than allocationSize bytes
@@ skipping 62 matching lines @@
     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);
+        Heap::orphanedPagePool()->addOrphanedPage(arenaIndex(), object);
     } else {
         ASSERT(!ThreadState::current()->isTerminating());
         PageMemory* memory = object->storage();
         object->~LargeObjectPage();
         delete memory;
     }
 }
 
 Address LargeObjectHeap::lazySweepPages(size_t allocationSize, size_t gcInfoIndex)
 {
@@ skipping 163 matching lines @@
 
         String dumpName = dumpBaseName + String::format("/buckets/bucket_%lu", static_cast<unsigned long>(1 << i));
         WebMemoryAllocatorDump* bucketDump = BlinkGCMemoryDumpProvider::instance()->createMemoryAllocatorDumpForCurrentGC(dumpName);
         bucketDump->addScalar("free_count", "objects", entryCount);
         bucketDump->addScalar("free_size", "bytes", freeSize);
         didDumpBucketStats = true;
     }
     return didDumpBucketStats;
 }
 
-BasePage::BasePage(PageMemory* storage, BaseHeap* heap)
+BasePage::BasePage(PageMemory* storage, BaseArena* arena)
     : m_storage(storage)
-    , m_heap(heap)
+    , m_arena(arena)
     , m_next(nullptr)
     , m_terminating(false)
     , m_swept(true)
 {
     ASSERT(isPageHeaderAddress(reinterpret_cast<Address>(this)));
 }
 
 void BasePage::markOrphaned()
 {
-    m_heap = nullptr;
+    m_arena = 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();
 }
 
-NormalPage::NormalPage(PageMemory* storage, BaseHeap* heap)
-    : BasePage(storage, heap)
+NormalPage::NormalPage(PageMemory* storage, BaseArena* arena)
+    : BasePage(storage, arena)
     , m_objectStartBitMapComputed(false)
 {
     ASSERT(isPageHeaderAddress(reinterpret_cast<Address>(this)));
 }
 
 size_t NormalPage::objectPayloadSizeForTesting()
 {
     size_t objectPayloadSize = 0;
     Address headerAddress = payload();
     markAsSwept();
@@ skipping 12 matching lines @@
 }
 
 bool NormalPage::isEmpty()
 {
     HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(payload());
     return header->isFree() && header->size() == payloadSize();
 }
 
 void NormalPage::removeFromHeap()
 {
-    heapForNormalPage()->freePage(this);
+    arenaForNormalPage()->freePage(this);
 }
 
 #if !ENABLE(ASSERT) && !defined(LEAK_SANITIZER) && !defined(ADDRESS_SANITIZER)
 static void discardPages(Address begin, Address end)
 {
     uintptr_t beginAddress = WTF::roundUpToSystemPage(reinterpret_cast<uintptr_t>(begin));
     uintptr_t endAddress = WTF::roundDownToSystemPage(reinterpret_cast<uintptr_t>(end));
     if (beginAddress < endAddress)
         WTF::discardSystemPages(reinterpret_cast<void*>(beginAddress), endAddress - beginAddress);
 }
 #endif
 
 void NormalPage::sweep()
 {
     size_t markedObjectSize = 0;
     Address startOfGap = payload();
-    NormalPageHeap* pageHeap = heapForNormalPage();
+    NormalPageHeap* pageHeap = arenaForNormalPage();
     for (Address headerAddress = startOfGap; headerAddress < payloadEnd(); ) {
         HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(headerAddress);
         size_t size = header->size();
         ASSERT(size > 0);
         ASSERT(size < blinkPagePayloadSize());
 
         if (header->isPromptlyFreed())
             pageHeap->decreasePromptlyFreedSize(size);
         if (header->isFree()) {
             // Zero the memory in the free list header to maintain the
@@ skipping 65 matching lines @@
         ASSERT(header->checkHeader());
         if (header->isMarked()) {
             header->unmark();
             markedObjectSize += header->size();
         } else {
             header->markDead();
         }
         headerAddress += header->size();
     }
     if (markedObjectSize)
-        heapForNormalPage()->threadState()->increaseMarkedObjectSize(markedObjectSize);
+        arenaForNormalPage()->threadState()->increaseMarkedObjectSize(markedObjectSize);
 }
 
 void NormalPage::makeConsistentForMutator()
 {
     Address startOfGap = payload();
     for (Address headerAddress = payload(); headerAddress < payloadEnd();) {
         HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(headerAddress);
         size_t size = header->size();
         ASSERT(size < blinkPagePayloadSize());
         if (header->isPromptlyFreed())
-            heapForNormalPage()->decreasePromptlyFreedSize(size);
+            arenaForNormalPage()->decreasePromptlyFreedSize(size);
         if (header->isFree()) {
             // 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.
             SET_MEMORY_INACCESSIBLE(headerAddress, size < sizeof(FreeListEntry) ? size : sizeof(FreeListEntry));
             CHECK_MEMORY_INACCESSIBLE(headerAddress, size);
             headerAddress += size;
             continue;
         }
         ASSERT(header->checkHeader());
 
         if (startOfGap != headerAddress)
-            heapForNormalPage()->addToFreeList(startOfGap, headerAddress - startOfGap);
+            arenaForNormalPage()->addToFreeList(startOfGap, headerAddress - startOfGap);
         if (header->isMarked())
             header->unmark();
         headerAddress += size;
         startOfGap = headerAddress;
         ASSERT(headerAddress <= payloadEnd());
     }
     if (startOfGap != payloadEnd())
-        heapForNormalPage()->addToFreeList(startOfGap, payloadEnd() - startOfGap);
+        arenaForNormalPage()->addToFreeList(startOfGap, payloadEnd() - startOfGap);
 }
 
 #if defined(ADDRESS_SANITIZER)
 void NormalPage::poisonObjects(BlinkGC::ObjectsToPoison objectsToPoison, BlinkGC::Poisoning poisoning)
 {
     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.
@@ skipping 177 matching lines @@
 
 #if ENABLE(ASSERT)
 bool NormalPage::contains(Address addr)
 {
     Address blinkPageStart = roundToBlinkPageStart(getAddress());
     ASSERT(blinkPageStart == getAddress() - blinkGuardPageSize); // Page is at aligned address plus guard page size.
     return blinkPageStart <= addr && addr < blinkPageStart + blinkPageSize;
 }
 #endif
 
-NormalPageHeap* NormalPage::heapForNormalPage()
+NormalPageHeap* NormalPage::arenaForNormalPage()
 {
-    return static_cast<NormalPageHeap*>(heap());
+    return static_cast<NormalPageHeap*>(arena());
 }
 
-LargeObjectPage::LargeObjectPage(PageMemory* storage, BaseHeap* heap, size_t payloadSize)
-    : BasePage(storage, heap)
+LargeObjectPage::LargeObjectPage(PageMemory* storage, BaseArena* arena, size_t payloadSize)
+    : BasePage(storage, arena)
     , m_payloadSize(payloadSize)
 #if ENABLE(ASAN_CONTAINER_ANNOTATIONS)
     , m_isVectorBackingPage(false)
 #endif
 {
 }
 
 size_t LargeObjectPage::objectPayloadSizeForTesting()
 {
     markAsSwept();
     return payloadSize();
 }
 
 bool LargeObjectPage::isEmpty()
 {
     return !heapObjectHeader()->isMarked();
 }
 
 void LargeObjectPage::removeFromHeap()
 {
-    static_cast<LargeObjectHeap*>(heap())->freeLargeObjectPage(this);
+    static_cast<LargeObjectHeap*>(arena())->freeLargeObjectPage(this);
 }
 
 void LargeObjectPage::sweep()
 {
     heapObjectHeader()->unmark();
-    heap()->threadState()->increaseMarkedObjectSize(size());
+    arena()->threadState()->increaseMarkedObjectSize(size());
 }
 
 void LargeObjectPage::makeConsistentForGC()
 {
     HeapObjectHeader* header = heapObjectHeader();
     if (header->isMarked()) {
         header->unmark();
-        heap()->threadState()->increaseMarkedObjectSize(size());
+        arena()->threadState()->increaseMarkedObjectSize(size());
     } else {
         header->markDead();
     }
 }
 
 void LargeObjectPage::makeConsistentForMutator()
 {
     HeapObjectHeader* header = heapObjectHeader();
     if (header->isMarked())
         header->unmark();
@@ skipping 100 matching lines @@
 
     m_hasEntries = true;
     size_t index = hash(address);
     ASSERT(!(index & 1));
     Address cachePage = roundToBlinkPageStart(address);
     m_entries[index + 1] = m_entries[index];
     m_entries[index] = cachePage;
 }
 
 } // namespace blink