Store SVGElement instead of SVGElementInstance for instancesForElement

Source/core/svg/SVGElement.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2008 Rob Buis <buis@kde.org>
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Alp Toker <alp@atoker.com>
  * Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
  *
  * 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
@@ skipping 514 matching lines @@
 {
     // This function is provided for use by SVGAnimatedProperty to avoid
     // global inclusion of core/dom/Document.h in SVG code.
     return document().accessSVGExtensions();
 }
 
 void SVGElement::mapInstanceToElement(SVGElementInstance* instance)
 {
     ASSERT(instance);
 
-    HashSet<SVGElementInstance*>& instances = ensureSVGRareData()->elementInstances();
-    ASSERT(!instances.contains(instance));
+    HashSet<SVGElement*>& instances = ensureSVGRareData()->elementInstances();
+    ASSERT(!instances.contains(instance->shadowTreeElement()));
 
-    instances.add(instance);
+    instances.add(instance->shadowTreeElement());
 }
 
 void SVGElement::removeInstanceMapping(SVGElementInstance* instance)
 {
     ASSERT(instance);
     ASSERT(hasSVGRareData());
 
-    HashSet<SVGElementInstance*>& instances = svgRareData()->elementInstances();
-    ASSERT(instances.contains(instance));
+    if (!instance->shadowTreeElement())
+        return;
 
-    instances.remove(instance);
+    HashSet<SVGElement*>& instances = svgRareData()->elementInstances();
+    ASSERT(instances.contains(instance->shadowTreeElement()));
+
+    instances.remove(instance->shadowTreeElement());
 }
 
-const HashSet<SVGElementInstance*>& SVGElement::instancesForElement() const
+const HashSet<SVGElement*>& SVGElement::instancesForElement() const
 {
     if (!hasSVGRareData()) {
-        DEFINE_STATIC_LOCAL(HashSet<SVGElementInstance*>, emptyInstances, ());
+        DEFINE_STATIC_LOCAL(HashSet<SVGElement*>, emptyInstances, ());
         return emptyInstances;
     }
     return svgRareData()->elementInstances();
 }
 
 bool SVGElement::getBoundingBox(FloatRect& rect)
 {
     if (!isSVGGraphicsElement())
         return false;
 
@@ skipping 40 matching lines @@
     svgRareData()->setCursorImageValue(0);
 }
 #endif
 
 SVGElement* SVGElement::correspondingElement()
 {
     ASSERT(!hasSVGRareData() || !svgRareData()->correspondingElement() || containingShadowRoot());
     return hasSVGRareData() ? svgRareData()->correspondingElement() : 0;
 }
 
+SVGUseElement* SVGElement::correspondingUseElement()

[pdr., 2014/05/04 00:03:03]

Can we now use this in inUseShadowTree?

bool SVGElement::inUseShadowTree() const
{
    return correspondingUseElement();
}

+{
+    if (ShadowRoot* root = containingShadowRoot()) {
+        if (isSVGUseElement(root->host()) && (root->type() == ShadowRoot::UserAgentShadowRoot))
+            return toSVGUseElement(root->host());
+    }
+    return 0;
+}
+
 void SVGElement::setCorrespondingElement(SVGElement* correspondingElement)
 {
     ensureSVGRareData()->setCorrespondingElement(correspondingElement);
 }
 
 bool SVGElement::inUseShadowTree() const
 {
     if (ShadowRoot* root = containingShadowRoot())
         return isSVGUseElement(root->host()) && (root->type() == ShadowRoot::UserAgentShadowRoot);
     return false;
@@ skipping 142 matching lines @@
 
 bool SVGElement::haveLoadedRequiredResources()
 {
     for (SVGElement* child = Traversal<SVGElement>::firstChild(*this); child; child = Traversal<SVGElement>::nextSibling(*child)) {
         if (!child->haveLoadedRequiredResources())
             return false;
     }
     return true;
 }
 
-static inline void collectInstancesForSVGElement(SVGElement* element, HashSet<SVGElementInstance*>& instances)
+static inline void collectInstancesForSVGElement(SVGElement* element, HashSet<SVGElement*>& instances)
 {
     ASSERT(element);
     if (element->containingShadowRoot())
         return;
 
     ASSERT(!element->instanceUpdatesBlocked());
 
     instances = element->instancesForElement();
 }
 
 bool SVGElement::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> prpListener, bool useCapture)
 {
     RefPtr<EventListener> listener = prpListener;
 
     // Add event listener to regular DOM element
     if (!Node::addEventListener(eventType, listener, useCapture))
         return false;
 
     // Add event listener to all shadow tree DOM element instances
-    HashSet<SVGElementInstance*> instances;
+    HashSet<SVGElement*> instances;
     collectInstancesForSVGElement(this, instances);
-    const HashSet<SVGElementInstance*>::const_iterator end = instances.end();
-    for (HashSet<SVGElementInstance*>::const_iterator it = instances.begin(); it != end; ++it) {
-        ASSERT((*it)->shadowTreeElement());
-        ASSERT((*it)->correspondingElement() == this);
-
-        bool result = (*it)->shadowTreeElement()->Node::addEventListener(eventType, listener, useCapture);
+    const HashSet<SVGElement*>::const_iterator end = instances.end();
+    for (HashSet<SVGElement*>::const_iterator it = instances.begin(); it != end; ++it) {
+        bool result = (*it)->Node::addEventListener(eventType, listener, useCapture);
         ASSERT_UNUSED(result, result);
     }
 
     return true;
 }
 
 bool SVGElement::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
 {
-    HashSet<SVGElementInstance*> instances;
+    HashSet<SVGElement*> instances;
     collectInstancesForSVGElement(this, instances);
     if (instances.isEmpty())
         return Node::removeEventListener(eventType, listener, useCapture);
 
     // EventTarget::removeEventListener creates a PassRefPtr around the given EventListener
     // object when creating a temporary RegisteredEventListener object used to look up the
     // event listener in a cache. If we want to be able to call removeEventListener() multiple
     // times on different nodes, we have to delay its immediate destruction, which would happen
     // after the first call below.
     RefPtr<EventListener> protector(listener);
 
     // Remove event listener from regular DOM element
     if (!Node::removeEventListener(eventType, listener, useCapture))
         return false;
 
     // Remove event listener from all shadow tree DOM element instances
-    const HashSet<SVGElementInstance*>::const_iterator end = instances.end();
-    for (HashSet<SVGElementInstance*>::const_iterator it = instances.begin(); it != end; ++it) {
-        ASSERT((*it)->correspondingElement() == this);
-
-        SVGElement* shadowTreeElement = (*it)->shadowTreeElement();
+    const HashSet<SVGElement*>::const_iterator end = instances.end();
+    for (HashSet<SVGElement*>::const_iterator it = instances.begin(); it != end; ++it) {
+        SVGElement* shadowTreeElement = *it;
         ASSERT(shadowTreeElement);
 
         if (shadowTreeElement->Node::removeEventListener(eventType, listener, useCapture))
             continue;
 
         // This case can only be hit for event listeners created from markup
         ASSERT(listener->wasCreatedFromMarkup());
 
         // If the event listener 'listener' has been created from markup and has been fired before
         // then JSLazyEventListener::parseCode() has been called and m_jsFunction of that listener
@@ skipping 296 matching lines @@
         animatableAttributes.add(SVGNames::zAttr);
     }
 
     if (name == classAttr)
         return true;
 
     return animatableAttributes.contains(name);
 }
 #endif
 }