Improve handling of duplicate id's for SVG resources

third_party/WebKit/Source/core/svg/SVGTreeScopeResources.cpp

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/svg/SVGTreeScopeResources.h"
 
 #include "core/dom/Element.h"
 #include "core/dom/TreeScope.h"
 #include "core/layout/svg/LayoutSVGResourceContainer.h"
 #include "core/layout/svg/SVGResourcesCache.h"
 #include "core/svg/SVGUseElement.h"
 #include "wtf/text/AtomicString.h"
 
 namespace blink {
 
-SVGTreeScopeResources::SVGTreeScopeResources(TreeScope* treeScope) {
+SVGTreeScopeResources::SVGTreeScopeResources(TreeScope* treeScope)
+    : m_treeScope(treeScope) {
   // Whenever an object of SVGTreeScopeResources is created, to keep the code
   // behave as before,
   // the document should also have an instance of SVGDocumentExtensions created.
   // Thus below line is added.
   treeScope->document().accessSVGExtensions();
 }
 
 SVGTreeScopeResources::~SVGTreeScopeResources() = default;
 
+static LayoutSVGResourceContainer* lookupResource(TreeScope& treeScope,
+                                                  const AtomicString& id) {
+  Element* element = treeScope.getElementById(id);
+  if (!element)
+    return nullptr;
+  LayoutObject* layoutObject = element->layoutObject();
+  if (!layoutObject || !layoutObject->isSVGResourceContainer())
+    return nullptr;
+  return toLayoutSVGResourceContainer(layoutObject);
+}
+
 void SVGTreeScopeResources::updateResource(
     const AtomicString& id,
     LayoutSVGResourceContainer* resource) {
   DCHECK(resource);
-  if (id.isEmpty())
+  if (resource->isRegistered() || id.isEmpty())
     return;
-  // Replaces resource if already present, to handle potential id changes.
-  m_resources.set(id, resource);
-
-  SVGPendingElements* pendingElements = m_pendingResources.take(id);
-  if (!pendingElements)
-    return;
-  // Update cached resources of pending clients.
-  for (Element* clientElement : *pendingElements) {
-    DCHECK(clientElement->hasPendingResources());
-    clearHasPendingResourcesIfPossible(*clientElement);
-
-    LayoutObject* layoutObject = clientElement->layoutObject();
-    if (!layoutObject)
-      continue;
-    DCHECK(layoutObject->isSVG());
-
-    StyleDifference diff;
-    diff.setNeedsFullLayout();
-    SVGResourcesCache::clientStyleChanged(layoutObject, diff,
-                                          layoutObject->styleRef());
-    layoutObject->setNeedsLayoutAndFullPaintInvalidation(
-        LayoutInvalidationReason::SvgResourceInvalidated);
+  // Lookup the current resource. (Could differ from what's in the map if an
+  // element was just added/removed.)
+  LayoutSVGResourceContainer* currentResource =
+      lookupResource(*m_treeScope, id);
+  // Lookup the currently registered resource.
+  auto it = m_resources.find(id);
+  if (it != m_resources.end()) {
+    // Is the local map up-to-date already?
+    if (it->value == currentResource)
+      return;
+    unregisterResource(it);
   }
+  if (currentResource)
+    registerResource(id, currentResource);
 }
 
-void SVGTreeScopeResources::removeResource(const AtomicString& id) {
-  if (id.isEmpty())
+void SVGTreeScopeResources::updateResource(
+    const AtomicString& oldId,
+    const AtomicString& newId,
+    LayoutSVGResourceContainer* resource) {
+  removeResource(oldId, resource);
+  updateResource(newId, resource);
+}
+
+void SVGTreeScopeResources::removeResource(
+    const AtomicString& id,
+    LayoutSVGResourceContainer* resource) {
+  DCHECK(resource);
+  if (!resource->isRegistered() || id.isEmpty())
     return;
-  m_resources.erase(id);
+  auto it = m_resources.find(id);
+  // If this is not the currently registered resource for this id, then do
+  // nothing.
+  if (it == m_resources.end() || it->value != resource)
+    return;
+  unregisterResource(it);
+  // If the layout tree is being torn down, then don't attempt to update the
+  // map, since that layout object is likely to be stale already.
+  if (resource->documentBeingDestroyed())
+    return;
+  // Another resource could now be current. Perform a lookup and potentially
+  // update the map.
+  LayoutSVGResourceContainer* currentResource =
+      lookupResource(*m_treeScope, id);
+  if (!currentResource)
+    return;
+  // Since this is a removal, don't allow re-adding the resource.
+  if (currentResource == resource)
+    return;
+  registerResource(id, currentResource);
+}
+
+void SVGTreeScopeResources::registerResource(
+    const AtomicString& id,
+    LayoutSVGResourceContainer* resource) {
+  DCHECK(!id.isEmpty());
+  DCHECK(resource);
+  DCHECK(!resource->isRegistered());
+
+  m_resources.set(id, resource);
+  resource->setRegistered(true);
+
+  notifyPendingClients(id);
+}
+
+void SVGTreeScopeResources::unregisterResource(ResourceMap::iterator it) {
+  LayoutSVGResourceContainer* resource = it->value;
+  DCHECK(resource);
+  DCHECK(resource->isRegistered());
+
+  resource->detachAllClients(it->key);
+
+  resource->setRegistered(false);
+  m_resources.remove(it);
 }
 
 LayoutSVGResourceContainer* SVGTreeScopeResources::resourceById(
     const AtomicString& id) const {
   if (id.isEmpty())
     return nullptr;
   return m_resources.at(id);
 }
 
 void SVGTreeScopeResources::addPendingResource(const AtomicString& id,
@@ skipping 47 matching lines @@
 
     elements->erase(&element);
     if (elements->isEmpty())
       toBeRemoved.push_back(entry.key);
   }
   m_pendingResources.removeAll(toBeRemoved);
 
   clearHasPendingResourcesIfPossible(element);
 }
 
+void SVGTreeScopeResources::notifyPendingClients(const AtomicString& id) {
+  DCHECK(!id.isEmpty());
+  SVGPendingElements* pendingElements = m_pendingResources.take(id);
+  if (!pendingElements)
+    return;
+  // Update cached resources of pending clients.
+  for (Element* clientElement : *pendingElements) {
+    DCHECK(clientElement->hasPendingResources());
+    clearHasPendingResourcesIfPossible(*clientElement);
+
+    LayoutObject* layoutObject = clientElement->layoutObject();
+    if (!layoutObject)
+      continue;
+    DCHECK(layoutObject->isSVG());
+
+    StyleDifference diff;
+    diff.setNeedsFullLayout();
+    SVGResourcesCache::clientStyleChanged(layoutObject, diff,
+                                          layoutObject->styleRef());
+    layoutObject->setNeedsLayoutAndFullPaintInvalidation(
+        LayoutInvalidationReason::SvgResourceInvalidated);
+  }
+}
+
 void SVGTreeScopeResources::notifyResourceAvailable(const AtomicString& id) {
   if (id.isEmpty())
     return;
   // Get pending elements for this id.
   SVGPendingElements* pendingElements = m_pendingResources.take(id);
   if (!pendingElements)
     return;
   // Rebuild pending resources for each client of a pending resource that is
   // being removed.
   for (Element* clientElement : *pendingElements) {
     DCHECK(clientElement->hasPendingResources());
     if (!clientElement->hasPendingResources())
       continue;
     // TODO(fs): Ideally we'd always resolve pending resources async instead of
     // inside insertedInto and svgAttributeChanged. For now we only do it for
     // <use> since that would stamp out DOM.
     if (isSVGUseElement(clientElement))
       toSVGUseElement(clientElement)->invalidateShadowTree();
     else
       clientElement->buildPendingResource();
 
     clearHasPendingResourcesIfPossible(*clientElement);
   }
 }
 
 DEFINE_TRACE(SVGTreeScopeResources) {
   visitor->trace(m_pendingResources);
+  visitor->trace(m_treeScope);
 }
 }