Use references some more in SVGUseElement

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 137 matching lines @@
 
 Document* SVGUseElement::externalDocument() const
 {
     // Gracefully handle error condition.
     if (!resourceIsValid())
         return nullptr;
     ASSERT(m_resource->document());
     return m_resource->document();
 }
 
-void transferUseWidthAndHeightIfNeeded(const SVGUseElement& use, SVGElement* shadowElement, const SVGElement& originalElement)
+static void transferUseWidthAndHeightIfNeeded(const SVGUseElement& use, SVGElement& shadowElement, const SVGElement& originalElement)
 {
     DEFINE_STATIC_LOCAL(const AtomicString, hundredPercentString, ("100%", AtomicString::ConstructFromLiteral));
-    ASSERT(shadowElement);
-    if (isSVGSymbolElement(*shadowElement)) {
+    if (isSVGSymbolElement(shadowElement)) {
         // Spec (<use> on <symbol>): 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.
-        shadowElement->setAttribute(SVGNames::widthAttr, use.width()->isSpecified() ? AtomicString(use.width()->currentValue()->valueAsString()) : hundredPercentString);
-        shadowElement->setAttribute(SVGNames::heightAttr, use.height()->isSpecified() ? AtomicString(use.height()->currentValue()->valueAsString()) : hundredPercentString);
-    } else if (isSVGSVGElement(*shadowElement)) {
+        shadowElement.setAttribute(SVGNames::widthAttr, use.width()->isSpecified() ? AtomicString(use.width()->currentValue()->valueAsString()) : hundredPercentString);
+        shadowElement.setAttribute(SVGNames::heightAttr, use.height()->isSpecified() ? AtomicString(use.height()->currentValue()->valueAsString()) : hundredPercentString);
+    } else if (isSVGSVGElement(shadowElement)) {
         // Spec (<use> on <svg>): If attributes width and/or height are provided on the 'use' element, then these
         // values will override the corresponding attributes on the 'svg' in the generated tree.
         if (use.width()->isSpecified())
-            shadowElement->setAttribute(SVGNames::widthAttr, AtomicString(use.width()->currentValue()->valueAsString()));
+            shadowElement.setAttribute(SVGNames::widthAttr, AtomicString(use.width()->currentValue()->valueAsString()));
         else
-            shadowElement->setAttribute(SVGNames::widthAttr, originalElement.getAttribute(SVGNames::widthAttr));
+            shadowElement.setAttribute(SVGNames::widthAttr, originalElement.getAttribute(SVGNames::widthAttr));
         if (use.height()->isSpecified())
-            shadowElement->setAttribute(SVGNames::heightAttr, AtomicString(use.height()->currentValue()->valueAsString()));
+            shadowElement.setAttribute(SVGNames::heightAttr, AtomicString(use.height()->currentValue()->valueAsString()));
         else
-            shadowElement->setAttribute(SVGNames::heightAttr, originalElement.getAttribute(SVGNames::heightAttr));
+            shadowElement.setAttribute(SVGNames::heightAttr, originalElement.getAttribute(SVGNames::heightAttr));
     }
 }
 
 bool SVGUseElement::isPresentationAttribute(const QualifiedName& attrName) const
 {
     if (attrName == SVGNames::xAttr || attrName == SVGNames::yAttr)
         return true;
     return SVGGraphicsElement::isPresentationAttribute(attrName);
 }
 
@@ skipping 26 matching lines @@
         if (attrName == SVGNames::xAttr
             || attrName == SVGNames::yAttr) {
             invalidateSVGPresentationAttributeStyle();
             setNeedsStyleRecalc(LocalStyleChange,
                 StyleChangeReasonForTracing::fromAttribute(attrName));
         }
 
         updateRelativeLengthsInformation();
         if (m_targetElementInstance) {
             ASSERT(m_targetElementInstance->correspondingElement());
-            transferUseWidthAndHeightIfNeeded(*this, m_targetElementInstance.get(), *m_targetElementInstance->correspondingElement());
+            transferUseWidthAndHeightIfNeeded(*this, *m_targetElementInstance, *m_targetElementInstance->correspondingElement());
         }
 
         LayoutObject* object = this->layoutObject();
         if (object)
             markForLayoutAndParentResourceInvalidation(object);
         return;
     }
 
     if (SVGURIReference::isKnownAttribute(attrName)) {
         SVGElement::InvalidationGuard invalidationGuard(this);
@@ skipping 106 matching lines @@
             return;
         if (id.isEmpty())
             return;
 
         referencedScope()->document().accessSVGExtensions().addPendingResource(id, this);
         ASSERT(hasPendingResources());
         return;
     }
 
     if (target->isSVGElement()) {
-        buildShadowAndInstanceTree(toSVGElement(target));
+        buildShadowAndInstanceTree(toSVGElement(*target));
         invalidateDependentShadowTrees();
     }
 
     ASSERT(!m_needsShadowTreeRecreation);
 }
 
 static PassRefPtrWillBeRawPtr<Node> cloneNodeAndAssociate(Node& toClone)
 {
     RefPtrWillBeRawPtr<Node> clone = toClone.cloneNode(false);
     if (!clone->isSVGElement())
         return clone.release();
 
     SVGElement& svgElement = toSVGElement(toClone);
     ASSERT(!svgElement.correspondingElement());
     toSVGElement(clone.get())->setCorrespondingElement(&svgElement);
     TrackExceptionState exceptionState;
     for (RefPtrWillBeRawPtr<Node> node = toClone.firstChild(); node && !exceptionState.hadException(); node = node->nextSibling())
         clone->appendChild(cloneNodeAndAssociate(*node), exceptionState);
     return clone.release();
 }
 
-void SVGUseElement::buildShadowAndInstanceTree(SVGElement* target)
+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))
+    if (&target == this || isDisallowedElement(target))
         return;
 
     // Set up root SVG element in shadow tree.
-    RefPtrWillBeRawPtr<Element> newChild = target->cloneElementWithoutChildren();
+    RefPtrWillBeRawPtr<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.
-    buildShadowTree(target, m_targetElementInstance.get(), false);
+    buildShadowTree(target, *m_targetElementInstance, false);
 
     if (instanceTreeIsLoading(m_targetElementInstance.get())) {
         cloneNonMarkupEventListeners();
         return;
     }
 
     // Assure shadow tree building was successful.
     ASSERT(m_targetElementInstance);
     ASSERT(m_targetElementInstance->correspondingUseElement() == this);
-    ASSERT(m_targetElementInstance->correspondingElement() == target);
+    ASSERT(m_targetElementInstance->correspondingElement() == &target);
 
     // Expand all <use> elements in the shadow tree.
     // Expand means: replace the actual <use> element by what it references.
     if (!expandUseElementsInShadowTree()) {
         clearShadowTree();
         return;
     }
 
     // Expand all <symbol> elements in the shadow tree.
     // Expand means: replace the actual <symbol> element by the <svg> element.
     expandSymbolElementsInShadowTree();
 
     m_targetElementInstance = toSVGElement(shadowTreeRootElement->firstChild());
-    transferUseWidthAndHeightIfNeeded(*this, m_targetElementInstance.get(), *m_targetElementInstance->correspondingElement());
+    transferUseWidthAndHeightIfNeeded(*this, *m_targetElementInstance, *m_targetElementInstance->correspondingElement());
     cloneNonMarkupEventListeners();
 
     ASSERT(m_targetElementInstance->parentNode() == shadowTreeRootElement);
 
     // Update relative length information.
     updateRelativeLengthsInformation();
 }
 
 LayoutObject* SVGUseElement::createLayoutObject(const ComputedStyle&)
 {
@@ skipping 46 matching lines @@
     // http://dev.w3.org/fxtf/css-masking-1/#the-clip-path
     if (!isDirectReference(element)) {
         // Spec: Indirect references are an error (14.3.5)
         document().accessSVGExtensions().reportError("Not allowed to use indirect reference in <clip-path>");
         return nullptr;
     }
 
     return &toSVGGraphicsElement(element);
 }
 
-void SVGUseElement::buildShadowTree(SVGElement* target, SVGElement* targetInstance, bool foundUse)
+void SVGUseElement::buildShadowTree(SVGElement& target, SVGElement& targetInstance, bool foundUse)
 {
-    ASSERT(target);
-    ASSERT(targetInstance);
-    ASSERT(!isDisallowedElement(*target));
+    ASSERT(!isDisallowedElement(target));
 
     // Spec: If the referenced object is itself a 'use', or if there are 'use' subelements within the referenced
     // object, the instance tree will contain recursive expansion of the indirect references to form a complete tree.
-    if (isSVGUseElement(*target)) {
+    if (isSVGUseElement(target)) {
         // We only need to track first degree <use> dependencies. Indirect references are handled
         // as the invalidation bubbles up the dependency chain.
         if (!foundUse && !isStructurallyExternal()) {
-            addReferenceTo(target);
+            addReferenceTo(&target);
             foundUse = true;
         }
     }
 
-    targetInstance->setCorrespondingElement(target);
+    targetInstance.setCorrespondingElement(&target);
 
-    for (RefPtrWillBeRawPtr<Node> child = target->firstChild(); child; child = child->nextSibling()) {
+    for (RefPtrWillBeRawPtr<Node> child = target.firstChild(); child; child = child->nextSibling()) {
         // Skip any disallowed element.
         if (isDisallowedElement(*child))
             continue;
 
         RefPtrWillBeRawPtr<Node> newChild = child->cloneNode(false);
-        targetInstance->appendChild(newChild.get());
+        targetInstance.appendChild(newChild.get());
         if (newChild->isSVGElement()) {
             // Enter recursion, appending new instance tree nodes to the "instance" object.
-            buildShadowTree(toSVGElement(child), toSVGElement(newChild), foundUse);
+            buildShadowTree(toSVGElement(*child), toSVGElement(*newChild), foundUse);
         }
     }
 }
 
 void SVGUseElement::cloneNonMarkupEventListeners()
 {
     for (SVGElement& element : Traversal<SVGElement>::descendantsOf(*userAgentShadowRoot())) {
         if (EventTargetData* data = element.correspondingElement()->eventTargetData())
             data->eventListenerMap.copyEventListenersNotCreatedFromMarkupToTarget(&element);
     }
 }
 
-bool SVGUseElement::hasCycleUseReferencing(SVGUseElement* use, ContainerNode* targetInstance, SVGElement*& newTarget)
+bool SVGUseElement::hasCycleUseReferencing(const SVGUseElement& use, const ContainerNode& targetInstance, SVGElement*& newTarget) const
 {
     ASSERT(referencedScope());
-    Element* targetElement = SVGURIReference::targetElementFromIRIString(use->hrefString(), *referencedScope());
+    Element* targetElement = SVGURIReference::targetElementFromIRIString(use.hrefString(), *referencedScope());
     newTarget = 0;
     if (targetElement && targetElement->isSVGElement())
         newTarget = toSVGElement(targetElement);
 
     if (!newTarget)
         return false;
 
     // Shortcut for self-references
     if (newTarget == this)
         return true;
 
     AtomicString targetId = newTarget->getIdAttribute();
-    ContainerNode* instance = targetInstance->parentNode();
+    ContainerNode* instance = targetInstance.parentNode();
     while (instance && instance->isSVGElement()) {
         SVGElement* element = toSVGElement(instance);
         if (element->hasID() && element->getIdAttribute() == targetId && element->document() == newTarget->document())
             return true;
 
         instance = instance->parentNode();
     }
     return false;
 }
 
@@ skipping 48 matching lines @@
     //
     // Short answer: Because we may miss to expand some elements. For example, if a <symbol>
     // contains <use> tags, we'd miss them. So once we're done with setting up the
     // actual shadow tree (after the special case modification for svg/symbol) we have
     // to walk it completely and expand all <use> elements.
     ShadowRoot* shadowRoot = userAgentShadowRoot();
     for (RefPtrWillBeRawPtr<SVGUseElement> use = Traversal<SVGUseElement>::firstWithin(*shadowRoot); use; ) {
         ASSERT(!use->resourceIsStillLoading());
 
         SVGElement* target = 0;
-        if (hasCycleUseReferencing(toSVGUseElement(use->correspondingElement()), use.get(), target))
+        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());
         // Transfer all data (attributes, etc.) from <use> to the new <g> element.
         cloneParent->cloneDataFromElement(*use);
         cloneParent->setCorrespondingElement(use->correspondingElement());
 
         removeAttributesFromReplacementElement(*cloneParent);
 
         // Move already cloned elements to the new <g> element.
         moveChildrenToReplacementElement(*use, *cloneParent);
 
         if (target) {
             RefPtrWillBeRawPtr<Node> newChild = cloneNodeAndAssociate(*target);
             ASSERT(newChild->isSVGElement());
-            transferUseWidthAndHeightIfNeeded(*use, toSVGElement(newChild.get()), *target);
+            transferUseWidthAndHeightIfNeeded(*use, toSVGElement(*newChild), *target);
             cloneParent->appendChild(newChild.release());
         }
 
         removeDisallowedElementsFromSubtree(*cloneParent);
 
         RefPtrWillBeRawPtr<SVGElement> replacingElement(cloneParent.get());
 
         // Replace <use> with referenced content.
         use->parentNode()->replaceChild(cloneParent.release(), use);
 
@@ skipping 148 matching lines @@
 
     if (m_resource)
         m_resource->removeClient(this);
 
     m_resource = resource;
     if (m_resource)
         m_resource->addClient(this);
 }
 
 } // namespace blink