Refactor the Heap into ThreadHeap to prepare for per thread heaps

third_party/WebKit/Source/platform/heap/PageMemory.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef PageMemory_h
 #define PageMemory_h
 
 #include "platform/heap/HeapPage.h"
 #include "wtf/Assertions.h"
 #include "wtf/PageAllocator.h"
@@ skipping 57 matching lines @@
     {
         ASSERT(!m_inUse[index(page)]);
         m_inUse[index(page)] = true;
     }
 
     void markPageUnused(Address page)
     {
         m_inUse[index(page)] = false;
     }
 
-    static PageMemoryRegion* allocateLargePage(size_t size)
+    static PageMemoryRegion* allocateLargePage(size_t size, GCGroup* gcGroup)
     {
-        return allocate(size, 1);
+        return allocate(size, 1, gcGroup);
     }
 
-    static PageMemoryRegion* allocateNormalPages()
+    static PageMemoryRegion* allocateNormalPages(GCGroup* gcGroup)
     {
-        return allocate(blinkPageSize * blinkPagesPerRegion, blinkPagesPerRegion);
+        return allocate(blinkPageSize * blinkPagesPerRegion, blinkPagesPerRegion, gcGroup);
     }
 
     BasePage* pageFromAddress(Address address)
     {
         ASSERT(contains(address));
         if (!m_inUse[index(address)])
             return nullptr;
         if (m_isLargePage)
             return pageFromObject(base());
         return pageFromObject(address);
     }
 
 private:
-    PageMemoryRegion(Address base, size_t, unsigned numPages);
+    PageMemoryRegion(Address base, size_t, unsigned numPages, GCGroup*);
 
     unsigned index(Address address)
     {
         ASSERT(contains(address));
         if (m_isLargePage)
             return 0;
         size_t offset = blinkPageAddress(address) - base();
         ASSERT(offset % blinkPageSize == 0);
         return offset / blinkPageSize;
     }
 
-    static PageMemoryRegion* allocate(size_t, unsigned numPages);
+    static PageMemoryRegion* allocate(size_t, unsigned numPages, GCGroup*);
 
     bool m_isLargePage;
     bool m_inUse[blinkPagesPerRegion];
     unsigned m_numPages;
+    GCGroup* m_gcGroup;
 };
 
 // A RegionTree is a simple binary search tree of PageMemoryRegions sorted
 // by base addresses.
 class RegionTree {
 public:
     explicit RegionTree(PageMemoryRegion* region)
         : m_region(region)
         , m_left(nullptr)
         , m_right(nullptr)
     {
     }
 
     ~RegionTree()
     {
         delete m_left;
         delete m_right;
     }
 
     PageMemoryRegion* lookup(Address);
     static void add(RegionTree*, RegionTree**);
     static void remove(PageMemoryRegion*, RegionTree**);
 
 private:
     PageMemoryRegion* m_region;
     RegionTree* m_left;
     RegionTree* m_right;
-
-    static RegionTree* s_regionTree;
 };
 
 // Representation of the memory used for a Blink heap page.
 //
 // The representation keeps track of two memory regions:
 //
 // 1. The virtual memory reserved from the system in order to be able
 //    to free all the virtual memory reserved.  Multiple PageMemory
 //    instances can share the same reserved memory region and
 //    therefore notify the reserved memory region on destruction so
@@ skipping 33 matching lines @@
     static PageMemory* setupPageMemoryInRegion(PageMemoryRegion*, size_t pageOffset, size_t payloadSize);
 
     // Allocate a virtual address space for one blink page with the
     // following layout:
     //
     //    [ guard os page | ... payload ... | guard os page ]
     //    ^---{ aligned to blink page size }
     //
     // The returned page memory region will be zeroed.
     //
-    static PageMemory* allocate(size_t payloadSize);
+    static PageMemory* allocate(size_t payloadSize, GCGroup*);
 
 private:
     PageMemory(PageMemoryRegion* reserved, const MemoryRegion& writable);
 
     PageMemoryRegion* m_reserved;
     MemoryRegion m_writable;
 };
 
 } // namespace blink
 
 #endif