Simplify visitor marking mode tracking.

third_party/WebKit/Source/platform/heap/Visitor.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 115 matching lines @@
   template <typename VisitorDispatcher>                                 \
   inline void traceAfterDispatchImpl(VisitorDispatcher visitor)
 
 #define EMPTY_MACRO_ARGUMENT
 
 #define DECLARE_TRACE() DECLARE_TRACE_IMPL(EMPTY_MACRO_ARGUMENT)
 #define DECLARE_VIRTUAL_TRACE() DECLARE_TRACE_IMPL(virtual)
 #define DEFINE_INLINE_TRACE() DEFINE_INLINE_TRACE_IMPL(EMPTY_MACRO_ARGUMENT)
 #define DEFINE_INLINE_VIRTUAL_TRACE() DEFINE_INLINE_TRACE_IMPL(virtual)
 
+enum class VisitorMarkingMode {
+  // This is a default visitor. This is used for GCType=GCWithSweep
+  // and GCType=GCWithoutSweep.
+  GlobalMarking,
+  // This visitor does not trace objects outside the heap of the
+  // GCing thread. This is used for GCType=ThreadTerminationGC.
+  ThreadLocalMarking,
+  // This visitor just marks objects and ignores weak processing.
+  // This is used for GCType=TakeSnapshot.
+  SnapshotMarking,
+  // This visitor is used to trace objects during weak processing.
+  // This visitor is allowed to trace only already marked objects.
+  WeakProcessing,
+  // Perform global marking along with preparing for additional sweep
+  // compaction of heap arenas afterwards. Compared to the GlobalMarking
+  // visitor, this visitor will also register references to objects
+  // that might be moved during arena compaction -- the compaction
+  // pass will then fix up those references when the object move goes
+  // ahead.
+  GlobalMarkingWithCompaction,
+};
+
 // VisitorHelper contains common implementation of Visitor helper methods.
 //
 // VisitorHelper avoids virtual methods by using CRTP.
 // c.f. http://en.wikipedia.org/wiki/Curiously_Recurring_Template_Pattern
 template <typename Derived>
 class VisitorHelper {
  public:
-  VisitorHelper(ThreadState* state) : m_state(state) {}
+  VisitorHelper(ThreadState* state, VisitorMarkingMode markingMode)
+      : m_state(state), m_markingMode(markingMode) {}
 
   // One-argument templated mark method. This uses the static type of
   // the argument to get the TraceTrait. By default, the mark method
   // of the TraceTrait just calls the virtual two-argument mark method on this
   // visitor, where the second argument is the static trace method of the trait.
   template <typename T>
   void mark(T* t) {
     static_assert(sizeof(T), "T must be fully defined");
     static_assert(IsGarbageCollectedType<T>::value,
                   "T needs to be a garbage collected object");
@@ skipping 114 matching lines @@
                                     MovingObjectCallback callback,
                                     void* callbackData) {
     Derived::fromHelper(this)->registerMovingObjectCallback(
         reinterpret_cast<MovableReference>(backingStore), callback,
         callbackData);
   }
 
   inline ThreadState* state() const { return m_state; }
   inline ThreadHeap& heap() const { return state()->heap(); }
 
+  inline VisitorMarkingMode getMarkingMode() const { return m_markingMode; }
+
+  inline bool isGlobalMarking() const {
+    return m_markingMode == VisitorMarkingMode::GlobalMarking ||
+           m_markingMode == VisitorMarkingMode::GlobalMarkingWithCompaction;
+  }
+
  private:
   template <typename T>
   static void handleWeakCell(Visitor* self, void* object);
 
   ThreadState* const m_state;
+  const VisitorMarkingMode m_markingMode;
 };
 
 // Visitor is used to traverse the Blink object graph. Used for the
 // marking phase of the mark-sweep garbage collector.
 //
 // Pointers are marked and pushed on the marking stack by calling the
 // |mark| method with the pointer as an argument.
 //
 // Pointers within objects are traced by calling the |trace| methods
 // with the object as an argument. Tracing objects will mark all of the
 // contained pointers and push them on the marking stack.
 class PLATFORM_EXPORT Visitor : public VisitorHelper<Visitor> {
  public:
   friend class VisitorHelper<Visitor>;
   friend class InlinedGlobalMarkingVisitor;
 
-  enum MarkingMode {
-    // This is a default visitor. This is used for GCType=GCWithSweep
-    // and GCType=GCWithoutSweep.
-    GlobalMarking,
-    // This visitor does not trace objects outside the heap of the
-    // GCing thread. This is used for GCType=ThreadTerminationGC.
-    ThreadLocalMarking,
-    // This visitor just marks objects and ignores weak processing.
-    // This is used for GCType=TakeSnapshot.
-    SnapshotMarking,
-    // This visitor is used to trace objects during weak processing.
-    // This visitor is allowed to trace only already marked objects.
-    WeakProcessing,
-    // Perform global marking along with preparing for additional sweep
-    // compaction of heap arenas afterwards. Compared to the GlobalMarking
-    // visitor, this visitor will also register references to objects
-    // that might be moved during arena compaction -- the compaction
-    // pass will then fix up those references when the object move goes
-    // ahead.
-    GlobalMarkingWithCompaction,
-  };
-
-  static std::unique_ptr<Visitor> create(ThreadState*, MarkingMode);
+  static std::unique_ptr<Visitor> create(ThreadState*, VisitorMarkingMode);
 
   virtual ~Visitor();
 
   using VisitorHelper<Visitor>::mark;
 
   // This method marks an object and adds it to the set of objects
   // that should have their trace method called. Since not all
   // objects have vtables we have to have the callback as an
   // explicit argument, but we can use the templated one-argument
   // mark method above to automatically provide the callback
@@ skipping 45 matching lines @@
   virtual bool ensureMarked(const void*) = 0;
 
   virtual void registerMovingObjectReference(MovableReference*) = 0;
 
   virtual void registerMovingObjectCallback(MovableReference,
                                             MovingObjectCallback,
                                             void*) = 0;
 
   virtual void registerWeakCellWithCallback(void**, WeakCallback) = 0;
 
-  inline MarkingMode getMarkingMode() const { return m_markingMode; }
-
-  inline bool isGlobalMarking() const {
-    return m_markingMode == GlobalMarking ||
-           m_markingMode == GlobalMarkingWithCompaction;
-  }
-
  protected:
-  Visitor(ThreadState*, MarkingMode);
+  Visitor(ThreadState*, VisitorMarkingMode);
 
  private:
   static Visitor* fromHelper(VisitorHelper<Visitor>* helper) {
     return static_cast<Visitor*>(helper);
   }
-
-  const MarkingMode m_markingMode;
 };
 
 }  // namespace blink
 
 #endif  // Visitor_h