Rename BaseHeap to BaseArena part 2

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 107 matching lines @@
 #endif
 
 #if !ENABLE(ASSERT) && CPU(64BIT)
 #define USE_4BYTE_HEADER_PADDING 1
 #else
 #define USE_4BYTE_HEADER_PADDING 0
 #endif
 
 class CallbackStack;
 class FreePagePool;
-class NormalPageHeap;
+class NormalPageArena;
 class OrphanedPagePool;
 class PageMemory;
 class PageMemoryRegion;
 class WebMemoryAllocatorDump;
 
 // HeapObjectHeader is 4 byte (32 bit) that has the following layout:
 //
 // | gcInfoIndex (14 bit) | DOM mark bit (1 bit) | size (14 bit) | dead bit (1 bit) | freed bit (1 bit) | mark bit (1 bit) |
 //
 // - For non-large objects, 14 bit is enough for |size| because the blink
@@ skipping 346 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* arenaForNormalPage();
+    NormalPageArena* 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.
@@ skipping 133 matching lines @@
     static void zapFreedMemory(Address, size_t);
     static void checkFreedMemoryIsZapped(Address, size_t);
 #endif
 
 private:
     int m_biggestFreeListIndex;
 
     // All FreeListEntries in the nth list have size >= 2^n.
     FreeListEntry* m_freeLists[blinkPageSizeLog2];
 
-    friend class NormalPageHeap;
+    friend class NormalPageArena;
 };
 
 // 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.
+// and BaseArena represents each thread arena.
 //
-// BaseArena is a parent class of NormalPageHeap and LargeObjectHeap.
-// NormalPageHeap represents a heap that contains NormalPages
-// and LargeObjectHeap represents a heap that contains LargeObjectPages.
+// BaseArena is a parent class of NormalPageArena and LargeObjectArena.
+// NormalPageArena represents a part of a heap that contains NormalPages
+// and LargeObjectArena represents a part of a heap that contains
+// LargeObjectPages.
 class PLATFORM_EXPORT BaseArena {
     USING_FAST_MALLOC(BaseArena);
 public:
     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);
+    void poisonArena(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 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 BaseArena {
+class PLATFORM_EXPORT NormalPageArena final : public BaseArena {
 public:
-    NormalPageHeap(ThreadState*, int);
+    NormalPageArena(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)
     bool isConsistentForGC() override;
     bool pagesToBeSweptContains(Address);
@@ skipping 32 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 BaseArena {
+class LargeObjectArena final : public BaseArena {
 public:
-    LargeObjectHeap(ThreadState*, int);
+    LargeObjectArena(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;
 };
 
@@ skipping 90 matching lines @@
 }
 
 NO_SANITIZE_ADDRESS inline
 void HeapObjectHeader::markDead()
 {
     ASSERT(checkHeader());
     ASSERT(!isMarked());
     m_encoded |= headerDeadBitMask;
 }
 
-inline Address NormalPageHeap::allocateObject(size_t allocationSize, size_t gcInfoIndex)
+inline Address NormalPageArena::allocateObject(size_t allocationSize, size_t gcInfoIndex)
 {
     if (LIKELY(allocationSize <= m_remainingAllocationSize)) {
         Address headerAddress = m_currentAllocationPoint;
         m_currentAllocationPoint += allocationSize;
         m_remainingAllocationSize -= allocationSize;
         ASSERT(gcInfoIndex > 0);
         new (NotNull, headerAddress) HeapObjectHeader(allocationSize, gcInfoIndex);
         Address result = headerAddress + sizeof(HeapObjectHeader);
         ASSERT(!(reinterpret_cast<uintptr_t>(result) & allocationMask));
 
         SET_MEMORY_ACCESSIBLE(result, allocationSize - sizeof(HeapObjectHeader));
         ASSERT(findPageFromAddress(headerAddress + allocationSize - 1));
         return result;
     }
     return outOfLineAllocate(allocationSize, gcInfoIndex);
 }
 
 } // namespace blink
 
 #endif // HeapPage_h