Templatize visitor arguments for TraceTrait mark and trace methods.

Source/platform/heap/Visitor.h

 /*
  * 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 181 matching lines @@
 // However, the TraceTrait can be specialized to use a different
 // implementation. A common case where a TraceTrait specialization is
 // needed is when multiple inheritance leads to pointers that are not
 // to the start of the object in the Blink garbage-collected heap. In
 // that case the pointer has to be adjusted before marking.
 template<typename T>
 class TraceTrait {
 public:
     // Default implementation of TraceTrait<T>::trace just statically
     // dispatches to the trace method of the class T.
-    template<typename TraceDispatcher>
-    static void trace(TraceDispatcher visitor, void* self)
+    template<typename VisitorDispatcher>
+    static void trace(VisitorDispatcher visitor, void* self)
     {
         TraceCompatibilityAdaptor<T>::trace(visitor, static_cast<T*>(self));
     }
 
-    static void mark(Visitor* visitor, const T* t)
+    template<typename VisitorDispatcher>
+    static void mark(VisitorDispatcher visitor, const T* t)
     {
         DefaultTraceTrait<T>::mark(visitor, t);
     }
 
 #if ENABLE(ASSERT)
     static void checkGCInfo(const T* t)
     {
         DefaultTraceTrait<T>::checkGCInfo(t);
     }
 #endif
@@ skipping 443 matching lines @@
     bool m_isGlobalMarkingVisitor;
 };
 
 // We trace vectors by using the trace trait on each element, which means you
 // can have vectors of general objects (not just pointers to objects) that can
 // be traced.
 template<typename T, size_t N>
 struct OffHeapCollectionTraceTrait<WTF::Vector<T, N, WTF::DefaultAllocator> > {
     typedef WTF::Vector<T, N, WTF::DefaultAllocator> Vector;
 
-    static void trace(Visitor* visitor, const Vector& vector)
+    template<typename VisitorDispatcher>
+    static void trace(VisitorDispatcher visitor, const Vector& vector)
     {
         if (vector.isEmpty())
             return;
         for (typename Vector::const_iterator it = vector.begin(), end = vector.end(); it != end; ++it)
             TraceTrait<T>::trace(visitor, const_cast<T*>(it));
     }
 };
 
 template<typename T, size_t N>
 struct OffHeapCollectionTraceTrait<WTF::Deque<T, N> > {
     typedef WTF::Deque<T, N> Deque;
 
-    static void trace(Visitor* visitor, const Deque& deque)
+    template<typename VisitorDispatcher>
+    static void trace(VisitorDispatcher visitor, const Deque& deque)
     {
         if (deque.isEmpty())
             return;
         for (typename Deque::const_iterator it = deque.begin(), end = deque.end(); it != end; ++it)
             TraceTrait<T>::trace(visitor, const_cast<T*>(&(*it)));
     }
 };
 
 template<typename T, typename Traits = WTF::VectorTraits<T> >
 class HeapVectorBacking;
 
 template<typename Table>
 class HeapHashTableBacking {
 public:
     static void finalize(void* pointer);
 };
 
 template<typename T>
 class DefaultTraceTrait<T, false> {
 public:
-    static void mark(Visitor* visitor, const T* t)
+    template<typename VisitorDispatcher>
+    static void mark(VisitorDispatcher visitor, const T* t)
     {
         // Default mark method of the trait just calls the two-argument mark
         // method on the visitor. The second argument is the static trace method
         // of the trait, which by default calls the instance method
         // trace(Visitor*) on the object.
         //
         // If the trait allows it, invoke the trace callback right here on the
         // not-yet-marked object.
         if (TraceEagerlyTrait<T>::value) {
             // Protect against too deep trace call chains, and the
@@ skipping 19 matching lines @@
     static void checkGCInfo(const T* t)
     {
         assertObjectHasGCInfo(const_cast<T*>(t), GCInfoTrait<T>::get());
     }
 #endif
 };
 
 template<typename T>
 class DefaultTraceTrait<T, true> {
 public:
-    static void mark(Visitor* visitor, const T* self)
+    template<typename VisitorDispatcher>
+    static void mark(VisitorDispatcher visitor, const T* self)
     {
         if (!self)
             return;
 
         // If you hit this ASSERT, it means that there is a dangling pointer
         // from a live thread heap to a dead thread heap. We must eliminate
         // the dangling pointer.
         // Release builds don't have the ASSERT, but it is OK because
         // release builds will crash at the following self->adjustAndMark
         // because all the entries of the orphaned heaps are zeroed out and
@@ skipping 129 matching lines @@
 struct GCInfoTrait {
     static const GCInfo* get()
     {
         return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::get();
     }
 };
 
 }
 
 #endif