Move VisitorMarkingMode into Visitor.

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 76 matching lines @@
 #define DEFINE_INLINE_TRACE_AFTER_DISPATCH() \
   void traceAfterDispatch(blink::Visitor* 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 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,
-};
-
 // 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:
-  static std::unique_ptr<Visitor> create(ThreadState*, VisitorMarkingMode);
+  enum MarkingMode {
+    // This is a default visitor. This is used for GCType=GCWithSweep
+    // and GCType=GCWithoutSweep.
+    GlobalMarking,
+    // 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,
+  };
 
-  Visitor(ThreadState*, VisitorMarkingMode);
+  static std::unique_ptr<Visitor> create(ThreadState*, MarkingMode);
+
+  Visitor(ThreadState*, MarkingMode);
   virtual ~Visitor();
 
   // 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,
@@ skipping 163 matching lines @@
   // Used to mark objects during conservative scanning.
   inline void markHeader(HeapObjectHeader*,
                          const void* objectPointer,
                          TraceCallback);
 
   inline void markHeader(HeapObjectHeader*, TraceCallback);
 
   inline ThreadState* state() const { return m_state; }
   inline ThreadHeap& heap() const { return state()->heap(); }
 
-  inline VisitorMarkingMode getMarkingMode() const { return m_markingMode; }
+  inline MarkingMode getMarkingMode() const { return m_markingMode; }
 
  private:
   template <typename T>
   static void handleWeakCell(Visitor* self, void*);
 
   static void markNoTracingCallback(Visitor*, void*);
 
   ThreadState* const m_state;
-  const VisitorMarkingMode m_markingMode;
+  const MarkingMode m_markingMode;
 };
 
 }  // namespace blink
 
 #endif  // Visitor_h