Fix template angle bracket syntax in platform

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 413 matching lines @@
     template<typename T>
     void registerWeakCell(T** cell)
     {
         Derived::fromHelper(this)->registerWeakCellWithCallback(reinterpret_cast<void**>(cell), &handleWeakCell<T>);
     }
 
     // The following trace methods are for off-heap collections.
     template<typename T, size_t inlineCapacity>
     void trace(const Vector<T, inlineCapacity>& vector)
     {
-        OffHeapCollectionTraceTrait<Vector<T, inlineCapacity, WTF::DefaultAllocator> >::trace(Derived::fromHelper(this), vector);
+        OffHeapCollectionTraceTrait<Vector<T, inlineCapacity, WTF::DefaultAllocator>>::trace(Derived::fromHelper(this), vector);
     }
 
     template<typename T, size_t N>
     void trace(const Deque<T, N>& deque)
     {
-        OffHeapCollectionTraceTrait<Deque<T, N> >::trace(Derived::fromHelper(this), deque);
+        OffHeapCollectionTraceTrait<Deque<T, N>>::trace(Derived::fromHelper(this), deque);
     }
 
 #if !ENABLE(OILPAN)
     // These trace methods are needed to allow compiling and calling trace on
     // transition types. We need to support calls in the non-oilpan build
     // because a fully transitioned type (which will have its trace method
     // called) might trace a field that is in transition. Once transition types
     // are removed these can be removed.
     template<typename T> void trace(const OwnPtr<T>&) { }
     template<typename T> void trace(const RefPtr<T>&) { }
@@ skipping 212 matching lines @@
     const int kMaxEagerTraceDepth = 100;
 
     static int m_traceDepth;
     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> > {
+struct OffHeapCollectionTraceTrait<WTF::Vector<T, N, WTF::DefaultAllocator>> {
     typedef WTF::Vector<T, N, WTF::DefaultAllocator> 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> > {
+struct OffHeapCollectionTraceTrait<WTF::Deque<T, N>> {
     typedef WTF::Deque<T, N> 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> >
+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> {
@@ skipping 215 matching lines @@
 struct GCInfoTrait {
     static size_t index()
     {
         return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::index();
     }
 };
 
 }
 
 #endif