Fix template angle bracket syntax in platform

Source/platform/animation/TimingFunctionTest.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 36 matching lines @@
         << b.first \
         << " (" << b.second->toString().latin1().data() << ")" \
         << "\n";
 
 namespace blink {
 
 namespace {
 
 class TimingFunctionTest : public ::testing::Test {
 public:
-    void notEqualHelperLoop(Vector<std::pair<std::string, RefPtr<TimingFunction> > >& v)
+    void notEqualHelperLoop(Vector<std::pair<std::string, RefPtr<TimingFunction>> >& v)
     {
         for (size_t i = 0; i < v.size(); ++i) {
             for (size_t j = 0; j < v.size(); ++j) {
                 if (i == j)
                     continue;
                 EXPECT_NE_WITH_MESSAGE(v[i], v[j]);
             }
         }
     }
 };
@@ skipping 41 matching lines @@
 }
 
 TEST_F(TimingFunctionTest, BaseOperatorEq)
 {
     RefPtr<TimingFunction> linearTiming = LinearTimingFunction::shared();
     RefPtr<TimingFunction> cubicTiming1 = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn);
     RefPtr<TimingFunction> cubicTiming2 = CubicBezierTimingFunction::create(0.17, 0.67, 1, -1.73);
     RefPtr<TimingFunction> stepsTiming1 = StepsTimingFunction::preset(StepsTimingFunction::End);
     RefPtr<TimingFunction> stepsTiming2 = StepsTimingFunction::create(5, StepsTimingFunction::Start);
 
-    Vector<std::pair<std::string, RefPtr<TimingFunction> > > v;
+    Vector<std::pair<std::string, RefPtr<TimingFunction>> > v;
     v.append(std::make_pair("linearTiming", linearTiming));
     v.append(std::make_pair("cubicTiming1", cubicTiming1));
     v.append(std::make_pair("cubicTiming2", cubicTiming2));
     v.append(std::make_pair("stepsTiming1", stepsTiming1));
     v.append(std::make_pair("stepsTiming2", stepsTiming2));
     notEqualHelperLoop(v);
 }
 
 TEST_F(TimingFunctionTest, LinearOperatorEq)
 {
@@ skipping 18 matching lines @@
     RefPtr<TimingFunction> cubicEaseInOutTiming1 = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseInOut);
     RefPtr<TimingFunction> cubicEaseInOutTiming2 = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseInOut);
     EXPECT_EQ(*cubicEaseInOutTiming1, *cubicEaseInOutTiming1);
     EXPECT_EQ(*cubicEaseInOutTiming1, *cubicEaseInOutTiming2);
 
     RefPtr<TimingFunction> cubicCustomTiming1 = CubicBezierTimingFunction::create(0.17, 0.67, 1, -1.73);
     RefPtr<TimingFunction> cubicCustomTiming2 = CubicBezierTimingFunction::create(0.17, 0.67, 1, -1.73);
     EXPECT_EQ(*cubicCustomTiming1, *cubicCustomTiming1);
     EXPECT_EQ(*cubicCustomTiming1, *cubicCustomTiming2);
 
-    Vector<std::pair<std::string, RefPtr<TimingFunction> > > v;
+    Vector<std::pair<std::string, RefPtr<TimingFunction>> > v;
     v.append(std::make_pair("cubicEaseInTiming1", cubicEaseInTiming1));
     v.append(std::make_pair("cubicEaseOutTiming1", cubicEaseOutTiming1));
     v.append(std::make_pair("cubicEaseInOutTiming1", cubicEaseInOutTiming1));
     v.append(std::make_pair("cubicCustomTiming1", cubicCustomTiming1));
     notEqualHelperLoop(v);
 }
 
 TEST_F(TimingFunctionTest, CubicOperatorEqReflectivity)
 {
     RefPtr<TimingFunction> cubicA = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn);
@@ skipping 17 matching lines @@
     RefPtr<TimingFunction> stepsTimingCustom1 = StepsTimingFunction::create(5, StepsTimingFunction::Start);
     RefPtr<TimingFunction> stepsTimingCustom2 = StepsTimingFunction::create(5, StepsTimingFunction::End);
     RefPtr<TimingFunction> stepsTimingCustom3 = StepsTimingFunction::create(7, StepsTimingFunction::Start);
     RefPtr<TimingFunction> stepsTimingCustom4 = StepsTimingFunction::create(7, StepsTimingFunction::End);
 
     EXPECT_EQ(*StepsTimingFunction::create(5, StepsTimingFunction::Start), *stepsTimingCustom1);
     EXPECT_EQ(*StepsTimingFunction::create(5, StepsTimingFunction::End), *stepsTimingCustom2);
     EXPECT_EQ(*StepsTimingFunction::create(7, StepsTimingFunction::Start), *stepsTimingCustom3);
     EXPECT_EQ(*StepsTimingFunction::create(7, StepsTimingFunction::End), *stepsTimingCustom4);
 
-    Vector<std::pair<std::string, RefPtr<TimingFunction> > > v;
+    Vector<std::pair<std::string, RefPtr<TimingFunction>> > v;
     v.append(std::make_pair("stepsTimingStart1", stepsTimingStart1));
     v.append(std::make_pair("stepsTimingEnd1", stepsTimingEnd1));
     v.append(std::make_pair("stepsTimingCustom1", stepsTimingCustom1));
     v.append(std::make_pair("stepsTimingCustom2", stepsTimingCustom2));
     v.append(std::make_pair("stepsTimingCustom3", stepsTimingCustom3));
     v.append(std::make_pair("stepsTimingCustom4", stepsTimingCustom4));
     notEqualHelperLoop(v);
 }
 
 TEST_F(TimingFunctionTest, StepsOperatorEqPreset)
@@ skipping 203 matching lines @@
     EXPECT_EQ(0.50, stepsTimingCustomEnd->evaluate(0.74, 0));
     EXPECT_EQ(0.75, stepsTimingCustomEnd->evaluate(0.75, 0));
     EXPECT_EQ(0.75, stepsTimingCustomEnd->evaluate(0.99, 0));
     EXPECT_EQ(1.00, stepsTimingCustomEnd->evaluate(1.00, 0));
     EXPECT_EQ(1.00, stepsTimingCustomEnd->evaluate(2.00, 0));
 }
 
 } // namespace
 
 } // namespace blink