Oilpan: Remove Heap::s_lastGCWasConservative

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 900 matching lines @@
         ConservativeGC,
         ForcedGC,
         NumberOfGCReason
     };
     static const char* gcReasonString(GCReason);
     static void collectGarbage(ThreadState::StackState, ThreadState::GCType, GCReason);
     static void collectGarbageForTerminatingThread(ThreadState*);
     static void collectAllGarbage();
 
     static void processMarkingStack(Visitor*);
+    static void processEphemerons(Visitor*);
     static void postMarkingProcessing(Visitor*);
     static void globalWeakProcessing(Visitor*);
     static void setForcePreciseGCForTesting();
 
     static void preGC();
     static void postGC(ThreadState::GCType);
 
     // Conservatively checks whether an address is a pointer in any of the
     // thread heaps.  If so marks the object pointed to as live.
     static Address checkAndMarkPointer(Visitor*, Address);
 
 #if ENABLE(GC_PROFILING)
     // Dump the path to specified object on the next GC.  This method is to be
     // invoked from GDB.
     static void dumpPathToObjectOnNextGC(void* p);
 
     // Forcibly find GCInfo of the object at Address.  This is slow and should
     // only be used for debug purposes.  It involves finding the heap page and
     // scanning the heap page for an object header.
     static const GCInfo* findGCInfo(Address);
 
     static String createBacktraceString();
 #endif
 
     static size_t objectPayloadSizeForTesting();
 
     static void flushHeapDoesNotContainCache();
 
-    // Return true if the last GC found a pointer into a heap page
-    // during conservative scanning.
-    static bool lastGCWasConservative() { return s_lastGCWasConservative; }
-
     static FreePagePool* freePagePool() { return s_freePagePool; }
     static OrphanedPagePool* orphanedPagePool() { return s_orphanedPagePool; }
 
     // This look-up uses the region search tree and a negative contains cache to
     // provide an efficient mapping from arbitrary addresses to the containing
     // heap-page if one exists.
     static BasePage* lookup(Address);
     static void addPageMemoryRegion(PageMemoryRegion*);
     static void removePageMemoryRegion(PageMemoryRegion*);
 
@@ skipping 45 matching lines @@
     // Reset counters that track live and allocated-since-last-GC sizes.
     static void resetHeapCounters();
 
     static Visitor* s_markingVisitor;
     static CallbackStack* s_markingStack;
     static CallbackStack* s_postMarkingCallbackStack;
     static CallbackStack* s_globalWeakCallbackStack;
     static CallbackStack* s_ephemeronStack;
     static HeapDoesNotContainCache* s_heapDoesNotContainCache;
     static bool s_shutdownCalled;
-    static bool s_lastGCWasConservative;
     static FreePagePool* s_freePagePool;
     static OrphanedPagePool* s_orphanedPagePool;
     static RegionTree* s_regionTree;
     static size_t s_allocatedSpace;
     static size_t s_allocatedObjectSize;
     static size_t s_markedObjectSize;
     static size_t s_estimatedLiveObjectSize;
     static size_t s_externalObjectSizeAtLastGC;
     static double s_estimatedMarkingTimePerByte;
 
@@ skipping 264 matching lines @@
     size_t copySize = previousHeader->payloadSize();
     if (copySize > size)
         copySize = size;
     memcpy(address, previous, copySize);
     return address;
 }
 
 } // namespace blink
 
 #endif // Heap_h