Remove SVGUseElement helper subtreeContainsDisallowedElement

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 235 matching lines @@
         }
 
         invalidateShadowTree();
 
         return;
     }
 
     SVGGraphicsElement::svgAttributeChanged(attrName);
 }
 
-static bool isDisallowedElement(const Node* node)
+static bool isDisallowedElement(const Node& node)
 {
     // Spec: "Any 'svg', 'symbol', 'g', graphics element or other 'use' is potentially a template object that can be re-used
     // (i.e., "instanced") in the SVG document via a 'use' element."
     // "Graphics Element" is defined as 'circle', 'ellipse', 'image', 'line', 'path', 'polygon', 'polyline', 'rect', 'text'
     // Excluded are anything that is used by reference or that only make sense to appear once in a document.
     // We must also allow the shadow roots of other use elements.
-    if (node->isShadowRoot() || node->isTextNode())
+    if (node.isShadowRoot() || node.isTextNode())
         return false;
 
-    if (!node->isSVGElement())
+    if (!node.isSVGElement())
         return true;
 
-    const Element* element = toElement(node);
+    const Element& element = toElement(node);
 
     DEFINE_STATIC_LOCAL(HashSet<QualifiedName>, allowedElementTags, ());
     if (allowedElementTags.isEmpty()) {
         allowedElementTags.add(SVGNames::aTag);
         allowedElementTags.add(SVGNames::circleTag);
         allowedElementTags.add(SVGNames::descTag);
         allowedElementTags.add(SVGNames::ellipseTag);
         allowedElementTags.add(SVGNames::gTag);
         allowedElementTags.add(SVGNames::imageTag);
         allowedElementTags.add(SVGNames::lineTag);
         allowedElementTags.add(SVGNames::metadataTag);
         allowedElementTags.add(SVGNames::pathTag);
         allowedElementTags.add(SVGNames::polygonTag);
         allowedElementTags.add(SVGNames::polylineTag);
         allowedElementTags.add(SVGNames::rectTag);
         allowedElementTags.add(SVGNames::svgTag);
         allowedElementTags.add(SVGNames::switchTag);
         allowedElementTags.add(SVGNames::symbolTag);
         allowedElementTags.add(SVGNames::textTag);
         allowedElementTags.add(SVGNames::textPathTag);
         allowedElementTags.add(SVGNames::titleTag);
         allowedElementTags.add(SVGNames::tspanTag);
         allowedElementTags.add(SVGNames::useTag);
     }
-    return !allowedElementTags.contains<SVGAttributeHashTranslator>(element->tagQName());
-}
-
-static bool subtreeContainsDisallowedElement(const Node* start)
-{
-    if (isDisallowedElement(start))
-        return true;
-
-    for (const Node* cur = start->firstChild(); cur; cur = cur->nextSibling()) {
-        if (subtreeContainsDisallowedElement(cur))
-            return true;
-    }
-
-    return false;
+    return !allowedElementTags.contains<SVGAttributeHashTranslator>(element.tagQName());
 }
 
 void SVGUseElement::scheduleShadowTreeRecreation()
 {
     if (inUseShadowTree())
         return;
     m_needsShadowTreeRecreation = true;
     document().scheduleUseShadowTreeUpdate(*this);
 }
 
@@ skipping 73 matching lines @@
     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 || target == this || isDisallowedElement(*target))
         return;
 
     // Set up root SVG element in shadow tree.
     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.
 
@@ skipping 87 matching lines @@
         return nullptr;
     }
 
     return &toSVGGraphicsElement(element);
 }
 
 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)) {
         // 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);
             foundUse = true;
         }
     }
 
     targetInstance->setCorrespondingElement(target);
 
     for (RefPtrWillBeRawPtr<Node> child = target->firstChild(); child; child = child->nextSibling()) {
         // Skip any disallowed element.
-        if (isDisallowedElement(child.get()))
+        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), foundUse);
         }
     }
 }
@@ skipping 26 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;
 }
 
-static inline void removeDisallowedElementsFromSubtree(Element& subtree)
+// 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)) {
+        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);
         }
     }
 }
 
@@ skipping 26 matching lines @@
     // 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))
             return false;
 
-        if (target && isDisallowedElement(target))
+        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());
 
         // 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.
         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);
             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);
+        removeDisallowedElementsFromSubtree(*cloneParent);
 
         RefPtrWillBeRawPtr<SVGElement> replacingElement(cloneParent.get());
 
         // Replace <use> with referenced content.
         use->parentNode()->replaceChild(cloneParent.release(), use);
 
         use = Traversal<SVGUseElement>::next(*replacingElement, shadowRoot);
     }
     return true;
 }
@@ skipping 10 matching lines @@
         // '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(*symbol);
         svgElement->setCorrespondingElement(symbol->correspondingElement());
 
         // Move already cloned elements to the new <svg> element.
         moveChildrenToReplacementElement(*symbol, *svgElement);
 
-        // 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);
+        removeDisallowedElementsFromSubtree(*svgElement);
 
         RefPtrWillBeRawPtr<SVGElement> replacingElement(svgElement.get());
 
         // Replace <symbol> with <svg>.
         symbol->parentNode()->replaceChild(svgElement.release(), symbol);
 
         symbol = Traversal<SVGSymbolElement>::next(*replacingElement, shadowRoot);
     }
 }
 
@@ skipping 113 matching lines @@
 
     if (m_resource)
         m_resource->removeClient(this);
 
     m_resource = resource;
     if (m_resource)
         m_resource->addClient(this);
 }
 
 } // namespace blink