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

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 273 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(WillBeHeapVector<OwnPtrWillBeMember<Expression>>& args)
+void Function::setArguments(HeapVector<Member<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);
 
-    WillBeHeapVector<OwnPtrWillBeMember<Expression>>::iterator end = args.end();
-    for (WillBeHeapVector<OwnPtrWillBeMember<Expression>>::iterator it = args.begin(); it != end; ++it)
-        addSubExpression(it->release());
+    for (Expression* arg : args)
+        addSubExpression(arg);
 }
 
 Value FunLast::evaluate(EvaluationContext& context) const
 {
     return context.size;
 }
 
 Value FunPosition::evaluate(EvaluationContext& context) const
 {
     return context.position;
@@ skipping 10 matching lines @@
             String str = stringValue(nodes[i]);
             idList.append(str);
             idList.append(' ');
         }
     } else {
         String str = a.toString();
         idList.append(str);
     }
 
     TreeScope& contextScope = context.node->treeScope();
-    OwnPtrWillBeRawPtr<NodeSet> result(NodeSet::create());
+    NodeSet* result(NodeSet::create());
     WillBeHeapHashSet<RawPtrWillBeMember<Node>> resultSet;
 
     unsigned startPos = 0;
     unsigned length = idList.length();
     while (true) {
         while (startPos < length && isWhitespace(idList[startPos]))
             ++startPos;
 
         if (startPos == length)
             break;
 
         size_t endPos = startPos;
         while (endPos < length && !isWhitespace(idList[endPos]))
             ++endPos;
 
         // If there are several nodes with the same id, id() should return the first one.
         // In WebKit, getElementById behaves so, too, although its behavior in this case is formally undefined.
         Node* node = contextScope.getElementById(AtomicString(idList.substring(startPos, endPos - startPos)));
         if (node && resultSet.add(node).isNewEntry)
             result->append(node);
 
         startPos = endPos;
     }
 
     result->markSorted(false);
 
-    return Value(result.release(), Value::adopt);
+    return Value(result, Value::adopt);
 }
 
 static inline String expandedNameLocalPart(Node* node)
 {
     // The local part of an XPath expanded-name matches DOM local name for most node types, except for namespace nodes and processing instruction nodes.
     // But note that Blink does not support namespace nodes.
     if (node->nodeType() == Node::PROCESSING_INSTRUCTION_NODE)
         return toProcessingInstruction(node)->target();
     return node->localName().string();
 }
@@ skipping 347 matching lines @@
     };
 
     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)
 {
-    WillBeHeapVector<OwnPtrWillBeMember<Expression>> args;
+    HeapVector<Member<Expression>> args;
     return createFunction(name, args);
 }
 
-Function* createFunction(const String& name, WillBeHeapVector<OwnPtrWillBeMember<Expression>>& args)
+Function* createFunction(const String& name, HeapVector<Member<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;
 }
 
 }
 }