Avoid WTF::Vector::at() and operator[] in core/xml.

third_party/WebKit/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 47 matching lines @@
 
 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].
   HeapVector<Member<Predicate>> remainingPredicates;
-  for (size_t i = 0; i < m_predicates.size(); ++i) {
-    Predicate* predicate = m_predicates[i];
+  for (const auto& predicate : m_predicates) {
     if ((!predicate->isContextPositionSensitive() ||
          nodeTest().mergedPredicates().isEmpty()) &&
         !predicate->isContextSizeSensitive() && remainingPredicates.isEmpty()) {
       nodeTest().mergedPredicates().append(predicate);
     } else {
       remainingPredicates.append(predicate);
     }
   }
   swap(remainingPredicates, m_predicates);
 }
@@ skipping 18 matching lines @@
            first->nodeTest().mergedPredicates());
       swap(second->m_predicates, first->m_predicates);
       first->optimize();
       return true;
     }
   }
   return false;
 }
 
 bool Step::predicatesAreContextListInsensitive() const {
-  for (size_t i = 0; i < m_predicates.size(); ++i) {
-    Predicate* predicate = m_predicates[i].get();
+  for (const auto& predicate : m_predicates) {
     if (predicate->isContextPositionSensitive() ||
         predicate->isContextSizeSensitive())
       return false;
   }
 
-  for (size_t i = 0; i < nodeTest().mergedPredicates().size(); ++i) {
-    Predicate* predicate = nodeTest().mergedPredicates()[i].get();
+  for (const auto& predicate : nodeTest().mergedPredicates()) {
     if (predicate->isContextPositionSensitive() ||
         predicate->isContextSizeSensitive())
       return false;
   }
 
   return true;
 }
 
 void Step::evaluate(EvaluationContext& evaluationContext,
                     Node* context,
                     NodeSet& nodes) const {
   evaluationContext.position = 0;
 
   nodesInAxis(evaluationContext, context, nodes);
 
   // Check predicates that couldn't be merged into node test.
-  for (unsigned i = 0; i < m_predicates.size(); i++) {
-    Predicate* predicate = m_predicates[i].get();
-
+  for (const auto& predicate : m_predicates) {
     NodeSet* newNodes = NodeSet::create();
     if (!nodes.isSorted())
       newNodes->markSorted(false);
 
     for (unsigned j = 0; j < nodes.size(); j++) {
       Node* node = nodes[j];
 
       evaluationContext.node = node;
       evaluationContext.size = nodes.size();
       evaluationContext.position = j + 1;
@@ skipping 93 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 HeapVector<Member<Predicate>>& mergedPredicates =
-      nodeTest.mergedPredicates();
-  for (unsigned i = 0; i < mergedPredicates.size(); i++) {
-    Predicate* predicate = mergedPredicates[i].get();
-
+  for (const auto& predicate : nodeTest.mergedPredicates()) {
     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;
   }
 
   return true;
 }
 
@@ skipping 183 matching lines @@
       nodes.markSorted(false);
       return;
     }
   }
   NOTREACHED();
 }
 
 }  // namespace XPath
 
 }  // namespace blink