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

Source/core/xml/XPathExpressionNode.h

 /*
  * Copyright (C) 2005 Frerich Raabe <raabe@kde.org>
  * Copyright (C) 2006, 2009 Apple Inc.
  *
  * 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
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 45 matching lines @@
         class Expression : public ParseNode {
             WTF_MAKE_NONCOPYABLE(Expression); WTF_MAKE_FAST_ALLOCATED;
         public:
             static EvaluationContext& evaluationContext();
 
             Expression();
             virtual ~Expression();
 
             virtual Value evaluate() const = 0;
 
             void addSubExpression(Expression* expr)

[abarth-chromium, 2013/10/11 20:28:05]

This should be a PassOwnPtr<Expression>

             {
-                m_subExpressions.append(expr);
+                m_subExpressions.append(adoptPtr(expr));

[abarth-chromium, 2013/10/11 20:28:05]

We should call adoptPtr immediately after calling new.  There shouldn't be
random adoptPtr calls littered throughout the code base.

[dshwang, 2013/10/11 20:43:35]

I hope so but this method is used by yacc.c
If it is possible, I will do it in next CL. the patch purpose will be very
different of this CL. Could you advice me? :)

/* Line 1806 of yacc.c  */
#line 411 "xml/XPathGrammar.y"
    {
        (yyval.expr) = new Union;
        (yyval.expr)->addSubExpression((yyvsp[(1) - (3)].expr));
        (yyval.expr)->addSubExpression((yyvsp[(3) - (3)].expr));
        parser->unregisterParseNode((yyvsp[(1) - (3)].expr));
        parser->unregisterParseNode((yyvsp[(3) - (3)].expr));
        parser->registerParseNode((yyval.expr));
    }

                 m_isContextNodeSensitive |= expr->m_isContextNodeSensitive;
                 m_isContextPositionSensitive |= expr->m_isContextPositionSensitive;
                 m_isContextSizeSensitive |= expr->m_isContextSizeSensitive;
             }
 
             bool isContextNodeSensitive() const { return m_isContextNodeSensitive; }
             bool isContextPositionSensitive() const { return m_isContextPositionSensitive; }
             bool isContextSizeSensitive() const { return m_isContextSizeSensitive; }
             void setIsContextNodeSensitive(bool value) { m_isContextNodeSensitive = value; }
             void setIsContextPositionSensitive(bool value) { m_isContextPositionSensitive = value; }
             void setIsContextSizeSensitive(bool value) { m_isContextSizeSensitive = value; }
 
             virtual Value::Type resultType() const = 0;
 
         protected:
             unsigned subExprCount() const { return m_subExpressions.size(); }
-            Expression* subExpr(unsigned i) { return m_subExpressions[i]; }
-            const Expression* subExpr(unsigned i) const { return m_subExpressions[i]; }
+            Expression* subExpr(unsigned i) { return m_subExpressions[i].get(); }
+            const Expression* subExpr(unsigned i) const { return m_subExpressions[i].get(); }
 
         private:
-            Vector<Expression*> m_subExpressions;
+            Vector<OwnPtr<Expression> > m_subExpressions;
 
             // Evaluation details that can be used for optimization.
             bool m_isContextNodeSensitive;
             bool m_isContextPositionSensitive;
             bool m_isContextSizeSensitive;
         };
 
     }
 
 }
 
 #endif // EXPRESSION_H