Oilpan: Introduce a state transition model for Oilpan GC states

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 901 matching lines @@
     template<typename T> static Address reallocate(void* previous, size_t);
 
     static void collectGarbage(ThreadState::StackState, ThreadState::CauseOfGC = ThreadState::NormalGC);
     static void collectGarbageForTerminatingThread(ThreadState*);
     static void collectAllGarbage();
     template<CallbackInvocationMode Mode> static void processMarkingStack();
     static void postMarkingProcessing();
     static void globalWeakProcessing();
     static void setForcePreciseGCForTesting();
 
-    static void prepareForGC();
+    static void preGC();
+    static void postGC();
 
     // 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_PROFILE_MARKING)
     // 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 void enterGC() { ASSERT(!s_inGC); s_inGC = true; }
+    static void leaveGC() { ASSERT(s_inGC); s_inGC = false; }
+    static bool isInGC() { return s_inGC; }
+
     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 BaseHeapPage* lookup(Address);
     static void addPageMemoryRegion(PageMemoryRegion*);
     static void removePageMemoryRegion(PageMemoryRegion*);
 
@@ skipping 19 matching lines @@
         }
         PageMemoryRegion* lookup(Address);
         static void add(RegionTree*, RegionTree**);
         static void remove(PageMemoryRegion*, RegionTree**);
     private:
         PageMemoryRegion* m_region;
         RegionTree* m_left;
         RegionTree* m_right;
     };
 
-    static void resetAllocatedObjectSize() { ASSERT(ThreadState::isAnyThreadInGC()); s_allocatedObjectSize = 0; }
-    static void resetMarkedObjectSize() { ASSERT(ThreadState::isAnyThreadInGC()); s_markedObjectSize = 0; }
+    static void resetAllocatedObjectSize() { ASSERT(Heap::isInGC()); s_allocatedObjectSize = 0; }
+    static void resetMarkedObjectSize() { ASSERT(Heap::isInGC()); s_markedObjectSize = 0; }
 
     static Visitor* s_markingVisitor;
     static CallbackStack* s_markingStack;
     static CallbackStack* s_postMarkingCallbackStack;
     static CallbackStack* s_weakCallbackStack;
     static CallbackStack* s_ephemeronStack;
     static HeapDoesNotContainCache* s_heapDoesNotContainCache;
     static bool s_shutdownCalled;
     static bool s_lastGCWasConservative;
+    static bool s_inGC;
     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;
     friend class ThreadState;
 };
 
 // The NoAllocationScope class is used in debug mode to catch unwanted
@@ skipping 1332 matching lines @@
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapVector<T, inlineCapacity> > : public GCInfoTrait<Vector<T, inlineCapacity, HeapAllocator> > { };
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapDeque<T, inlineCapacity> > : public GCInfoTrait<Deque<T, inlineCapacity, HeapAllocator> > { };
 template<typename T, typename U, typename V>
 struct GCInfoTrait<HeapHashCountedSet<T, U, V> > : public GCInfoTrait<HashCountedSet<T, U, V, HeapAllocator> > { };
 
 } // namespace blink
 
 #endif // Heap_h