Fix template angle bracket syntax

Source/wtf/HashSetTest.cpp

 /*
  * Copyright (C) 2012 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 24 matching lines @@
 
 template<int initialCapacity>
     struct InitialCapacityTestHashTraits : public WTF::UnsignedWithZeroKeyHashTraits<int> {
     static const int minimumTableSize = initialCapacity;
 };
 
 template<unsigned size>
 void testInitialCapacity()
 {
     const unsigned initialCapacity = WTF::HashTableCapacityForSize<size>::value;
-    HashSet<int, DefaultHash<int>::Hash, InitialCapacityTestHashTraits<initialCapacity> > testSet;
+    HashSet<int, DefaultHash<int>::Hash, InitialCapacityTestHashTraits<initialCapacity>> testSet;
 
     // Initial capacity is null.
     EXPECT_EQ(0UL, testSet.capacity());
 
     // Adding items up to size should never change the capacity.
     for (size_t i = 0; i < size; ++i) {
         testSet.add(i);
         EXPECT_EQ(initialCapacity, testSet.capacity());
     }
 
@@ skipping 32 matching lines @@
         deleted = true;
     }
 
     bool& deleted;
 };
 
 TEST(HashSetTest, HashSetOwnPtr)
 {
     bool deleted1 = false, deleted2 = false;
 
-    typedef HashSet<OwnPtr<Dummy> > OwnPtrSet;
+    typedef HashSet<OwnPtr<Dummy>> OwnPtrSet;
     OwnPtrSet set;
 
     Dummy* ptr1 = new Dummy(deleted1);
     {
         // AddResult in a separate scope to avoid assertion hit,
         // since we modify the container further.
-        HashSet<OwnPtr<Dummy> >::AddResult res1 = set.add(adoptPtr(ptr1));
+        HashSet<OwnPtr<Dummy>>::AddResult res1 = set.add(adoptPtr(ptr1));
         EXPECT_EQ(ptr1, res1.storedValue->get());
     }
 
     EXPECT_FALSE(deleted1);
     EXPECT_EQ(1UL, set.size());
     OwnPtrSet::iterator it1 = set.find(ptr1);
     EXPECT_NE(set.end(), it1);
     EXPECT_EQ(ptr1, (*it1));
 
     Dummy* ptr2 = new Dummy(deleted2);
     {
-        HashSet<OwnPtr<Dummy> >::AddResult res2 = set.add(adoptPtr(ptr2));
+        HashSet<OwnPtr<Dummy>>::AddResult res2 = set.add(adoptPtr(ptr2));
         EXPECT_EQ(res2.storedValue->get(), ptr2);
     }
 
     EXPECT_FALSE(deleted2);
     EXPECT_EQ(2UL, set.size());
     OwnPtrSet::iterator it2 = set.find(ptr2);
     EXPECT_NE(set.end(), it2);
     EXPECT_EQ(ptr2, (*it2));
 
     set.remove(ptr1);
@@ skipping 52 matching lines @@
     bool& m_isDeleted;
 };
 
 int DummyRefCounted::s_refInvokesCount = 0;
 
 TEST(HashSetTest, HashSetRefPtr)
 {
     bool isDeleted = false;
     RefPtr<DummyRefCounted> ptr = adoptRef(new DummyRefCounted(isDeleted));
     EXPECT_EQ(0, DummyRefCounted::s_refInvokesCount);
-    HashSet<RefPtr<DummyRefCounted> > set;
+    HashSet<RefPtr<DummyRefCounted>> set;
     set.add(ptr);
     // Referenced only once (to store a copy in the container).
     EXPECT_EQ(1, DummyRefCounted::s_refInvokesCount);
 
     DummyRefCounted* rawPtr = ptr.get();
 
     EXPECT_TRUE(set.contains(rawPtr));
     EXPECT_NE(set.end(), set.find(rawPtr));
     EXPECT_TRUE(set.contains(ptr));
     EXPECT_NE(set.end(), set.find(ptr));
 
     ptr.clear();
     EXPECT_FALSE(isDeleted);
 
     set.remove(rawPtr);
     EXPECT_TRUE(isDeleted);
     EXPECT_TRUE(set.isEmpty());
     EXPECT_EQ(1, DummyRefCounted::s_refInvokesCount);
 }
 
 
 } // namespace