Remove SVGUseElement::buildShadowTree

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 346 matching lines @@
     auto targetRange = Traversal<SVGElement>::inclusiveDescendantsOf(targetRoot);
     auto targetIterator = targetRange.begin();
     for (SVGElement& instance : Traversal<SVGElement>::inclusiveDescendantsOf(instanceRoot)) {
         ASSERT(!instance.correspondingElement());
         instance.setCorrespondingElement(&*targetIterator);
         ++targetIterator;
     }
     ASSERT(!(targetIterator != targetRange.end()));
 }
 
+// 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).
+static inline void removeDisallowedElementsFromSubtree(SVGElement& subtree)
+{
+    ASSERT(!subtree.inDocument());
+    Element* element = ElementTraversal::firstWithin(subtree);
+    while (element) {
+        if (isDisallowedElement(*element)) {
+            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);
+        }
+    }
+}
+
 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.
     if (&target == this || isDisallowedElement(target))
         return;
 
     // Set up root SVG element in shadow tree.
-    RefPtrWillBeRawPtr<Element> newChild = target.cloneElementWithoutChildren();
-    m_targetElementInstance = toSVGElement(newChild.get());
+    // Clone the target subtree into the shadow tree, not handling <use> and <symbol> yet.
+    RefPtrWillBeRawPtr<Element> instanceRoot = target.cloneElementWithChildren();
+    ASSERT(instanceRoot->isSVGElement());
+    associateCorrespondingElements(target, toSVGElement(*instanceRoot));
+    removeDisallowedElementsFromSubtree(toSVGElement(*instanceRoot));
+
+    m_targetElementInstance = toSVGElement(instanceRoot.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);
+    shadowTreeRootElement->appendChild(instanceRoot.release());
 
     addReferencesToFirstDegreeNestedUseElements(target);
 
     if (instanceTreeIsLoading()) {
         cloneNonMarkupEventListeners();
         return;
     }
 
     // Assure shadow tree building was successful.
     ASSERT(m_targetElementInstance);
@@ skipping 86 matching lines @@
         return;
     // We only need to track first degree <use> dependencies. Indirect
     // references are handled as the invalidation bubbles up the dependency
     // chain.
     SVGUseElement* useElement =
         isSVGUseElement(target) ? toSVGUseElement(&target) : Traversal<SVGUseElement>::firstWithin(target);
     for (; useElement; useElement = Traversal<SVGUseElement>::nextSkippingChildren(*useElement, &target))
         addReferenceTo(useElement);
 }
 
-void SVGUseElement::buildShadowTree(SVGElement& target, SVGElement& targetInstance)
-{
-    ASSERT(!isDisallowedElement(target));
-
-    targetInstance.setCorrespondingElement(&target);
-
-    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());
-        if (newChild->isSVGElement()) {
-            // Enter recursion, appending new instance tree nodes to the "instance" object.
-            buildShadowTree(toSVGElement(*child), toSVGElement(*newChild));
-        }
-    }
-}
-
 void SVGUseElement::cloneNonMarkupEventListeners()
 {
     for (SVGElement& element : Traversal<SVGElement>::descendantsOf(*userAgentShadowRoot())) {
         if (EventTargetData* data = element.correspondingElement()->eventTargetData())
             data->eventListenerMap.copyEventListenersNotCreatedFromMarkupToTarget(&element);
     }
 }
 
 bool SVGUseElement::hasCycleUseReferencing(const SVGUseElement& use, const ContainerNode& targetInstance, SVGElement*& newTarget) const
 {
@@ skipping 14 matching lines @@
     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;
 }
 
-// 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).
-static inline void removeDisallowedElementsFromSubtree(SVGElement& subtree)
-{
-    ASSERT(!subtree.inDocument());
-    Element* element = ElementTraversal::firstWithin(subtree);
-    while (element) {
-        if (isDisallowedElement(*element)) {
-            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);
-        }
-    }
-}
-
 static void moveChildrenToReplacementElement(ContainerNode& sourceRoot, ContainerNode& destinationRoot)
 {
     for (RefPtrWillBeRawPtr<Node> child = sourceRoot.firstChild(); child; ) {
         RefPtrWillBeRawPtr<Node> nextChild = child->nextSibling();
         destinationRoot.appendChild(child);
         child = nextChild.release();
     }
 }
 
 // Spec: In the generated content, the 'use' will be replaced by 'g', where all
@@ skipping 206 matching lines @@
 
     if (m_resource)
         m_resource->removeClient(this);
 
     m_resource = resource;
     if (m_resource)
         m_resource->addClient(this);
 }
 
 } // namespace blink