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

third_party/WebKit/Source/core/xml/XPathPath.cpp

 /*
  * Copyright (C) 2005 Frerich Raabe <raabe@kde.org>
  * Copyright (C) 2006, 2009 Apple Inc.
  * 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 40 matching lines @@
   visitor->trace(m_predicates);
   Expression::trace(visitor);
 }
 
 Value Filter::evaluate(EvaluationContext& evaluationContext) const {
   Value v = m_expr->evaluate(evaluationContext);
 
   NodeSet& nodes = v.modifiableNodeSet(evaluationContext);
   nodes.sort();
 
-  for (unsigned i = 0; i < m_predicates.size(); i++) {
+  for (const auto& predicate : m_predicates) {
     NodeSet* newNodes = NodeSet::create();
     evaluationContext.size = nodes.size();
     evaluationContext.position = 0;
 
-    for (unsigned j = 0; j < nodes.size(); j++) {
-      Node* node = nodes[j];
-
+    for (const auto& node : nodes) {
       evaluationContext.node = node;
       ++evaluationContext.position;
 
-      if (m_predicates[i]->evaluate(evaluationContext))
+      if (predicate->evaluate(evaluationContext))
         newNodes->append(node);
     }
     nodes.swap(*newNodes);
   }
 
   return v;
 }
 
 LocationPath::LocationPath() : m_absolute(false) {
   setIsContextNodeSensitive(true);
@@ skipping 29 matching lines @@
   NodeSet* nodes = NodeSet::create();
   nodes->append(context);
   evaluate(clonedContext, *nodes);
 
   return Value(nodes, Value::adopt);
 }
 
 void LocationPath::evaluate(EvaluationContext& context, NodeSet& nodes) const {
   bool resultIsSorted = nodes.isSorted();
 
-  for (unsigned i = 0; i < m_steps.size(); i++) {
-    Step* step = m_steps[i];
+  for (const auto& step : m_steps) {
     NodeSet* newNodes = NodeSet::create();
     HeapHashSet<Member<Node>> newNodesSet;
 
     bool needToCheckForDuplicateNodes =
         !nodes.subtreesAreDisjoint() ||
         (step->getAxis() != Step::ChildAxis &&
          step->getAxis() != Step::SelfAxis &&
          step->getAxis() != Step::DescendantAxis &&
          step->getAxis() != Step::DescendantOrSelfAxis &&
          step->getAxis() != Step::AttributeAxis);
 
     if (needToCheckForDuplicateNodes)
       resultIsSorted = false;
 
     // This is a simplified check that can be improved to handle more cases.
     if (nodes.subtreesAreDisjoint() && (step->getAxis() == Step::ChildAxis ||
                                         step->getAxis() == Step::SelfAxis))
       newNodes->markSubtreesDisjoint(true);
 
-    for (unsigned j = 0; j < nodes.size(); j++) {
+    for (const auto& inputNode : nodes) {
       NodeSet* matches = NodeSet::create();
-      step->evaluate(context, nodes[j], *matches);
+      step->evaluate(context, inputNode, *matches);
 
       if (!matches->isSorted())
         resultIsSorted = false;
 
-      for (size_t nodeIndex = 0; nodeIndex < matches->size(); ++nodeIndex) {
-        Node* node = (*matches)[nodeIndex];
+      for (const auto& node : *matches) {
         if (!needToCheckForDuplicateNodes || newNodesSet.add(node).isNewEntry)
           newNodes->append(node);
       }
     }
 
     nodes.swap(*newNodes);
   }
 
   nodes.markSorted(resultIsSorted);
 }
@@ skipping 35 matching lines @@
 
   NodeSet& nodes = v.modifiableNodeSet(context);
   m_path->evaluate(context, nodes);
 
   return v;
 }
 
 }  // namespace XPath
 
 }  // namespace blink