[oilpan] Rename visit to mark.

Source/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 35 matching lines @@
 #define TRACE_GC_USING_CLASSOF 1
 #else
 #define TRACE_GC_USING_CLASSOF 0
 #endif
 
 namespace WebCore {
 
 template<typename T> class Member;
 template<typename T> class WeakMember;
 class HeapAllocator;
-template<bool needsVisiting, bool isWeak, bool visitWeakPointersStrongly, typename T, typename Traits> struct VisitCollectionBackingTrait;
+template<bool needsTracing, bool isWeak, bool markWeakPointersStrongly, typename T, typename Traits> struct CollectionBackingTraceTrait;
 
 typedef void (*FinalizationCallback)(void*);
 
 class Visitor;
 typedef void (*VisitorCallback)(Visitor*, void* self);
 typedef VisitorCallback TraceCallback;
 typedef VisitorCallback WeakPointerCallback;
 
 template<typename T, void (T::*method)(Visitor*)>
 struct TraceMethodDelegate {
@@ skipping 120 matching lines @@
 template<typename T>
 class TraceTrait {
 public:
     // Default implementation of TraceTrait<T>::trace just statically
     // dispatches to the trace method of the class T.
     static void trace(Visitor* visitor, void* self)
     {
         static_cast<T*>(self)->trace(visitor);
     }
 
-    static void visit(Visitor*, const T*);
+    static void mark(Visitor*, const T*);
 
 #ifndef NDEBUG
     static void checkTypeMarker(Visitor*, const T*);
 #endif
 };
 
 template<typename T> class TraceTrait<const T> : public TraceTrait<T> { };
 
 template<typename K, typename V, typename HashTraits, typename KeyTraits, typename ValueTraits>
 void processWeakOffHeapHashMap(Visitor*, void* map);
 template<typename T, typename HashFunctions, typename Traits>
 void processWeakOffHeapHashSet(Visitor*, void* set);
 
 template<typename Collection>
-struct CollectionVisitingTrait {
-    static void visit(Visitor*, const Collection&);
+struct OffHeapCollectionTraceTrait {
+    static void mark(Visitor*, const Collection&);
 };
 
 template<typename T>
 struct ObjectAliveTrait {
     static bool isAlive(Visitor*, T);
 };
 
 template<typename T>
 struct ObjectAliveTrait<Member<T> > {
     static bool isAlive(Visitor*, const Member<T>&);
 };
 
 class HeapObjectHeader;
 class FinalizedHeapObjectHeader;
 
 #ifndef NDEBUG
 #define DEBUG_ONLY(x) x
 #else
 #define DEBUG_ONLY(x)
 #endif
 
 class Visitor {
 public:
 #if defined(TRACE_GC_MARKING) && TRACE_GC_MARKING
     Visitor() : m_hostObject(0), m_hostName(0) { }
 #endif
 
-    // One-argument templated visit method. This uses the static type of
-    // the argument to get the TraceTrait. By default, the visit method
-    // of the TraceTrait just calls the virtual two-argument visit method on this
+    // 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.
     template<typename T>
-    void visit(T* t)
+    void mark(T* t)
     {
         if (!t)
             return;
 #ifndef NDEBUG
         TraceTrait<T>::checkTypeMarker(this, t);
 #endif
-        TraceTrait<T>::visit(this, t);
+        TraceTrait<T>::mark(this, t);
     }
 
-    // Member version of the one-argument templated visit method.
+    // Member version of the one-argument templated mark method.
     template<typename T>
     void trace(const Member<T>& t)
     {
         if (!t)
             return;
 #ifndef NDEBUG
         TraceTrait<T>::checkTypeMarker(this, t.raw());
 #endif
-        TraceTrait<T>::visit(this, t.raw());
+        TraceTrait<T>::mark(this, t.raw());
     }
 
-    // Doesn't keep the visited thing alive, but will write null to the
+    // Doesn't keep the traced thing alive, but will write null to the
     // WeakMember later if the pointed-to object is dead.
     template<typename T>
     void trace(const WeakMember<T>& t)
     {
         registerWeakCell(t.cell());
     }
 
-    // The following visit methods are for off-heap collections.
+    // The following mark methods are for off-heap collections.
     template<typename T, size_t inlineCapacity>
     void trace(const Vector<T, inlineCapacity, WTF::FastAllocator>& vector)
     {
-        CollectionVisitingTrait<Vector<T, inlineCapacity, WTF::FastAllocator> >::visit(this, vector);
+        OffHeapCollectionTraceTrait<Vector<T, inlineCapacity, WTF::FastAllocator> >::mark(this, vector);
     }
 
     template<typename T, typename U, typename V>
     void trace(const HashSet<T, WTF::FastAllocator, U, V>& hashSet)
     {
-        CollectionVisitingTrait<HashSet<T, WTF::FastAllocator, U, V> >::visit(this, hashSet);
+        OffHeapCollectionTraceTrait<HashSet<T, WTF::FastAllocator, U, V> >::mark(this, hashSet);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     void trace(const ListHashSet<T, inlineCapacity, U>& hashSet)
     {
-        CollectionVisitingTrait<ListHashSet<T, inlineCapacity, U> >::visit(this, hashSet);
+        OffHeapCollectionTraceTrait<ListHashSet<T, inlineCapacity, U> >::mark(this, hashSet);
     }
 
     template<typename T, size_t N>
     void trace(const Deque<T, N>& deque)
     {
-        CollectionVisitingTrait<Deque<T, N> >::visit(this, deque);
+        OffHeapCollectionTraceTrait<Deque<T, N> >::mark(this, deque);
     }
 
     template<typename T, typename U, typename V, typename W, typename X>
     void trace(const HashMap<T, U, WTF::FastAllocator, V, W, X>& map)
     {
-        CollectionVisitingTrait<HashMap<T, U, WTF::FastAllocator, V, W, X> >::visit(this, map);
+        OffHeapCollectionTraceTrait<HashMap<T, U, WTF::FastAllocator, V, W, X> >::mark(this, map);
     }
 
     // Fallback trace method for part objects to allow individual
     // trace methods to trace through a part object with
     // visitor->trace(m_partObject).
     template<typename T>
     void trace(const T& t)
     {
         const_cast<T&>(t).trace(this);
     }
 
     // OwnPtrs that are traced are treated as part objects and the
     // trace method of the owned object is called.
     template<typename T>
     void trace(const OwnPtr<T>& t)
     {
         t->trace(this);
     }
 
     // This method adds the object 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 visit method above to automatically provide the callback
+    // one-argument mark method above to automatically provide the callback
     // function.
-    virtual void visit(const void*, TraceCallback) = 0;
+    virtual void mark(const void*, TraceCallback) = 0;
 
     // Used during conservative scanning.
-    virtual void visit(HeapObjectHeader*, TraceCallback) = 0;
-    virtual void visit(FinalizedHeapObjectHeader*, TraceCallback) = 0;
+    virtual void mark(HeapObjectHeader*, TraceCallback) = 0;
+    virtual void mark(FinalizedHeapObjectHeader*, TraceCallback) = 0;
 
     // If the object calls this during the regular trace callback, then the
     // WeakPointerCallback argument may be called later, when the strong roots
     // have all been found. The WeakPointerCallback will normally use isAlive
     // to find out whether some pointers are pointing to dying objects. When
     // the WeakPointerCallback is done the object must have purged all pointers
     // to objects where isAlive returned false.
     virtual void registerWeakPointers(const void*, WeakPointerCallback) = 0;
 
     template<typename T, void (T::*method)(Visitor*)>
@@ skipping 26 matching lines @@
     }
 #endif
 
 #ifndef NDEBUG
     void checkTypeMarker(const void*, const char* marker);
 #endif
 
 // Macro to declare methods needed for each typed heap.
 #define DECLARE_VISITOR_METHODS(Type)                                   \
     DEBUG_ONLY(void checkTypeMarker(const Type*, const char* marker);)  \
-    virtual void visit(const Type*, TraceCallback) = 0;                 \
+    virtual void mark(const Type*, TraceCallback) = 0;                  \
     virtual bool isMarked(const Type*) = 0;
 
     FOR_EACH_TYPED_HEAP(DECLARE_VISITOR_METHODS)
 #undef DECLARE_VISITOR_METHODS
 
 #if defined(TRACE_GC_MARKING) && TRACE_GC_MARKING
 protected:
     void* m_hostObject;
     const char* m_hostName;
 #endif
 private:
     template<typename T>
     static void handleWeakCell(Visitor* self, void* obj)
     {
         T** cell = reinterpret_cast<T**>(obj);
         if (*cell && !self->isAlive(*cell))
             *cell = 0;
     }
 };
 
 template<typename T, typename HashFunctions, typename Traits>
-struct CollectionVisitingTrait<WTF::HashSet<T, WTF::FastAllocator, HashFunctions, Traits> > {
+struct OffHeapCollectionTraceTrait<WTF::HashSet<T, WTF::FastAllocator, HashFunctions, Traits> > {
     typedef WTF::HashSet<T, WTF::FastAllocator, HashFunctions, Traits> HashSet;
 
-    static void visit(Visitor* v, const HashSet& set)
+    static void mark(Visitor* v, const HashSet& set)
     {
         if (set.isEmpty())
             return;
-        if (WTF::NeedsVisiting<T>::value) {
+        if (WTF::NeedsTracing<T>::value) {
             for (typename HashSet::const_iterator it = set.begin(), end = set.end(); it != end; ++it)
-                VisitCollectionBackingTrait<Traits::needsVisiting, Traits::isWeak, false, T, Traits>::visit(v, *it);
+                CollectionBackingTraceTrait<Traits::needsTracing, Traits::isWeak, false, T, Traits>::mark(v, *it);
         }
         if (Traits::isWeak) {
             if (!set.isEmpty())
                 v->registerWeakPointers(&set, processWeakOffHeapHashSet<T, HashFunctions, Traits>);
         }
     }
 };
 
 template<typename T, size_t inlineCapacity, typename HashFunctions>
-struct CollectionVisitingTrait<WTF::ListHashSet<T, inlineCapacity, HashFunctions> > {
+struct OffHeapCollectionTraceTrait<WTF::ListHashSet<T, inlineCapacity, HashFunctions> > {
     typedef WTF::ListHashSet<T, inlineCapacity, HashFunctions> ListHashSet;
 
-    static void visit(Visitor* visitor, const ListHashSet& set)
+    static void mark(Visitor* visitor, const ListHashSet& set)
     {
         if (set.isEmpty())
             return;
         for (typename ListHashSet::const_iterator it = set.begin(), end = set.end(); it != end; ++it)
             visitor->trace(*it);
     }
 };
 
 template<typename Key, typename Value, typename HashFunctions, typename KeyTraits, typename ValueTraits>
-struct CollectionVisitingTrait<WTF::HashMap<Key, Value, WTF::FastAllocator, HashFunctions, KeyTraits, ValueTraits> > {
+struct OffHeapCollectionTraceTrait<WTF::HashMap<Key, Value, WTF::FastAllocator, HashFunctions, KeyTraits, ValueTraits> > {
     typedef WTF::HashMap<Key, Value, WTF::FastAllocator, HashFunctions, KeyTraits, ValueTraits> HashMap;
 
-    static void visit(Visitor* v, const HashMap& map)
+    static void mark(Visitor* v, const HashMap& map)
     {
         if (map.isEmpty())
             return;
-        if (WTF::NeedsVisiting<Key>::value || WTF::NeedsVisiting<Value>::value) {
+        if (WTF::NeedsTracing<Key>::value || WTF::NeedsTracing<Value>::value) {
             for (typename HashMap::const_iterator it = map.begin(), end = map.end(); it != end; ++it) {
-                VisitCollectionBackingTrait<KeyTraits::needsVisiting, KeyTraits::isWeak, false, Key, KeyTraits>::visit(v, it->key);
-                VisitCollectionBackingTrait<ValueTraits::needsVisiting, ValueTraits::isWeak, false, Value, ValueTraits>::visit(v, it->value);
+                CollectionBackingTraceTrait<KeyTraits::needsTracing, KeyTraits::isWeak, false, Key, KeyTraits>::mark(v, it->key);
+                CollectionBackingTraceTrait<ValueTraits::needsTracing, ValueTraits::isWeak, false, Value, ValueTraits>::mark(v, it->value);
             }
         }
         if (KeyTraits::isWeak || ValueTraits::isWeak) {
             if (!map.isEmpty())
                 v->registerWeakPointers(&map, processWeakOffHeapHashMap<Key, Value, HashFunctions, KeyTraits, ValueTraits>);
         }
     }
 };
 
 #ifndef NDEBUG
 template<typename T> void TraceTrait<T>::checkTypeMarker(Visitor* visitor, const T* t)
 {
     visitor->checkTypeMarker(const_cast<T*>(t), getTypeMarker<T>());
 }
 #endif
 
-template<typename T> void TraceTrait<T>::visit(Visitor* visitor, const T* t)
+template<typename T> void TraceTrait<T>::mark(Visitor* visitor, const T* t)
 {
-    // Default visit method of the trait just calls the two-argument visit
+    // Default mark method of the trait just calls the two-argument mark
     // method on the visitor. The second argument is the static trace method
     // of the trait, which by default calls the instance method
     // trace(Visitor*) on the object.
-    visitor->visit(const_cast<T*>(t), &trace);
+    visitor->mark(const_cast<T*>(t), &trace);
 }
 
 inline void doNothingTrace(Visitor*, void*)
 {
 }
 
 template<typename T, typename Traits = WTF::VectorTraits<T> >
 class HeapVectorBacking;
 template<typename Key, typename Value, typename Extractor, typename Traits, typename KeyTraits>
 class HeapHashTableBacking;
 
 // Non-class types like char don't have an trace method, so we provide a more
 // specialized template instantiation here that will be selected in preference
 // to the default. Most of them do nothing, since the type in question cannot
 // point to other heap allocated objects.
 #define ITERATE_DO_NOTHING_TYPES(f)                            \
     f(uint8_t)                                                 \
     f(void)
 
 #define DECLARE_DO_NOTHING_TRAIT(type)                         \
     template<>                                                 \
     class TraceTrait<type> {                                   \
     public:                                                    \
         static void checkTypeMarker(Visitor*, const void*) { } \
-        static void visit(Visitor* v, const type* p) {         \
-            v->visit(p, nullptr);                              \
+        static void mark(Visitor* v, const type* p) {          \
+            v->mark(p, nullptr);                               \
         }                                                      \
     };                                                         \
     template<>                                                 \
     struct FinalizerTrait<type> {                              \
         static void finalize(void*) { }                        \
         static const bool nonTrivialFinalizer = false;         \
     };                                                         \
     template<>                                                 \
     struct GCInfoTrait<type> {                                 \
         static const GCInfo* get()                             \
         {                                                      \
             return &info;                                      \
         }                                                      \
         static const GCInfo info;                              \
     };
 
 ITERATE_DO_NOTHING_TYPES(DECLARE_DO_NOTHING_TRAIT)
 
 #undef DECLARE_DO_NOTHING_TRAIT
 
-// Vectors are simple collections, and it's possible to visit vectors in a more
+// Vectors are simple collections, and it's possible to mark vectors in a more
 // general way so that collections of objects (not pointers to objects) can be
-// visited.
+// marked.
 template<typename T, size_t N>
-struct CollectionVisitingTrait<WTF::Vector<T, N, WTF::FastAllocator> > {
+struct OffHeapCollectionTraceTrait<WTF::Vector<T, N, WTF::FastAllocator> > {
     typedef WTF::Vector<T, N, WTF::FastAllocator> Vector;
 
-    static void visit(Visitor* v, const Vector& vector)
+    static void mark(Visitor* v, const Vector& vector)
     {
         if (vector.isEmpty())
             return;
         for (typename Vector::const_iterator it = vector.begin(), end = vector.end(); it != end; ++it)
             TraceTrait<T>::trace(v, const_cast<T*>(it));
     }
 };
 
 // Fallback definition.
-template<typename Collection> void CollectionVisitingTrait<Collection>::visit(Visitor* visitor, const Collection& collection)
+template<typename Collection> void OffHeapCollectionTraceTrait<Collection>::mark(Visitor* visitor, const Collection& collection)
 {
     if (collection.isEmpty())
         return;
     for (typename Collection::const_iterator it = collection.begin(), end = collection.end(); it != end; ++it)
         visitor->trace(*it);
 }
 
 template<typename T> bool ObjectAliveTrait<T>::isAlive(Visitor* visitor, T obj)
 {
     return visitor->isMarked(obj);
 }
 
 template<typename T> bool ObjectAliveTrait<Member<T> >::isAlive(Visitor* visitor, const Member<T>& obj)
 {
     return visitor->isMarked(obj.raw());
 }
 
 class HeapVisitable {
 public:
     virtual void trace(Visitor*) = 0;
     virtual ~HeapVisitable()
     {
     }
 };
 
 }
 #endif