Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/dom/TreeScope.cpp

 /*
  * Copyright (C) 2011 Google Inc. All Rights Reserved.
  * Copyright (C) 2012 Apple Inc. All rights reserved.
  *
  * 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 150 matching lines @@
 
 Element* TreeScope::getElementById(const AtomicString& elementId) const
 {
     if (elementId.isEmpty())
         return 0;
     if (!m_elementsById)
         return 0;
     return m_elementsById->getElementById(elementId, this);
 }
 
-const WillBeHeapVector<RawPtrWillBeMember<Element>>& TreeScope::getAllElementsById(const AtomicString& elementId) const
+const HeapVector<Member<Element>>& TreeScope::getAllElementsById(const AtomicString& elementId) const
 {
-    DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<WillBeHeapVector<RawPtrWillBeMember<Element>>>, emptyVector, (adoptPtrWillBeNoop(new WillBeHeapVector<RawPtrWillBeMember<Element>>())));
+    DEFINE_STATIC_LOCAL(Persistent<HeapVector<Member<Element>>>, emptyVector, (new HeapVector<Member<Element>>()));
     if (elementId.isEmpty())
         return *emptyVector;
     if (!m_elementsById)
         return *emptyVector;
     return m_elementsById->getAllElementsById(elementId, this);
 }
 
 void TreeScope::addElementById(const AtomicString& elementId, Element* element)
 {
     if (!m_elementsById)
@@ skipping 103 matching lines @@
         return 0;
     if (node->isPseudoElement() || node->isTextNode())
         node = node->parentOrShadowHostNode();
     ASSERT(!node || node->isElementNode() || node->isShadowRoot());
     node = ancestorInThisScope(node);
     if (!node || !node->isElementNode())
         return 0;
     return toElement(node);
 }
 
-WillBeHeapVector<RawPtrWillBeMember<Element>> TreeScope::elementsFromHitTestResult(HitTestResult& result) const
+HeapVector<Member<Element>> TreeScope::elementsFromHitTestResult(HitTestResult& result) const
 {
-    WillBeHeapVector<RawPtrWillBeMember<Element>> elements;
+    HeapVector<Member<Element>> elements;
 
     Node* lastNode = nullptr;
     for (const auto rectBasedNode : result.listBasedTestResult()) {
         Node* node = rectBasedNode.get();
         if (!node || !node->isElementNode() || node->isDocumentNode())
             continue;
 
         if (node->isPseudoElement() || node->isTextNode())
             node = node->parentOrShadowHostNode();
         node = ancestorInThisScope(node);
@@ skipping 12 matching lines @@
     if (rootNode().isDocumentNode()) {
         if (Element* rootElement = toDocument(rootNode()).documentElement()) {
             if (elements.isEmpty() || elements.last() != rootElement)
                 elements.append(rootElement);
         }
     }
 
     return elements;
 }
 
-WillBeHeapVector<RawPtrWillBeMember<Element>> TreeScope::elementsFromPoint(int x, int y) const
+HeapVector<Member<Element>> TreeScope::elementsFromPoint(int x, int y) const
 {
     Document& document = rootNode().document();
     IntPoint hitPoint(x, y);
     if (!pointWithScrollAndZoomIfPossible(document, hitPoint))
-        return WillBeHeapVector<RawPtrWillBeMember<Element>>();
+        return HeapVector<Member<Element>>();
 
     HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::ListBased | HitTestRequest::PenetratingList);
     HitTestResult result(request, hitPoint);
     document.layoutView()->hitTest(result);
 
     return elementsFromHitTestResult(result);
 }
 
 void TreeScope::addLabel(const AtomicString& forAttributeValue, HTMLLabelElement* element)
 {
@@ skipping 74 matching lines @@
 
 Element* TreeScope::adjustedFocusedElement() const
 {
     Document& document = rootNode().document();
     Element* element = document.focusedElement();
     if (!element && document.page())
         element = document.page()->focusController().focusedFrameOwnerElement(*document.frame());
     if (!element)
         return 0;
 
-    OwnPtrWillBeRawPtr<EventPath> eventPath = adoptPtrWillBeNoop(new EventPath(*element));
+    RawPtr<EventPath> eventPath = new EventPath(*element);
     for (size_t i = 0; i < eventPath->size(); ++i) {
         if (eventPath->at(i).node() == rootNode()) {
             // eventPath->at(i).target() is one of the followings:
             // - InsertionPoint
             // - shadow host
             // - Document::focusedElement()
             // So, it's safe to do toElement().
             return toElement(eventPath->at(i).target()->toNode());
         }
     }
     return 0;
 }
 
 unsigned short TreeScope::comparePosition(const TreeScope& otherScope) const
 {
     if (otherScope == this)
         return Node::DOCUMENT_POSITION_EQUIVALENT;
 
-    WillBeHeapVector<RawPtrWillBeMember<const TreeScope>, 16> chain1;
-    WillBeHeapVector<RawPtrWillBeMember<const TreeScope>, 16> chain2;
+    HeapVector<Member<const TreeScope>, 16> chain1;
+    HeapVector<Member<const TreeScope>, 16> chain2;
     const TreeScope* current;
     for (current = this; current; current = current->parentTreeScope())
         chain1.append(current);
     for (current = &otherScope; current; current = current->parentTreeScope())
         chain2.append(current);
 
     unsigned index1 = chain1.size();
     unsigned index2 = chain2.size();
     if (chain1[index1 - 1] != chain2[index2 - 1])
         return Node::DOCUMENT_POSITION_DISCONNECTED | Node::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC;
@@ skipping 18 matching lines @@
 
     // There was no difference between the two parent chains, i.e., one was a subset of the other. The shorter
     // chain is the ancestor.
     return index1 < index2 ?
         Node::DOCUMENT_POSITION_FOLLOWING | Node::DOCUMENT_POSITION_CONTAINED_BY :
         Node::DOCUMENT_POSITION_PRECEDING | Node::DOCUMENT_POSITION_CONTAINS;
 }
 
 const TreeScope* TreeScope::commonAncestorTreeScope(const TreeScope& other) const
 {
-    WillBeHeapVector<RawPtrWillBeMember<const TreeScope>, 16> thisChain;
+    HeapVector<Member<const TreeScope>, 16> thisChain;
     for (const TreeScope* tree = this; tree; tree = tree->parentTreeScope())
         thisChain.append(tree);
 
-    WillBeHeapVector<RawPtrWillBeMember<const TreeScope>, 16> otherChain;
+    HeapVector<Member<const TreeScope>, 16> otherChain;
     for (const TreeScope* tree = &other; tree; tree = tree->parentTreeScope())
         otherChain.append(tree);
 
     // Keep popping out the last elements of these chains until a mismatched pair is found. If |this| and |other|
     // belong to different documents, null will be returned.
     const TreeScope* lastAncestor = nullptr;
     while (!thisChain.isEmpty() && !otherChain.isEmpty() && thisChain.last() == otherChain.last()) {
         lastAncestor = thisChain.last();
         thisChain.removeLast();
         otherChain.removeLast();
@@ skipping 70 matching lines @@
     visitor->trace(m_idTargetObserverRegistry);
     visitor->trace(m_selection);
     visitor->trace(m_elementsById);
     visitor->trace(m_imageMapsByName);
     visitor->trace(m_labelsByForAttribute);
     visitor->trace(m_scopedStyleResolver);
     visitor->trace(m_radioButtonGroupScope);
 }
 
 } // namespace blink