Fix template angle bracket syntax in platform

Source/platform/heap/Handle.h

 /*
  * Copyright (C) 2014 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 283 matching lines @@
 // between objects that are in the managed heap. They are only
 // meant to point to managed heap objects from variables/members
 // outside the managed heap.
 //
 // A Persistent is always a GC root from the point of view of
 // the garbage collector.
 //
 // We have to construct and destruct Persistent with default RootsAccessor in
 // the same thread.
 template<typename T, typename RootsAccessor /* = ThreadLocalPersistents<ThreadingTrait<T>::Affinity > */ >
-class Persistent : public PersistentBase<RootsAccessor, Persistent<T, RootsAccessor> > {
+class Persistent : public PersistentBase<RootsAccessor, Persistent<T, RootsAccessor>> {
 public:
     Persistent() : m_raw(nullptr) { }
 
     Persistent(std::nullptr_t) : m_raw(nullptr) { }
 
     Persistent(T* raw) : m_raw(raw)
     {
         ASSERT_IS_VALID_PERSISTENT_POINTER(m_raw);
         recordBacktrace();
     }
@@ skipping 118 matching lines @@
 public:
     CrossThreadPersistent(T* raw) : Persistent<T, GlobalPersistents>(raw) { }
 
     using Persistent<T, GlobalPersistents>::operator=;
 };
 
 // FIXME: derive affinity based on the collection.
 template<typename Collection, ThreadAffinity Affinity = AnyThread>
 class PersistentHeapCollectionBase
     : public Collection
-    , public PersistentBase<ThreadLocalPersistents<Affinity>, PersistentHeapCollectionBase<Collection, Affinity> > {
+    , public PersistentBase<ThreadLocalPersistents<Affinity>, PersistentHeapCollectionBase<Collection, Affinity>> {
     // We overload the various new and delete operators with using the WTF DefaultAllocator to ensure persistent
     // heap collections are always allocated off-heap. This allows persistent collections to be used in
     // DEFINE_STATIC_LOCAL et. al.
     WTF_USE_ALLOCATOR(PersistentHeapCollectionBase, WTF::DefaultAllocator);
 public:
     PersistentHeapCollectionBase() { }
 
     template<typename OtherCollection>
     PersistentHeapCollectionBase(const OtherCollection& other) : Collection(other) { }
 
     void trace(Visitor* visitor)
     {
 #if ENABLE(GC_PROFILE_MARKING)
         visitor->setHostInfo(this, "PersistentHeapCollectionBase");
 #endif
         visitor->trace(*static_cast<Collection*>(this));
     }
 };
 
 template<
     typename KeyArg,
     typename MappedArg,
     typename HashArg = typename DefaultHash<KeyArg>::Hash,
     typename KeyTraitsArg = HashTraits<KeyArg>,
-    typename MappedTraitsArg = HashTraits<MappedArg> >
-class PersistentHeapHashMap : public PersistentHeapCollectionBase<HeapHashMap<KeyArg, MappedArg, HashArg, KeyTraitsArg, MappedTraitsArg> > { };
+    typename MappedTraitsArg = HashTraits<MappedArg>>
+class PersistentHeapHashMap : public PersistentHeapCollectionBase<HeapHashMap<KeyArg, MappedArg, HashArg, KeyTraitsArg, MappedTraitsArg>> { };
 
 template<
     typename ValueArg,
     typename HashArg = typename DefaultHash<ValueArg>::Hash,
-    typename TraitsArg = HashTraits<ValueArg> >
-class PersistentHeapHashSet : public PersistentHeapCollectionBase<HeapHashSet<ValueArg, HashArg, TraitsArg> > { };
+    typename TraitsArg = HashTraits<ValueArg>>
+class PersistentHeapHashSet : public PersistentHeapCollectionBase<HeapHashSet<ValueArg, HashArg, TraitsArg>> { };
 
 template<
     typename ValueArg,
     typename HashArg = typename DefaultHash<ValueArg>::Hash,
-    typename TraitsArg = HashTraits<ValueArg> >
-class PersistentHeapLinkedHashSet : public PersistentHeapCollectionBase<HeapLinkedHashSet<ValueArg, HashArg, TraitsArg> > { };
+    typename TraitsArg = HashTraits<ValueArg>>
+class PersistentHeapLinkedHashSet : public PersistentHeapCollectionBase<HeapLinkedHashSet<ValueArg, HashArg, TraitsArg>> { };
 
 template<
     typename ValueArg,
     size_t inlineCapacity = 0,
     typename HashArg = typename DefaultHash<ValueArg>::Hash>
-class PersistentHeapListHashSet : public PersistentHeapCollectionBase<HeapListHashSet<ValueArg, inlineCapacity, HashArg> > { };
+class PersistentHeapListHashSet : public PersistentHeapCollectionBase<HeapListHashSet<ValueArg, inlineCapacity, HashArg>> { };
 
 template<typename T, typename U, typename V>
-class PersistentHeapHashCountedSet : public PersistentHeapCollectionBase<HeapHashCountedSet<T, U, V> > { };
+class PersistentHeapHashCountedSet : public PersistentHeapCollectionBase<HeapHashCountedSet<T, U, V>> { };
 
 template<typename T, size_t inlineCapacity = 0>
-class PersistentHeapVector : public PersistentHeapCollectionBase<HeapVector<T, inlineCapacity> > {
+class PersistentHeapVector : public PersistentHeapCollectionBase<HeapVector<T, inlineCapacity>> {
 public:
     PersistentHeapVector() { }
 
     template<size_t otherCapacity>
     PersistentHeapVector(const HeapVector<T, otherCapacity>& other)
-        : PersistentHeapCollectionBase<HeapVector<T, inlineCapacity> >(other)
+        : PersistentHeapCollectionBase<HeapVector<T, inlineCapacity>>(other)
     {
     }
 };
 
 template<typename T, size_t inlineCapacity = 0>
-class PersistentHeapDeque : public PersistentHeapCollectionBase<HeapDeque<T, inlineCapacity> > {
+class PersistentHeapDeque : public PersistentHeapCollectionBase<HeapDeque<T, inlineCapacity>> {
 public:
     PersistentHeapDeque() { }
 
     template<size_t otherCapacity>
     PersistentHeapDeque(const HeapDeque<T, otherCapacity>& other)
-        : PersistentHeapCollectionBase<HeapDeque<T, inlineCapacity> >(other)
+        : PersistentHeapCollectionBase<HeapDeque<T, inlineCapacity>>(other)
     {
     }
 };
 
 // Members are used in classes to contain strong pointers to other oilpan heap
 // allocated objects.
 // All Member fields of a class must be traced in the class' trace method.
 // During the mark phase of the GC all live objects are marked as live and
 // all Member fields of a live object will be traced marked as live as well.
 template<typename T>
@@ skipping 122 matching lines @@
 // NeedsTracing<T>::value || IsWeakMember<T>::value. It should not need to test
 // raw pointer types. To remove these tests, we may need support for
 // instantiating a template with a RawPtrOrMember'ish template.
 template<typename T>
 struct TraceIfNeeded : public TraceIfEnabled<T, WTF::NeedsTracing<T>::value || blink::IsGarbageCollectedType<typename RemoveHeapPointerWrapperTypes<typename WTF::RemovePointer<T>::Type>::Type>::value> { };
 
 // This trace trait for std::pair will null weak members if their referent is
 // collected. If you have a collection that contain weakness it does not remove
 // entries from the collection that contain nulled weak members.
 template<typename T, typename U>
-class TraceTrait<std::pair<T, U> > {
+class TraceTrait<std::pair<T, U>> {
 public:
     static const bool firstNeedsTracing = WTF::NeedsTracing<T>::value || WTF::IsWeak<T>::value;
     static const bool secondNeedsTracing = WTF::NeedsTracing<U>::value || WTF::IsWeak<U>::value;
     static void trace(Visitor* visitor, std::pair<T, U>* pair)
     {
         TraceIfEnabled<T, firstNeedsTracing>::trace(visitor, &pair->first);
         TraceIfEnabled<U, secondNeedsTracing>::trace(visitor, &pair->second);
     }
 };
 
@@ skipping 266 matching lines @@
     static const bool value = TraceEagerlyTrait<T>::value;
 };
 
 template<typename T>
 class TraceEagerlyTrait<CrossThreadPersistent<T>> {
 public:
     static const bool value = TraceEagerlyTrait<T>::value;
 };
 
 template<typename T, typename U, typename V, typename W, typename X>
-class TraceEagerlyTrait<HeapHashMap<T, U, V, W, X> > {
+class TraceEagerlyTrait<HeapHashMap<T, U, V, W, X>> {
 public:
     static const bool value = MARKER_EAGER_TRACING || TraceEagerlyTrait<T>::value || TraceEagerlyTrait<U>::value;
 };
 
 template<typename T, typename U, typename V>
-class TraceEagerlyTrait<HeapHashSet<T, U, V> > {
+class TraceEagerlyTrait<HeapHashSet<T, U, V>> {
 public:
     static const bool value = MARKER_EAGER_TRACING || TraceEagerlyTrait<T>::value;
 };
 
 template<typename T, typename U, typename V>
-class TraceEagerlyTrait<HeapLinkedHashSet<T, U, V> > {
+class TraceEagerlyTrait<HeapLinkedHashSet<T, U, V>> {
 public:
     static const bool value = MARKER_EAGER_TRACING || TraceEagerlyTrait<T>::value;
 };
 
 template<typename T, size_t inlineCapacity, typename U>
-class TraceEagerlyTrait<HeapListHashSet<T, inlineCapacity, U> > {
+class TraceEagerlyTrait<HeapListHashSet<T, inlineCapacity, U>> {
 public:
     static const bool value = MARKER_EAGER_TRACING || TraceEagerlyTrait<T>::value;
 };
 
 template<typename T, size_t inlineCapacity>
 class TraceEagerlyTrait<WTF::ListHashSetNode<T, HeapListHashSetAllocator<T, inlineCapacity>>> {
 public:
     static const bool value = false;
 };
 
 template<typename T, size_t inlineCapacity>
-class TraceEagerlyTrait<HeapVector<T, inlineCapacity> > {
+class TraceEagerlyTrait<HeapVector<T, inlineCapacity>> {
 public:
     static const bool value = MARKER_EAGER_TRACING || TraceEagerlyTrait<T>::value;
 };
 
 template<typename T, typename U>
 class TraceEagerlyTrait<HeapVectorBacking<T, U>> {
 public:
     static const bool value = MARKER_EAGER_TRACING || TraceEagerlyTrait<T>::value;
 };
 
@@ skipping 199 matching lines @@
 template<typename T>
 struct ParamStorageTraits<RawPtr<T>> : public PointerParamStorageTraits<T*, blink::IsGarbageCollectedType<T>::value> {
 };
 
 template<typename T>
 PassRefPtr<T> adoptRef(blink::RefCountedGarbageCollected<T>*) = delete;
 
 } // namespace WTF
 
 #endif