[oilpan] Rename visit to mark.

Source/wtf/HashTable.h

Index: Source/wtf/HashTable.h
diff --git a/Source/wtf/HashTable.h b/Source/wtf/HashTable.h
index efe40e1d9c9f7d5560264baa1ababf13b6496f4b..8f2175af96eb7a59dfdfc0351d9470fd67e0b332 100644
--- a/Source/wtf/HashTable.h
+++ b/Source/wtf/HashTable.h
@@ -1201,7 +1201,7 @@ namespace WTF {
             if (table->m_table) {
                 // This just marks it live and does not push anything onto the
                 // marking stack because there is no trace for void*.
-                Allocator::visitWith(visitor, reinterpret_cast<void*>(table->m_table));
+                Allocator::adjustAndMark(visitor, reinterpret_cast<void*>(table->m_table));
                 // Now perform weak processing (this is a no-op if the backing
                 // was accessible through an iterator and was already marked
                 // strongly).
@@ -1335,26 +1335,26 @@ namespace WTF {
         // and/or weak callback then we are done.
         if (!m_table || visitor->isAlive(m_table))
             return;
-        // Normally, we visit the backing store cast to a void pointer. This
-        // means it is marked live, but the pointers inside it are not visited.
-        // Instead we will visit the pointers below. However, for backing
+        // Normally, we mark the backing store cast to a void pointer. This
+        // means it is marked live, but the pointers inside it are not marked.
+        // Instead we will mark the pointers below. However, for backing
         // stores that contain weak pointers the handling is rather different.
-        // We don't visit the backing store here, so the marking GC will leave
+        // We don't mark the backing store here, so the marking GC will leave
         // the backing unmarked. If the backing is found in any other way than
         // through its HashTable (ie from an iterator) then the mark bit will
-        // be set and the pointers will be visited strongly, avoiding problems
+        // be set and the pointers will be marked strongly, avoiding problems
         // with iterating over things that disappear due to weak processing
         // while we are iterating over them. The weakProcessing callback will
-        // visit the backing as a void pointer, marking it live and will
-        // perform weak processing if needed.
+        // mark the backing as a void pointer, and will perform weak processing
+        // if needed.
         if (!Traits::isWeak)
-            Allocator::visitWith(visitor, reinterpret_cast<void*>(m_table));
+            Allocator::adjustAndMark(visitor, reinterpret_cast<void*>(m_table));
         else
             Allocator::registerWeakPointers(visitor, this, WeakProcessingHashTableHelper<Traits::isWeak, Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::process);
-        if (Traits::needsVisiting) {
+        if (Traits::needsTracing) {
             for (ValueType* element = m_table + m_tableSize - 1; element >= m_table; element--) {
                 if (!isEmptyOrDeletedBucket(*element))
-                    Allocator::template visitWith<ValueType, Traits>(visitor, *element);
+                    Allocator::template adjustAndMark<ValueType, Traits>(visitor, *element);
             }
         }
     }