Oilpan: Always enter a GCScope when we run a GC

Source/platform/heap/ThreadState.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 169 matching lines @@
     // each thread. When threads reach a safe point they record
     // whether or not they have pointers on the stack.
     enum StackState {
         NoHeapPointersOnStack,
         HeapPointersOnStack
     };
 
     enum GCType {
         GCWithSweep, // Sweeping is completed in Heap::collectGarbage().
         GCWithoutSweep, // Lazy sweeping is scheduled.
+        ThreadTerminationGC, // A thread-local GC scheduled before the thread shutdown.
     };
 
     // See setGCState() for possible state transitions.
     enum GCState {
         NoGCScheduled,
         IdleGCScheduled,
         PreciseGCScheduled,
         FullGCScheduled,
         StoppingOtherThreads,
         GCRunning,
@@ skipping 186 matching lines @@
 
     // Request all other threads to stop. Must only be called if the current thread is at safepoint.
     static bool stopThreads();
     static void resumeThreads();
 
     // Check if GC is requested by another thread and pause this thread if this is the case.
     // Can only be called when current thread is in a consistent state.
     void safePoint(StackState);
 
     // Mark current thread as running inside safepoint.
-    void enterSafePointWithPointers(void* scopeMarker) { enterSafePoint(HeapPointersOnStack, scopeMarker); }
+    void enterSafePoint(StackState, void*);
     void leaveSafePoint(SafePointAwareMutexLocker* = nullptr);
     bool isAtSafePoint() const { return m_atSafePoint; }
 
     // If attached thread enters long running loop that can call back
     // into Blink and leaving and reentering safepoint at every
     // transition between this loop and Blink is deemed too expensive
     // then instead of marking this loop as a GC safepoint thread
     // can provide an interruptor object which would allow GC
     // to temporarily interrupt and pause this long running loop at
     // an arbitrary moment creating a safepoint for a GC.
@@ skipping 208 matching lines @@
     {
         return Vector1HeapIndex <= heapIndex && heapIndex <= Vector4HeapIndex;
     }
     void allocationPointAdjusted(int heapIndex);
     void promptlyFreed(size_t gcInfoIndex);
 
 private:
     ThreadState();
     ~ThreadState();
 
-    void enterSafePoint(StackState, void*);
     NO_SANITIZE_ADDRESS void copyStackUntilSafePointScope();
     void clearSafePointScopeMarker()
     {
         m_safePointStackCopy.clear();
         m_safePointScopeMarker = nullptr;
     }
 
     // shouldSchedule{Precise,Idle}GC and shouldForceConservativeGC
     // implement the heuristics that are used to determine when to collect garbage.
     // If shouldForceConservativeGC returns true, we force the garbage
@@ skipping 106 matching lines @@
 };
 
 template<> class ThreadStateFor<AnyThread> {
 public:
     static ThreadState* state() { return ThreadState::current(); }
 };
 
 } // namespace blink
 
 #endif // ThreadState_h