Prepare for incremental sweep by making the FreeList independent of the ThreadHeap

Source/platform/heap/Heap.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 705 matching lines @@
     virtual void getStatsForTesting(HeapStats&) = 0;
 
     virtual void updateRemainingAllocationSize() = 0;
 
     virtual void prepareHeapForTermination() = 0;
 
     virtual int normalPageCount() = 0;
 
     virtual PassOwnPtr<BaseHeap> split(int normalPages) = 0;
     virtual void merge(PassOwnPtr<BaseHeap> other) = 0;
+};
 
+template<typename Header>
+class FreeList {
+public:
+    FreeList();
+
+    void addToFreeList(Address, size_t);
+    void clear();
+
+private:
     // Returns a bucket number for inserting a FreeListEntry of a
     // given size. All FreeListEntries in the given bucket, n, have
     // size >= 2^n.
     static int bucketIndexForSize(size_t);
+
+    int m_biggestFreeListIndex;
+
+    // All FreeListEntries in the nth list have size >= 2^n.
+    FreeListEntry* m_freeLists[blinkPageSizeLog2];
+    FreeListEntry* m_lastFreeListEntries[blinkPageSizeLog2];
+
+    friend class ThreadHeap<Header>;
 };
 
 // Thread heaps represent a part of the per-thread Blink heap.
 //
 // Each Blink thread has a number of thread heaps: one general heap
 // that contains any type of object and a number of heaps specialized
 // for specific object types (such as Node).
 //
 // Each thread heap contains the functionality to allocate new objects
 // (potentially adding new pages to the heap), to find and mark
@@ skipping 24 matching lines @@
 #if ENABLE(ASSERT)
     virtual bool isConsistentForSweeping() override;
 #endif
     virtual void getStatsForTesting(HeapStats&) override;
 
     virtual void updateRemainingAllocationSize() override;
 
     ThreadState* threadState() { return m_threadState; }
     HeapStats& stats() { return m_threadState->stats(); }
 
+    void addToFreeList(Address address, size_t size)
+    {
+        ASSERT(heapPageFromAddress(address));
+        ASSERT(heapPageFromAddress(address + size - 1));
+        m_freeList.addToFreeList(address, size);
+    }
+
     inline Address allocate(size_t, const GCInfo*);
-    void addToFreeList(Address, size_t);
     inline static size_t roundedAllocationSize(size_t size)
     {
         return allocationSizeFromSize(size) - sizeof(Header);
     }
 
     virtual void prepareHeapForTermination() override;
 
     virtual int normalPageCount() override { return m_numberOfNormalPages; }
 
     virtual PassOwnPtr<BaseHeap> split(int numberOfNormalPages) override;
@@ skipping 40 matching lines @@
 
     HeapPage<Header>* m_firstPage;
     LargeHeapObject<Header>* m_firstLargeHeapObject;
 
     HeapPage<Header>* m_firstPageAllocatedDuringSweeping;
     HeapPage<Header>* m_lastPageAllocatedDuringSweeping;
 
     // Merge point for parallel sweep.
     HeapPage<Header>* m_mergePoint;
 
-    int m_biggestFreeListIndex;
-
     ThreadState* m_threadState;
 
-    // All FreeListEntries in the nth list have size >= 2^n.
-    FreeListEntry* m_freeLists[blinkPageSizeLog2];
-    FreeListEntry* m_lastFreeListEntries[blinkPageSizeLog2];
+    FreeList<Header> m_freeList;
 
     // 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;
 
     int m_numberOfNormalPages;
 
     // The promptly freed count contains the number of promptly freed objects
     // since the last sweep or since it was manually reset to delay coalescing.
     size_t m_promptlyFreedCount;
@@ skipping 1544 matching lines @@
 };
 
 template<typename T>
 struct IfWeakMember<WeakMember<T> > {
     static bool isDead(Visitor* visitor, const WeakMember<T>& t) { return !visitor->isAlive(t.get()); }
 };
 
 }
 
 #endif // Heap_h