Oilpan: Remove WillBe types (part 7)

third_party/WebKit/Source/core/xml/XPathNodeSet.cpp

 /*
  * 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
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 20 matching lines @@
 #include "core/dom/NodeTraversal.h"
 
 namespace blink {
 namespace XPath {
 
 // When a node set is large, sorting it by traversing the whole document is
 // better (we can assume that we aren't dealing with documents that we cannot
 // even traverse in reasonable time).
 const unsigned traversalSortCutoff = 10000;
 
-typedef WillBeHeapVector<RawPtrWillBeMember<Node>> NodeSetVector;
+typedef HeapVector<Member<Node>> NodeSetVector;
 
 NodeSet* NodeSet::create(const NodeSet& other)
 {
     NodeSet* nodeSet = NodeSet::create();
     nodeSet->m_isSorted = other.m_isSorted;
     nodeSet->m_subtreesAreDisjoint = other.m_subtreesAreDisjoint;
     nodeSet->m_nodes.appendVector(other.m_nodes);
     return nodeSet;
 }
 
 static inline Node* parentWithDepth(unsigned depth, const NodeSetVector& parents)
 {
     ASSERT(parents.size() >= depth + 1);
     return parents[parents.size() - 1 - depth];
 }
 
-static void sortBlock(unsigned from, unsigned to, WillBeHeapVector<NodeSetVector>& parentMatrix, bool mayContainAttributeNodes)
+static void sortBlock(unsigned from, unsigned to, HeapVector<NodeSetVector>& parentMatrix, bool mayContainAttributeNodes)
 {
     // Should not call this function with less that two nodes to sort.
     ASSERT(from + 1 < to);
     unsigned minDepth = UINT_MAX;
     for (unsigned i = from; i < to; ++i) {
         unsigned depth = parentMatrix[i].size() - 1;
         if (minDepth > depth)
             minDepth = depth;
     }
 
@@ skipping 47 matching lines @@
         if (sortedEnd != from) {
             if (to - sortedEnd > 1)
                 sortBlock(sortedEnd, to, parentMatrix, mayContainAttributeNodes);
             return;
         }
     }
 
     // Children nodes of the common ancestor induce a subdivision of our
     // node-set. Sort it according to this subdivision, and recursively sort
     // each group.
-    WillBeHeapHashSet<RawPtrWillBeMember<Node>> parentNodes;
+    HeapHashSet<Member<Node>> parentNodes;
     for (unsigned i = from; i < to; ++i)
         parentNodes.add(parentWithDepth(commonAncestorDepth + 1, parentMatrix[i]));
 
     unsigned previousGroupEnd = from;
     unsigned groupEnd = from;
     for (Node* n = commonAncestor->firstChild(); n; n = n->nextSibling()) {
         // If parentNodes contains the node, perform a linear search to move its
         // children in the node-set to the beginning.
         if (parentNodes.contains(n)) {
             for (unsigned i = groupEnd; i < to; ++i) {
@@ skipping 26 matching lines @@
         return;
     }
 
     if (nodeCount > traversalSortCutoff) {
         traversalSort();
         return;
     }
 
     bool containsAttributeNodes = false;
 
-    WillBeHeapVector<NodeSetVector> parentMatrix(nodeCount);
+    HeapVector<NodeSetVector> parentMatrix(nodeCount);
     for (unsigned i = 0; i < nodeCount; ++i) {
         NodeSetVector& parentsVector = parentMatrix[i];
         Node* n = m_nodes[i].get();
         parentsVector.append(n);
         if (n->isAttributeNode()) {
             n = toAttr(n)->ownerElement();
             parentsVector.append(n);
             containsAttributeNodes = true;
         }
         for (n = n->parentNode(); n; n = n->parentNode())
             parentsVector.append(n);
     }
     sortBlock(0, nodeCount, parentMatrix, containsAttributeNodes);
 
     // It is not possible to just assign the result to m_nodes, because some
     // nodes may get dereferenced and destroyed.
-    WillBeHeapVector<RefPtrWillBeMember<Node>> sortedNodes;
+    HeapVector<Member<Node>> sortedNodes;
     sortedNodes.reserveInitialCapacity(nodeCount);
     for (unsigned i = 0; i < nodeCount; ++i)
         sortedNodes.append(parentMatrix[i][0]);
 
-    const_cast<WillBeHeapVector<RefPtrWillBeMember<Node>>&>(m_nodes).swap(sortedNodes);
+    const_cast<HeapVector<Member<Node>>&>(m_nodes).swap(sortedNodes);
 }
 
 static Node* findRootNode(Node* node)
 {
     if (node->isAttributeNode())
         node = toAttr(node)->ownerElement();
     if (node->inDocument()) {
         node = &node->document();
     } else {
         while (Node* parent = node->parentNode())
             node = parent;
     }
     return node;
 }
 
 void NodeSet::traversalSort() const
 {
-    WillBeHeapHashSet<RawPtrWillBeMember<Node>> nodes;
+    HeapHashSet<Member<Node>> nodes;
     bool containsAttributeNodes = false;
 
     unsigned nodeCount = m_nodes.size();
     ASSERT(nodeCount > 1);
     for (unsigned i = 0; i < nodeCount; ++i) {
         Node* node = m_nodes[i].get();
         nodes.add(node);
         if (node->isAttributeNode())
             containsAttributeNodes = true;
     }
 
-    WillBeHeapVector<RefPtrWillBeMember<Node>> sortedNodes;
+    HeapVector<Member<Node>> sortedNodes;
     sortedNodes.reserveInitialCapacity(nodeCount);
 
     for (Node& n : NodeTraversal::startsAt(findRootNode(m_nodes.first().get()))) {
         if (nodes.contains(&n))
             sortedNodes.append(&n);
 
         if (!containsAttributeNodes || !n.isElementNode())
             continue;
 
         Element* element = toElement(&n);
         AttributeCollection attributes = element->attributes();
         for (auto& attribute : attributes) {
-            RefPtrWillBeRawPtr<Attr> attr = element->attrIfExists(attribute.name());
+            RawPtr<Attr> attr = element->attrIfExists(attribute.name());
             if (attr && nodes.contains(attr.get()))
                 sortedNodes.append(attr);
         }
     }
 
     ASSERT(sortedNodes.size() == nodeCount);
-    const_cast<WillBeHeapVector<RefPtrWillBeMember<Node>>&>(m_nodes).swap(sortedNodes);
+    const_cast<HeapVector<Member<Node>>&>(m_nodes).swap(sortedNodes);
 }
 
 void NodeSet::reverse()
 {
     if (m_nodes.isEmpty())
         return;
 
     unsigned from = 0;
     unsigned to = m_nodes.size() - 1;
     while (from < to) {
@@ skipping 17 matching lines @@
 Node* NodeSet::anyNode() const
 {
     if (isEmpty())
         return nullptr;
 
     return m_nodes.at(0).get();
 }
 
 } // namespace XPath
 } // namespace blink