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

Source/core/xml/XPathGrammar.y

 /*
  * Copyright 2005 Frerich Raabe <raabe@kde.org>
  * Copyright (C) 2006 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 45 matching lines @@
 
 %union
 {
     Step::Axis axis;
     Step::NodeTest* nodeTest;
     NumericOp::Opcode numop;
     EqTestOp::Opcode eqop;
     String* str;
     Expression* expr;
     Vector<Predicate*>* predList;
-    Vector<Expression*>* argList;
+    Vector<OwnPtr<Expression> >* argList;
     Step* step;
     LocationPath* locationPath;
 }
 
 %{
 
 static int xpathyylex(YYSTYPE* yylval) { return Parser::current()->lex(yylval); }
 static void xpathyyerror(void*, const char*) { }
     
 %}
@@ skipping 208 matching lines @@
         $$ = 0;
     }
     |
     PredicateList
     ;
 
 PredicateList:
     Predicate
     {
         $$ = new Vector<Predicate*>;
-        $$->append(new Predicate($1));
+        $$->append(new Predicate(adoptPtr($1)));
         parser->unregisterParseNode($1);
         parser->registerPredicateVector($$);
     }
     |
     PredicateList Predicate
     {
-        $$->append(new Predicate($2));
+        $$->append(new Predicate(adoptPtr($2)));
         parser->unregisterParseNode($2);
     }
     ;
 
 Predicate:
     '[' Expr ']'
     {
         $$ = $2;
     }
     ;
@@ skipping 67 matching lines @@
             YYABORT;
         parser->deleteString($1);
         parser->deleteExpressionVector($3);
         parser->registerParseNode($$);
     }
     ;
 
 ArgumentList:
     Argument
     {
-        $$ = new Vector<Expression*>;
-        $$->append($1);
+        $$ = new Vector<OwnPtr<Expression> >;
+        $$->append(adoptPtr($1));
         parser->unregisterParseNode($1);
         parser->registerExpressionVector($$);
     }
     |
     ArgumentList ',' Argument
     {
-        $$->append($3);
+        $$->append(adoptPtr($3));
         parser->unregisterParseNode($3);
     }
     ;
 
 Argument:
     Expr
     ;
 
 UnionExpr:
     PathExpr
     |
     UnionExpr '|' PathExpr
     {
         $$ = new Union;
-        $$->addSubExpression($1);
-        $$->addSubExpression($3);
+        $$->addSubExpression(adoptPtr($1));
+        $$->addSubExpression(adoptPtr($3));
         parser->unregisterParseNode($1);
         parser->unregisterParseNode($3);
         parser->registerParseNode($$);
     }
     ;
 
 PathExpr:
     LocationPath
     {
         $$ = $1;
@@ skipping 20 matching lines @@
         parser->unregisterParseNode($3);
         parser->registerParseNode($$);
     }
     ;
 
 FilterExpr:
     PrimaryExpr
     |
     PrimaryExpr PredicateList
     {
-        $$ = new Filter($1, *$2);
+        $$ = new Filter(adoptPtr($1), *$2);
         parser->unregisterParseNode($1);
         parser->deletePredicateVector($2);
         parser->registerParseNode($$);
     }
     ;
 
 OrExpr:
     AndExpr
     |
     OrExpr OR AndExpr
     {
-        $$ = new LogicalOp(LogicalOp::OP_Or, $1, $3);
+        $$ = new LogicalOp(LogicalOp::OP_Or, adoptPtr($1), adoptPtr($3));
         parser->unregisterParseNode($1);
         parser->unregisterParseNode($3);
         parser->registerParseNode($$);
     }
     ;
 
 AndExpr:
     EqualityExpr
     |
     AndExpr AND EqualityExpr
     {
-        $$ = new LogicalOp(LogicalOp::OP_And, $1, $3);
+        $$ = new LogicalOp(LogicalOp::OP_And, adoptPtr($1), adoptPtr($3));
         parser->unregisterParseNode($1);
         parser->unregisterParseNode($3);
         parser->registerParseNode($$);
     }
     ;
 
 EqualityExpr:
     RelationalExpr
     |
     EqualityExpr EQOP RelationalExpr
     {
-        $$ = new EqTestOp($2, $1, $3);
+        $$ = new EqTestOp($2, adoptPtr($1), adoptPtr($3));
         parser->unregisterParseNode($1);
         parser->unregisterParseNode($3);
         parser->registerParseNode($$);
     }
     ;
 
 RelationalExpr:
     AdditiveExpr
     |
     RelationalExpr RELOP AdditiveExpr
     {
-        $$ = new EqTestOp($2, $1, $3);
+        $$ = new EqTestOp($2, adoptPtr($1), adoptPtr($3));
         parser->unregisterParseNode($1);
         parser->unregisterParseNode($3);
         parser->registerParseNode($$);
     }
     ;
 
 AdditiveExpr:
     MultiplicativeExpr
     |
     AdditiveExpr PLUS MultiplicativeExpr
     {
-        $$ = new NumericOp(NumericOp::OP_Add, $1, $3);
+        $$ = new NumericOp(NumericOp::OP_Add, adoptPtr($1), adoptPtr($3));
         parser->unregisterParseNode($1);
         parser->unregisterParseNode($3);
         parser->registerParseNode($$);
     }
     |
     AdditiveExpr MINUS MultiplicativeExpr
     {
-        $$ = new NumericOp(NumericOp::OP_Sub, $1, $3);
+        $$ = new NumericOp(NumericOp::OP_Sub, adoptPtr($1), adoptPtr($3));
         parser->unregisterParseNode($1);
         parser->unregisterParseNode($3);
         parser->registerParseNode($$);
     }
     ;
 
 MultiplicativeExpr:
     UnaryExpr
     |
     MultiplicativeExpr MULOP UnaryExpr
     {
-        $$ = new NumericOp($2, $1, $3);
+        $$ = new NumericOp($2, adoptPtr($1), adoptPtr($3));
         parser->unregisterParseNode($1);
         parser->unregisterParseNode($3);
         parser->registerParseNode($$);
     }
     ;
 
 UnaryExpr:
     UnionExpr
     |
     MINUS UnaryExpr
     {
         $$ = new Negative;
-        $$->addSubExpression($2);
+        $$->addSubExpression(adoptPtr($2));
         parser->unregisterParseNode($2);
         parser->registerParseNode($$);
     }
     ;
 
 %%