SVG objects with same idrefs conflict when under different shadow root

third_party/WebKit/Source/core/layout/svg/SVGResources.cpp

 /*
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 141 matching lines @@
     hasPendingResource = true;
     return nullptr;
   }
 
   if (!container->isSVGPaintServer())
     return nullptr;
 
   return toLayoutSVGResourcePaintServer(container);
 }
 
-static inline void registerPendingResource(SVGDocumentExtensions& extensions,
-                                           const AtomicString& id,
-                                           SVGElement* element) {
-  ASSERT(element);
-  extensions.addPendingResource(id, element);
+static inline void registerPendingResource(
+    SVGTreeScopeResources& treeScopeResources,
+    const AtomicString& id,
+    SVGElement* element) {
+  DCHECK(element);
+  treeScopeResources.addPendingResource(id, element);
 }
 
 bool SVGResources::hasResourceData() const {
   return m_clipperFilterMaskerData || m_markerData || m_fillStrokeData ||
          m_linkedResource;
 }
 
 static inline SVGResources& ensureResources(
     std::unique_ptr<SVGResources>& resources) {
   if (!resources)
@@ skipping 10 matching lines @@
   Node* node = object->node();
   ASSERT(node);
   SECURITY_DCHECK(node->isSVGElement());
 
   SVGElement* element = toSVGElement(node);
   ASSERT(element);
 
   const AtomicString& tagName = element->localName();
   ASSERT(!tagName.isNull());
 
-  TreeScope& treeScope = element->treeScope();
-  SVGDocumentExtensions& extensions = element->document().accessSVGExtensions();
+  TreeScope& treeScope = element->treeScopeForIdResolution();
+  SVGTreeScopeResources& treeScopeResources =
+      treeScope.ensureSVGTreeScopedResources();
 
   const SVGComputedStyle& style = computedStyle.svgStyle();
 
   std::unique_ptr<SVGResources> resources;
   if (clipperFilterMaskerTags().contains(tagName)) {
     if (computedStyle.clipPath() && !object->isSVGRoot()) {
       ClipPathOperation* clipPathOperation = computedStyle.clipPath();
       if (clipPathOperation->type() == ClipPathOperation::REFERENCE) {
         const ReferenceClipPathOperation& clipPathReference =
             toReferenceClipPathOperation(*clipPathOperation);
         AtomicString id = SVGURIReference::fragmentIdentifierFromIRIString(
             clipPathReference.url(), treeScope);
         if (!ensureResources(resources).setClipper(
                 getLayoutSVGResourceById<LayoutSVGResourceClipper>(treeScope,
                                                                    id)))
-          registerPendingResource(extensions, id, element);
+          registerPendingResource(treeScopeResources, id, element);
       }
     }
 
     if (computedStyle.hasFilter() && !object->isSVGRoot()) {
       const FilterOperations& filterOperations = computedStyle.filter();
       if (filterOperations.size() == 1) {
         const FilterOperation& filterOperation = *filterOperations.at(0);
         if (filterOperation.type() == FilterOperation::REFERENCE) {
           const auto& referenceFilterOperation =
               toReferenceFilterOperation(filterOperation);
           AtomicString id = SVGURIReference::fragmentIdentifierFromIRIString(
               referenceFilterOperation.url(), treeScope);
           if (!ensureResources(resources).setFilter(
                   getLayoutSVGResourceById<LayoutSVGResourceFilter>(treeScope,
                                                                     id)))
-            registerPendingResource(extensions, id, element);
+            registerPendingResource(treeScopeResources, id, element);
         }
       }
     }
 
     if (style.hasMasker()) {
       AtomicString id = style.maskerResource();
       if (!ensureResources(resources).setMasker(
               getLayoutSVGResourceById<LayoutSVGResourceMasker>(treeScope, id)))
-        registerPendingResource(extensions, id, element);
+        registerPendingResource(treeScopeResources, id, element);
     }
   }
 
   if (style.hasMarkers() && supportsMarkers(*element)) {
     const AtomicString& markerStartId = style.markerStartResource();
     if (!ensureResources(resources).setMarkerStart(
             getLayoutSVGResourceById<LayoutSVGResourceMarker>(treeScope,
                                                               markerStartId)))
-      registerPendingResource(extensions, markerStartId, element);
+      registerPendingResource(treeScopeResources, markerStartId, element);
 
     const AtomicString& markerMidId = style.markerMidResource();
     if (!ensureResources(resources).setMarkerMid(
             getLayoutSVGResourceById<LayoutSVGResourceMarker>(treeScope,
                                                               markerMidId)))
-      registerPendingResource(extensions, markerMidId, element);
+      registerPendingResource(treeScopeResources, markerMidId, element);
 
     const AtomicString& markerEndId = style.markerEndResource();
     if (!ensureResources(resources).setMarkerEnd(
             getLayoutSVGResourceById<LayoutSVGResourceMarker>(
                 treeScope, style.markerEndResource())))
-      registerPendingResource(extensions, markerEndId, element);
+      registerPendingResource(treeScopeResources, markerEndId, element);
   }
 
   if (fillAndStrokeTags().contains(tagName)) {
     if (style.hasFill()) {
       bool hasPendingResource = false;
       AtomicString id;
       LayoutSVGResourcePaintServer* resource = paintingResourceFromSVGPaint(
           treeScope, style.fillPaintType(), style.fillPaintUri(), id,
           hasPendingResource);
       if (!ensureResources(resources).setFill(resource) && hasPendingResource)
-        registerPendingResource(extensions, id, element);
+        registerPendingResource(treeScopeResources, id, element);
     }
 
     if (style.hasStroke()) {
       bool hasPendingResource = false;
       AtomicString id;
       LayoutSVGResourcePaintServer* resource = paintingResourceFromSVGPaint(
           treeScope, style.strokePaintType(), style.strokePaintUri(), id,
           hasPendingResource);
       if (!ensureResources(resources).setStroke(resource) && hasPendingResource)
-        registerPendingResource(extensions, id, element);
+        registerPendingResource(treeScopeResources, id, element);
     }
   }
 
   if (chainableResourceTags().contains(tagName)) {
     AtomicString id = targetReferenceFromResource(*element);
     if (!ensureResources(resources).setLinkedResource(
             getLayoutSVGResourceContainerById(treeScope, id)))
-      registerPendingResource(extensions, id, element);
+      registerPendingResource(treeScopeResources, id, element);
   }
 
   return (!resources || !resources->hasResourceData()) ? nullptr
                                                        : std::move(resources);
 }
 
 void SVGResources::layoutIfNeeded() {
   if (m_clipperFilterMaskerData) {
     if (LayoutSVGResourceClipper* clipper = m_clipperFilterMaskerData->clipper)
       clipper->layoutIfNeeded();
@@ skipping 376 matching lines @@
               stroke->element());
   }
 
   if (m_linkedResource)
     fprintf(stderr, " |-> xlink:href : %p (node=%p)\n", m_linkedResource,
             m_linkedResource->element());
 }
 #endif
 
 }  // namespace blink