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

Source/core/xml/XPathFunctions.cpp

 /*
  * Copyright (C) 2005 Frerich Raabe <raabe@kde.org>
  * Copyright (C) 2006, 2009 Apple 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 272 matching lines @@
 
     if (m_min == Inf)
         return value <= m_max;
 
     if (m_max == Inf)
         return value >= m_min;
 
     return value >= m_min && value <= m_max;
 }
 
-void Function::setArguments(const Vector<Expression*>& args)
+void Function::setArguments(Vector<OwnPtr<Expression> >& args)
 {
     ASSERT(!subExprCount());
 
     // Some functions use context node as implicit argument, so when explicit arguments are added, they may no longer be context node sensitive.
     if (m_name != "lang" && !args.isEmpty())
         setIsContextNodeSensitive(false);
 
-    Vector<Expression*>::const_iterator end = args.end();
-    for (Vector<Expression*>::const_iterator it = args.begin(); it != end; it++)
-        addSubExpression(*it);
+    Vector<OwnPtr<Expression> >::iterator end = args.end();
+    for (Vector<OwnPtr<Expression> >::iterator it = args.begin(); it != end; it++)
+        addSubExpression(it->release());
 }
 
 Value FunLast::evaluate() const
 {
     return Expression::evaluationContext().size;
 }
 
 Value FunPosition::evaluate() const
 {
     return Expression::evaluationContext().position;
@@ skipping 391 matching lines @@
         { "sum", { &createFunSum, 1 } },
         { "translate", { &createFunTranslate, 3 } },
         { "true", { &createFunTrue, 0 } },
     };
 
     functionMap = new HashMap<String, FunctionRec>;
     for (size_t i = 0; i < WTF_ARRAY_LENGTH(functions); ++i)
         functionMap->set(functions[i].name, functions[i].function);
 }
 
-Function* createFunction(const String& name, const Vector<Expression*>& args)
+
+Function* createFunction(const String& name)
+{
+    Vector<OwnPtr<Expression> > args;
+    return createFunction(name, args);
+}
+
+Function* createFunction(const String& name, Vector<OwnPtr<Expression> >& args)
 {
     if (!functionMap)
         createFunctionMap();
 
     HashMap<String, FunctionRec>::iterator functionMapIter = functionMap->find(name);
     FunctionRec* functionRec = 0;
 
     if (functionMapIter == functionMap->end() || !(functionRec = &functionMapIter->value)->args.contains(args.size()))
         return 0;
 
     Function* function = functionRec->factoryFn();
     function->setArguments(args);
     function->setName(name);
     return function;
 }
 
 }
 }