Fix template angle bracket syntax in platform

Source/platform/heap/HeapTest.cpp

 /*
  * 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 87 matching lines @@
     }
 
     static bool equal(const ThreadMarker& a, const ThreadMarker& b)
     {
         return a == b;
     }
 
     static const bool safeToCompareToEmptyOrDeleted = false;
 };
 
-typedef std::pair<Member<IntWrapper>, WeakMember<IntWrapper> > StrongWeakPair;
+typedef std::pair<Member<IntWrapper>, WeakMember<IntWrapper>> StrongWeakPair;
 
 struct PairWithWeakHandling : public StrongWeakPair {
     ALLOW_ONLY_INLINE_ALLOCATION();
 
 public:
     // Regular constructor.
     PairWithWeakHandling(IntWrapper* one, IntWrapper* two)
         : StrongWeakPair(one, two)
     {
         ASSERT(one); // We use null first field to indicate empty slots in the hash table.
@@ skipping 44 matching lines @@
     static const bool emptyValueIsZero = true;
     static void constructDeletedValue(blink::ThreadMarker& slot, bool) { new (NotNull, &slot) blink::ThreadMarker(HashTableDeletedValue); }
     static bool isDeletedValue(const blink::ThreadMarker& slot) { return slot.isHashTableDeletedValue(); }
 };
 
 // The hash algorithm for our custom pair class is just the standard double
 // hash for pairs. Note that this means you can't mutate either of the parts of
 // the pair while they are in the hash table, as that would change their hash
 // code and thus their preferred placement in the table.
 template<> struct DefaultHash<blink::PairWithWeakHandling> {
-    typedef PairHash<blink::Member<blink::IntWrapper>, blink::WeakMember<blink::IntWrapper> > Hash;
+    typedef PairHash<blink::Member<blink::IntWrapper>, blink::WeakMember<blink::IntWrapper>> Hash;
 };
 
 // Custom traits for the pair. These are weakness handling traits, which means
 // PairWithWeakHandling must implement the traceInCollection method.
 // In addition, these traits are concerned with the two magic values for the
 // object, that represent empty and deleted slots in the hash table. The
 // SimpleClassHashTraits allow empty slots in the table to be initialzed with
 // memset to zero, and we use -1 in the first part of the pair to represent
 // deleted slots.
 template<> struct HashTraits<blink::PairWithWeakHandling> : blink::WeakHandlingHashTraits<blink::PairWithWeakHandling> {
@@ skipping 326 matching lines @@
 
 private:
     virtual void runThread() override
     {
         ThreadState::attach();
 
         int gcCount = 0;
         while (!done()) {
             ThreadState::current()->safePoint(ThreadState::NoHeapPointersOnStack);
             {
-                Persistent<HeapHashMap<ThreadMarker, WeakMember<IntWrapper> > > weakMap = new HeapHashMap<ThreadMarker, WeakMember<IntWrapper> >;
-                PersistentHeapHashMap<ThreadMarker, WeakMember<IntWrapper> > weakMap2;
+                Persistent<HeapHashMap<ThreadMarker, WeakMember<IntWrapper>> > weakMap = new HeapHashMap<ThreadMarker, WeakMember<IntWrapper>>;
+                PersistentHeapHashMap<ThreadMarker, WeakMember<IntWrapper>> weakMap2;
 
                 for (int i = 0; i < numberOfAllocations; i++) {
                     weakMap->add(static_cast<unsigned>(i), IntWrapper::create(0));
                     weakMap2.add(static_cast<unsigned>(i), IntWrapper::create(0));
                     ThreadState::SafePointScope scope(ThreadState::NoHeapPointersOnStack);
                     Platform::current()->yieldCurrentThread();
                 }
 
                 if (gcCount < gcPerThread) {
                     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
@@ skipping 615 matching lines @@
         : m_wasDestructed(false)
     {
         ThreadState::current()->registerPreFinalizer(*this);
     }
 
     bool m_wasDestructed;
 };
 
 bool ObservableWithPreFinalizer::s_disposeWasCalled = false;
 
-template <typename T> class FinalizationObserver : public GarbageCollected<FinalizationObserver<T> > {
+template <typename T> class FinalizationObserver : public GarbageCollected<FinalizationObserver<T>> {
 public:
     static FinalizationObserver* create(T* data) { return new FinalizationObserver(data); }
     bool didCallWillFinalize() const { return m_didCallWillFinalize; }
 
     void trace(Visitor* visitor)
     {
         visitor->registerWeakMembers(this, zapWeakMembers);
     }
 
 private:
@@ skipping 12 matching lines @@
             o->m_didCallWillFinalize = true;
         }
     }
 
     WeakMember<T> m_data;
     bool m_didCallWillFinalize;
 };
 
 class FinalizationObserverWithHashMap {
 public:
-    typedef HeapHashMap<WeakMember<Observable>, OwnPtr<FinalizationObserverWithHashMap> > ObserverMap;
+    typedef HeapHashMap<WeakMember<Observable>, OwnPtr<FinalizationObserverWithHashMap>> ObserverMap;
 
     explicit FinalizationObserverWithHashMap(Observable& target) : m_target(target) { }
     ~FinalizationObserverWithHashMap()
     {
         m_target.willFinalize();
         s_didCallWillFinalize = true;
     }
 
     static ObserverMap& observe(Observable& target)
     {
@@ skipping 759 matching lines @@
 TEST(HeapTest, HashMapOfMembers)
 {
     IntWrapper::s_destructorCalls = 0;
 
     clearOutOldGarbage();
     size_t initialObjectPayloadSize = Heap::objectPayloadSizeForTesting();
     {
         typedef HeapHashMap<
             Member<IntWrapper>,
             Member<IntWrapper>,
-            DefaultHash<Member<IntWrapper> >::Hash,
-            HashTraits<Member<IntWrapper> >,
-            HashTraits<Member<IntWrapper> > > HeapObjectIdentityMap;
+            DefaultHash<Member<IntWrapper>>::Hash,
+            HashTraits<Member<IntWrapper>>,
+            HashTraits<Member<IntWrapper>> > HeapObjectIdentityMap;
 
         Persistent<HeapObjectIdentityMap> map = new HeapObjectIdentityMap();
 
         map->clear();
         size_t afterSetWasCreated = Heap::objectPayloadSizeForTesting();
         EXPECT_TRUE(afterSetWasCreated > initialObjectPayloadSize);
 
         Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
         size_t afterGC = Heap::objectPayloadSizeForTesting();
         EXPECT_EQ(afterGC, afterSetWasCreated);
@@ skipping 128 matching lines @@
     }
     clearOutOldGarbage();
     EXPECT_TRUE(initialObjectPayloadSize == Heap::objectPayloadSizeForTesting());
     EXPECT_TRUE(initialAllocatedSpace == Heap::allocatedSpace());
     EXPECT_EQ(11, IntWrapper::s_destructorCalls);
     EXPECT_EQ(11, LargeHeapObject::s_destructorCalls);
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
 }
 
 typedef std::pair<Member<IntWrapper>, int> PairWrappedUnwrapped;
-typedef std::pair<int, Member<IntWrapper> > PairUnwrappedWrapped;
-typedef std::pair<WeakMember<IntWrapper>, Member<IntWrapper> > PairWeakStrong;
-typedef std::pair<Member<IntWrapper>, WeakMember<IntWrapper> > PairStrongWeak;
+typedef std::pair<int, Member<IntWrapper>> PairUnwrappedWrapped;
+typedef std::pair<WeakMember<IntWrapper>, Member<IntWrapper>> PairWeakStrong;
+typedef std::pair<Member<IntWrapper>, WeakMember<IntWrapper>> PairStrongWeak;
 typedef std::pair<WeakMember<IntWrapper>, int> PairWeakUnwrapped;
-typedef std::pair<int, WeakMember<IntWrapper> > PairUnwrappedWeak;
+typedef std::pair<int, WeakMember<IntWrapper>> PairUnwrappedWeak;
 
 class Container : public GarbageCollected<Container> {
 public:
     static Container* create() { return new Container(); }
-    HeapHashMap<Member<IntWrapper>, Member<IntWrapper> > map;
-    HeapHashSet<Member<IntWrapper> > set;
-    HeapHashSet<Member<IntWrapper> > set2;
-    HeapHashCountedSet<Member<IntWrapper> > set3;
+    HeapHashMap<Member<IntWrapper>, Member<IntWrapper>> map;
+    HeapHashSet<Member<IntWrapper>> set;
+    HeapHashSet<Member<IntWrapper>> set2;
+    HeapHashCountedSet<Member<IntWrapper>> set3;
     HeapVector<Member<IntWrapper>, 2> vector;
     HeapVector<PairWrappedUnwrapped, 2> vectorWU;
     HeapVector<PairUnwrappedWrapped, 2> vectorUW;
     HeapDeque<Member<IntWrapper>, 0> deque;
     HeapDeque<PairWrappedUnwrapped, 0> dequeWU;
     HeapDeque<PairUnwrappedWrapped, 0> dequeUW;
     void trace(Visitor* visitor)
     {
         visitor->trace(map);
         visitor->trace(set);
@@ skipping 63 matching lines @@
 
 class B : public NoBaseWillBeGarbageCollected<B>, public A {
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(B);
 public:
     void trace(Visitor*) { }
 };
 
 TEST(HeapTest, HeapVectorFilledWithValue)
 {
     IntWrapper* val = IntWrapper::create(1);
-    HeapVector<Member<IntWrapper> > vector(10, val);
+    HeapVector<Member<IntWrapper>> vector(10, val);
     EXPECT_EQ(10u, vector.size());
     for (size_t i = 0; i < vector.size(); i++)
         EXPECT_EQ(val, vector[i]);
 }
 
 TEST(HeapTest, HeapVectorWithInlineCapacity)
 {
     IntWrapper* one = IntWrapper::create(1);
     IntWrapper* two = IntWrapper::create(2);
     IntWrapper* three = IntWrapper::create(3);
@@ skipping 113 matching lines @@
         if (*it == u)
             return true;
     }
     return false;
 }
 
 TEST(HeapTest, HeapCollectionTypes)
 {
     IntWrapper::s_destructorCalls = 0;
 
-    typedef HeapHashMap<Member<IntWrapper>, Member<IntWrapper> > MemberMember;
+    typedef HeapHashMap<Member<IntWrapper>, Member<IntWrapper>> MemberMember;
     typedef HeapHashMap<Member<IntWrapper>, int> MemberPrimitive;
-    typedef HeapHashMap<int, Member<IntWrapper> > PrimitiveMember;
+    typedef HeapHashMap<int, Member<IntWrapper>> PrimitiveMember;
 
-    typedef HeapHashSet<Member<IntWrapper> > MemberSet;
-    typedef HeapHashCountedSet<Member<IntWrapper> > MemberCountedSet;
+    typedef HeapHashSet<Member<IntWrapper>> MemberSet;
+    typedef HeapHashCountedSet<Member<IntWrapper>> MemberCountedSet;
 
     typedef HeapVector<Member<IntWrapper>, 2> MemberVector;
     typedef HeapDeque<Member<IntWrapper>, 0> MemberDeque;
 
     typedef HeapVector<PairWrappedUnwrapped, 2> VectorWU;
     typedef HeapVector<PairUnwrappedWrapped, 2> VectorUW;
     typedef HeapDeque<PairWrappedUnwrapped, 0> DequeWU;
     typedef HeapDeque<PairUnwrappedWrapped, 0> DequeUW;
 
     Persistent<MemberMember> memberMember = new MemberMember();
@@ skipping 297 matching lines @@
         ++it;
     }
     EXPECT_EQ(expected, found);
 }
 
 TEST(HeapTest, HeapWeakCollectionSimple)
 {
     clearOutOldGarbage();
     IntWrapper::s_destructorCalls = 0;
 
-    PersistentHeapVector<Member<IntWrapper> > keepNumbersAlive;
+    PersistentHeapVector<Member<IntWrapper>> keepNumbersAlive;
 
-    typedef HeapHashMap<WeakMember<IntWrapper>, Member<IntWrapper> > WeakStrong;
-    typedef HeapHashMap<Member<IntWrapper>, WeakMember<IntWrapper> > StrongWeak;
-    typedef HeapHashMap<WeakMember<IntWrapper>, WeakMember<IntWrapper> > WeakWeak;
-    typedef HeapHashSet<WeakMember<IntWrapper> > WeakSet;
-    typedef HeapHashCountedSet<WeakMember<IntWrapper> > WeakCountedSet;
+    typedef HeapHashMap<WeakMember<IntWrapper>, Member<IntWrapper>> WeakStrong;
+    typedef HeapHashMap<Member<IntWrapper>, WeakMember<IntWrapper>> StrongWeak;
+    typedef HeapHashMap<WeakMember<IntWrapper>, WeakMember<IntWrapper>> WeakWeak;
+    typedef HeapHashSet<WeakMember<IntWrapper>> WeakSet;
+    typedef HeapHashCountedSet<WeakMember<IntWrapper>> WeakCountedSet;
 
     Persistent<WeakStrong> weakStrong = new WeakStrong();
     Persistent<StrongWeak> strongWeak = new StrongWeak();
     Persistent<WeakWeak> weakWeak = new WeakWeak();
     Persistent<WeakSet> weakSet = new WeakSet();
     Persistent<WeakCountedSet> weakCountedSet = new WeakCountedSet();
 
     Persistent<IntWrapper> two = IntWrapper::create(2);
 
     keepNumbersAlive.append(IntWrapper::create(103));
@@ skipping 34 matching lines @@
     EXPECT_EQ(2u, weakSet->size());
     EXPECT_EQ(2u, weakCountedSet->size());
 }
 
 template<typename Set>
 void orderedSetHelper(bool strong)
 {
     clearOutOldGarbage();
     IntWrapper::s_destructorCalls = 0;
 
-    PersistentHeapVector<Member<IntWrapper> > keepNumbersAlive;
+    PersistentHeapVector<Member<IntWrapper>> keepNumbersAlive;
 
     Persistent<Set> set1 = new Set();
     Persistent<Set> set2 = new Set();
 
     const Set& constSet = *set1.get();
 
     keepNumbersAlive.append(IntWrapper::create(2));
     keepNumbersAlive.append(IntWrapper::create(103));
     keepNumbersAlive.append(IntWrapper::create(10));
 
@@ skipping 86 matching lines @@
     EXPECT_EQ(103, (*i2)->value());
     ++i2;
     EXPECT_NE(set1->end(), i2);
     EXPECT_EQ(10, (*i2)->value());
     ++i2;
     EXPECT_EQ(set1->end(), i2);
 }
 
 TEST(HeapTest, HeapWeakLinkedHashSet)
 {
-    orderedSetHelper<HeapLinkedHashSet<Member<IntWrapper> > >(true);
-    orderedSetHelper<HeapLinkedHashSet<WeakMember<IntWrapper> > >(false);
-    orderedSetHelper<HeapListHashSet<Member<IntWrapper> > >(true);
+    orderedSetHelper<HeapLinkedHashSet<Member<IntWrapper>> >(true);
+    orderedSetHelper<HeapLinkedHashSet<WeakMember<IntWrapper>> >(false);
+    orderedSetHelper<HeapListHashSet<Member<IntWrapper>> >(true);
 }
 
 class ThingWithDestructor {
 public:
     ThingWithDestructor()
         : m_x(emptyValue)
     {
         s_liveThingsWithDestructor++;
     }
 
@@ skipping 29 matching lines @@
 
 struct ThingWithDestructorTraits : public HashTraits<ThingWithDestructor> {
     static const bool needsDestruction = true;
 };
 
 static void heapMapDestructorHelper(bool clearMaps)
 {
     clearOutOldGarbage();
     ThingWithDestructor::s_liveThingsWithDestructor = 0;
 
-    typedef HeapHashMap<WeakMember<IntWrapper>, Member<RefCountedAndGarbageCollected> > RefMap;
+    typedef HeapHashMap<WeakMember<IntWrapper>, Member<RefCountedAndGarbageCollected>> RefMap;
 
     typedef HeapHashMap<
         WeakMember<IntWrapper>,
         ThingWithDestructor,
-        DefaultHash<WeakMember<IntWrapper> >::Hash,
-        HashTraits<WeakMember<IntWrapper> >,
+        DefaultHash<WeakMember<IntWrapper>>::Hash,
+        HashTraits<WeakMember<IntWrapper>>,
         ThingWithDestructorTraits> Map;
 
     Persistent<Map> map(new Map());
     Persistent<RefMap> refMap(new RefMap());
 
     Persistent<IntWrapper> luck(IntWrapper::create(103));
 
     int baseLine, refBaseLine;
 
     {
@@ skipping 141 matching lines @@
     EXPECT_TRUE(strongWeak->contains(PairStrongWeak(&*two, &*two)));
     EXPECT_TRUE(weakUnwrapped->contains(PairWeakUnwrapped(&*two, 2)));
     EXPECT_TRUE(unwrappedWeak->contains(PairUnwrappedWeak(2, &*two)));
 }
 
 template<typename WSSet, typename SWSet, typename WUSet, typename UWSet>
 void weakPairsHelper()
 {
     IntWrapper::s_destructorCalls = 0;
 
-    PersistentHeapVector<Member<IntWrapper> > keepNumbersAlive;
+    PersistentHeapVector<Member<IntWrapper>> keepNumbersAlive;
 
     Persistent<WSSet> weakStrong = new WSSet();
     Persistent<SWSet> strongWeak = new SWSet();
     Persistent<WUSet> weakUnwrapped = new WUSet();
     Persistent<UWSet> unwrappedWeak = new UWSet();
 
     Persistent<IntWrapper> two = IntWrapper::create(2);
 
     weakStrong->add(PairWeakStrong(IntWrapper::create(1), &*two));
     weakStrong->add(PairWeakStrong(&*two, &*two));
@@ skipping 34 matching lines @@
         typedef HeapLinkedHashSet<PairStrongWeak> StrongWeakSet;
         typedef HeapLinkedHashSet<PairUnwrappedWeak> UnwrappedWeakSet;
         weakPairsHelper<WeakStrongSet, StrongWeakSet, WeakUnwrappedSet, UnwrappedWeakSet>();
     }
 }
 
 TEST(HeapTest, HeapWeakCollectionTypes)
 {
     IntWrapper::s_destructorCalls = 0;
 
-    typedef HeapHashMap<WeakMember<IntWrapper>, Member<IntWrapper> > WeakStrong;
-    typedef HeapHashMap<Member<IntWrapper>, WeakMember<IntWrapper> > StrongWeak;
-    typedef HeapHashMap<WeakMember<IntWrapper>, WeakMember<IntWrapper> > WeakWeak;
-    typedef HeapHashSet<WeakMember<IntWrapper> > WeakSet;
-    typedef HeapLinkedHashSet<WeakMember<IntWrapper> > WeakOrderedSet;
+    typedef HeapHashMap<WeakMember<IntWrapper>, Member<IntWrapper>> WeakStrong;
+    typedef HeapHashMap<Member<IntWrapper>, WeakMember<IntWrapper>> StrongWeak;
+    typedef HeapHashMap<WeakMember<IntWrapper>, WeakMember<IntWrapper>> WeakWeak;
+    typedef HeapHashSet<WeakMember<IntWrapper>> WeakSet;
+    typedef HeapLinkedHashSet<WeakMember<IntWrapper>> WeakOrderedSet;
 
     clearOutOldGarbage();
 
     const int weakStrongIndex = 0;
     const int strongWeakIndex = 1;
     const int weakWeakIndex = 2;
     const int numberOfMapIndices = 3;
     const int weakSetIndex = 3;
     const int weakOrderedSetIndex = 4;
     const int numberOfCollections = 5;
@@ skipping 11 matching lines @@
 
             unsigned added = addAfterwards ? 100 : 0;
 
             Persistent<WeakStrong> weakStrong = new WeakStrong();
             Persistent<StrongWeak> strongWeak = new StrongWeak();
             Persistent<WeakWeak> weakWeak = new WeakWeak();
 
             Persistent<WeakSet> weakSet = new WeakSet();
             Persistent<WeakOrderedSet> weakOrderedSet = new WeakOrderedSet();
 
-            PersistentHeapVector<Member<IntWrapper> > keepNumbersAlive;
+            PersistentHeapVector<Member<IntWrapper>> keepNumbersAlive;
             for (int i = 0; i < 128; i += 2) {
                 IntWrapper* wrapped = IntWrapper::create(i);
                 IntWrapper* wrapped2 = IntWrapper::create(i + 1);
                 keepNumbersAlive.append(wrapped);
                 keepNumbersAlive.append(wrapped2);
                 weakStrong->add(wrapped, wrapped2);
                 strongWeak->add(wrapped2, wrapped);
                 weakWeak->add(wrapped, wrapped2);
                 weakSet->add(wrapped);
                 weakOrderedSet->add(wrapped);
@@ skipping 265 matching lines @@
         EXPECT_TRUE(h4->strongIsThere()); // h2 is still pointed to from h4.
         EXPECT_TRUE(h5->strongIsThere()); // h2 is still pointed to from h5.
     }
     // h4 and h5 have gone out of scope now and they were keeping h2 alive.
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(0u, Bar::s_live); // All gone.
 }
 
 TEST(HeapTest, FinalizationObserver)
 {
-    Persistent<FinalizationObserver<Observable> > o;
+    Persistent<FinalizationObserver<Observable>> o;
     {
         Observable* foo = Observable::create(Bar::create());
         // |o| observes |foo|.
         o = FinalizationObserver<Observable>::create(foo);
     }
     // FinalizationObserver doesn't have a strong reference to |foo|. So |foo|
     // and its member will be collected.
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(0u, Bar::s_live);
     EXPECT_TRUE(o->didCallWillFinalize());
@@ skipping 133 matching lines @@
     EXPECT_EQ(0, IntWrapper::s_destructorCalls);
     container = nullptr;
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(OffHeapContainer::deadWrappers, IntWrapper::s_destructorCalls);
 }
 
 TEST(HeapTest, PersistentHeapCollectionTypes)
 {
     IntWrapper::s_destructorCalls = 0;
 
-    typedef HeapVector<Member<IntWrapper> > Vec;
-    typedef PersistentHeapVector<Member<IntWrapper> > PVec;
-    typedef PersistentHeapHashSet<Member<IntWrapper> > PSet;
-    typedef PersistentHeapListHashSet<Member<IntWrapper> > PListSet;
-    typedef PersistentHeapLinkedHashSet<Member<IntWrapper> > PLinkedSet;
-    typedef PersistentHeapHashMap<Member<IntWrapper>, Member<IntWrapper> > PMap;
-    typedef PersistentHeapHashMap<WeakMember<IntWrapper>, Member<IntWrapper> > WeakPMap;
-    typedef PersistentHeapDeque<Member<IntWrapper> > PDeque;
+    typedef HeapVector<Member<IntWrapper>> Vec;
+    typedef PersistentHeapVector<Member<IntWrapper>> PVec;
+    typedef PersistentHeapHashSet<Member<IntWrapper>> PSet;
+    typedef PersistentHeapListHashSet<Member<IntWrapper>> PListSet;
+    typedef PersistentHeapLinkedHashSet<Member<IntWrapper>> PLinkedSet;
+    typedef PersistentHeapHashMap<Member<IntWrapper>, Member<IntWrapper>> PMap;
+    typedef PersistentHeapHashMap<WeakMember<IntWrapper>, Member<IntWrapper>> WeakPMap;
+    typedef PersistentHeapDeque<Member<IntWrapper>> PDeque;
 
     clearOutOldGarbage();
     {
         PVec pVec;
         PDeque pDeque;
         PSet pSet;
         PListSet pListSet;
         PLinkedSet pLinkedSet;
         PMap pMap;
         WeakPMap wpMap;
@@ skipping 66 matching lines @@
     // Collect previous roots.
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(11, IntWrapper::s_destructorCalls);
 }
 
 TEST(HeapTest, CollectionNesting)
 {
     clearOutOldGarbage();
     int* key = &IntWrapper::s_destructorCalls;
     IntWrapper::s_destructorCalls = 0;
-    typedef HeapVector<Member<IntWrapper> > IntVector;
-    typedef HeapDeque<Member<IntWrapper> > IntDeque;
+    typedef HeapVector<Member<IntWrapper>> IntVector;
+    typedef HeapDeque<Member<IntWrapper>> IntDeque;
     HeapHashMap<void*, IntVector>* map = new HeapHashMap<void*, IntVector>();
     HeapHashMap<void*, IntDeque>* map2 = new HeapHashMap<void*, IntDeque>();
     static_assert(WTF::NeedsTracing<IntVector>::value, "Failed to recognize HeapVector as NeedsTracing");
     static_assert(WTF::NeedsTracing<IntDeque>::value, "Failed to recognize HeapDeque as NeedsTracing");
 
     map->add(key, IntVector());
     map2->add(key, IntDeque());
 
     HeapHashMap<void*, IntVector>::iterator it = map->find(key);
     EXPECT_EQ(0u, map->get(key).size());
 
     HeapHashMap<void*, IntDeque>::iterator it2 = map2->find(key);
     EXPECT_EQ(0u, map2->get(key).size());
 
     it->value.append(IntWrapper::create(42));
     EXPECT_EQ(1u, map->get(key).size());
 
     it2->value.append(IntWrapper::create(42));
     EXPECT_EQ(1u, map2->get(key).size());
 
-    Persistent<HeapHashMap<void*, IntVector> > keepAlive(map);
-    Persistent<HeapHashMap<void*, IntDeque> > keepAlive2(map2);
+    Persistent<HeapHashMap<void*, IntVector>> keepAlive(map);
+    Persistent<HeapHashMap<void*, IntDeque>> keepAlive2(map2);
 
     for (int i = 0; i < 100; i++) {
         map->add(key + 1 + i, IntVector());
         map2->add(key + 1 + i, IntDeque());
     }
 
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
 
     EXPECT_EQ(1u, map->get(key).size());
     EXPECT_EQ(1u, map2->get(key).size());
@@ skipping 11 matching lines @@
     Persistent<UseMixin> usemixin = UseMixin::create();
     EXPECT_EQ(0, UseMixin::s_traceCount);
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(1, UseMixin::s_traceCount);
 
     Persistent<Mixin> mixin = usemixin;
     usemixin = nullptr;
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(2, UseMixin::s_traceCount);
 
-    PersistentHeapHashSet<WeakMember<Mixin> > weakMap;
+    PersistentHeapHashSet<WeakMember<Mixin>> weakMap;
     weakMap.add(UseMixin::create());
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(0u, weakMap.size());
 }
 
 TEST(HeapTest, CollectionNesting2)
 {
     clearOutOldGarbage();
     void* key = &IntWrapper::s_destructorCalls;
     IntWrapper::s_destructorCalls = 0;
-    typedef HeapHashSet<Member<IntWrapper> > IntSet;
+    typedef HeapHashSet<Member<IntWrapper>> IntSet;
     HeapHashMap<void*, IntSet>* map = new HeapHashMap<void*, IntSet>();
 
     map->add(key, IntSet());
 
     HeapHashMap<void*, IntSet>::iterator it = map->find(key);
     EXPECT_EQ(0u, map->get(key).size());
 
     it->value.add(IntWrapper::create(42));
     EXPECT_EQ(1u, map->get(key).size());
 
-    Persistent<HeapHashMap<void*, IntSet> > keepAlive(map);
+    Persistent<HeapHashMap<void*, IntSet>> keepAlive(map);
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(1u, map->get(key).size());
     EXPECT_EQ(0, IntWrapper::s_destructorCalls);
 }
 
 TEST(HeapTest, CollectionNesting3)
 {
     clearOutOldGarbage();
     IntWrapper::s_destructorCalls = 0;
-    typedef HeapVector<Member<IntWrapper> > IntVector;
-    typedef HeapDeque<Member<IntWrapper> > IntDeque;
+    typedef HeapVector<Member<IntWrapper>> IntVector;
+    typedef HeapDeque<Member<IntWrapper>> IntDeque;
     HeapVector<IntVector>* vector = new HeapVector<IntVector>();
     HeapDeque<IntDeque>* deque = new HeapDeque<IntDeque>();
 
     vector->append(IntVector());
     deque->append(IntDeque());
 
     HeapVector<IntVector>::iterator it = vector->begin();
     HeapDeque<IntDeque>::iterator it2 = deque->begin();
     EXPECT_EQ(0u, it->size());
     EXPECT_EQ(0u, it2->size());
 
     it->append(IntWrapper::create(42));
     it2->append(IntWrapper::create(42));
     EXPECT_EQ(1u, it->size());
     EXPECT_EQ(1u, it2->size());
 
-    Persistent<HeapVector<IntVector> > keepAlive(vector);
-    Persistent<HeapDeque<IntDeque> > keepAlive2(deque);
+    Persistent<HeapVector<IntVector>> keepAlive(vector);
+    Persistent<HeapDeque<IntDeque>> keepAlive2(deque);
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(1u, it->size());
     EXPECT_EQ(1u, it2->size());
     EXPECT_EQ(0, IntWrapper::s_destructorCalls);
 }
 
 TEST(HeapTest, EmbeddedInVector)
 {
     clearOutOldGarbage();
     SimpleFinalizedObject::s_destructorCalls = 0;
@@ skipping 79 matching lines @@
     set.add(new int(42));
     EXPECT_EQ(2u, set.size());
     for (typename Set::iterator it = set.begin(); it != set.end(); ++it) {
         EXPECT_EQ(42, **it);
         delete *it;
     }
 }
 
 TEST(HeapTest, RawPtrInHash)
 {
-    rawPtrInHashHelper<HashSet<RawPtr<int> > >();
-    rawPtrInHashHelper<ListHashSet<RawPtr<int> > >();
-    rawPtrInHashHelper<LinkedHashSet<RawPtr<int> > >();
+    rawPtrInHashHelper<HashSet<RawPtr<int>> >();
+    rawPtrInHashHelper<ListHashSet<RawPtr<int>> >();
+    rawPtrInHashHelper<LinkedHashSet<RawPtr<int>> >();
 }
 
 TEST(HeapTest, HeapTerminatedArray)
 {
     clearOutOldGarbage();
     IntWrapper::s_destructorCalls = 0;
 
     HeapTerminatedArray<TerminatedArrayItem>* arr = 0;
 
     const size_t prefixSize = 4;
@@ skipping 21 matching lines @@
         arr = builder.release();
     }
 
     Heap::collectGarbage(ThreadState::HeapPointersOnStack);
     EXPECT_EQ(0, IntWrapper::s_destructorCalls);
     EXPECT_EQ(prefixSize + suffixSize, arr->size());
     for (size_t i = 0; i < prefixSize + suffixSize; i++)
         EXPECT_EQ(i, static_cast<size_t>(arr->at(i).payload()->value()));
 
     {
-        Persistent<HeapTerminatedArray<TerminatedArrayItem> > persistentArr = arr;
+        Persistent<HeapTerminatedArray<TerminatedArrayItem>> persistentArr = arr;
         arr = 0;
         Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
         arr = persistentArr.get();
         EXPECT_EQ(0, IntWrapper::s_destructorCalls);
         EXPECT_EQ(prefixSize + suffixSize, arr->size());
         for (size_t i = 0; i < prefixSize + suffixSize; i++)
             EXPECT_EQ(i, static_cast<size_t>(arr->at(i).payload()->value()));
     }
 
     arr = 0;
@@ skipping 14 matching lines @@
         stack->push(TerminatedArrayItem(IntWrapper::create(i)));
 
     Heap::collectGarbage(ThreadState::HeapPointersOnStack);
     EXPECT_EQ(0, IntWrapper::s_destructorCalls);
     EXPECT_EQ(stackSize, stack->size());
     while (!stack->isEmpty()) {
         EXPECT_EQ(stack->size() - 1, static_cast<size_t>(stack->peek().payload()->value()));
         stack->pop();
     }
 
-    Persistent<HeapLinkedStack<TerminatedArrayItem> > pStack = stack;
+    Persistent<HeapLinkedStack<TerminatedArrayItem>> pStack = stack;
 
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(stackSize, static_cast<size_t>(IntWrapper::s_destructorCalls));
     EXPECT_EQ(0u, pStack->size());
 }
 
 TEST(HeapTest, AllocationDuringFinalization)
 {
     clearOutOldGarbage();
     IntWrapper::s_destructorCalls = 0;
@@ skipping 85 matching lines @@
         }
     }
 
     EXPECT_FALSE(RefCountedWithDestructor::s_wasDestructed);
     set.clear();
     EXPECT_TRUE(RefCountedWithDestructor::s_wasDestructed);
 }
 
 TEST(HeapTest, DestructorsCalled)
 {
-    HeapHashMap<SimpleClassWithDestructor*, OwnPtr<SimpleClassWithDestructor> > map;
+    HeapHashMap<SimpleClassWithDestructor*, OwnPtr<SimpleClassWithDestructor>> map;
     SimpleClassWithDestructor* hasDestructor = new SimpleClassWithDestructor();
     map.add(hasDestructor, adoptPtr(hasDestructor));
     SimpleClassWithDestructor::s_wasDestructed = false;
     map.clear();
     EXPECT_TRUE(SimpleClassWithDestructor::s_wasDestructed);
 
-    destructorsCalledOnClear<HeapHashSet<RefPtr<RefCountedWithDestructor> > >(false);
-    destructorsCalledOnClear<HeapListHashSet<RefPtr<RefCountedWithDestructor> > >(false);
-    destructorsCalledOnClear<HeapLinkedHashSet<RefPtr<RefCountedWithDestructor> > >(false);
-    destructorsCalledOnClear<HeapHashSet<RefPtr<RefCountedWithDestructor> > >(true);
-    destructorsCalledOnClear<HeapListHashSet<RefPtr<RefCountedWithDestructor> > >(true);
-    destructorsCalledOnClear<HeapLinkedHashSet<RefPtr<RefCountedWithDestructor> > >(true);
+    destructorsCalledOnClear<HeapHashSet<RefPtr<RefCountedWithDestructor>> >(false);
+    destructorsCalledOnClear<HeapListHashSet<RefPtr<RefCountedWithDestructor>> >(false);
+    destructorsCalledOnClear<HeapLinkedHashSet<RefPtr<RefCountedWithDestructor>> >(false);
+    destructorsCalledOnClear<HeapHashSet<RefPtr<RefCountedWithDestructor>> >(true);
+    destructorsCalledOnClear<HeapListHashSet<RefPtr<RefCountedWithDestructor>> >(true);
+    destructorsCalledOnClear<HeapLinkedHashSet<RefPtr<RefCountedWithDestructor>> >(true);
 
-    destructorsCalledOnGC<HeapHashSet<RefPtr<RefCountedWithDestructor> > >(false);
-    destructorsCalledOnGC<HeapListHashSet<RefPtr<RefCountedWithDestructor> > >(false);
-    destructorsCalledOnGC<HeapLinkedHashSet<RefPtr<RefCountedWithDestructor> > >(false);
-    destructorsCalledOnGC<HeapHashSet<RefPtr<RefCountedWithDestructor> > >(true);
-    destructorsCalledOnGC<HeapListHashSet<RefPtr<RefCountedWithDestructor> > >(true);
-    destructorsCalledOnGC<HeapLinkedHashSet<RefPtr<RefCountedWithDestructor> > >(true);
+    destructorsCalledOnGC<HeapHashSet<RefPtr<RefCountedWithDestructor>> >(false);
+    destructorsCalledOnGC<HeapListHashSet<RefPtr<RefCountedWithDestructor>> >(false);
+    destructorsCalledOnGC<HeapLinkedHashSet<RefPtr<RefCountedWithDestructor>> >(false);
+    destructorsCalledOnGC<HeapHashSet<RefPtr<RefCountedWithDestructor>> >(true);
+    destructorsCalledOnGC<HeapListHashSet<RefPtr<RefCountedWithDestructor>> >(true);
+    destructorsCalledOnGC<HeapLinkedHashSet<RefPtr<RefCountedWithDestructor>> >(true);
 }
 
 class MixinA : public GarbageCollectedMixin {
 public:
     MixinA() : m_obj(IntWrapper::create(100)) { }
     virtual void trace(Visitor* visitor)
     {
         visitor->trace(m_obj);
     }
     Member<IntWrapper> m_obj;
@@ skipping 170 matching lines @@
     Iterator i1 = set1->begin();
     EXPECT_TRUE(i1->first->value() == 103 || i1->first == livingInt);
     EXPECT_EQ(livingInt, i1->second);
     ++i1;
     EXPECT_TRUE(i1->first->value() == 103 || i1->first == livingInt);
     EXPECT_EQ(livingInt, i1->second);
 }
 
 TEST(HeapTest, SetWithCustomWeaknessHandling)
 {
-    setWithCustomWeaknessHandling<HeapHashSet<PairWithWeakHandling> >();
-    setWithCustomWeaknessHandling<HeapLinkedHashSet<PairWithWeakHandling> >();
+    setWithCustomWeaknessHandling<HeapHashSet<PairWithWeakHandling>>();
+    setWithCustomWeaknessHandling<HeapLinkedHashSet<PairWithWeakHandling>>();
 }
 
 TEST(HeapTest, MapWithCustomWeaknessHandling)
 {
-    typedef HeapHashMap<PairWithWeakHandling, RefPtr<OffHeapInt> > Map;
+    typedef HeapHashMap<PairWithWeakHandling, RefPtr<OffHeapInt>> Map;
     typedef Map::iterator Iterator;
     clearOutOldGarbage();
     OffHeapInt::s_destructorCalls = 0;
 
     Persistent<Map> map1(new Map());
     Persistent<IntWrapper> livingInt(IntWrapper::create(42));
     {
         Map map2;
         Map* map3 = new Map();
         map2.add(PairWithWeakHandling(IntWrapper::create(0), IntWrapper::create(1)), OffHeapInt::create(1001));
@@ skipping 116 matching lines @@
     EXPECT_EQ(2, OffHeapInt::s_destructorCalls);
     EXPECT_EQ(2u, map1->size());
     Iterator i1 = map1->begin();
     EXPECT_TRUE(i1->value.first->value() == 103 || i1->value.first == livingInt);
     EXPECT_EQ(livingInt, i1->value.second);
     ++i1;
     EXPECT_TRUE(i1->value.first->value() == 103 || i1->value.first == livingInt);
     EXPECT_EQ(livingInt, i1->value.second);
 }
 
-static void addElementsToWeakMap(HeapHashMap<int, WeakMember<IntWrapper> >* map)
+static void addElementsToWeakMap(HeapHashMap<int, WeakMember<IntWrapper>>* map)
 {
     // Key cannot be zero in hashmap.
     for (int i = 1; i < 11; i++)
         map->add(i, IntWrapper::create(i));
 }
 
 // crbug.com/402426
 // If it doesn't assert a concurrent modification to the map, then it's passing.
 TEST(HeapTest, RegressNullIsStrongified)
 {
-    Persistent<HeapHashMap<int, WeakMember<IntWrapper> > > map = new HeapHashMap<int, WeakMember<IntWrapper> >();
+    Persistent<HeapHashMap<int, WeakMember<IntWrapper>> > map = new HeapHashMap<int, WeakMember<IntWrapper>>();
     addElementsToWeakMap(map);
-    HeapHashMap<int, WeakMember<IntWrapper> >::AddResult result = map->add(800, nullptr);
+    HeapHashMap<int, WeakMember<IntWrapper>>::AddResult result = map->add(800, nullptr);
     Heap::collectGarbage(ThreadState::HeapPointersOnStack);
     result.storedValue->value = IntWrapper::create(42);
 }
 
 TEST(HeapTest, Bind)
 {
     OwnPtr<Closure> closure = bind(&Bar::trace, Bar::create(), static_cast<Visitor*>(0));
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     // The closure should have a persistent handle to the Bar.
     EXPECT_EQ(1u, Bar::s_live);
 
     OwnPtr<Closure> closure2 = bind(&Bar::trace, RawPtr<Bar>(Bar::create()), static_cast<Visitor*>(0));
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     // The closure should have a persistent handle to the Bar.
     EXPECT_EQ(2u, Bar::s_live);
     // RawPtr<OffHeapInt> should not make Persistent.
     OwnPtr<Closure> closure3 = bind(&OffHeapInt::voidFunction, RawPtr<OffHeapInt>(OffHeapInt::create(1).get()));
 
     UseMixin::s_traceCount = 0;
     Mixin* mixin = UseMixin::create();
     OwnPtr<Closure> mixinClosure = bind(&Mixin::trace, mixin, static_cast<Visitor*>(0));
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     // The closure should have a persistent handle to the mixin.
     EXPECT_EQ(1, UseMixin::s_traceCount);
 }
 
-typedef HeapHashSet<WeakMember<IntWrapper> > WeakSet;
+typedef HeapHashSet<WeakMember<IntWrapper>> WeakSet;
 
 // These special traits will remove a set from a map when the set is empty.
 struct EmptyClearingHashSetTraits : HashTraits<WeakSet> {
     static const WTF::WeakHandlingFlag weakHandlingFlag = WTF::WeakHandlingInCollections;
     static bool traceInCollection(Visitor* visitor, WeakSet& set, WTF::ShouldWeakPointersBeMarkedStrongly strongify)
     {
         bool liveEntriesFound = false;
         WeakSet::iterator end = set.end();
         for (WeakSet::iterator it = set.begin(); it != end; ++it) {
             if (visitor->isAlive(*it)) {
@@ skipping 53 matching lines @@
         EXPECT_EQ(1u, set.size());
     }
 
     livingInt.clear(); // The weak set can no longer keep the '42' alive now.
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(0u, map->size());
 }
 
 TEST(HeapTest, EphemeronsInEphemerons)
 {
-    typedef HeapHashMap<WeakMember<IntWrapper>, Member<IntWrapper> > InnerMap;
+    typedef HeapHashMap<WeakMember<IntWrapper>, Member<IntWrapper>> InnerMap;
     typedef HeapHashMap<WeakMember<IntWrapper>, InnerMap> OuterMap;
 
     for (int keepOuterAlive = 0; keepOuterAlive <= 1; keepOuterAlive++) {
         for (int keepInnerAlive = 0; keepInnerAlive <=1; keepInnerAlive++) {
             Persistent<OuterMap> outer = new OuterMap();
             Persistent<IntWrapper> one = IntWrapper::create(1);
             Persistent<IntWrapper> two = IntWrapper::create(2);
             outer->add(one, InnerMap());
             outer->begin()->value.add(two, IntWrapper::create(3));
             EXPECT_EQ(1u, outer->get(one).size());
@@ skipping 11 matching lines @@
                 } else {
                     EXPECT_EQ(0u, inner.size());
                 }
             } else {
                 EXPECT_EQ(0u, outer->size());
             }
             outer->clear();
             Persistent<IntWrapper> deep = IntWrapper::create(42);
             Persistent<IntWrapper> home = IntWrapper::create(103);
             Persistent<IntWrapper> composite = IntWrapper::create(91);
-            Persistent<HeapVector<Member<IntWrapper> > > keepAlive = new HeapVector<Member<IntWrapper> >();
+            Persistent<HeapVector<Member<IntWrapper>> > keepAlive = new HeapVector<Member<IntWrapper>>();
             for (int i = 0; i < 10000; i++) {
                 IntWrapper* value = IntWrapper::create(i);
                 keepAlive->append(value);
                 OuterMap::AddResult newEntry = outer->add(value, InnerMap());
                 newEntry.storedValue->value.add(deep, home);
                 newEntry.storedValue->value.add(composite, home);
             }
             composite.clear();
             Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
             EXPECT_EQ(10000u, outer->size());
             for (int i = 0; i < 10000; i++) {
                 IntWrapper* value = keepAlive->at(i);
                 EXPECT_EQ(1u, outer->get(value).size()); // Other one was deleted by weak handling.
                 if (i & 1)
                     keepAlive->at(i) = nullptr;
             }
             Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
             EXPECT_EQ(5000u, outer->size());
         }
     }
 }
 
 class EphemeronWrapper : public GarbageCollected<EphemeronWrapper> {
 public:
     void trace(Visitor* visitor)
     {
         visitor->trace(m_map);
     }
 
-    typedef HeapHashMap<WeakMember<IntWrapper>, Member<EphemeronWrapper> > Map;
+    typedef HeapHashMap<WeakMember<IntWrapper>, Member<EphemeronWrapper>> Map;
     Map& map() { return m_map; }
 
 private:
     Map m_map;
 };
 
 TEST(HeapTest, EphemeronsPointToEphemerons)
 {
     Persistent<IntWrapper> key = IntWrapper::create(42);
     Persistent<IntWrapper> key2 = IntWrapper::create(103);
@@ skipping 32 matching lines @@
     EXPECT_EQ(nullptr, wrapper);
 
     key.clear();
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(0u, chain->map().size());
 }
 
 TEST(HeapTest, Ephemeron)
 {
     typedef HeapHashMap<WeakMember<IntWrapper>, PairWithWeakHandling>  WeakPairMap;
-    typedef HeapHashMap<PairWithWeakHandling, WeakMember<IntWrapper> >  PairWeakMap;
-    typedef HeapHashSet<WeakMember<IntWrapper> > Set;
+    typedef HeapHashMap<PairWithWeakHandling, WeakMember<IntWrapper>>  PairWeakMap;
+    typedef HeapHashSet<WeakMember<IntWrapper>> Set;
 
     Persistent<WeakPairMap> weakPairMap = new WeakPairMap();
     Persistent<WeakPairMap> weakPairMap2 = new WeakPairMap();
     Persistent<WeakPairMap> weakPairMap3 = new WeakPairMap();
     Persistent<WeakPairMap> weakPairMap4 = new WeakPairMap();
 
     Persistent<PairWeakMap> pairWeakMap = new PairWeakMap();
     Persistent<PairWeakMap> pairWeakMap2 = new PairWeakMap();
 
     Persistent<Set> set = new Set();
@@ skipping 76 matching lines @@
     }
 
     IntWrapper* link() { return m_link; }
 
 private:
     Member<IntWrapper> m_link;
 };
 
 TEST(HeapTest, IndirectStrongToWeak)
 {
-    typedef HeapHashMap<WeakMember<IntWrapper>, Member<Link1> > Map;
+    typedef HeapHashMap<WeakMember<IntWrapper>, Member<Link1>> Map;
     Persistent<Map> map = new Map();
     Persistent<IntWrapper> deadObject = IntWrapper::create(100); // Named for "Drowning by Numbers" (1988).
     Persistent<IntWrapper> lifeObject = IntWrapper::create(42);
     map->add(deadObject, new Link1(deadObject));
     map->add(lifeObject, new Link1(lifeObject));
     EXPECT_EQ(2u, map->size());
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(2u, map->size());
     EXPECT_EQ(deadObject, map->get(deadObject)->link());
     EXPECT_EQ(lifeObject, map->get(lifeObject)->link());
@@ skipping 185 matching lines @@
 
         // Wait for the worker thread to sweep its heaps before checking.
         {
             ThreadState::SafePointScope scope(ThreadState::NoHeapPointersOnStack);
             parkMainThread();
         }
     }
 
 private:
 
-    static HeapHashSet<WeakMember<IntWrapper> >* allocateCollection()
+    static HeapHashSet<WeakMember<IntWrapper>>* allocateCollection()
     {
         // Create a weak collection that is kept alive by a persistent
         // and keep the contents alive with a persistents as
         // well.
         Persistent<IntWrapper> wrapper1 = IntWrapper::create(32);
         Persistent<IntWrapper> wrapper2 = IntWrapper::create(32);
         Persistent<IntWrapper> wrapper3 = IntWrapper::create(32);
         Persistent<IntWrapper> wrapper4 = IntWrapper::create(32);
         Persistent<IntWrapper> wrapper5 = IntWrapper::create(32);
         Persistent<IntWrapper> wrapper6 = IntWrapper::create(32);
-        Persistent<HeapHashSet<WeakMember<IntWrapper> > > weakCollection = new HeapHashSet<WeakMember<IntWrapper> >;
+        Persistent<HeapHashSet<WeakMember<IntWrapper>> > weakCollection = new HeapHashSet<WeakMember<IntWrapper>>;
         weakCollection->add(wrapper1);
         weakCollection->add(wrapper2);
         weakCollection->add(wrapper3);
         weakCollection->add(wrapper4);
         weakCollection->add(wrapper5);
         weakCollection->add(wrapper6);
 
         // Signal the main thread that the worker is done with its allocation.
         wakeMainThread();
 
@@ skipping 11 matching lines @@
         return weakCollection;
     }
 
     static void workerThreadMain()
     {
         MutexLocker locker(workerThreadMutex());
 
         ThreadState::attach();
 
         {
-            Persistent<HeapHashSet<WeakMember<IntWrapper> > > collection = allocateCollection();
+            Persistent<HeapHashSet<WeakMember<IntWrapper>> > collection = allocateCollection();
             {
                 // Prevent weak processing with an iterator and GC.
-                HeapHashSet<WeakMember<IntWrapper> >::iterator it = collection->begin();
+                HeapHashSet<WeakMember<IntWrapper>>::iterator it = collection->begin();
                 Heap::collectGarbage(ThreadState::HeapPointersOnStack);
 
                 // The backing should be strongified because of the iterator.
                 EXPECT_EQ(6u, collection->size());
                 EXPECT_EQ(32, (*it)->value());
             }
 
             // Disregarding the iterator but keeping the collection alive
             // with a persistent should lead to weak processing.
             Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
@@ skipping 157 matching lines @@
 
     static volatile IntWrapper* s_workerObjectPointer;
 };
 
 TEST(HeapTest, RecursiveMutex)
 {
     RecursiveLockingTester::test();
 }
 
 template<typename T>
-class TraceIfNeededTester : public GarbageCollectedFinalized<TraceIfNeededTester<T> > {
+class TraceIfNeededTester : public GarbageCollectedFinalized<TraceIfNeededTester<T>> {
 public:
     static TraceIfNeededTester<T>* create() { return new TraceIfNeededTester<T>(); }
     static TraceIfNeededTester<T>* create(const T& obj) { return new TraceIfNeededTester<T>(obj); }
     void trace(Visitor* visitor) { TraceIfNeeded<T>::trace(visitor, &m_obj); }
     T& obj() { return m_obj; }
     ~TraceIfNeededTester() { }
 private:
     TraceIfNeededTester() { }
     explicit TraceIfNeededTester(const T& obj) : m_obj(obj) { }
     T m_obj;
 };
 
 class PartObject {
     DISALLOW_ALLOCATION();
 public:
     PartObject() : m_obj(SimpleObject::create()) { }
     void trace(Visitor* visitor) { visitor->trace(m_obj); }
 private:
     Member<SimpleObject> m_obj;
 };
 
 TEST(HeapTest, TraceIfNeeded)
 {
     CountingVisitor visitor;
 
     {
-        TraceIfNeededTester<RefPtr<OffHeapInt> >* m_offHeap = TraceIfNeededTester<RefPtr<OffHeapInt> >::create(OffHeapInt::create(42));
+        TraceIfNeededTester<RefPtr<OffHeapInt>>* m_offHeap = TraceIfNeededTester<RefPtr<OffHeapInt>>::create(OffHeapInt::create(42));
         visitor.reset();
         m_offHeap->trace(&visitor);
         EXPECT_EQ(0u, visitor.count());
     }
 
     {
         TraceIfNeededTester<PartObject>* m_part = TraceIfNeededTester<PartObject>::create();
         visitor.reset();
         m_part->trace(&visitor);
         EXPECT_EQ(1u, visitor.count());
     }
 
     {
-        TraceIfNeededTester<Member<SimpleObject> >* m_obj = TraceIfNeededTester<Member<SimpleObject> >::create(Member<SimpleObject>(SimpleObject::create()));
+        TraceIfNeededTester<Member<SimpleObject>>* m_obj = TraceIfNeededTester<Member<SimpleObject>>::create(Member<SimpleObject>(SimpleObject::create()));
         visitor.reset();
         m_obj->trace(&visitor);
         EXPECT_EQ(1u, visitor.count());
     }
 
     {
-        TraceIfNeededTester<HeapVector<Member<SimpleObject> > >* m_vec = TraceIfNeededTester<HeapVector<Member<SimpleObject> > >::create();
+        TraceIfNeededTester<HeapVector<Member<SimpleObject>> >* m_vec = TraceIfNeededTester<HeapVector<Member<SimpleObject>> >::create();
         m_vec->obj().append(SimpleObject::create());
         visitor.reset();
         m_vec->trace(&visitor);
         EXPECT_EQ(2u, visitor.count());
     }
 }
 
 class AllocatesOnAssignment {
 public:
     AllocatesOnAssignment(std::nullptr_t)
@@ skipping 284 matching lines @@
     // re-adjusting both start&end indices in terms of that expanded buffer.
     EXPECT_EQ(80u, deque->size());
     i = 0;
     for (const auto& intWrapper : *deque) {
         EXPECT_EQ(i + 50, intWrapper->value());
         i++;
     }
 }
 
 } // namespace blink