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

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

 /*
  * Copyright 2005 Frerich Raabe <raabe@kde.org>
  * Copyright (C) 2006 Apple Computer, 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 92 matching lines @@
                        const Value& rhs) const {
   if (lhs.isNodeSet()) {
     const NodeSet& lhsSet = lhs.toNodeSet(&context);
     if (rhs.isNodeSet()) {
       // If both objects to be compared are node-sets, then the comparison
       // will be true if and only if there is a node in the first node-set
       // and a node in the second node-set such that the result of
       // performing the comparison on the string-values of the two nodes
       // is true.
       const NodeSet& rhsSet = rhs.toNodeSet(&context);
-      for (unsigned lindex = 0; lindex < lhsSet.size(); ++lindex) {
-        for (unsigned rindex = 0; rindex < rhsSet.size(); ++rindex) {
-          if (compare(context, stringValue(lhsSet[lindex]),
-                      stringValue(rhsSet[rindex])))
+      for (const auto& leftNode : lhsSet) {
+        for (const auto& rightNode : rhsSet) {
+          if (compare(context, stringValue(leftNode), stringValue(rightNode)))
             return true;
         }
       }
       return false;
     }
     if (rhs.isNumber()) {
       // If one object to be compared is a node-set and the other is a
       // number, then the comparison will be true if and only if there is
       // a node in the node-set such that the result of performing the
       // comparison on the number to be compared and on the result of
       // converting the string-value of that node to a number using the
       // number function is true.
-      for (unsigned lindex = 0; lindex < lhsSet.size(); ++lindex) {
-        if (compare(context, Value(stringValue(lhsSet[lindex])).toNumber(),
-                    rhs))
+      for (const auto& leftNode : lhsSet) {
+        if (compare(context, Value(stringValue(leftNode)).toNumber(), rhs))
           return true;
       }
       return false;
     }
     if (rhs.isString()) {
       // If one object to be compared is a node-set and the other is a
       // string, then the comparison will be true if and only if there is
       // a node in the node-set such that the result of performing the
       // comparison on the string-value of the node and the other string
       // is true.
-      for (unsigned lindex = 0; lindex < lhsSet.size(); ++lindex) {
-        if (compare(context, stringValue(lhsSet[lindex]), rhs))
+      for (const auto& leftNode : lhsSet) {
+        if (compare(context, stringValue(leftNode), rhs))
           return true;
       }
       return false;
     }
     if (rhs.isBoolean()) {
       // If one object to be compared is a node-set and the other is a
       // boolean, then the comparison will be true if and only if the
       // result of performing the comparison on the boolean and on the
       // result of converting the node-set to a boolean using the boolean
       // function is true.
       return compare(context, lhs.toBoolean(), rhs);
     }
     NOTREACHED();
   }
   if (rhs.isNodeSet()) {
     const NodeSet& rhsSet = rhs.toNodeSet(&context);
     if (lhs.isNumber()) {
-      for (unsigned rindex = 0; rindex < rhsSet.size(); ++rindex) {
-        if (compare(context, lhs,
-                    Value(stringValue(rhsSet[rindex])).toNumber()))
+      for (const auto& rightNode : rhsSet) {
+        if (compare(context, lhs, Value(stringValue(rightNode)).toNumber()))
           return true;
       }
       return false;
     }
     if (lhs.isString()) {
-      for (unsigned rindex = 0; rindex < rhsSet.size(); ++rindex) {
-        if (compare(context, lhs, stringValue(rhsSet[rindex])))
+      for (const auto& rightNode : rhsSet) {
+        if (compare(context, lhs, stringValue(rightNode)))
           return true;
       }
       return false;
     }
     if (lhs.isBoolean())
       return compare(context, lhs, rhs.toBoolean());
     NOTREACHED();
   }
 
   // Neither side is a NodeSet.
@@ skipping 54 matching lines @@
 }
 
 Value Union::evaluate(EvaluationContext& context) const {
   Value lhsResult = subExpr(0)->evaluate(context);
   Value rhs = subExpr(1)->evaluate(context);
 
   NodeSet& resultSet = lhsResult.modifiableNodeSet(context);
   const NodeSet& rhsNodes = rhs.toNodeSet(&context);
 
   HeapHashSet<Member<Node>> nodes;
-  for (size_t i = 0; i < resultSet.size(); ++i)
-    nodes.add(resultSet[i]);
+  for (const auto& node : resultSet)
+    nodes.add(node);
 
-  for (size_t i = 0; i < rhsNodes.size(); ++i) {
-    Node* node = rhsNodes[i];
+  for (const auto& node : rhsNodes) {
     if (nodes.add(node).isNewEntry)
       resultSet.append(node);
   }
 
   // It is also possible to use merge sort to avoid making the result
   // unsorted; but this would waste the time in cases when order is not
   // important.
   resultSet.markSorted(false);
   return lhsResult;
 }
@@ skipping 15 matching lines @@
                     new Number(result.toNumber()))
         .evaluate(context)
         .toBoolean();
 
   return result.toBoolean();
 }
 
 }  // namespace XPath
 
 }  // namespace blink