Oilpan: Rename makeConsistentForSweeping to makeConsistentForGC

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 367 matching lines @@
     }
     BasePage* next() const { return m_next; }
 
     // virtual methods are slow. So performance-sensitive methods
     // should be defined as non-virtual methods on NormalPage and LargeObjectPage.
     // The following methods are not performance-sensitive.
     virtual size_t objectPayloadSizeForTesting() = 0;
     virtual bool isEmpty() = 0;
     virtual void removeFromHeap() = 0;
     virtual void sweep() = 0;
-    virtual void markUnmarkedObjectsDead() = 0;
+    virtual void makeConsistentForGC() = 0;
 #if defined(ADDRESS_SANITIZER)
     virtual void poisonUnmarkedObjects() = 0;
 #endif
     // Check if the given address points to an object in this
     // heap page. If so, find the start of that object and mark it
     // using the given Visitor. Otherwise do nothing. The pointer must
     // be within the same aligned blinkPageSize as the this-pointer.
     //
     // This is used during conservative stack scanning to
     // conservatively mark all objects that could be referenced from
@@ skipping 66 matching lines @@
     Address payloadEnd() { return payload() + payloadSize(); }
     bool containedInObjectPayload(Address address)
     {
         return payload() <= address && address < payloadEnd();
     }
 
     virtual size_t objectPayloadSizeForTesting() override;
     virtual bool isEmpty() override;
     virtual void removeFromHeap() override;
     virtual void sweep() override;
-    virtual void markUnmarkedObjectsDead() override;
+    virtual void makeConsistentForGC() override;
 #if defined(ADDRESS_SANITIZER)
     virtual void poisonUnmarkedObjects() override;
 #endif
     virtual void checkAndMarkPointer(Visitor*, Address) override;
     virtual void markOrphaned() override;
 #if ENABLE(GC_PROFILING)
     const GCInfo* findGCInfo(Address) override;
     void snapshot(TracedValue*, ThreadState::SnapshotInfo*) override;
     void incrementMarkedObjectsAge() override;
     void countMarkedObjects(ClassAgeCountsMap&) override;
@@ skipping 41 matching lines @@
     Address payloadEnd() { return payload() + payloadSize(); }
     bool containedInObjectPayload(Address address)
     {
         return payload() <= address && address < payloadEnd();
     }
 
     virtual size_t objectPayloadSizeForTesting() override;
     virtual bool isEmpty() override;
     virtual void removeFromHeap() override;
     virtual void sweep() override;
-    virtual void markUnmarkedObjectsDead() override;
+    virtual void makeConsistentForGC() override;
 #if defined(ADDRESS_SANITIZER)
     virtual void poisonUnmarkedObjects() override;
 #endif
     virtual void checkAndMarkPointer(Visitor*, Address) override;
     virtual void markOrphaned() override;
 
 #if ENABLE(GC_PROFILING)
     const GCInfo* findGCInfo(Address) override;
     void snapshot(TracedValue*, ThreadState::SnapshotInfo*) override;
     void incrementMarkedObjectsAge() override;
@@ skipping 137 matching lines @@
 #if ENABLE(GC_PROFILING)
     void snapshot(TracedValue*, ThreadState::SnapshotInfo*);
     virtual void snapshotFreeList(TracedValue&) { };
 
     void countMarkedObjects(ClassAgeCountsMap&) const;
     void countObjectsToSweep(ClassAgeCountsMap&) const;
     void incrementMarkedObjectsAge();
 #endif
 
     virtual void clearFreeLists() { }
-    void makeConsistentForSweeping();
+    void makeConsistentForGC();
 #if ENABLE(ASSERT)
-    virtual bool isConsistentForSweeping() = 0;
+    virtual bool isConsistentForGC() = 0;
 #endif
     size_t objectPayloadSizeForTesting();
     void prepareHeapForTermination();
     void prepareForSweep();
 #if defined(ADDRESS_SANITIZER)
     void poisonUnmarkedObjects();
 #endif
     Address lazySweep(size_t, size_t gcInfoIndex);
     void sweepUnsweptPage();
     // Returns true if we have swept all pages within the deadline.
@@ skipping 22 matching lines @@
 public:
     NormalPageHeap(ThreadState*, int);
     void addToFreeList(Address address, size_t size)
     {
         ASSERT(findPageFromAddress(address));
         ASSERT(findPageFromAddress(address + size - 1));
         m_freeList.addToFreeList(address, size);
     }
     virtual void clearFreeLists() override;
 #if ENABLE(ASSERT)
-    virtual bool isConsistentForSweeping() override;
+    virtual bool isConsistentForGC() override;
     bool pagesToBeSweptContains(Address);
 #endif
 #if ENABLE(GC_PROFILING)
     void snapshotFreeList(TracedValue&) override;
 #endif
 
     Address allocateObject(size_t allocationSize, size_t gcInfoIndex);
 
     void freePage(NormalPage*);
 
@@ skipping 28 matching lines @@
     size_t m_inlineAllocationCount;
 #endif
 };
 
 class LargeObjectHeap final : public BaseHeap {
 public:
     LargeObjectHeap(ThreadState*, int);
     Address allocateLargeObjectPage(size_t, size_t gcInfoIndex);
     void freeLargeObjectPage(LargeObjectPage*);
 #if ENABLE(ASSERT)
-    virtual bool isConsistentForSweeping() override { return true; }
+    virtual bool isConsistentForGC() override { return true; }
 #endif
 private:
     Address doAllocateLargeObjectPage(size_t, size_t gcInfoIndex);
     virtual 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 an OS page 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.
@@ skipping 496 matching lines @@
     size_t copySize = previousHeader->payloadSize();
     if (copySize > size)
         copySize = size;
     memcpy(address, previous, copySize);
     return address;
 }
 
 } // namespace blink
 
 #endif // Heap_h