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

Source/core/xml/XPathStep.cpp

 /*
  * Copyright (C) 2005 Frerich Raabe <raabe@kde.org>
  * Copyright (C) 2006, 2009 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 23 matching lines @@
 #include "core/dom/Element.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/xml/XPathParser.h"
 #include "core/xml/XPathUtil.h"
 
 namespace blink {
 namespace XPath {
 
 Step::Step(Axis axis, const NodeTest& nodeTest)
     : m_axis(axis)
-    , m_nodeTest(adoptPtrWillBeNoop(new NodeTest(nodeTest)))
+    , m_nodeTest(new NodeTest(nodeTest))
 {
 }
 
-Step::Step(Axis axis, const NodeTest& nodeTest, WillBeHeapVector<OwnPtrWillBeMember<Predicate>>& predicates)
+Step::Step(Axis axis, const NodeTest& nodeTest, HeapVector<Member<Predicate>>& predicates)
     : m_axis(axis)
-    , m_nodeTest(adoptPtrWillBeNoop(new NodeTest(nodeTest)))
+    , m_nodeTest(new NodeTest(nodeTest))
 {
     m_predicates.swap(predicates);
 }
 
 Step::~Step()
 {
 }
 
 DEFINE_TRACE(Step)
 {
     visitor->trace(m_nodeTest);
     visitor->trace(m_predicates);
     ParseNode::trace(visitor);
 }
 
 void Step::optimize()
 {
     // Evaluate predicates as part of node test if possible to avoid building
     // unnecessary NodeSets.
     // E.g., there is no need to build a set of all "foo" nodes to evaluate
     // "foo[@bar]", we can check the predicate while enumerating.
     // This optimization can be applied to predicates that are not context node
     // list sensitive, or to first predicate that is only context position
     // sensitive, e.g. foo[position() mod 2 = 0].
-    WillBeHeapVector<OwnPtrWillBeMember<Predicate>> remainingPredicates;
+    HeapVector<Member<Predicate>> remainingPredicates;
     for (size_t i = 0; i < m_predicates.size(); ++i) {
-        OwnPtrWillBeRawPtr<Predicate> predicate(m_predicates[i].release());
+        Predicate* predicate = m_predicates[i];
         if ((!predicate->isContextPositionSensitive() || nodeTest().mergedPredicates().isEmpty()) && !predicate->isContextSizeSensitive() && remainingPredicates.isEmpty()) {
-            nodeTest().mergedPredicates().append(predicate.release());
+            nodeTest().mergedPredicates().append(predicate);
         } else {
-            remainingPredicates.append(predicate.release());
+            remainingPredicates.append(predicate);
         }
     }
     swap(remainingPredicates, m_predicates);
 }
 
-void optimizeStepPair(Step* first, Step* second, bool& dropSecondStep)
+bool optimizeStepPair(Step* first, Step* second)
 {
-    dropSecondStep = false;
-
     if (first->m_axis == Step::DescendantOrSelfAxis
         && first->nodeTest().kind() == Step::NodeTest::AnyNodeTest
         && !first->m_predicates.size()
         && !first->nodeTest().mergedPredicates().size()) {
 
         ASSERT(first->nodeTest().data().isEmpty());
         ASSERT(first->nodeTest().namespaceURI().isEmpty());
 
         // Optimize the common case of "//" AKA
         // /descendant-or-self::node()/child::NodeTest to /descendant::NodeTest.
         if (second->m_axis == Step::ChildAxis && second->predicatesAreContextListInsensitive()) {
             first->m_axis = Step::DescendantAxis;
             first->nodeTest() = Step::NodeTest(second->nodeTest().kind(), second->nodeTest().data(), second->nodeTest().namespaceURI());
             swap(second->nodeTest().mergedPredicates(), first->nodeTest().mergedPredicates());
             swap(second->m_predicates, first->m_predicates);
             first->optimize();
-            dropSecondStep = true;
+            return true;
         }
     }
+    return false;
 }
 
 bool Step::predicatesAreContextListInsensitive() const
 {
     for (size_t i = 0; i < m_predicates.size(); ++i) {
         Predicate* predicate = m_predicates[i].get();
         if (predicate->isContextPositionSensitive() || predicate->isContextSizeSensitive())
             return false;
     }
 
     for (size_t i = 0; i < nodeTest().mergedPredicates().size(); ++i) {
         Predicate* predicate = nodeTest().mergedPredicates()[i].get();
         if (predicate->isContextPositionSensitive() || predicate->isContextSizeSensitive())
             return false;
     }
 
     return true;
 }
 
 void Step::evaluate(EvaluationContext& evaluationContext, Node* context, NodeSet& nodes) const
 {
     evaluationContext.position = 0;
 
     nodesInAxis(evaluationContext, context, nodes);
 
     // Check predicates that couldn't be merged into node test.
     for (unsigned i = 0; i < m_predicates.size(); i++) {
         Predicate* predicate = m_predicates[i].get();
 
-        OwnPtrWillBeRawPtr<NodeSet> newNodes(NodeSet::create());
+        NodeSet* newNodes = NodeSet::create();
         if (!nodes.isSorted())
             newNodes->markSorted(false);
 
         for (unsigned j = 0; j < nodes.size(); j++) {
             Node* node = nodes[j];
 
             evaluationContext.node = node;
             evaluationContext.size = nodes.size();
             evaluationContext.position = j + 1;
             if (predicate->evaluate(evaluationContext))
@@ skipping 82 matching lines @@
 }
 
 static inline bool nodeMatches(EvaluationContext& evaluationContext, Node* node, Step::Axis axis, const Step::NodeTest& nodeTest)
 {
     if (!nodeMatchesBasicTest(node, axis, nodeTest))
         return false;
 
     // Only the first merged predicate may depend on position.
     ++evaluationContext.position;
 
-    const WillBeHeapVector<OwnPtrWillBeMember<Predicate>>& mergedPredicates = nodeTest.mergedPredicates();
+    const HeapVector<Member<Predicate>>& mergedPredicates = nodeTest.mergedPredicates();
     for (unsigned i = 0; i < mergedPredicates.size(); i++) {
         Predicate* predicate = mergedPredicates[i].get();
 
         evaluationContext.node = node;
         // No need to set context size - we only get here when evaluating
         // predicates that do not depend on it.
         if (!predicate->evaluate(evaluationContext))
             return false;
     }
 
@@ skipping 177 matching lines @@
         nodes.markSorted(false);
         return;
     }
     }
     ASSERT_NOT_REACHED();
 }
 
 }
 
 }