Oilpan: Factor out GC-related enum definitions to BlinkGC.h

third_party/WebKit/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 187 matching lines @@
     enum GCReason {
         IdleGC,
         PreciseGC,
         ConservativeGC,
         ForcedGC,
         MemoryPressureGC,
         PageNavigationGC,
         NumberOfGCReason,
     };
     static const char* gcReasonString(GCReason);
-    static void collectGarbage(ThreadState::StackState, ThreadState::GCType, GCReason);
+    static void collectGarbage(BlinkGC::StackState, BlinkGC::GCType, GCReason);
     static void collectGarbageForTerminatingThread(ThreadState*);
     static void collectAllGarbage();
 
     static void processMarkingStack(Visitor*);
     static void postMarkingProcessing(Visitor*);
     static void globalWeakProcessing(Visitor*);
     static void setForcePreciseGCForTesting();
 
     static void preGC();
-    static void postGC(ThreadState::GCType);
+    static void postGC(BlinkGC::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);
 
@@ skipping 175 matching lines @@
 // sweeping kicks in for their heap and page. The EAGERLY_FINALIZE()
 // macro is used to declare a class (and its derived classes) as being
 // in need of eager finalization. Must be defined with 'public' visibility
 // for a class.
 //
 
 inline int Heap::heapIndexForObjectSize(size_t size)
 {
     if (size < 64) {
         if (size < 32)
-            return ThreadState::NormalPage1HeapIndex;
-        return ThreadState::NormalPage2HeapIndex;
+            return BlinkGC::NormalPage1HeapIndex;
+        return BlinkGC::NormalPage2HeapIndex;
     }
     if (size < 128)
-        return ThreadState::NormalPage3HeapIndex;
-    return ThreadState::NormalPage4HeapIndex;
+        return BlinkGC::NormalPage3HeapIndex;
+    return BlinkGC::NormalPage4HeapIndex;
 }
 
 inline bool Heap::isNormalHeapIndex(int index)
 {
-    return index >= ThreadState::NormalPage1HeapIndex && index <= ThreadState::NormalPage4HeapIndex;
+    return index >= BlinkGC::NormalPage1HeapIndex && index <= BlinkGC::NormalPage4HeapIndex;
 }
 
 #define DECLARE_EAGER_FINALIZATION_OPERATOR_NEW() \
 public:                                           \
     GC_PLUGIN_IGNORE("491488")                    \
     void* operator new(size_t size)               \
     {                                             \
         return allocateObject(size, true);        \
     }
 
-#define IS_EAGERLY_FINALIZED() (pageFromObject(this)->heap()->heapIndex() == ThreadState::EagerSweepHeapIndex)
+#define IS_EAGERLY_FINALIZED() (pageFromObject(this)->heap()->heapIndex() == BlinkGC::EagerSweepHeapIndex)
 #if ENABLE(ASSERT) && ENABLE(OILPAN)
 class VerifyEagerFinalization {
 public:
     ~VerifyEagerFinalization()
     {
         // If this assert triggers, the class annotated as eagerly
         // finalized ended up not being allocated on the heap
         // set aside for eager finalization. The reason is most
         // likely that the effective 'operator new' overload for
         // this class' leftmost base is for a class that is not
@@ skipping 14 matching lines @@
 
 #if !ENABLE(OILPAN)
 #define EAGERLY_FINALIZE_WILL_BE_REMOVED() EAGERLY_FINALIZE()
 #else
 #define EAGERLY_FINALIZE_WILL_BE_REMOVED()
 #endif
 
 inline Address Heap::allocateOnHeapIndex(ThreadState* state, size_t size, int heapIndex, size_t gcInfoIndex)
 {
     ASSERT(state->isAllocationAllowed());
-    ASSERT(heapIndex != ThreadState::LargeObjectHeapIndex);
+    ASSERT(heapIndex != BlinkGC::LargeObjectHeapIndex);
     NormalPageHeap* heap = static_cast<NormalPageHeap*>(state->heap(heapIndex));
     return heap->allocateObject(allocationSizeFromSize(size), gcInfoIndex);
 }
 
 template<typename T>
 Address Heap::allocate(size_t size, bool eagerlySweep)
 {
     ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
-    return Heap::allocateOnHeapIndex(state, size, eagerlySweep ? ThreadState::EagerSweepHeapIndex : Heap::heapIndexForObjectSize(size), GCInfoTrait<T>::index());
+    return Heap::allocateOnHeapIndex(state, size, eagerlySweep ? BlinkGC::EagerSweepHeapIndex : Heap::heapIndexForObjectSize(size), GCInfoTrait<T>::index());
 }
 
 template<typename T>
 Address Heap::reallocate(void* previous, size_t size)
 {
     // Not intended to be a full C realloc() substitute;
     // realloc(nullptr, size) is not a supported alias for malloc(size).
 
     // TODO(sof): promptly free the previous object.
     if (!size) {
         // If the new size is 0 this is considered equivalent to free(previous).
         return nullptr;
     }
 
     ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
     HeapObjectHeader* previousHeader = HeapObjectHeader::fromPayload(previous);
     BasePage* page = pageFromObject(previousHeader);
     ASSERT(page);
     int heapIndex = page->heap()->heapIndex();
     // Recompute the effective heap index if previous allocation
     // was on the normal heaps or a large object.
-    if (isNormalHeapIndex(heapIndex) || heapIndex == ThreadState::LargeObjectHeapIndex)
+    if (isNormalHeapIndex(heapIndex) || heapIndex == BlinkGC::LargeObjectHeapIndex)
         heapIndex = heapIndexForObjectSize(size);
 
     // TODO(haraken): We don't support reallocate() for finalizable objects.
     ASSERT(!Heap::gcInfo(previousHeader->gcInfoIndex())->hasFinalizer());
     ASSERT(previousHeader->gcInfoIndex() == GCInfoTrait<T>::index());
     Address address = Heap::allocateOnHeapIndex(state, size, heapIndex, GCInfoTrait<T>::index());
     size_t copySize = previousHeader->payloadSize();
     if (copySize > size)
         copySize = size;
     memcpy(address, previous, copySize);
     return address;
 }
 
 template<typename Derived>
 template<typename T>
 void VisitorHelper<Derived>::handleWeakCell(Visitor* self, void* object)
 {
     T** cell = reinterpret_cast<T**>(object);
     if (*cell && !ObjectAliveTrait<T>::isHeapObjectAlive(*cell))
         *cell = nullptr;
 }
 
 } // namespace blink
 
 #endif // Heap_h