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

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 45 matching lines @@
 {
     return m_value;
 }
 
 Value Negative::evaluate() const
 {
     Value p(subExpr(0)->evaluate());
     return -p.toNumber();
 }
 
-NumericOp::NumericOp(Opcode opcode, Expression* lhs, Expression* rhs)
+NumericOp::NumericOp(Opcode opcode, PassOwnPtr<Expression> lhs, PassOwnPtr<Expression> rhs)
     : m_opcode(opcode)
 {
     addSubExpression(lhs);
     addSubExpression(rhs);
 }
 
 Value NumericOp::evaluate() const
 {
     Value lhs(subExpr(0)->evaluate());
     Value rhs(subExpr(1)->evaluate());
@@ skipping 10 matching lines @@
             return leftVal * rightVal;
         case OP_Div:
             return leftVal / rightVal;
         case OP_Mod:
             return fmod(leftVal, rightVal);
     }
     ASSERT_NOT_REACHED();
     return 0.0;
 }
 
-EqTestOp::EqTestOp(Opcode opcode, Expression* lhs, Expression* rhs)
+EqTestOp::EqTestOp(Opcode opcode, PassOwnPtr<Expression> lhs, PassOwnPtr<Expression> rhs)
     : m_opcode(opcode)
 {
     addSubExpression(lhs);
     addSubExpression(rhs);
 }
 
 bool EqTestOp::compare(const Value& lhs, const Value& rhs) const
 {
     if (lhs.isNodeSet()) {
         const NodeSet& lhsSet = lhs.toNodeSet();
@@ skipping 82 matching lines @@
 }
 
 Value EqTestOp::evaluate() const
 {
     Value lhs(subExpr(0)->evaluate());
     Value rhs(subExpr(1)->evaluate());
 
     return compare(lhs, rhs);
 }
 
-LogicalOp::LogicalOp(Opcode opcode, Expression* lhs, Expression* rhs)
+LogicalOp::LogicalOp(Opcode opcode, PassOwnPtr<Expression> lhs, PassOwnPtr<Expression> rhs)
     : m_opcode(opcode)
 {
     addSubExpression(lhs);
     addSubExpression(rhs);
 }
 
 bool LogicalOp::shortCircuitOn() const
 {
     if (m_opcode == OP_And)
         return false; //false and foo
@@ skipping 31 matching lines @@
         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;
 }
 
-Predicate::Predicate(Expression* expr)
+Predicate::Predicate(PassOwnPtr<Expression> expr)
     : m_expr(expr)
 {
 }
 
 Predicate::~Predicate()
 {
-    delete m_expr;
 }
 
 bool Predicate::evaluate() const
 {
-    ASSERT(m_expr != 0);
+    ASSERT(m_expr);
 
     Value result(m_expr->evaluate());
 
     // foo[3] means foo[position()=3]
     if (result.isNumber())
-        return EqTestOp(EqTestOp::OP_EQ, createFunction("position"), new Number(result.toNumber())).evaluate().toBoolean();
+        return EqTestOp(EqTestOp::OP_EQ, adoptPtr(createFunction("position")), adoptPtr(new Number(result.toNumber()))).evaluate().toBoolean();
 
     return result.toBoolean();
 }
 
 }
 }