Simplify SVGUseElement::expand* methods

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 21 matching lines @@
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/events/Event.h"
 #include "core/fetch/FetchRequest.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/layout/svg/LayoutSVGTransformableContainer.h"
 #include "core/svg/SVGDocumentExtensions.h"
 #include "core/svg/SVGGElement.h"
 #include "core/svg/SVGLengthContext.h"
 #include "core/svg/SVGSVGElement.h"
+#include "core/svg/SVGSymbolElement.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)));
     return *sharedLoadEventSender;
 }
@@ skipping 364 matching lines @@
         return;
     }
 
     // Assure shadow tree building was successful.
     ASSERT(m_targetElementInstance);
     ASSERT(m_targetElementInstance->correspondingUseElement() == this);
     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(m_targetElementInstance.get())) {
+    if (!expandUseElementsInShadowTree()) {
         clearShadowTree();
         return;
     }
 
     // Expand all <symbol> elements in the shadow tree.
     // Expand means: replace the actual <symbol> element by the <svg> element.
-    expandSymbolElementsInShadowTree(toSVGElement(shadowTreeRootElement->firstChild()));
+    expandSymbolElementsInShadowTree();
 
     m_targetElementInstance = toSVGElement(shadowTreeRootElement->firstChild());
     transferUseWidthAndHeightIfNeeded(*this, m_targetElementInstance.get(), *m_targetElementInstance->correspondingElement());
     cloneNonMarkupEventListeners();
 
     ASSERT(m_targetElementInstance->parentNode() == shadowTreeRootElement);
 
     // Update relative length information.
     updateRelativeLengthsInformation();
 }
@@ skipping 133 matching lines @@
             Element* next = ElementTraversal::nextSkippingChildren(*element, &subtree);
             // The subtree is not in document so this won't generate events that could mutate the tree.
             element->parentNode()->removeChild(element);
             element = next;
         } else {
             element = ElementTraversal::next(*element, &subtree);
         }
     }
 }
 
-bool SVGUseElement::expandUseElementsInShadowTree(SVGElement* element)
+bool SVGUseElement::expandUseElementsInShadowTree()
 {
-    ASSERT(element);
     // Why expand the <use> elements in the shadow tree here, and not just
     // do this directly in buildShadowTree, if we encounter a <use> element?
     //
     // 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.
-    if (isSVGUseElement(*element)) {
-        SVGUseElement* use = toSVGUseElement(element);
+    ShadowRoot* shadowRoot = userAgentShadowRoot();
+    for (RefPtrWillBeRawPtr<SVGUseElement> use = Traversal<SVGUseElement>::firstWithin(*shadowRoot); use; ) {
         ASSERT(!use->resourceIsStillLoading());
 
         SVGElement* target = 0;
-        if (hasCycleUseReferencing(toSVGUseElement(use->correspondingElement()), use, target))
+        if (hasCycleUseReferencing(toSVGUseElement(use->correspondingElement()), use.get(), 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());
         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();
             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());
+        transferUseAttributesToReplacedElement(use.get(), cloneParent.get());
 
         if (target) {
             RefPtrWillBeRawPtr<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());
 
         // 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)) {
-            if (!expandUseElementsInShadowTree(sibling.get()))
-                return false;
-        }
-    }
-
-    for (RefPtrWillBeRawPtr<SVGElement> child = Traversal<SVGElement>::firstChild(*element); child; child = Traversal<SVGElement>::nextSibling(*child)) {
-        if (!expandUseElementsInShadowTree(child.get()))
-            return false;
+        use = Traversal<SVGUseElement>::next(*replacingElement, shadowRoot);
     }
     return true;
 }
 
-void SVGUseElement::expandSymbolElementsInShadowTree(SVGElement* element)
+void SVGUseElement::expandSymbolElementsInShadowTree()
 {
-    ASSERT(element);
-    if (isSVGSymbolElement(*element)) {
+    ShadowRoot* shadowRoot = userAgentShadowRoot();
+    for (RefPtrWillBeRawPtr<SVGSymbolElement> symbol = Traversal<SVGSymbolElement>::firstWithin(*shadowRoot); symbol; ) {
         // 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());
         // Transfer all data (attributes, etc.) from <symbol> to the new <svg> element.
-        svgElement->cloneDataFromElement(*element);
-        svgElement->setCorrespondingElement(element->correspondingElement());
+        svgElement->cloneDataFromElement(*symbol);
+        svgElement->setCorrespondingElement(symbol->correspondingElement());
 
         // Move already cloned elements to the new <svg> element
-        for (RefPtrWillBeRawPtr<Node> child = element->firstChild(); child; ) {
+        for (RefPtrWillBeRawPtr<Node> child = symbol->firstChild(); child; ) {
             RefPtrWillBeRawPtr<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());
 
         // Replace <symbol> with <svg>.
-        ASSERT(element->parentNode());
-        element->parentNode()->replaceChild(svgElement.release(), element);
+        symbol->parentNode()->replaceChild(svgElement.release(), symbol);
 
-        // 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))
-            expandSymbolElementsInShadowTree(sibling.get());
+        symbol = Traversal<SVGSymbolElement>::next(*replacingElement, shadowRoot);
     }
-
-    for (RefPtrWillBeRawPtr<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();
 }
@@ skipping 120 matching lines @@
 
     if (m_resource)
         m_resource->removeClient(this);
 
     m_resource = resource;
     if (m_resource)
         m_resource->addClient(this);
 }
 
 } // namespace blink