Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/svg/SVGUseElement.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  * Copyright (C) 2011 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  * Copyright (C) 2012 University of Szeged
  * Copyright (C) 2012 Renata Hodovan <reni@webkit.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 28 matching lines @@
 #include "core/svg/SVGGElement.h"
 #include "core/svg/SVGLengthContext.h"
 #include "core/svg/SVGSVGElement.h"
 #include "core/xml/parser/XMLDocumentParser.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 static SVGUseEventSender& svgUseLoadEventSender()
 {
-    DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<SVGUseEventSender>, sharedLoadEventSender, (SVGUseEventSender::create(EventTypeNames::load)));
+    DEFINE_STATIC_LOCAL(Persistent<SVGUseEventSender>, sharedLoadEventSender, (SVGUseEventSender::create(EventTypeNames::load)));
     return *sharedLoadEventSender;
 }
 
 inline SVGUseElement::SVGUseElement(Document& document)
     : SVGGraphicsElement(SVGNames::useTag, document)
     , SVGURIReference(this)
     , m_x(SVGAnimatedLength::create(this, SVGNames::xAttr, SVGLength::create(SVGLengthMode::Width)))
     , m_y(SVGAnimatedLength::create(this, SVGNames::yAttr, SVGLength::create(SVGLengthMode::Height)))
     , m_width(SVGAnimatedLength::create(this, SVGNames::widthAttr, SVGLength::create(SVGLengthMode::Width)))
     , m_height(SVGAnimatedLength::create(this, SVGNames::heightAttr, SVGLength::create(SVGLengthMode::Height)))
     , m_haveFiredLoadEvent(false)
     , m_needsShadowTreeRecreation(false)
 {
     ASSERT(hasCustomStyleCallbacks());
 
     addToPropertyMap(m_x);
     addToPropertyMap(m_y);
     addToPropertyMap(m_width);
     addToPropertyMap(m_height);
 
 #if ENABLE(OILPAN)
     ThreadState::current()->registerPreFinalizer(this);
 #endif
 }
 
-PassRefPtrWillBeRawPtr<SVGUseElement> SVGUseElement::create(Document& document)
+RawPtr<SVGUseElement> SVGUseElement::create(Document& document)
 {
     // Always build a user agent #shadow-root for SVGUseElement.
-    RefPtrWillBeRawPtr<SVGUseElement> use = adoptRefWillBeNoop(new SVGUseElement(document));
+    RawPtr<SVGUseElement> use = (new SVGUseElement(document));
     use->ensureUserAgentShadowRoot();
     return use.release();
 }
 
 SVGUseElement::~SVGUseElement()
 {
 #if !ENABLE(OILPAN)
     clearShadowTree();
     cancelShadowTreeRecreation();
     svgUseLoadEventSender().cancelEvent(this);
@@ skipping 275 matching lines @@
     }
 
     if (target->isSVGElement()) {
         buildShadowAndInstanceTree(toSVGElement(target));
         invalidateDependentShadowTrees();
     }
 
     ASSERT(!m_needsShadowTreeRecreation);
 }
 
-static PassRefPtrWillBeRawPtr<Node> cloneNodeAndAssociate(Node& toClone)
+static RawPtr<Node> cloneNodeAndAssociate(Node& toClone)
 {
-    RefPtrWillBeRawPtr<Node> clone = toClone.cloneNode(false);
+    RawPtr<Node> clone = toClone.cloneNode(false);
     if (!clone->isSVGElement())
         return clone.release();
 
     SVGElement& svgElement = toSVGElement(toClone);
     ASSERT(!svgElement.correspondingElement());
     toSVGElement(clone.get())->setCorrespondingElement(&svgElement);
     if (EventTargetData* data = toClone.eventTargetData())
         data->eventListenerMap.copyEventListenersNotCreatedFromMarkupToTarget(clone.get());
     TrackExceptionState exceptionState;
-    for (RefPtrWillBeRawPtr<Node> node = toClone.firstChild(); node && !exceptionState.hadException(); node = node->nextSibling())
+    for (RawPtr<Node> node = toClone.firstChild(); node && !exceptionState.hadException(); node = node->nextSibling())
         clone->appendChild(cloneNodeAndAssociate(*node), exceptionState);
     return clone.release();
 }
 
 void SVGUseElement::buildShadowAndInstanceTree(SVGElement* target)
 {
     ASSERT(!m_targetElementInstance);
     ASSERT(!m_needsShadowTreeRecreation);
 
     // <use> creates a "user agent" shadow root. Do not build the shadow/instance tree for <use>
     // elements living in a user agent shadow tree because they will get expanded in a second
     // pass -- see expandUseElementsInShadowTree().
     if (inUseShadowTree())
         return;
 
     // Do not allow self-referencing.
     // 'target' may be null, if it's a non SVG namespaced element.
     if (!target || target == this || isDisallowedElement(target))
         return;
 
     // Set up root SVG element in shadow tree.
-    RefPtrWillBeRawPtr<Element> newChild = target->cloneElementWithoutChildren();
+    RawPtr<Element> newChild = target->cloneElementWithoutChildren();
     m_targetElementInstance = toSVGElement(newChild.get());
     ShadowRoot* shadowTreeRootElement = userAgentShadowRoot();
     shadowTreeRootElement->appendChild(newChild.release());
 
     // Clone the target subtree into the shadow tree, not handling <use> and <symbol> yet.
 
     // SVG specification does not say a word about <use> & cycles. My view on this is: just ignore it!
     // Non-appearing <use> content is easier to debug, then half-appearing content.
     if (!buildShadowTree(target, m_targetElementInstance.get(), false)) {
         clearShadowTree();
@@ skipping 101 matching lines @@
             foundUse = true;
         }
     } else if (isDisallowedElement(target)) {
         return false;
     }
 
     targetInstance->setCorrespondingElement(target);
     if (EventTargetData* data = target->eventTargetData())
         data->eventListenerMap.copyEventListenersNotCreatedFromMarkupToTarget(targetInstance);
 
-    for (RefPtrWillBeRawPtr<Node> child = target->firstChild(); child; child = child->nextSibling()) {
+    for (RawPtr<Node> child = target->firstChild(); child; child = child->nextSibling()) {
         // Skip any disallowed element.
         if (isDisallowedElement(child.get()))
             continue;
 
-        RefPtrWillBeRawPtr<Node> newChild = child->cloneNode(false);
+        RawPtr<Node> newChild = child->cloneNode(false);
         targetInstance->appendChild(newChild.get());
         if (newChild->isSVGElement()) {
             // Enter recursion, appending new instance tree nodes to the "instance" object.
             if (!buildShadowTree(toSVGElement(child), toSVGElement(newChild), foundUse))
                 return false;
         }
     }
     return true;
 }
 
@@ skipping 55 matching lines @@
         ASSERT(!use->resourceIsStillLoading());
 
         SVGElement* target = 0;
         if (hasCycleUseReferencing(toSVGUseElement(use->correspondingElement()), use, target))
             return false;
 
         if (target && isDisallowedElement(target))
             return false;
         // Don't ASSERT(target) here, it may be "pending", too.
         // Setup sub-shadow tree root node
-        RefPtrWillBeRawPtr<SVGGElement> cloneParent = SVGGElement::create(referencedScope()->document());
+        RawPtr<SVGGElement> cloneParent = SVGGElement::create(referencedScope()->document());
         cloneParent->setCorrespondingElement(use->correspondingElement());
 
         // Move already cloned elements to the new <g> element
-        for (RefPtrWillBeRawPtr<Node> child = use->firstChild(); child; ) {
-            RefPtrWillBeRawPtr<Node> nextChild = child->nextSibling();
+        for (RawPtr<Node> child = use->firstChild(); child; ) {
+            RawPtr<Node> nextChild = child->nextSibling();
             cloneParent->appendChild(child);
             child = nextChild.release();
         }
 
         // Spec: In the generated content, the 'use' will be replaced by 'g', where all attributes from the
         // 'use' element except for x, y, width, height and xlink:href are transferred to the generated 'g' element.
         transferUseAttributesToReplacedElement(use, cloneParent.get());
 
         if (target) {
-            RefPtrWillBeRawPtr<Node> newChild = cloneNodeAndAssociate(*target);
+            RawPtr<Node> newChild = cloneNodeAndAssociate(*target);
             ASSERT(newChild->isSVGElement());
             transferUseWidthAndHeightIfNeeded(*use, toSVGElement(newChild.get()), *target);
             cloneParent->appendChild(newChild.release());
         }
 
         // We don't walk the target tree element-by-element, and clone each element,
         // but instead use cloneElementWithChildren(). This is an optimization for the common
         // case where <use> doesn't contain disallowed elements (ie. <foreignObject>).
         // Though if there are disallowed elements in the subtree, we have to remove them.
         // For instance: <use> on <g> containing <foreignObject> (indirect case).
         if (subtreeContainsDisallowedElement(cloneParent.get()))
             removeDisallowedElementsFromSubtree(*cloneParent);
 
-        RefPtrWillBeRawPtr<SVGElement> replacingElement(cloneParent.get());
+        RawPtr<SVGElement> replacingElement(cloneParent.get());
 
         // Replace <use> with referenced content.
         ASSERT(use->parentNode());
         use->parentNode()->replaceChild(cloneParent.release(), use);
 
         // Expand the siblings because the *element* is replaced and we will
         // lose the sibling chain when we are back from recursion.
         element = replacingElement.get();
-        for (RefPtrWillBeRawPtr<SVGElement> sibling = Traversal<SVGElement>::nextSibling(*element); sibling; sibling = Traversal<SVGElement>::nextSibling(*sibling)) {
+        for (RawPtr<SVGElement> sibling = Traversal<SVGElement>::nextSibling(*element); sibling; sibling = Traversal<SVGElement>::nextSibling(*sibling)) {
             if (!expandUseElementsInShadowTree(sibling.get()))
                 return false;
         }
     }
 
-    for (RefPtrWillBeRawPtr<SVGElement> child = Traversal<SVGElement>::firstChild(*element); child; child = Traversal<SVGElement>::nextSibling(*child)) {
+    for (RawPtr<SVGElement> child = Traversal<SVGElement>::firstChild(*element); child; child = Traversal<SVGElement>::nextSibling(*child)) {
         if (!expandUseElementsInShadowTree(child.get()))
             return false;
     }
     return true;
 }
 
 void SVGUseElement::expandSymbolElementsInShadowTree(SVGElement* element)
 {
     ASSERT(element);
     if (isSVGSymbolElement(*element)) {
         // Spec: The referenced 'symbol' and its contents are deep-cloned into the generated tree,
         // with the exception that the 'symbol' is replaced by an 'svg'. This generated 'svg' will
         // always have explicit values for attributes width and height. If attributes width and/or
         // height are provided on the 'use' element, then these attributes will be transferred to
         // the generated 'svg'. If attributes width and/or height are not specified, the generated
         // 'svg' element will use values of 100% for these attributes.
         ASSERT(referencedScope());
-        RefPtrWillBeRawPtr<SVGSVGElement> svgElement = SVGSVGElement::create(referencedScope()->document());
+        RawPtr<SVGSVGElement> svgElement = SVGSVGElement::create(referencedScope()->document());
         // Transfer all data (attributes, etc.) from <symbol> to the new <svg> element.
         svgElement->cloneDataFromElement(*element);
         svgElement->setCorrespondingElement(element->correspondingElement());
 
         // Move already cloned elements to the new <svg> element
-        for (RefPtrWillBeRawPtr<Node> child = element->firstChild(); child; ) {
-            RefPtrWillBeRawPtr<Node> nextChild = child->nextSibling();
+        for (RawPtr<Node> child = element->firstChild(); child; ) {
+            RawPtr<Node> nextChild = child->nextSibling();
             svgElement->appendChild(child);
             child = nextChild.release();
         }
 
         // We don't walk the target tree element-by-element, and clone each element,
         // but instead use cloneNode(deep=true). This is an optimization for the common
         // case where <use> doesn't contain disallowed elements (ie. <foreignObject>).
         // Though if there are disallowed elements in the subtree, we have to remove them.
         // For instance: <use> on <g> containing <foreignObject> (indirect case).
         if (subtreeContainsDisallowedElement(svgElement.get()))
             removeDisallowedElementsFromSubtree(*svgElement);
 
-        RefPtrWillBeRawPtr<SVGElement> replacingElement(svgElement.get());
+        RawPtr<SVGElement> replacingElement(svgElement.get());
 
         // Replace <symbol> with <svg>.
         ASSERT(element->parentNode());
         element->parentNode()->replaceChild(svgElement.release(), element);
 
         // Expand the siblings because the *element* is replaced and we will
         // lose the sibling chain when we are back from recursion.
         element = replacingElement.get();
     }
 
-    for (RefPtrWillBeRawPtr<SVGElement> child = Traversal<SVGElement>::firstChild(*element); child; child = Traversal<SVGElement>::nextSibling(*child))
+    for (RawPtr<SVGElement> child = Traversal<SVGElement>::firstChild(*element); child; child = Traversal<SVGElement>::nextSibling(*child))
         expandSymbolElementsInShadowTree(child.get());
 }
 
 void SVGUseElement::invalidateShadowTree()
 {
     if (!inActiveDocument() || m_needsShadowTreeRecreation)
         return;
     clearInstanceRoot();
     scheduleShadowTreeRecreation();
     invalidateDependentShadowTrees();
 }
 
 void SVGUseElement::invalidateDependentShadowTrees()
 {
     // Recursively invalidate dependent <use> shadow trees
-    const WillBeHeapHashSet<RawPtrWillBeWeakMember<SVGElement>>& rawInstances = instancesForElement();
-    WillBeHeapVector<RefPtrWillBeMember<SVGElement>> instances;
+    const HeapHashSet<WeakMember<SVGElement>>& rawInstances = instancesForElement();
+    HeapVector<Member<SVGElement>> instances;
     instances.appendRange(rawInstances.begin(), rawInstances.end());
     for (auto& instance : instances) {
-        if (RefPtrWillBeRawPtr<SVGUseElement> element = instance->correspondingUseElement()) {
+        if (RawPtr<SVGUseElement> element = instance->correspondingUseElement()) {
             ASSERT(element->inDocument());
             element->invalidateShadowTree();
         }
     }
 }
 
 void SVGUseElement::transferUseAttributesToReplacedElement(SVGElement* from, SVGElement* to) const
 {
     ASSERT(from);
     ASSERT(to);
@@ skipping 77 matching lines @@
 
 bool SVGUseElement::instanceTreeIsLoading(const SVGElement* targetInstance)
 {
     for (const SVGElement* element = targetInstance; element; element = Traversal<SVGElement>::next(*element, targetInstance)) {
         if (isSVGUseElement(*element) && toSVGUseElement(*element).resourceIsStillLoading())
             return true;
     }
     return false;
 }
 
-void SVGUseElement::setDocumentResource(PassRefPtrWillBeRawPtr<DocumentResource> resource)
+void SVGUseElement::setDocumentResource(RawPtr<DocumentResource> resource)
 {
     if (m_resource == resource)
         return;
 
     if (m_resource)
         m_resource->removeClient(this);
 
     m_resource = resource;
     if (m_resource)
         m_resource->addClient(this);
 }
 
 } // namespace blink