[oilpan] Rename visit to mark.

Source/heap/tests/HeapTest.cpp

 /*
  * 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 138 matching lines @@
     friend struct InlinedThingTraits;
 };
 
 struct InlinedThingHash {
     static unsigned hash(const InlinedThing& key) { return WTF::PtrHash<IntWrapper*>::hash(key.m_intWrapper); }
     static bool equal(const InlinedThing& a, const InlinedThing& b) { return a.m_intWrapper == b.m_intWrapper; }
     static const bool safeToCompareToEmptyOrDeleted = true;
 };
 
 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); }
 };
 
 } // namespace WebCore
 
 namespace WTF {
 
 template<>
 struct VectorTraits<WebCore::InlinedThing> : public SimpleClassVectorTraits {
-    static const bool needsVisiting = true;
+    static const bool needsMarking = true;
 };
 
 } // namespace WTF
 
 namespace WebCore {
 
 struct IntWrapperTranslator {
     static unsigned hash(int x) { return IntHash<unsigned>::hash(x); }
     static bool equal(const Member<IntWrapper>& wrapped, int x) { return x == wrapped->value(); }
     static void translate(Member<IntWrapper>& dest, int value, unsigned unused)
@@ skipping 75 matching lines @@
 
 DEFINE_GC_INFO(RefCountedAndGarbageCollected2);
 
 int HeapTestSuperClass::s_destructorCalls = 0;
 int HeapTestSubClass::s_destructorCalls = 0;
 int RefCountedAndGarbageCollected::s_destructorCalls = 0;
 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++;                                              \
     }                                                               \
     virtual bool isMarked(const Type*) { return false; }
 
 class CountingVisitor : public Visitor {
 public:
     CountingVisitor()
         : m_count(0)
     {
     }
 
-    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++;
     }
 
     virtual void registerWeakPointers(const void*, WeakPointerCallback) { }
     virtual bool isMarked(const void*) { return false; }
 
     FOR_EACH_TYPED_HEAP(DEFINE_VISITOR_METHODS)
 
     size_t count() { return m_count; }
     void reset() { m_count = 0; }
 
 private:
     size_t m_count;
 };
 
 class RefCountedGarbageCollectedVisitor : public CountingVisitor {
 public:
     RefCountedGarbageCollectedVisitor(int expected, void** objects)
         : m_count(0)
         , m_expectedCount(expected)
         , m_expectedObjects(objects)
     {
     }
 
-    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;
         if (m_count < m_expectedCount)
             EXPECT_TRUE(expectedObject(ptr));
         else
             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; }
     void reset() { m_count = 0; }
 
 private:
     bool expectedObject(const void* ptr)
     {
         for (int i = 0; i < m_expectedCount; i++) {
             if (m_expectedObjects[i] == ptr)
@@ skipping 269 matching lines @@
     static void memberTest();
     static void weakOnHeapTest();
     static void hashSet();
     static void vectorsOfThings();
     static void hashSetMembers();
     static void hashMap();
     static void hashMapMembers();
     static void hashMapMembers2();
     static void hashMapFinalizers();
     static void onStackHeapCollections();
-    static void checkAndVisitPointer();
+    static void checkAndMarkPointer();
     static void heapCollectionWithFinalizers();
     static void weakOffHeap();
     static void heapVectorWithInlineCapacity();
     static void heapCollectionTypes();
     static void heapWeakCollectionSimple();
     static void heapWeakCollectionTypes();
     static void collectionsEmbedded();
     static void largeObjects();
 
     // Do several GCs to make sure that later GCs don't free up old memory from
@@ skipping 55 matching lines @@
     }
 
     static Foo* create(Foo* foo)
     {
         return new Foo(foo);
     }
 
     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:
     Foo(Bar* bar)
         : Bar()
         , m_bar(bar)
         , m_pointsToFoo(false)
     {
     }
 
@@ skipping 11 matching lines @@
 class Bars : public Bar {
 public:
     static Bars* create()
     {
         return new Bars();
     }
 
     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
     {
         return m_width;
     }
 
     static const unsigned width = 7500;
 private:
     Bars() : m_width(0)
@@ skipping 1132 matching lines @@
     {
         m_state->leaveGC();
         if (!m_state->isInGC())
             ThreadState::resumeThreads();
     }
 
 private:
     ThreadState* m_state;
 };
 
-void HeapTester::checkAndVisitPointer()
+void HeapTester::checkAndMarkPointer()
 {
     HeapStats initialHeapStats;
     clearOutOldGarbage(&initialHeapStats);
 
     Vector<Address> objectAddresses;
     Vector<Address> endAddresses;
     Address largeObjectAddress;
     Address largeObjectEndAddress;
     CountingVisitor visitor;
     {
         for (int i = 0; i < 10; i++) {
             SimpleObject* object = SimpleObject::create();
             Address objectAddress = reinterpret_cast<Address>(object);
             objectAddresses.append(objectAddress);
             endAddresses.append(objectAddress + sizeof(SimpleObject) - 1);
         }
         LargeObject* largeObject = LargeObject::create();
         largeObjectAddress = reinterpret_cast<Address>(largeObject);
         largeObjectEndAddress = largeObjectAddress + sizeof(LargeObject) - 1;
         {
             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();
         }
     }
     clearOutOldGarbage(&initialHeapStats);
     {
         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
     // bitmap are cleared out.
     clearOutOldGarbage(&initialHeapStats);
 }
 
 class OffHeapWithDestructor {
 public:
     OffHeapWithDestructor() : m_x((int*)this)
@@ skipping 839 matching lines @@
     HeapTester::heapWeakCollectionSimple();
 }
 
 TEST(heap, HeapWeakCollectionTypes)
 {
     HeapTester::heapWeakCollectionTypes();
 }
 
 TEST(heap, CheckAndVisitPointer)
 {
-    HeapTester::checkAndVisitPointer();
+    HeapTester::checkAndMarkPointer();
 }
 
 TEST(heap, HeapCollectionWithFinalizers)
 {
     HeapTester::heapCollectionWithFinalizers();
 }
 
 } // namespace WebCore