[oilpan] Rename visit to mark.

Source/heap/tests/HeapTest.cpp

Index: Source/heap/tests/HeapTest.cpp
diff --git a/Source/heap/tests/HeapTest.cpp b/Source/heap/tests/HeapTest.cpp
index 371169740af626c9a051bcaeb0547bae47fd12d5..d6e83536454dd34fa3a3d926bcbbd8812ca81a93 100644
--- a/Source/heap/tests/HeapTest.cpp
+++ b/Source/heap/tests/HeapTest.cpp
@@ -156,7 +156,7 @@ struct InlinedThingHash {
 };
 
 struct InlinedThingTraits : public WTF::GenericHashTraits<InlinedThing> {
-    static const bool needsVisiting = true;
+    static const bool needsMarking = true;
     static const bool emptyValueIsZero = true;
     static void constructDeletedValue(InlinedThing& slot) { slot.m_intWrapper = reinterpret_cast<IntWrapper*>(-1); }
     static bool isDeletedValue(const InlinedThing& slot) { return slot.m_intWrapper.raw() == reinterpret_cast<IntWrapper*>(-1); }
@@ -168,7 +168,7 @@ namespace WTF {
 
 template<>
 struct VectorTraits<WebCore::InlinedThing> : public SimpleClassVectorTraits {
-    static const bool needsVisiting = true;
+    static const bool needsMarking = true;
 };
 
 } // namespace WTF
@@ -264,7 +264,7 @@ int RefCountedAndGarbageCollected2::s_destructorCalls = 0;
 int IntWrapper::s_destructorCalls = 0;
 
 #define DEFINE_VISITOR_METHODS(Type)                                \
-    virtual void visit(const Type* object, TraceCallback callback)  \
+    virtual void mark(const Type* object, TraceCallback callback)  \
     {                                                               \
         if (object)                                                 \
             m_count++;                                              \
@@ -278,19 +278,19 @@ public:
     {
     }
 
-    virtual void visit(const void* object, TraceCallback)
+    virtual void mark(const void* object, TraceCallback)
     {
         if (object)
             m_count++;
     }
 
-    virtual void visit(HeapObjectHeader* header, TraceCallback callback)
+    virtual void mark(HeapObjectHeader* header, TraceCallback callback)
     {
         ASSERT(header->payload());
         m_count++;
     }
 
-    virtual void visit(FinalizedHeapObjectHeader* header, TraceCallback callback)
+    virtual void mark(FinalizedHeapObjectHeader* header, TraceCallback callback)
     {
         ASSERT(header->payload());
         m_count++;
@@ -317,12 +317,12 @@ public:
     {
     }
 
-    void visit(const void* ptr)
+    void mark(const void* ptr)
     {
-        visitNoTrace(ptr);
+        markNoTrace(ptr);
     }
 
-    virtual void visitNoTrace(const void* ptr)
+    virtual void markNoTrace(const void* ptr)
     {
         if (!ptr)
             return;
@@ -332,24 +332,24 @@ public:
             EXPECT_FALSE(expectedObject(ptr));
         m_count++;
     }
-    virtual void visit(const void* ptr, TraceCallback)
+    virtual void mark(const void* ptr, TraceCallback)
     {
-        visit(ptr);
+        mark(ptr);
     }
 
-    virtual void visit(const Node* ptr, TraceCallback callback)
+    virtual void mark(const Node* ptr, TraceCallback callback)
     {
-        visit(ptr);
+        mark(ptr);
     }
 
-    virtual void visit(HeapObjectHeader* header, TraceCallback callback)
+    virtual void mark(HeapObjectHeader* header, TraceCallback callback)
     {
-        visit(header->payload());
+        mark(header->payload());
     }
 
-    virtual void visit(FinalizedHeapObjectHeader* header, TraceCallback callback)
+    virtual void mark(FinalizedHeapObjectHeader* header, TraceCallback callback)
     {
-        visit(header->payload());
+        mark(header->payload());
     }
 
     bool validate() { return m_count >= m_expectedCount; }
@@ -639,7 +639,7 @@ public:
     static void hashMapMembers2();
     static void hashMapFinalizers();
     static void onStackHeapCollections();
-    static void checkAndVisitPointer();
+    static void checkAndMarkPointer();
     static void heapCollectionWithFinalizers();
     static void weakOffHeap();
     static void heapVectorWithInlineCapacity();
@@ -715,9 +715,9 @@ public:
     virtual void trace(Visitor* visitor)
     {
         if (m_pointsToFoo)
-            visitor->visit(static_cast<Foo*>(m_bar));
+            visitor->mark(static_cast<Foo*>(m_bar));
         else
-            visitor->visit(m_bar);
+            visitor->mark(m_bar);
     }
 
 private:
@@ -749,7 +749,7 @@ public:
     virtual void trace(Visitor* visitor)
     {
         for (unsigned i = 0; i < m_width; i++)
-            visitor->visit(m_bars[i]);
+            visitor->mark(m_bars[i]);
     }
 
     unsigned getWidth() const
@@ -1902,7 +1902,7 @@ private:
     ThreadState* m_state;
 };
 
-void HeapTester::checkAndVisitPointer()
+void HeapTester::checkAndMarkPointer()
 {
     HeapStats initialHeapStats;
     clearOutOldGarbage(&initialHeapStats);
@@ -1925,13 +1925,13 @@ void HeapTester::checkAndVisitPointer()
         {
             TestGCScope scope;
             for (size_t i = 0; i < objectAddresses.size(); i++) {
-                EXPECT_TRUE(Heap::checkAndVisitPointer(&visitor, objectAddresses[i]));
-                EXPECT_TRUE(Heap::checkAndVisitPointer(&visitor, endAddresses[i]));
+                EXPECT_TRUE(Heap::checkAndMarkPointer(&visitor, objectAddresses[i]));
+                EXPECT_TRUE(Heap::checkAndMarkPointer(&visitor, endAddresses[i]));
             }
             EXPECT_EQ(objectAddresses.size() * 2, visitor.count());
             visitor.reset();
-            EXPECT_TRUE(Heap::checkAndVisitPointer(&visitor, largeObjectAddress));
-            EXPECT_TRUE(Heap::checkAndVisitPointer(&visitor, largeObjectEndAddress));
+            EXPECT_TRUE(Heap::checkAndMarkPointer(&visitor, largeObjectAddress));
+            EXPECT_TRUE(Heap::checkAndMarkPointer(&visitor, largeObjectEndAddress));
             EXPECT_EQ(2ul, visitor.count());
             visitor.reset();
         }
@@ -1940,12 +1940,12 @@ void HeapTester::checkAndVisitPointer()
     {
         TestGCScope scope;
         for (size_t i = 0; i < objectAddresses.size(); i++) {
-            EXPECT_FALSE(Heap::checkAndVisitPointer(&visitor, objectAddresses[i]));
-            EXPECT_FALSE(Heap::checkAndVisitPointer(&visitor, endAddresses[i]));
+            EXPECT_FALSE(Heap::checkAndMarkPointer(&visitor, objectAddresses[i]));
+            EXPECT_FALSE(Heap::checkAndMarkPointer(&visitor, endAddresses[i]));
         }
         EXPECT_EQ(0ul, visitor.count());
-        EXPECT_FALSE(Heap::checkAndVisitPointer(&visitor, largeObjectAddress));
-        EXPECT_FALSE(Heap::checkAndVisitPointer(&visitor, largeObjectEndAddress));
+        EXPECT_FALSE(Heap::checkAndMarkPointer(&visitor, largeObjectAddress));
+        EXPECT_FALSE(Heap::checkAndMarkPointer(&visitor, largeObjectEndAddress));
         EXPECT_EQ(0ul, visitor.count());
     }
     // This round of GC is important to make sure that the object start
@@ -2805,7 +2805,7 @@ TEST(heap, HeapWeakCollectionTypes)
 
 TEST(heap, CheckAndVisitPointer)
 {
-    HeapTester::checkAndVisitPointer();
+    HeapTester::checkAndMarkPointer();
 }
 
 TEST(heap, HeapCollectionWithFinalizers)