webkitgtk-2.4.11webkitgtk-2.4.11

1 files changed, 26 insertions, 22 deletions

diff --git a/Source/WebCore/xml/XPathPath.cpp b/Source/WebCore/xml/XPathPath.cpp
index a72fc31c6..06d73f9b0 100644
--- a/Source/WebCore/xml/XPathPath.cpp
+++ b/Source/WebCore/xml/XPathPath.cpp
@@ -36,7 +36,7 @@ namespace WebCore {
 namespace XPath {
         
 Filter::Filter(std::unique_ptr<Expression> expression, Vector<std::unique_ptr<Expression>> predicates)
-    : m_expression(WTFMove(expression)), m_predicates(WTFMove(predicates))
+    : m_expression(std::move(expression)), m_predicates(std::move(predicates))
 {
     setIsContextNodeSensitive(m_expression->isContextNodeSensitive());
     setIsContextPositionSensitive(m_expression->isContextPositionSensitive());
@@ -51,19 +51,21 @@ Value Filter::evaluate() const
     nodes.sort();
 
     EvaluationContext& evaluationContext = Expression::evaluationContext();
-    for (auto& predicate : m_predicates) {
+    for (unsigned i = 0; i < m_predicates.size(); i++) {
         NodeSet newNodes;
         evaluationContext.size = nodes.size();
         evaluationContext.position = 0;
         
-        for (auto& node : nodes) {
+        for (unsigned j = 0; j < nodes.size(); j++) {
+            Node* node = nodes[j];
+            
             evaluationContext.node = node;
             ++evaluationContext.position;
             
-            if (evaluatePredicate(*predicate))
-                newNodes.append(node.copyRef());
+            if (evaluatePredicate(*m_predicates[i]))
+                newNodes.append(node);
         }
-        nodes = WTFMove(newNodes);
+        nodes = std::move(newNodes);
     }
 
     return result;
@@ -100,41 +102,43 @@ Value LocationPath::evaluate() const
     evaluate(nodes);
     
     evaluationContext = backupContext;
-    return Value(WTFMove(nodes));
+    return Value(std::move(nodes));
 }
 
 void LocationPath::evaluate(NodeSet& nodes) const
 {
     bool resultIsSorted = nodes.isSorted();
 
-    for (auto& step : m_steps) {
+    for (unsigned i = 0; i < m_steps.size(); i++) {
+        Step& step = *m_steps[i];
         NodeSet newNodes;
         HashSet<Node*> newNodesSet;
 
-        bool needToCheckForDuplicateNodes = !nodes.subtreesAreDisjoint() || (step->axis() != Step::ChildAxis && step->axis() != Step::SelfAxis
-            && step->axis() != Step::DescendantAxis && step->axis() != Step::DescendantOrSelfAxis && step->axis() != Step::AttributeAxis);
+        bool needToCheckForDuplicateNodes = !nodes.subtreesAreDisjoint() || (step.axis() != Step::ChildAxis && step.axis() != Step::SelfAxis
+            && step.axis() != Step::DescendantAxis && step.axis() != Step::DescendantOrSelfAxis && step.axis() != Step::AttributeAxis);
 
         if (needToCheckForDuplicateNodes)
             resultIsSorted = false;
 
         // This is a simplified check that can be improved to handle more cases.
-        if (nodes.subtreesAreDisjoint() && (step->axis() == Step::ChildAxis || step->axis() == Step::SelfAxis))
+        if (nodes.subtreesAreDisjoint() && (step.axis() == Step::ChildAxis || step.axis() == Step::SelfAxis))
             newNodes.markSubtreesDisjoint(true);
 
-        for (auto& node : nodes) {
+        for (unsigned j = 0; j < nodes.size(); j++) {
             NodeSet matches;
-            step->evaluate(*node, matches);
+            step.evaluate(*nodes[j], matches);
 
             if (!matches.isSorted())
                 resultIsSorted = false;
 
-            for (auto& match : matches) {
-                if (!needToCheckForDuplicateNodes || newNodesSet.add(match.get()).isNewEntry)
-                    newNodes.append(match.copyRef());
+            for (size_t nodeIndex = 0; nodeIndex < matches.size(); ++nodeIndex) {
+                Node* node = matches[nodeIndex];
+                if (!needToCheckForDuplicateNodes || newNodesSet.add(node).isNewEntry)
+                    newNodes.append(node);
             }
         }
         
-        nodes = WTFMove(newNodes);
+        nodes = std::move(newNodes);
     }
 
     nodes.markSorted(resultIsSorted);
@@ -150,7 +154,7 @@ void LocationPath::appendStep(std::unique_ptr<Step> step)
             return;
     }
     step->optimize();
-    m_steps.append(WTFMove(step));
+    m_steps.append(std::move(step));
 }
 
 void LocationPath::prependStep(std::unique_ptr<Step> step)
@@ -159,17 +163,17 @@ void LocationPath::prependStep(std::unique_ptr<Step> step)
         bool dropSecondStep;
         optimizeStepPair(*step, *m_steps[0], dropSecondStep);
         if (dropSecondStep) {
-            m_steps[0] = WTFMove(step);
+            m_steps[0] = std::move(step);
             return;
         }
     }
     step->optimize();
-    m_steps.insert(0, WTFMove(step));
+    m_steps.insert(0, std::move(step));
 }
 
 Path::Path(std::unique_ptr<Expression> filter, std::unique_ptr<LocationPath> path)
-    : m_filter(WTFMove(filter))
-    , m_path(WTFMove(path))
+    : m_filter(std::move(filter))
+    , m_path(std::move(path))
 {
     setIsContextNodeSensitive(m_filter->isContextNodeSensitive());
     setIsContextPositionSensitive(m_filter->isContextPositionSensitive());