Fix template angle bracket syntax in xml

Source/core/xml/XPathStep.cpp

 /*
  * Copyright (C) 2005 Frerich Raabe <raabe@kde.org>
  * Copyright (C) 2006, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  *
  * 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
@@ skipping 27 matching lines @@
 
 namespace blink {
 namespace XPath {
 
 Step::Step(Axis axis, const NodeTest& nodeTest)
     : m_axis(axis)
     , m_nodeTest(adoptPtrWillBeNoop(new NodeTest(nodeTest)))
 {
 }
 
-Step::Step(Axis axis, const NodeTest& nodeTest, WillBeHeapVector<OwnPtrWillBeMember<Predicate> >& predicates)
+Step::Step(Axis axis, const NodeTest& nodeTest, WillBeHeapVector<OwnPtrWillBeMember<Predicate>>& predicates)
     : m_axis(axis)
     , m_nodeTest(adoptPtrWillBeNoop(new NodeTest(nodeTest)))
 {
     m_predicates.swap(predicates);
 }
 
 Step::~Step()
 {
 }
 
 DEFINE_TRACE(Step)
 {
     visitor->trace(m_nodeTest);
     visitor->trace(m_predicates);
     ParseNode::trace(visitor);
 }
 
 void Step::optimize()
 {
     // Evaluate predicates as part of node test if possible to avoid building
     // unnecessary NodeSets.
     // E.g., there is no need to build a set of all "foo" nodes to evaluate
     // "foo[@bar]", we can check the predicate while enumerating.
     // This optimization can be applied to predicates that are not context node
     // list sensitive, or to first predicate that is only context position
     // sensitive, e.g. foo[position() mod 2 = 0].
-    WillBeHeapVector<OwnPtrWillBeMember<Predicate> > remainingPredicates;
+    WillBeHeapVector<OwnPtrWillBeMember<Predicate>> remainingPredicates;
     for (size_t i = 0; i < m_predicates.size(); ++i) {
         OwnPtrWillBeRawPtr<Predicate> predicate(m_predicates[i].release());
         if ((!predicate->isContextPositionSensitive() || nodeTest().mergedPredicates().isEmpty()) && !predicate->isContextSizeSensitive() && remainingPredicates.isEmpty()) {
             nodeTest().mergedPredicates().append(predicate.release());
         } else {
             remainingPredicates.append(predicate.release());
         }
     }
     swap(remainingPredicates, m_predicates);
 }
@@ skipping 146 matching lines @@
 }
 
 static inline bool nodeMatches(EvaluationContext& evaluationContext, Node* node, Step::Axis axis, const Step::NodeTest& nodeTest)
 {
     if (!nodeMatchesBasicTest(node, axis, nodeTest))
         return false;
 
     // Only the first merged predicate may depend on position.
     ++evaluationContext.position;
 
-    const WillBeHeapVector<OwnPtrWillBeMember<Predicate> >& mergedPredicates = nodeTest.mergedPredicates();
+    const WillBeHeapVector<OwnPtrWillBeMember<Predicate>>& mergedPredicates = nodeTest.mergedPredicates();
     for (unsigned i = 0; i < mergedPredicates.size(); i++) {
         Predicate* predicate = mergedPredicates[i].get();
 
         evaluationContext.node = node;
         // No need to set context size - we only get here when evaluating
         // predicates that do not depend on it.
         if (!predicate->evaluate(evaluationContext))
             return false;
     }
 
@@ skipping 177 matching lines @@
         nodes.markSorted(false);
         return;
     }
     }
     ASSERT_NOT_REACHED();
 }
 
 }
 
 }