[oilpan] Rename visit to mark.

Source/heap/Handle.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 42 matching lines @@
 template<typename A, typename B, typename C, typename D, typename E, typename F, typename G> class HashTableConstIterator;
 
 }
 
 namespace WebCore {
 
 // Forward declarations.
 template<typename T> class Member;
 template<typename T> class WeakMember;
 template<typename T> struct HeapObjectHash;
-template<typename T> struct CollectionVisitingTrait;
+template<typename T> struct OffHeapCollectionTraceTrait;

[wibling-chromium, 2013/12/05 12:37:17]

NIT: Shouldn't this be OffHeapCollectionMarkTrait?

[Mads Ager (chromium), 2013/12/05 12:41:17]

I found it more fitting to call it a TraceTrait. This trait controls how
pointers inside a collection are iterated. When we look through the pointers in
an object we usually call that trace.

 
 #if defined(TRACE_GC_MARKING) && TRACE_GC_MARKING
 // To print root names during marking for CollectionPersistent and Persistent handles
 // we prepend annotation objects to this fields using ANNOTATED_FIELD macro.
 // Annotation object must directly preceed Persistent handles in memory.
 // It is conservatively detected by the presence of magic. This can have some
 // false-positives but TRACE_GC_MARKING is debugging functionality so
 // we don't care.
 typedef const char* (*NameCallback)();
 
@@ skipping 205 matching lines @@
     {
         m_raw = 0;
     }
 
     template<typename U>
     U* as() const
     {
         return static_cast<U*>(m_raw);
     }
 
-    void trace(Visitor* visitor) { visitor->visit(m_raw); }
+    void trace(Visitor* visitor) { visitor->mark(m_raw); }
 
     T* clear()
     {
         T* result = m_raw;
         m_raw = 0;
         return result;
     }
 
     T* raw() const { return m_raw; }
     T& operator*() const { return *raw(); }
@@ skipping 188 matching lines @@
     template<typename U, typename V> friend bool operator!=(const Persistent<U>&, const Member<V>&);
     template<typename U, typename V> friend bool operator==(const Member<U>&, const Member<V>&);
     template<typename U, typename V> friend bool operator!=(const Member<U>&, const Member<V>&);
 };
 
 template<typename T>
 class TraceTrait<Member<T> > {
 public:
     static void trace(Visitor* visitor, void* self)
     {
-        TraceTrait<T>::visit(visitor, static_cast<Member<T>*>(self)->raw());
+        TraceTrait<T>::mark(visitor, static_cast<Member<T>*>(self)->raw());
     }
 };
 
 template<typename T>
 class WeakMember : public Member<T> {
 public:
     WeakMember() : Member<T>() { }
 
     WeakMember(T* raw) : Member<T>(raw) { }
 
@@ skipping 81 matching lines @@
     explicit CollectionPersistent(const Collection& collection) : m_collection(collection) { }
     CollectionPersistent& operator=(const Collection& collection) { m_collection = collection; return *this; }
 
     Collection* operator->() { return &m_collection; }
     const Collection* operator->() const { return &m_collection; }
     Collection& operator*() { return m_collection; }
     const Collection& operator*() const { return m_collection; }
 
     void trace(Visitor* visitor)
     {
-        CollectionVisitingTrait<Collection>::visit(visitor, m_collection);
+        OffHeapCollectionTraceTrait<Collection>::mark(visitor, m_collection);
     }
 
 #if defined(TRACE_GC_MARKING) && TRACE_GC_MARKING
     virtual const char* name() OVERRIDE
     {
         ASSERT(this == static_cast<PersistentNode*>(this));
         const char* n = FieldAnnotationBase::fromAddress(this);
         return n ? n : "CollectionPersistent";
     }
 #endif
@@ skipping 99 matching lines @@
     }
 
     static const bool heapAllocation = true;
 
     typedef NoAllocation<MainThreadOnly> NoAllocationObject;
 
     typedef WebCore::Visitor Visitor;
 
     static void visitHeapPointer(Visitor* visitor, const void* buffer)
     {
-        visitor->visit(buffer, FinalizedHeapObjectHeader::fromPayload(buffer)->traceCallback());
+        visitor->mark(buffer, FinalizedHeapObjectHeader::fromPayload(buffer)->traceCallback());
     }
 
-    static void visitWith(Visitor* visitor, const void* t)
+    static void adjustAndMark(Visitor* visitor, const void* t)
     {
-        visitor->visit(t);
+        visitor->mark(t);
     }
 
     template<typename T, typename Traits>
-    static void visitWith(Visitor* visitor, T& t)
+    static void adjustAndMark(Visitor* visitor, T& t)
     {
-        VisitCollectionBackingTrait<Traits::needsVisiting, Traits::isWeak, false, T, Traits>::visit(visitor, t);
+        CollectionBackingTraceTrait<Traits::needsMarking, Traits::isWeak, false, T, Traits>::mark(visitor, t);
     }
 
     template<typename T>
     static bool hasDeadMember(Visitor* visitor, const T& t)
     {
         return false;
     }
 
     template<typename T>
     static bool hasDeadMember(Visitor* visitor, const Member<T>& t)
@@ skipping 536 matching lines @@
 // HeapObjectHash<T> instead.
 template<typename T> struct DefaultHash<WebCore::Member<T> > {
     typedef PtrHash<WebCore::Member<T> > Hash;
 };
 
 template<typename T> struct DefaultHash<WebCore::WeakMember<T> > {
     typedef PtrHash<WebCore::WeakMember<T> > Hash;
 };
 
 template<typename T>
-struct NeedsVisiting<WebCore::Member<T> > {
+struct NeedsMarking<WebCore::Member<T> > {
     static const bool value = true;
 };
 
 template<typename T>
 struct IsWeak<WebCore::WeakMember<T> > {
     static const bool value = true;
 };
 
 template<typename T, size_t inlinedCapacity>
 struct IsPod<WebCore::HeapVector<T, inlinedCapacity> > {
     static const bool value = true;
 };
 
 template<typename T, size_t inlinedCapacity>
-struct NeedsVisiting<WebCore::HeapVector<T, inlinedCapacity> > {
+struct NeedsMarking<WebCore::HeapVector<T, inlinedCapacity> > {
     static const bool value = true;
 };
 
 #if TRACE_GC_USING_CLASSOF
 #define DEFINE_CLASS_NAME(Type) \
     virtual const char* className() { return #Type; }
 #else
 #define DEFINE_CLASS_NAME(Type)
 #endif
 
@@ skipping 11 matching lines @@
 // inject virtual className() getter into heap allocated types.
 // FIXME(oilpan): Rename DEFINE_SELF_HANDLE to DEFINE_CLASS_NAME.
 #define DEFINE_SELF_HANDLE(Type)                                                                   \
 public:                                                                                            \
     DEFINE_CLASS_NAME(Type)                                                                        \
     Type* nonConstSelfHandle() const { return const_cast<Type*>(this); }
 
 }
 
 #endif