Change the type of a SVG <use> element's shadow tree from "user agent" to "closed"

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
@@ skipping 14 matching lines @@
 
 #include "core/svg/SVGUseElement.h"
 
 #include "core/SVGNames.h"
 #include "core/XLinkNames.h"
 #include "core/dom/Document.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/IdTargetObserver.h"
 #include "core/dom/StyleChangeReason.h"
 #include "core/dom/TaskRunnerHelper.h"
+#include "core/dom/shadow/ElementShadow.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/events/Event.h"
 #include "core/layout/svg/LayoutSVGTransformableContainer.h"
 #include "core/svg/SVGGElement.h"
 #include "core/svg/SVGLengthContext.h"
 #include "core/svg/SVGSVGElement.h"
 #include "core/svg/SVGSymbolElement.h"
 #include "core/svg/SVGTitleElement.h"
 #include "core/xml/parser/XMLDocumentParser.h"
 #include "platform/loader/fetch/FetchRequest.h"
@@ skipping 28 matching lines @@
 
   addToPropertyMap(m_x);
   addToPropertyMap(m_y);
   addToPropertyMap(m_width);
   addToPropertyMap(m_height);
 }
 
 SVGUseElement* SVGUseElement::create(Document& document) {
   // Always build a user agent #shadow-root for SVGUseElement.
   SVGUseElement* use = new SVGUseElement(document);
-  use->ensureUserAgentShadowRoot();
+  use->ensureShadow().addShadowRoot(*use, ShadowRootType::Closed);
   return use;
 }
 
 SVGUseElement::~SVGUseElement() {}
 
 void SVGUseElement::dispose() {
   setDocumentResource(nullptr);
 }
 
 DEFINE_TRACE(SVGUseElement) {
@@ skipping 212 matching lines @@
   }
   if (!resourceIsValid())
     return nullptr;
   return m_resource->document()->getElementById(m_elementIdentifier);
 }
 
 void SVGUseElement::buildPendingResource() {
   if (inUseShadowTree())
     return;
   // FIXME: We should try to optimize this, to at least allow partial reclones.
-  userAgentShadowRoot()->removeChildren(OmitSubtreeModifiedEvent);
+  useShadowRoot().removeChildren(OmitSubtreeModifiedEvent);
   clearResourceReference();
   cancelShadowTreeRecreation();
   if (!isConnected())
     return;
   Element* target = resolveTargetElement();
   // TODO(fs): Why would the Element not be "connected" at this point?
   if (target && target->isConnected() && target->isSVGElement()) {
     buildShadowAndInstanceTree(toSVGElement(*target));
     invalidateDependentShadowTrees();
   }
@@ skipping 86 matching lines @@
                                     targetRoot);
   associateCorrespondingElements(targetRoot, toSVGElement(*instanceRoot));
   removeDisallowedElementsFromSubtree(toSVGElement(*instanceRoot));
   return instanceRoot;
 }
 
 void SVGUseElement::buildShadowAndInstanceTree(SVGElement& target) {
   DCHECK(!m_targetElementInstance);
   DCHECK(!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
+  // <use> creates a closed shadow root. Do not build the shadow/instance
+  // tree for <use> elements living in a closed 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.
   // Clone the target subtree into the shadow tree, not handling <use> and
   // <symbol> yet.
   Element* instanceRoot = createInstanceTree(target);
   m_targetElementInstance = toSVGElement(instanceRoot);
-  ShadowRoot* shadowTreeRootElement = userAgentShadowRoot();
-  shadowTreeRootElement->appendChild(instanceRoot);
+  ShadowRoot& shadowRoot = useShadowRoot();
+  shadowRoot.appendChild(instanceRoot);
 
   addReferencesToFirstDegreeNestedUseElements(target);
 
   if (instanceTreeIsLoading())
     return;
 
   // Assure shadow tree building was successful.
   DCHECK(m_targetElementInstance);
   DCHECK_EQ(m_targetElementInstance->correspondingUseElement(), this);
   DCHECK_EQ(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()) {
-    shadowTreeRootElement->removeChildren(OmitSubtreeModifiedEvent);
+    shadowRoot.removeChildren(OmitSubtreeModifiedEvent);
     clearResourceReference();
     return;
   }
 
   // If the instance root was a <use>, it could have been replaced now, so
   // reset |m_targetElementInstance|.
-  m_targetElementInstance =
-      toSVGElementOrDie(shadowTreeRootElement->firstChild());
-  DCHECK_EQ(m_targetElementInstance->parentNode(), shadowTreeRootElement);
+  m_targetElementInstance = toSVGElementOrDie(shadowRoot.firstChild());
+  DCHECK_EQ(m_targetElementInstance->parentNode(), shadowRoot);
 
   // Update relative length information.
   updateRelativeLengthsInformation();
 }
 
 LayoutObject* SVGUseElement::createLayoutObject(const ComputedStyle&) {
   return new LayoutSVGTransformableContainer(this);
 }
 
 static bool isDirectReference(const SVGElement& element) {
@@ skipping 16 matching lines @@
     // FIXME: Avoid manual resolution of x/y here. Its potentially harmful.
     SVGLengthContext lengthContext(this);
     path.translate(FloatSize(m_x->currentValue()->value(lengthContext),
                              m_y->currentValue()->value(lengthContext)));
     path.transform(calculateTransform(SVGElement::IncludeMotionTransform));
   }
 }
 
 SVGGraphicsElement* SVGUseElement::visibleTargetGraphicsElementForClipping()
     const {
-  Node* n = userAgentShadowRoot()->firstChild();
+  Node* n = useShadowRoot().firstChild();
   if (!n || !n->isSVGElement())
     return nullptr;
 
   SVGElement& element = toSVGElement(*n);
 
   if (!element.isSVGGraphicsElement())
     return nullptr;
 
   // Spec: "If a <use> element is a child of a clipPath element, it must
   // directly reference <path>, <text> or basic shapes elements. Indirect
@@ skipping 67 matching lines @@
 }
 
 bool SVGUseElement::expandUseElementsInShadowTree() {
   // 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.
-  ShadowRoot* shadowRoot = userAgentShadowRoot();
-  for (SVGUseElement* use = Traversal<SVGUseElement>::firstWithin(*shadowRoot);
+  ShadowRoot& shadowRoot = useShadowRoot();
+  for (SVGUseElement* use = Traversal<SVGUseElement>::firstWithin(shadowRoot);
        use;) {
     DCHECK(!use->resourceIsStillLoading());
 
     SVGUseElement& originalUse = toSVGUseElement(*use->correspondingElement());
     SVGElement* target = nullptr;
     if (hasCycleUseReferencing(originalUse, *use, target))
       return false;
 
     if (target && isDisallowedElement(*target))
       return false;
@@ skipping 10 matching lines @@
     moveChildrenToReplacementElement(*use, *cloneParent);
 
     if (target)
       cloneParent->appendChild(use->createInstanceTree(*target));
 
     SVGElement* replacingElement(cloneParent);
 
     // Replace <use> with referenced content.
     use->parentNode()->replaceChild(cloneParent, use);
 
-    use = Traversal<SVGUseElement>::next(*replacingElement, shadowRoot);
+    use = Traversal<SVGUseElement>::next(*replacingElement, &shadowRoot);
   }
   return true;
 }
 
 void SVGUseElement::invalidateShadowTree() {
   if (!inActiveDocument() || m_needsShadowTreeRecreation)
     return;
   clearInstanceRoot();
   scheduleShadowTreeRecreation();
   invalidateDependentShadowTrees();
@@ skipping 80 matching lines @@
   return m_resource && m_resource->isLoading();
 }
 
 bool SVGUseElement::resourceIsValid() const {
   return m_resource && m_resource->isLoaded() && !m_resource->errorOccurred() &&
          m_resource->document();
 }
 
 bool SVGUseElement::instanceTreeIsLoading() const {
   for (const SVGUseElement& useElement :
-       Traversal<SVGUseElement>::descendantsOf(*userAgentShadowRoot())) {
+       Traversal<SVGUseElement>::descendantsOf(useShadowRoot())) {
     if (useElement.resourceIsStillLoading())
       return true;
   }
   return false;
 }
 
 void SVGUseElement::setDocumentResource(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