Decouple root visitors from object visitors.

src/global-handles.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_GLOBAL_HANDLES_H_
 #define V8_GLOBAL_HANDLES_H_
 
 #include <type_traits>
 
 #include "include/v8.h"
 #include "include/v8-profiler.h"
 
 #include "src/handles.h"
 #include "src/list.h"
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 
 class HeapStats;
-class ObjectVisitor;
+class RootVisitor;
 
 // Structure for tracking global handles.
 // A single list keeps all the allocated global handles.
 // Destroyed handles stay in the list but is added to the free list.
 // At GC the destroyed global handles are removed from the free list
 // and deallocated.
 
 enum WeaknessType {
   // Embedder gets a handle to the dying object.
   FINALIZER_WEAK,
@@ skipping 86 matching lines @@
 
   // Tells whether global handle is weak.
   static bool IsWeak(Object** location);
 
   // Process pending weak handles.
   // Returns the number of freed nodes.
   int PostGarbageCollectionProcessing(
       GarbageCollector collector, const v8::GCCallbackFlags gc_callback_flags);
 
   // Iterates over all strong handles.
-  void IterateStrongRoots(ObjectVisitor* v);
+  void IterateStrongRoots(RootVisitor* v);
 
   // Iterates over all handles.
-  void IterateAllRoots(ObjectVisitor* v);
+  void IterateAllRoots(RootVisitor* v);
 
   // Iterates over all handles that have embedder-assigned class ID.
   void IterateAllRootsWithClassIds(v8::PersistentHandleVisitor* v);
 
   // Iterates over all handles in the new space that have embedder-assigned
   // class ID.
   void IterateAllRootsInNewSpaceWithClassIds(v8::PersistentHandleVisitor* v);
 
   // Iterate over all handles in the new space that are weak, unmodified
   // and have class IDs
   void IterateWeakRootsInNewSpaceWithClassIds(v8::PersistentHandleVisitor* v);
 
   // Iterates over all weak roots in heap.
-  void IterateWeakRoots(ObjectVisitor* v);
+  void IterateWeakRoots(RootVisitor* v);
 
   // Find all weak handles satisfying the callback predicate, mark
   // them as pending.
   void IdentifyWeakHandles(WeakSlotCallback f);
 
   // NOTE: Five ...NewSpace... functions below are used during
   // scavenge collections and iterate over sets of handles that are
   // guaranteed to contain all handles holding new space objects (but
   // may also include old space objects).
 
   // Iterates over strong and dependent handles. See the node above.
-  void IterateNewSpaceStrongAndDependentRoots(ObjectVisitor* v);
+  void IterateNewSpaceStrongAndDependentRoots(RootVisitor* v);
 
   // Finds weak independent or partially independent handles satisfying
   // the callback predicate and marks them as pending. See the note above.
   void IdentifyNewSpaceWeakIndependentHandles(WeakSlotCallbackWithHeap f);
 
   // Iterates over weak independent or partially independent handles.
   // See the note above.
-  void IterateNewSpaceWeakIndependentRoots(ObjectVisitor* v);
+  void IterateNewSpaceWeakIndependentRoots(RootVisitor* v);
 
   // Finds weak independent or unmodified handles satisfying
   // the callback predicate and marks them as pending. See the note above.
   void MarkNewSpaceWeakUnmodifiedObjectsPending(
       WeakSlotCallbackWithHeap is_unscavenged);
 
   // Iterates over weak independent or unmodified handles.
   // See the note above.
   template <IterationMode mode>
-  void IterateNewSpaceWeakUnmodifiedRoots(ObjectVisitor* v);
+  void IterateNewSpaceWeakUnmodifiedRoots(RootVisitor* v);
 
   // Identify unmodified objects that are in weak state and marks them
   // unmodified
   void IdentifyWeakUnmodifiedObjects(WeakSlotCallback is_unmodified);
 
   // Tear down the global handle structure.
   void TearDown();
 
   Isolate* isolate() { return isolate_; }
 
@@ skipping 111 matching lines @@
 
   // Assign a SingletonHandle to an empty slot and returns the handle.
   Handle<Object> CreateSingleton(Isolate* isolate,
                                  Object* object,
                                  SingletonHandle singleton) {
     Create(isolate, object, &singleton_handles_[singleton]);
     return Get(singleton_handles_[singleton]);
   }
 
   // Iterates over all handles.
-  void IterateAllRoots(ObjectVisitor* visitor);
+  void IterateAllRoots(RootVisitor* visitor);
   // Iterates over all handles which might be in new space.
-  void IterateNewSpaceRoots(ObjectVisitor* visitor);
+  void IterateNewSpaceRoots(RootVisitor* visitor);
   // Rebuilds new space list.
   void PostGarbageCollectionProcessing(Heap* heap);
 
  private:
   static const int kInvalidIndex = -1;
   static const int kShift = 8;
   static const int kSize = 1 << kShift;
   static const int kMask = 0xff;
 
   // Gets the slot for an index
   inline Object** GetLocation(int index) {
     DCHECK(index >= 0 && index < size_);
     return &blocks_[index >> kShift][index & kMask];
   }
 
   int size_;
   List<Object**> blocks_;
   List<int> new_space_indices_;
   int singleton_handles_[NUMBER_OF_SINGLETON_HANDLES];
 
   DISALLOW_COPY_AND_ASSIGN(EternalHandles);
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_GLOBAL_HANDLES_H_