Oilpan: have xml/ objects on the heap by default.

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 57 matching lines @@
 {
     return m_value;
 }
 
 Value Negative::evaluate(EvaluationContext& context) const
 {
     Value p(subExpr(0)->evaluate(context));
     return -p.toNumber();
 }
 
-NumericOp::NumericOp(Opcode opcode, PassOwnPtrWillBeRawPtr<Expression> lhs, PassOwnPtrWillBeRawPtr<Expression> rhs)
+NumericOp::NumericOp(Opcode opcode, Expression* lhs, Expression* rhs)
     : m_opcode(opcode)
 {
     addSubExpression(lhs);
     addSubExpression(rhs);
 }
 
 Value NumericOp::evaluate(EvaluationContext& context) const
 {
     Value lhs(subExpr(0)->evaluate(context));
     Value rhs(subExpr(1)->evaluate(context));
@@ 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, PassOwnPtrWillBeRawPtr<Expression> lhs, PassOwnPtrWillBeRawPtr<Expression> rhs)
+EqTestOp::EqTestOp(Opcode opcode, Expression* lhs, Expression* rhs)
     : m_opcode(opcode)
 {
     addSubExpression(lhs);
     addSubExpression(rhs);
 }
 
 bool EqTestOp::compare(EvaluationContext& context, const Value& lhs, const Value& rhs) const
 {
     if (lhs.isNodeSet()) {
         const NodeSet& lhsSet = lhs.toNodeSet(&context);
@@ skipping 97 matching lines @@
 }
 
 Value EqTestOp::evaluate(EvaluationContext& context) const
 {
     Value lhs(subExpr(0)->evaluate(context));
     Value rhs(subExpr(1)->evaluate(context));
 
     return compare(context, lhs, rhs);
 }
 
-LogicalOp::LogicalOp(Opcode opcode, PassOwnPtrWillBeRawPtr<Expression> lhs, PassOwnPtrWillBeRawPtr<Expression> rhs)
+LogicalOp::LogicalOp(Opcode opcode, Expression* lhs, Expression* rhs)
     : m_opcode(opcode)
 {
     addSubExpression(lhs);
     addSubExpression(rhs);
 }
 
 bool LogicalOp::shortCircuitOn() const
 {
     return m_opcode != OP_And;
 }
@@ skipping 29 matching lines @@
             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(PassOwnPtrWillBeRawPtr<Expression> expr)
+Predicate::Predicate(Expression* expr)
     : m_expr(expr)
 {
 }
 
-DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(Predicate);
-
 DEFINE_TRACE(Predicate)
 {
     visitor->trace(m_expr);
 }
 
 bool Predicate::evaluate(EvaluationContext& context) const
 {
     ASSERT(m_expr);
 
     Value result(m_expr->evaluate(context));
 
     // foo[3] means foo[position()=3]
     if (result.isNumber())
-        return EqTestOp(EqTestOp::OpcodeEqual, adoptPtrWillBeNoop(createFunction("position")), adoptPtrWillBeNoop(new Number(result.toNumber()))).evaluate(context).toBoolean();
+        return EqTestOp(EqTestOp::OpcodeEqual, createFunction("position"), new Number(result.toNumber())).evaluate(context).toBoolean();
 
     return result.toBoolean();
 }
 
-}
-}
+} // namespace XPath
+
+} // namespace blink