Templatize visitor arguments for TraceTrait mark and trace methods.

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 461 matching lines @@
         void clear();
 
         static bool isEmptyBucket(const ValueType& value) { return isHashTraitsEmptyValue<KeyTraits>(Extractor::extract(value)); }
         static bool isDeletedBucket(const ValueType& value) { return KeyTraits::isDeletedValue(Extractor::extract(value)); }
         static bool isEmptyOrDeletedBucket(const ValueType& value) { return HashTableHelper<ValueType, Extractor, KeyTraits>:: isEmptyOrDeletedBucket(value); }
 
         ValueType* lookup(KeyPeekInType key) { return lookup<IdentityTranslatorType, KeyPeekInType>(key); }
         template<typename HashTranslator, typename T> ValueType* lookup(T);
         template<typename HashTranslator, typename T> const ValueType* lookup(T) const;
 
-        void trace(typename Allocator::Visitor*);
+        template<typename VisitorDispatcher> void trace(VisitorDispatcher);
 
 #if ENABLE(ASSERT)
         int64_t modifications() const { return m_modifications; }
         void registerModification() { m_modifications++; }
         // HashTable and collections that build on it do not support
         // modifications while there is an iterator in use. The exception is
         // ListHashSet, which has its own iterators that tolerate modification
         // of the underlying set.
         void checkModifications(int64_t mods) const { ASSERT(mods == m_modifications); }
 #else
@@ skipping 723 matching lines @@
         static void ephemeronIterationDone(typename Allocator::Visitor* visitor, void* closure)
         {
             typedef HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> HashTableType;
             HashTableType* table = reinterpret_cast<HashTableType*>(closure);
             ASSERT(Allocator::weakTableRegistered(visitor, table));
             table->clearEnqueued();
         }
     };
 
     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)
+    template<typename VisitorDispatcher>
+    void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::trace(VisitorDispatcher visitor)
     {
         // If someone else already marked the backing and queued up the trace
         // and/or weak callback then we are done. This optimization does not
         // happen for ListHashSet since its iterator does not point at the
         // backing.
         if (!m_table || visitor->isAlive(m_table))
             return;
         // Normally, we mark the backing store without performing trace. This
         // means it is marked live, but the pointers inside it are not marked.
         // Instead we will mark the pointers below. However, for backing
@@ skipping 30 matching lines @@
                 // We don't need to trace the elements here, since registering
                 // as a weak table above will cause them to be traced (perhaps
                 // several times). It's better to wait until everything else is
                 // traced before tracing the elements for the first time; this
                 // may reduce (by one) the number of iterations needed to get
                 // to a fixed point.
                 return;
             }
             for (ValueType* element = m_table + m_tableSize - 1; element >= m_table; element--) {
                 if (!isEmptyOrDeletedBucket(*element))
-                    Allocator::template trace<ValueType, Traits>(visitor, *element);
+                    Allocator::template trace<VisitorDispatcher, ValueType, Traits>(visitor, *element);
             }
         }
     }
 
     // iterator adapters
 
     template<typename HashTableType, typename Traits> struct HashTableConstIteratorAdapter {
         HashTableConstIteratorAdapter() {}
         HashTableConstIteratorAdapter(const typename HashTableType::const_iterator& impl) : m_impl(impl) {}
         typedef typename Traits::IteratorConstGetType GetType;
@@ skipping 90 matching lines @@
         CollectionIterator end(toBeRemoved.end());
         for (CollectionIterator it(toBeRemoved.begin()); it != end; ++it)
             collection.remove(*it);
     }
 
 } // namespace WTF
 
 #include "wtf/HashIterators.h"
 
 #endif // WTF_HashTable_h