[oilpan] Rename visit to mark.

Source/wtf/HashTable.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008 David Levin <levin@chromium.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 1183 matching lines @@
 
     template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
     struct WeakProcessingHashTableHelper<true, Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> {
         static void process(typename Allocator::Visitor* visitor, void* closure)
         {
             typedef HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> HashTableType;
             HashTableType* table = reinterpret_cast<HashTableType*>(closure);
             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).
                 for (typename HashTableType::ValueType* element = table->m_table + table->m_tableSize - 1; element >= table->m_table; element--) {
                     if (!HashTableType::isEmptyOrDeletedBucket(*element)) {
                         if (Allocator::hasDeadMember(visitor, *element)) {
                             HashTableType::deleteBucket(*element); // Also calls the destructor.
                             table->m_deletedCount++;
                             table->m_keyCount--;
                             // We don't rehash the backing until the next add
@@ skipping 113 matching lines @@
         return *this;
     }
 
     template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
     void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::trace(typename Allocator::Visitor* visitor)
     {
         // If someone else already marked the backing and queued up the trace
         // 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);
             }
         }
     }
 
 #if !ASSERT_DISABLED
 
     template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
     void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::checkTableConsistency() const
     {
         checkTableConsistencyExceptSize();
@@ skipping 195 matching lines @@
     inline bool operator!=(const HashTableIteratorAdapter<T, U>& a, const HashTableConstIteratorAdapter<T, U>& b)
     {
         return a.m_impl != b.m_impl;
     }
 
 } // namespace WTF
 
 #include <wtf/HashIterators.h>
 
 #endif // WTF_HashTable_h