Rename BaseHeap to BaseArena

third_party/WebKit/Source/platform/heap/HeapPage.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 334 matching lines @@
 //
 // - LargeObjectPage is a page that contains only one object. The object size
 //   is arbitrary. An object whose size is larger than |blinkPageSize| is stored
 //   as a single project in LargeObjectPage.
 //
 // Note: An object whose size is between |largeObjectSizeThreshold| and
 // |blinkPageSize| can go to either of NormalPage or LargeObjectPage.
 class BasePage {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 public:
-    BasePage(PageMemory*, BaseHeap*);
+    BasePage(PageMemory*, BaseArena*);
     virtual ~BasePage() { }
 
     void link(BasePage** previousNext)
     {
         m_next = *previousNext;
         *previousNext = this;
     }
     void unlink(BasePage** previousNext)
     {
         *previousNext = m_next;
@@ skipping 35 matching lines @@
 
     virtual void takeSnapshot(WebMemoryAllocatorDump*, ThreadState::GCSnapshotInfo&, HeapSnapshotInfo&) = 0;
 #if ENABLE(ASSERT)
     virtual bool contains(Address) = 0;
 #endif
     virtual size_t size() = 0;
     virtual bool isLargeObjectPage() { return false; }
 
     Address getAddress() { return reinterpret_cast<Address>(this); }
     PageMemory* storage() const { return m_storage; }
-    BaseHeap* heap() const { return m_heap; }
-    bool orphaned() { return !m_heap; }
+    BaseArena* arena() const { return m_arena; }
+    bool orphaned() { return !m_arena; }
     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;
-    BaseHeap* m_heap;
+    BaseArena* m_arena;
     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 BaseHeap;
+    friend class BaseArena;
 };
 
 class NormalPage final : public BasePage {
 public:
-    NormalPage(PageMemory*, BaseHeap*);
+    NormalPage(PageMemory*, BaseArena*);
 
     Address payload()
     {
         return getAddress() + pageHeaderSize();
     }
     size_t payloadSize()
     {
         return (blinkPagePayloadSize() - pageHeaderSize()) & ~allocationMask;
     }
     Address payloadEnd() { return payload() + payloadSize(); }
@@ skipping 25 matching lines @@
     size_t size() override { return blinkPageSize; }
     static size_t pageHeaderSize()
     {
         // 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.
         size_t paddingSize = (sizeof(NormalPage) + allocationGranularity - (sizeof(HeapObjectHeader) % allocationGranularity)) % allocationGranularity;
         return sizeof(NormalPage) + paddingSize;
     }
 
 
-    NormalPageHeap* heapForNormalPage();
+    NormalPageHeap* arenaForNormalPage();
 
 private:
     HeapObjectHeader* findHeaderFromAddress(Address);
     void populateObjectStartBitMap();
 
     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 LargeObjectPage final : public BasePage {
 public:
-    LargeObjectPage(PageMemory*, BaseHeap*, size_t);
+    LargeObjectPage(PageMemory*, BaseArena*, size_t);
 
     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();
     }
 
     size_t objectPayloadSizeForTesting() override;
@@ skipping 119 matching lines @@
 
 private:
     int m_biggestFreeListIndex;
 
     // All FreeListEntries in the nth list have size >= 2^n.
     FreeListEntry* m_freeLists[blinkPageSizeLog2];
 
     friend class NormalPageHeap;
 };
 
-// Each thread has a number of thread heaps (e.g., Generic heaps,
-// typed heaps for Node, heaps for collection backings etc)
-// and BaseHeap represents each thread heap.
+// Each thread has a number of thread arenas (e.g., Generic arenas,
+// typed arenas for Node, arenas for collection backings etc)
+// and BaseArena represents each thread heap.
 //
-// BaseHeap is a parent class of NormalPageHeap and LargeObjectHeap.
+// BaseArena is a parent class of NormalPageHeap and LargeObjectHeap.
 // NormalPageHeap represents a heap that contains NormalPages
 // and LargeObjectHeap represents a heap that contains LargeObjectPages.
-class PLATFORM_EXPORT BaseHeap {
-    USING_FAST_MALLOC(BaseHeap);
+class PLATFORM_EXPORT BaseArena {
+    USING_FAST_MALLOC(BaseArena);
 public:
-    BaseHeap(ThreadState*, int);
-    virtual ~BaseHeap();
+    BaseArena(ThreadState*, int);
+    virtual ~BaseArena();
     void cleanupPages();
 
     void takeSnapshot(const String& dumpBaseName, ThreadState::GCSnapshotInfo&);
 #if ENABLE(ASSERT)
     BasePage* findPageFromAddress(Address);
 #endif
     virtual void takeFreelistSnapshot(const String& dumpBaseName) { }
     virtual void clearFreeLists() { }
     void makeConsistentForGC();
     void makeConsistentForMutator();
 #if ENABLE(ASSERT)
     virtual bool isConsistentForGC() = 0;
 #endif
     size_t objectPayloadSizeForTesting();
     void prepareHeapForTermination();
     void prepareForSweep();
 #if defined(ADDRESS_SANITIZER)
     void poisonHeap(BlinkGC::ObjectsToPoison, BlinkGC::Poisoning);
 #endif
     Address lazySweep(size_t, size_t gcInfoIndex);
     void sweepUnsweptPage();
     // Returns true if we have swept all pages within the deadline.
     // Returns false otherwise.
     bool lazySweepWithDeadline(double deadlineSeconds);
     void completeSweep();
 
     ThreadState* threadState() { return m_threadState; }
-    int heapIndex() const { return m_index; }
+    int arenaIndex() const { return m_index; }
 
 protected:
     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 NormalPageHeap final : public BaseHeap {
+class PLATFORM_EXPORT NormalPageHeap final : public BaseArena {
 public:
     NormalPageHeap(ThreadState*, int);
     void addToFreeList(Address address, size_t size)
     {
         ASSERT(findPageFromAddress(address));
         ASSERT(findPageFromAddress(address + size - 1));
         m_freeList.addToFreeList(address, size);
     }
     void clearFreeLists() override;
 #if ENABLE(ASSERT)
@@ skipping 34 matching lines @@
 
     FreeList m_freeList;
     Address m_currentAllocationPoint;
     size_t m_remainingAllocationSize;
     size_t m_lastRemainingAllocationSize;
 
     // The size of promptly freed objects in the heap.
     size_t m_promptlyFreedSize;
 };
 
-class LargeObjectHeap final : public BaseHeap {
+class LargeObjectHeap final : public BaseArena {
 public:
     LargeObjectHeap(ThreadState*, int);
     Address allocateLargeObjectPage(size_t, size_t gcInfoIndex);
     void freeLargeObjectPage(LargeObjectPage*);
 #if ENABLE(ASSERT)
     bool isConsistentForGC() override { return true; }
 #endif
 private:
     Address doAllocateLargeObjectPage(size_t, size_t gcInfoIndex);
     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 the size of a guard 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.
+// typed arenas.  This is only exported to enable tests in HeapTest.cpp.
 PLATFORM_EXPORT inline BasePage* pageFromObject(const void* object)
 {
     Address address = reinterpret_cast<Address>(const_cast<void*>(object));
     BasePage* page = reinterpret_cast<BasePage*>(blinkPageAddress(address) + blinkGuardPageSize);
     ASSERT(page->contains(address));
     return page;
 }
 
 NO_SANITIZE_ADDRESS inline
 size_t HeapObjectHeader::size() const
@@ skipping 97 matching lines @@
         SET_MEMORY_ACCESSIBLE(result, allocationSize - sizeof(HeapObjectHeader));
         ASSERT(findPageFromAddress(headerAddress + allocationSize - 1));
         return result;
     }
     return outOfLineAllocate(allocationSize, gcInfoIndex);
 }
 
 } // namespace blink
 
 #endif // HeapPage_h