Fix template angle bracket syntax leftovers

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 502 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>>;
+                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));
                     SafePointScope scope(ThreadState::NoHeapPointersOnStack);
                     Platform::current()->yieldCurrentThread();
                 }
 
                 if (gcCount < gcPerThread) {
@@ skipping 1438 matching lines @@
     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;
+            HashTraits<Member<IntWrapper>>> HeapObjectIdentityMap;
 
         Persistent<HeapObjectIdentityMap> map = new HeapObjectIdentityMap();
 
         map->clear();
         size_t afterSetWasCreated = Heap::objectPayloadSizeForTesting();
         EXPECT_TRUE(afterSetWasCreated > initialObjectPayloadSize);
 
         Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGCForTesting);
         size_t afterGC = Heap::objectPayloadSizeForTesting();
         EXPECT_EQ(afterGC, afterSetWasCreated);
@@ skipping 849 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 1023 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 169 matching lines @@
 
 TEST(HeapTest, DestructorsCalled)
 {
     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)) { }
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_obj);
     }
     Member<IntWrapper> m_obj;
@@ skipping 324 matching lines @@
 {
     // 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);
     Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGCForTesting);
     result.storedValue->value = IntWrapper::create(42);
 }
 
 TEST(HeapTest, Bind)
 {
     OwnPtr<Closure> closure = bind(static_cast<void (Bar::*)(Visitor*)>(&Bar::trace), Bar::create(), static_cast<Visitor*>(0));
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGCForTesting);
@@ skipping 115 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, ThreadState::GCWithSweep, Heap::ForcedGCForTesting);
             EXPECT_EQ(10000u, outer->size());
@@ skipping 377 matching lines @@
     {
         // 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();
                 Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGCForTesting);
 
                 // The backing should be strongified because of the iterator.
                 EXPECT_EQ(6u, collection->size());
                 EXPECT_EQ(32, (*it)->value());
             }
 
@@ skipping 219 matching lines @@
     }
 
     {
         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 419 matching lines @@
 {
     Persistent<ClassWithMember> object = ClassWithMember::create();
     EXPECT_EQ(0, object->traceCount());
     TestMixinAllocatingObject* mixin = TestMixinAllocatingObject::create(object.get());
     EXPECT_TRUE(mixin);
     EXPECT_GT(object->traceCount(), 0);
     EXPECT_GT(mixin->traceCount(), 0);
 }
 
 } // namespace blink