Vector stores Predicate object as OwnPtr instead of raw pointer in XPath.

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 21 matching lines @@
 #include "core/dom/Attr.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/xml/XPathParser.h"
 #include "core/xml/XPathUtil.h"
 
 namespace WebCore {
 namespace XPath {
 
-Step::Step(Axis axis, const NodeTest& nodeTest, const Vector<Predicate*>& predicates)
+Step::Step(Axis axis, const NodeTest& nodeTest)
     : m_axis(axis)
     , m_nodeTest(nodeTest)
-    , m_predicates(predicates)
 {
 }
 
+Step::Step(Axis axis, const NodeTest& nodeTest, Vector<OwnPtr<Predicate> >& predicates)
+    : m_axis(axis)
+    , m_nodeTest(nodeTest)
+{
+    m_predicates.swap(predicates);
+}
+
 Step::~Step()
 {
-    deleteAllValues(m_predicates);
-    deleteAllValues(m_nodeTest.mergedPredicates());
 }
 
 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].
-    Vector<Predicate*> remainingPredicates;
+    Vector<OwnPtr<Predicate> > remainingPredicates;
     for (size_t i = 0; i < m_predicates.size(); ++i) {
-        Predicate* predicate = m_predicates[i];
+        OwnPtr<Predicate> predicate(m_predicates[i].release());
         if ((!predicate->isContextPositionSensitive() || m_nodeTest.mergedPredicates().isEmpty()) && !predicate->isContextSizeSensitive() && remainingPredicates.isEmpty()) {
-            m_nodeTest.mergedPredicates().append(predicate);
-        } else
-            remainingPredicates.append(predicate);
+            m_nodeTest.mergedPredicates().append(predicate.release());
+        } else {
+            remainingPredicates.append(predicate.release());
+        }
     }
     swap(remainingPredicates, m_predicates);
 }
 
 void optimizeStepPair(Step* first, Step* second, bool& dropSecondStep)
 {
     dropSecondStep = false;
 
     if (first->m_axis == Step::DescendantOrSelfAxis
         && first->m_nodeTest.kind() == Step::NodeTest::AnyNodeTest
@@ skipping 11 matching lines @@
             swap(second->m_predicates, first->m_predicates);
             first->optimize();
             dropSecondStep = true;
         }
     }
 }
 
 bool Step::predicatesAreContextListInsensitive() const
 {
     for (size_t i = 0; i < m_predicates.size(); ++i) {
-        Predicate* predicate = m_predicates[i];
+        Predicate* predicate = m_predicates[i].get();
         if (predicate->isContextPositionSensitive() || predicate->isContextSizeSensitive())
             return false;
     }
 
     for (size_t i = 0; i < m_nodeTest.mergedPredicates().size(); ++i) {
-        Predicate* predicate = m_nodeTest.mergedPredicates()[i];
+        Predicate* predicate = m_nodeTest.mergedPredicates()[i].get();
         if (predicate->isContextPositionSensitive() || predicate->isContextSizeSensitive())
             return false;
     }
 
     return true;
 }
 
 void Step::evaluate(Node* context, NodeSet& nodes) const
 {
     EvaluationContext& evaluationContext = Expression::evaluationContext();
     evaluationContext.position = 0;
 
     nodesInAxis(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];
+        Predicate* predicate = m_predicates[i].get();
 
         NodeSet newNodes;
         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();
@@ skipping 78 matching lines @@
 static inline bool nodeMatches(Node* node, Step::Axis axis, const Step::NodeTest& nodeTest)
 {
     if (!nodeMatchesBasicTest(node, axis, nodeTest))
         return false;
 
     EvaluationContext& evaluationContext = Expression::evaluationContext();
 
     // Only the first merged predicate may depend on position.
     ++evaluationContext.position;
 
-    const Vector<Predicate*>& mergedPredicates = nodeTest.mergedPredicates();
+    const Vector<OwnPtr<Predicate> >& mergedPredicates = nodeTest.mergedPredicates();
     for (unsigned i = 0; i < mergedPredicates.size(); i++) {
-        Predicate* predicate = mergedPredicates[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())
             return false;
     }
 
     return true;
 }
 
@@ skipping 154 matching lines @@
             nodes.markSorted(false);
             return;
         }
     }
     ASSERT_NOT_REACHED();
 }
 
 
 }
 }