cac76d6b008690dde606f19d34313b318fdfa071
[WebKit-https.git] / Source / WebCore / svg / SVGElement.cpp
1 /*
2  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
3  * Copyright (C) 2004, 2005, 2006, 2008 Rob Buis <buis@kde.org>
4  * Copyright (C) 2008, 2014 Apple Inc. All rights reserved.
5  * Copyright (C) 2008 Alp Toker <alp@atoker.com>
6  * Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
7  * Copyright (C) 2013 Samsung Electronics. All rights reserved.
8  * Copyright (C) 2014 Adobe Systems Incorporated. All rights reserved.
9  *
10  * This library is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Library General Public
12  * License as published by the Free Software Foundation; either
13  * version 2 of the License, or (at your option) any later version.
14  *
15  * This library is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Library General Public License for more details.
19  *
20  * You should have received a copy of the GNU Library General Public License
21  * along with this library; see the file COPYING.LIB.  If not, write to
22  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
23  * Boston, MA 02110-1301, USA.
24  */
25
26 #include "config.h"
27 #include "SVGElement.h"
28
29 #include "CSSCursorImageValue.h"
30 #include "CSSParser.h"
31 #include "DOMImplementation.h"
32 #include "Document.h"
33 #include "ElementIterator.h"
34 #include "Event.h"
35 #include "EventNames.h"
36 #include "HTMLElement.h"
37 #include "HTMLNames.h"
38 #include "HTMLParserIdioms.h"
39 #include "RenderObject.h"
40 #include "RenderSVGResource.h"
41 #include "RenderSVGResourceFilter.h"
42 #include "RenderSVGResourceMasker.h"
43 #include "SVGCursorElement.h"
44 #include "SVGDocumentExtensions.h"
45 #include "SVGElementRareData.h"
46 #include "SVGGraphicsElement.h"
47 #include "SVGImageElement.h"
48 #include "SVGNames.h"
49 #include "SVGRenderStyle.h"
50 #include "SVGRenderSupport.h"
51 #include "SVGSVGElement.h"
52 #include "SVGTitleElement.h"
53 #include "SVGUseElement.h"
54 #include "ShadowRoot.h"
55 #include "XLinkNames.h"
56 #include "XMLNames.h"
57 #include <wtf/Assertions.h>
58 #include <wtf/HashMap.h>
59 #include <wtf/NeverDestroyed.h>
60 #include <wtf/StdLibExtras.h>
61 #include <wtf/text/WTFString.h>
62
63
64 namespace WebCore {
65
66 // Animated property definitions
67 DEFINE_ANIMATED_STRING(SVGElement, HTMLNames::classAttr, ClassName, className)
68
69 BEGIN_REGISTER_ANIMATED_PROPERTIES(SVGElement)
70     REGISTER_LOCAL_ANIMATED_PROPERTY(className)
71 END_REGISTER_ANIMATED_PROPERTIES
72
73 static NEVER_INLINE void populateAttributeNameToCSSPropertyIDMap(HashMap<AtomicStringImpl*, CSSPropertyID>& map)
74 {
75     using namespace HTMLNames;
76     using namespace SVGNames;
77
78     // This list should include all base CSS and SVG CSS properties which are exposed as SVG XML attributes.
79     static const QualifiedName* const attributeNames[] = {
80         &alignment_baselineAttr,
81         &baseline_shiftAttr,
82         &buffered_renderingAttr,
83         &clipAttr,
84         &clip_pathAttr,
85         &clip_ruleAttr,
86         &SVGNames::colorAttr,
87         &color_interpolationAttr,
88         &color_interpolation_filtersAttr,
89         &color_profileAttr,
90         &color_renderingAttr,
91         &cursorAttr,
92         &cxAttr,
93         &cyAttr,
94         &SVGNames::directionAttr,
95         &displayAttr,
96         &dominant_baselineAttr,
97         &enable_backgroundAttr,
98         &fillAttr,
99         &fill_opacityAttr,
100         &fill_ruleAttr,
101         &filterAttr,
102         &flood_colorAttr,
103         &flood_opacityAttr,
104         &font_familyAttr,
105         &font_sizeAttr,
106         &font_stretchAttr,
107         &font_styleAttr,
108         &font_variantAttr,
109         &font_weightAttr,
110         &glyph_orientation_horizontalAttr,
111         &glyph_orientation_verticalAttr,
112         &image_renderingAttr,
113         &SVGNames::heightAttr,
114         &kerningAttr,
115         &letter_spacingAttr,
116         &lighting_colorAttr,
117         &marker_endAttr,
118         &marker_midAttr,
119         &marker_startAttr,
120         &maskAttr,
121         &mask_typeAttr,
122         &opacityAttr,
123         &overflowAttr,
124         &paint_orderAttr,
125         &pointer_eventsAttr,
126         &rAttr,
127         &rxAttr,
128         &ryAttr,
129         &shape_renderingAttr,
130         &stop_colorAttr,
131         &stop_opacityAttr,
132         &strokeAttr,
133         &stroke_dasharrayAttr,
134         &stroke_dashoffsetAttr,
135         &stroke_linecapAttr,
136         &stroke_linejoinAttr,
137         &stroke_miterlimitAttr,
138         &stroke_opacityAttr,
139         &stroke_widthAttr,
140         &text_anchorAttr,
141         &text_decorationAttr,
142         &text_renderingAttr,
143         &unicode_bidiAttr,
144         &vector_effectAttr,
145         &visibilityAttr,
146         &SVGNames::widthAttr,
147         &word_spacingAttr,
148         &writing_modeAttr,
149         &xAttr,
150         &yAttr,
151     };
152
153     for (auto& name : attributeNames) {
154         const AtomicString& localName = name->localName();
155         map.add(localName.impl(), cssPropertyID(localName));
156     }
157
158     // FIXME: When CSS supports "transform-origin" this special case can be removed,
159     // and we can add transform_originAttr to the table above instead.
160     map.add(transform_originAttr.localName().impl(), CSSPropertyTransformOrigin);
161 }
162
163 static NEVER_INLINE void populateAttributeNameToAnimatedPropertyTypeMap(HashMap<QualifiedName::QualifiedNameImpl*, AnimatedPropertyType>& map)
164 {
165     using namespace HTMLNames;
166     using namespace SVGNames;
167
168     struct TableEntry {
169         const QualifiedName& attributeName;
170         AnimatedPropertyType type;
171     };
172
173     static const TableEntry table[] = {
174         { alignment_baselineAttr, AnimatedString },
175         { baseline_shiftAttr, AnimatedString },
176         { buffered_renderingAttr, AnimatedString },
177         { clipAttr, AnimatedRect },
178         { clip_pathAttr, AnimatedString },
179         { clip_ruleAttr, AnimatedString },
180         { SVGNames::colorAttr, AnimatedColor },
181         { color_interpolationAttr, AnimatedString },
182         { color_interpolation_filtersAttr, AnimatedString },
183         { color_profileAttr, AnimatedString },
184         { color_renderingAttr, AnimatedString },
185         { cursorAttr, AnimatedString },
186         { displayAttr, AnimatedString },
187         { dominant_baselineAttr, AnimatedString },
188         { fillAttr, AnimatedColor },
189         { fill_opacityAttr, AnimatedNumber },
190         { fill_ruleAttr, AnimatedString },
191         { filterAttr, AnimatedString },
192         { flood_colorAttr, AnimatedColor },
193         { flood_opacityAttr, AnimatedNumber },
194         { font_familyAttr, AnimatedString },
195         { font_sizeAttr, AnimatedLength },
196         { font_stretchAttr, AnimatedString },
197         { font_styleAttr, AnimatedString },
198         { font_variantAttr, AnimatedString },
199         { font_weightAttr, AnimatedString },
200         { image_renderingAttr, AnimatedString },
201         { kerningAttr, AnimatedLength },
202         { letter_spacingAttr, AnimatedLength },
203         { lighting_colorAttr, AnimatedColor },
204         { marker_endAttr, AnimatedString },
205         { marker_midAttr, AnimatedString },
206         { marker_startAttr, AnimatedString },
207         { maskAttr, AnimatedString },
208         { mask_typeAttr, AnimatedString },
209         { opacityAttr, AnimatedNumber },
210         { overflowAttr, AnimatedString },
211         { paint_orderAttr, AnimatedString },
212         { pointer_eventsAttr, AnimatedString },
213         { shape_renderingAttr, AnimatedString },
214         { stop_colorAttr, AnimatedColor },
215         { stop_opacityAttr, AnimatedNumber },
216         { strokeAttr, AnimatedColor },
217         { stroke_dasharrayAttr, AnimatedLengthList },
218         { stroke_dashoffsetAttr, AnimatedLength },
219         { stroke_linecapAttr, AnimatedString },
220         { stroke_linejoinAttr, AnimatedString },
221         { stroke_miterlimitAttr, AnimatedNumber },
222         { stroke_opacityAttr, AnimatedNumber },
223         { stroke_widthAttr, AnimatedLength },
224         { text_anchorAttr, AnimatedString },
225         { text_decorationAttr, AnimatedString },
226         { text_renderingAttr, AnimatedString },
227         { vector_effectAttr, AnimatedString },
228         { visibilityAttr, AnimatedString },
229         { word_spacingAttr, AnimatedLength },
230     };
231
232     for (auto& entry : table)
233         map.add(entry.attributeName.impl(), entry.type);
234 }
235
236 static inline HashMap<QualifiedName::QualifiedNameImpl*, AnimatedPropertyType>& attributeNameToAnimatedPropertyTypeMap()
237 {
238     static NeverDestroyed<HashMap<QualifiedName::QualifiedNameImpl*, AnimatedPropertyType>> map;
239     if (map.get().isEmpty())
240         populateAttributeNameToAnimatedPropertyTypeMap(map);
241     return map;
242 }
243
244 static NEVER_INLINE void populateCSSPropertyWithSVGDOMNameToAnimatedPropertyTypeMap(HashMap<QualifiedName::QualifiedNameImpl*, AnimatedPropertyType>& map)
245 {
246     using namespace HTMLNames;
247     using namespace SVGNames;
248
249     struct TableEntry {
250         const QualifiedName& attributeName;
251         AnimatedPropertyType type;
252     };
253
254     static const TableEntry table[] = {
255         { cxAttr, AnimatedLength },
256         { cyAttr, AnimatedLength },
257         { rAttr, AnimatedLength },
258         { rxAttr, AnimatedLength },
259         { ryAttr, AnimatedLength },
260         { SVGNames::heightAttr, AnimatedLength },
261         { SVGNames::widthAttr, AnimatedLength },
262         { xAttr, AnimatedLength },
263         { yAttr, AnimatedLength },
264     };
265
266     for (auto& entry : table)
267         map.add(entry.attributeName.impl(), entry.type);
268 }
269
270 static inline HashMap<QualifiedName::QualifiedNameImpl*, AnimatedPropertyType>& cssPropertyWithSVGDOMNameToAnimatedPropertyTypeMap()
271 {
272     static NeverDestroyed<HashMap<QualifiedName::QualifiedNameImpl*, AnimatedPropertyType>> map;
273     if (map.get().isEmpty())
274         populateCSSPropertyWithSVGDOMNameToAnimatedPropertyTypeMap(map);
275     return map;
276 }
277
278 SVGElement::SVGElement(const QualifiedName& tagName, Document& document)
279     : StyledElement(tagName, document, CreateSVGElement)
280 {
281     registerAnimatedPropertiesForSVGElement();
282 }
283
284 SVGElement::~SVGElement()
285 {
286     if (m_svgRareData) {
287         for (SVGElement* instance : m_svgRareData->instances())
288             instance->m_svgRareData->setCorrespondingElement(nullptr);
289         if (SVGCursorElement* cursorElement = m_svgRareData->cursorElement())
290             cursorElement->removeClient(this);
291         if (CSSCursorImageValue* cursorImageValue = m_svgRareData->cursorImageValue())
292             cursorImageValue->removeReferencedElement(this);
293         if (SVGElement* correspondingElement = m_svgRareData->correspondingElement())
294             correspondingElement->m_svgRareData->instances().remove(this);
295
296         m_svgRareData = nullptr;
297     }
298     document().accessSVGExtensions().rebuildAllElementReferencesForTarget(*this);
299     document().accessSVGExtensions().removeAllElementReferencesForTarget(this);
300 }
301
302 short SVGElement::tabIndex() const
303 {
304     if (supportsFocus())
305         return Element::tabIndex();
306     return -1;
307 }
308
309 bool SVGElement::willRecalcStyle(Style::Change change)
310 {
311     if (!m_svgRareData || styleChangeType() == SyntheticStyleChange)
312         return true;
313     // If the style changes because of a regular property change (not induced by SMIL animations themselves)
314     // reset the "computed style without SMIL style properties", so the base value change gets reflected.
315     if (change > Style::NoChange || needsStyleRecalc())
316         m_svgRareData->setNeedsOverrideComputedStyleUpdate();
317     return true;
318 }
319
320 SVGElementRareData& SVGElement::ensureSVGRareData()
321 {
322     if (!m_svgRareData)
323         m_svgRareData = std::make_unique<SVGElementRareData>();
324     return *m_svgRareData;
325 }
326
327 bool SVGElement::isOutermostSVGSVGElement() const
328 {
329     if (!is<SVGSVGElement>(*this))
330         return false;
331
332     // If we're living in a shadow tree, we're a <svg> element that got created as replacement
333     // for a <symbol> element or a cloned <svg> element in the referenced tree. In that case
334     // we're always an inner <svg> element.
335     if (isInShadowTree() && parentOrShadowHostElement() && parentOrShadowHostElement()->isSVGElement())
336         return false;
337
338     // Element may not be in the document, pretend we're outermost for viewport(), getCTM(), etc.
339     if (!parentNode())
340         return true;
341
342     // We act like an outermost SVG element, if we're a direct child of a <foreignObject> element.
343     if (parentNode()->hasTagName(SVGNames::foreignObjectTag))
344         return true;
345
346     // This is true whenever this is the outermost SVG, even if there are HTML elements outside it
347     return !parentNode()->isSVGElement();
348 }
349
350 void SVGElement::reportAttributeParsingError(SVGParsingError error, const QualifiedName& name, const AtomicString& value)
351 {
352     if (error == NoError)
353         return;
354
355     String errorString = "<" + tagName() + "> attribute " + name.toString() + "=\"" + value + "\"";
356     SVGDocumentExtensions& extensions = document().accessSVGExtensions();
357
358     if (error == NegativeValueForbiddenError) {
359         extensions.reportError("Invalid negative value for " + errorString);
360         return;
361     }
362
363     if (error == ParsingAttributeFailedError) {
364         extensions.reportError("Invalid value for " + errorString);
365         return;
366     }
367
368     ASSERT_NOT_REACHED();
369 }
370
371 bool SVGElement::isSupported(StringImpl* feature, StringImpl* version) const
372 {
373     return DOMImplementation::hasFeature(feature, version);
374 }
375
376 String SVGElement::xmlbase() const
377 {
378     return fastGetAttribute(XMLNames::baseAttr);
379 }
380
381 void SVGElement::setXmlbase(const String& value, ExceptionCode&)
382 {
383     setAttribute(XMLNames::baseAttr, value);
384 }
385
386 void SVGElement::removedFrom(ContainerNode& rootParent)
387 {
388     bool wasInDocument = rootParent.inDocument();
389     if (wasInDocument)
390         updateRelativeLengthsInformation(false, this);
391
392     StyledElement::removedFrom(rootParent);
393
394     if (wasInDocument) {
395         document().accessSVGExtensions().clearTargetDependencies(*this);
396         document().accessSVGExtensions().removeAllElementReferencesForTarget(this);
397     }
398     invalidateInstances();
399 }
400
401 SVGSVGElement* SVGElement::ownerSVGElement() const
402 {
403     ContainerNode* node = parentOrShadowHostNode();
404     while (node) {
405         if (is<SVGSVGElement>(*node))
406             return downcast<SVGSVGElement>(node);
407
408         node = node->parentOrShadowHostNode();
409     }
410
411     return nullptr;
412 }
413
414 SVGElement* SVGElement::viewportElement() const
415 {
416     // This function needs shadow tree support - as RenderSVGContainer uses this function
417     // to determine the "overflow" property. <use> on <symbol> wouldn't work otherwhise.
418     ContainerNode* node = parentOrShadowHostNode();
419     while (node) {
420         if (is<SVGSVGElement>(*node) || is<SVGImageElement>(*node) || node->hasTagName(SVGNames::symbolTag))
421             return downcast<SVGElement>(node);
422
423         node = node->parentOrShadowHostNode();
424     }
425
426     return nullptr;
427 }
428  
429 const HashSet<SVGElement*>& SVGElement::instances() const
430 {
431     if (!m_svgRareData) {
432         static NeverDestroyed<HashSet<SVGElement*>> emptyInstances;
433         return emptyInstances;
434     }
435     return m_svgRareData->instances();
436 }
437
438 bool SVGElement::getBoundingBox(FloatRect& rect, SVGLocatable::StyleUpdateStrategy styleUpdateStrategy)
439 {
440     if (is<SVGGraphicsElement>(*this)) {
441         rect = downcast<SVGGraphicsElement>(*this).getBBox(styleUpdateStrategy);
442         return true;
443     }
444     return false;
445 }
446
447 void SVGElement::setCursorElement(SVGCursorElement* cursorElement)
448 {
449     SVGElementRareData& rareData = ensureSVGRareData();
450     if (SVGCursorElement* oldCursorElement = rareData.cursorElement()) {
451         if (cursorElement == oldCursorElement)
452             return;
453         oldCursorElement->removeReferencedElement(this);
454     }
455     rareData.setCursorElement(cursorElement);
456 }
457
458 void SVGElement::cursorElementRemoved() 
459 {
460     ASSERT(m_svgRareData);
461     m_svgRareData->setCursorElement(nullptr);
462 }
463
464 void SVGElement::setCursorImageValue(CSSCursorImageValue* cursorImageValue)
465 {
466     SVGElementRareData& rareData = ensureSVGRareData();
467     if (CSSCursorImageValue* oldCursorImageValue = rareData.cursorImageValue()) {
468         if (cursorImageValue == oldCursorImageValue)
469             return;
470         oldCursorImageValue->removeReferencedElement(this);
471     }
472     rareData.setCursorImageValue(cursorImageValue);
473 }
474
475 void SVGElement::cursorImageValueRemoved()
476 {
477     ASSERT(m_svgRareData);
478     m_svgRareData->setCursorImageValue(nullptr);
479 }
480
481 SVGElement* SVGElement::correspondingElement() const
482 {
483     return m_svgRareData ? m_svgRareData->correspondingElement() : nullptr;
484 }
485
486 SVGUseElement* SVGElement::correspondingUseElement() const
487 {
488     auto* root = containingShadowRoot();
489     if (!root)
490         return nullptr;
491     if (root->type() != ShadowRoot::UserAgentShadowRoot)
492         return nullptr;
493     auto* host = root->host();
494     if (!is<SVGUseElement>(host))
495         return nullptr;
496     return &downcast<SVGUseElement>(*host);
497 }
498
499 void SVGElement::setCorrespondingElement(SVGElement* correspondingElement)
500 {
501     if (m_svgRareData) {
502         if (SVGElement* oldCorrespondingElement = m_svgRareData->correspondingElement())
503             oldCorrespondingElement->m_svgRareData->instances().remove(this);
504     }
505     if (m_svgRareData || correspondingElement)
506         ensureSVGRareData().setCorrespondingElement(correspondingElement);
507     if (correspondingElement)
508         correspondingElement->ensureSVGRareData().instances().add(this);
509 }
510
511 void SVGElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
512 {
513     if (name == HTMLNames::classAttr) {
514         setClassNameBaseValue(value);
515         return;
516     }
517
518     if (name == HTMLNames::tabindexAttr) {
519         int tabindex = 0;
520         if (value.isEmpty())
521             clearTabIndexExplicitlyIfNeeded();
522         else if (parseHTMLInteger(value, tabindex)) {
523             // Clamp tabindex to the range of 'short' to match Firefox's behavior.
524             setTabIndexExplicitly(std::max(static_cast<int>(std::numeric_limits<short>::min()), std::min(tabindex, static_cast<int>(std::numeric_limits<short>::max()))));
525         }
526         return;
527     }
528
529     auto& eventName = HTMLElement::eventNameForEventHandlerAttribute(name);
530     if (!eventName.isNull()) {
531         setAttributeEventListener(eventName, name, value);
532         return;
533     }
534
535     SVGLangSpace::parseAttribute(name, value);
536 }
537
538 Vector<AnimatedPropertyType> SVGElement::animatedPropertyTypesForAttribute(const QualifiedName& attributeName)
539 {
540     auto types = localAttributeToPropertyMap().types(attributeName);
541     if (!types.isEmpty())
542         return types;
543
544     {
545         auto& map = attributeNameToAnimatedPropertyTypeMap();
546         auto it = map.find(attributeName.impl());
547         if (it != map.end()) {
548             types.append(it->value);
549             return types;
550         }
551     }
552
553     {
554         auto& map = cssPropertyWithSVGDOMNameToAnimatedPropertyTypeMap();
555         auto it = map.find(attributeName.impl());
556         if (it != map.end()) {
557             types.append(it->value);
558             return types;
559         }
560     }
561
562     return types;
563 }
564
565 bool SVGElement::haveLoadedRequiredResources()
566 {
567     for (auto& child : childrenOfType<SVGElement>(*this)) {
568         if (!child.haveLoadedRequiredResources())
569             return false;
570     }
571     return true;
572 }
573
574 bool SVGElement::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> prpListener, bool useCapture)
575 {
576     RefPtr<EventListener> listener = prpListener;
577     
578     // Add event listener to regular DOM element
579     if (!Node::addEventListener(eventType, listener, useCapture))
580         return false;
581
582     if (containingShadowRoot())
583         return true;
584
585     // Add event listener to all shadow tree DOM element instances
586     ASSERT(!instanceUpdatesBlocked());
587     for (auto* instance : instances()) {
588         ASSERT(instance->correspondingElement() == this);
589         bool result = instance->Node::addEventListener(eventType, listener, useCapture);
590         ASSERT_UNUSED(result, result);
591     }
592
593     return true;
594 }
595
596 bool SVGElement::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
597 {
598     if (containingShadowRoot())
599         return Node::removeEventListener(eventType, listener, useCapture);
600
601     // EventTarget::removeEventListener creates a PassRefPtr around the given EventListener
602     // object when creating a temporary RegisteredEventListener object used to look up the
603     // event listener in a cache. If we want to be able to call removeEventListener() multiple
604     // times on different nodes, we have to delay its immediate destruction, which would happen
605     // after the first call below.
606     RefPtr<EventListener> protector(listener);
607
608     // Remove event listener from regular DOM element
609     if (!Node::removeEventListener(eventType, listener, useCapture))
610         return false;
611
612     // Remove event listener from all shadow tree DOM element instances
613     ASSERT(!instanceUpdatesBlocked());
614     for (auto& instance : instances()) {
615         ASSERT(instance->correspondingElement() == this);
616
617         if (instance->Node::removeEventListener(eventType, listener, useCapture))
618             continue;
619
620         // This case can only be hit for event listeners created from markup
621         ASSERT(listener->wasCreatedFromMarkup());
622
623         // If the event listener 'listener' has been created from markup and has been fired before
624         // then JSLazyEventListener::parseCode() has been called and m_jsFunction of that listener
625         // has been created (read: it's not 0 anymore). During shadow tree creation, the event
626         // listener DOM attribute has been cloned, and another event listener has been setup in
627         // the shadow tree. If that event listener has not been used yet, m_jsFunction is still 0,
628         // and tryRemoveEventListener() above will fail. Work around that very rare problem.
629         ASSERT(instance->eventTargetData());
630         instance->eventTargetData()->eventListenerMap.removeFirstEventListenerCreatedFromMarkup(eventType);
631     }
632
633     return true;
634 }
635
636 static bool hasLoadListener(Element* element)
637 {
638     if (element->hasEventListeners(eventNames().loadEvent))
639         return true;
640
641     for (element = element->parentOrShadowHostElement(); element; element = element->parentOrShadowHostElement()) {
642         const EventListenerVector& entry = element->getEventListeners(eventNames().loadEvent);
643         for (auto& listener : entry) {
644             if (listener.useCapture)
645                 return true;
646         }
647     }
648
649     return false;
650 }
651
652 #if ENABLE(CSS_REGIONS)
653 bool SVGElement::shouldMoveToFlowThread(const RenderStyle& styleToUse) const
654 {
655     // Allow only svg root elements to be directly collected by a render flow thread.
656     return parentNode() && !parentNode()->isSVGElement() && hasTagName(SVGNames::svgTag) && Element::shouldMoveToFlowThread(styleToUse);
657 }
658 #endif
659
660 void SVGElement::sendSVGLoadEventIfPossible(bool sendParentLoadEvents)
661 {
662     RefPtr<SVGElement> currentTarget = this;
663     while (currentTarget && currentTarget->haveLoadedRequiredResources()) {
664         RefPtr<Element> parent;
665         if (sendParentLoadEvents)
666             parent = currentTarget->parentOrShadowHostElement(); // save the next parent to dispatch too incase dispatching the event changes the tree
667         if (hasLoadListener(currentTarget.get()))
668             currentTarget->dispatchEvent(Event::create(eventNames().loadEvent, false, false));
669         currentTarget = (parent && parent->isSVGElement()) ? static_pointer_cast<SVGElement>(parent) : RefPtr<SVGElement>();
670         SVGElement* element = currentTarget.get();
671         if (!element || !element->isOutermostSVGSVGElement())
672             continue;
673
674         // Consider <svg onload="foo()"><image xlink:href="foo.png" externalResourcesRequired="true"/></svg>.
675         // If foo.png is not yet loaded, the first SVGLoad event will go to the <svg> element, sent through
676         // Document::implicitClose(). Then the SVGLoad event will fire for <image>, once its loaded.
677         ASSERT(sendParentLoadEvents);
678
679         // If the load event was not sent yet by Document::implicitClose(), but the <image> from the example
680         // above, just appeared, don't send the SVGLoad event to the outermost <svg>, but wait for the document
681         // to be "ready to render", first.
682         if (!document().loadEventFinished())
683             break;
684     }
685 }
686
687 void SVGElement::sendSVGLoadEventIfPossibleAsynchronously()
688 {
689     svgLoadEventTimer()->startOneShot(0);
690 }
691
692 void SVGElement::svgLoadEventTimerFired()
693 {
694     sendSVGLoadEventIfPossible();
695 }
696
697 Timer* SVGElement::svgLoadEventTimer()
698 {
699     ASSERT_NOT_REACHED();
700     return 0;
701 }
702
703 void SVGElement::finishParsingChildren()
704 {
705     StyledElement::finishParsingChildren();
706
707     // The outermost SVGSVGElement SVGLoad event is fired through Document::dispatchWindowLoadEvent.
708     if (isOutermostSVGSVGElement())
709         return;
710
711     // finishParsingChildren() is called when the close tag is reached for an element (e.g. </svg>)
712     // we send SVGLoad events here if we can, otherwise they'll be sent when any required loads finish
713     sendSVGLoadEventIfPossible();
714
715     // Notify all the elements which have references to this element to rebuild their shadow and render
716     // trees, e.g. a <use> element references a target element before this target element is defined.
717     invalidateInstances();
718 }
719
720 bool SVGElement::childShouldCreateRenderer(const Node& child) const
721 {
722     static NeverDestroyed<HashSet<QualifiedName>> invalidTextContent;
723
724     if (invalidTextContent.get().isEmpty()) {
725         invalidTextContent.get().add(SVGNames::textPathTag);
726 #if ENABLE(SVG_FONTS)
727         invalidTextContent.get().add(SVGNames::altGlyphTag);
728 #endif
729         invalidTextContent.get().add(SVGNames::trefTag);
730         invalidTextContent.get().add(SVGNames::tspanTag);
731     }
732     if (child.isSVGElement()) {
733         const SVGElement& svgChild = downcast<SVGElement>(child);
734         if (invalidTextContent.get().contains(svgChild.tagQName()))
735             return false;
736
737         return svgChild.isValid();
738     }
739     return false;
740 }
741
742 void SVGElement::attributeChanged(const QualifiedName& name, const AtomicString& oldValue, const AtomicString& newValue, AttributeModificationReason)
743 {
744     StyledElement::attributeChanged(name, oldValue, newValue);
745
746     if (name == HTMLNames::idAttr)
747         document().accessSVGExtensions().rebuildAllElementReferencesForTarget(*this);
748
749     // Changes to the style attribute are processed lazily (see Element::getAttribute() and related methods),
750     // so we don't want changes to the style attribute to result in extra work here.
751     if (name != HTMLNames::styleAttr)
752         svgAttributeChanged(name);
753 }
754
755 void SVGElement::synchronizeAllAnimatedSVGAttribute(SVGElement* svgElement)
756 {
757     ASSERT(svgElement->elementData());
758     ASSERT(svgElement->elementData()->animatedSVGAttributesAreDirty());
759
760     svgElement->localAttributeToPropertyMap().synchronizeProperties(*svgElement);
761     svgElement->elementData()->setAnimatedSVGAttributesAreDirty(false);
762 }
763
764 void SVGElement::synchronizeAnimatedSVGAttribute(const QualifiedName& name) const
765 {
766     if (!elementData() || !elementData()->animatedSVGAttributesAreDirty())
767         return;
768
769     SVGElement* nonConstThis = const_cast<SVGElement*>(this);
770     if (name == anyQName())
771         synchronizeAllAnimatedSVGAttribute(nonConstThis);
772     else
773         nonConstThis->localAttributeToPropertyMap().synchronizeProperty(*nonConstThis, name);
774 }
775
776 void SVGElement::synchronizeRequiredFeatures(SVGElement* contextElement)
777 {
778     ASSERT(contextElement);
779     contextElement->synchronizeRequiredFeatures();
780 }
781
782 void SVGElement::synchronizeRequiredExtensions(SVGElement* contextElement)
783 {
784     ASSERT(contextElement);
785     contextElement->synchronizeRequiredExtensions();
786 }
787
788 void SVGElement::synchronizeSystemLanguage(SVGElement* contextElement)
789 {
790     ASSERT(contextElement);
791     contextElement->synchronizeSystemLanguage();
792 }
793
794 RefPtr<RenderStyle> SVGElement::customStyleForRenderer(RenderStyle& parentStyle)
795 {
796     if (!correspondingElement())
797         return document().ensureStyleResolver().styleForElement(this, &parentStyle);
798
799     return document().ensureStyleResolver().styleForElement(correspondingElement(), &parentStyle, DisallowStyleSharing);
800 }
801
802 MutableStyleProperties* SVGElement::animatedSMILStyleProperties() const
803 {
804     if (m_svgRareData)
805         return m_svgRareData->animatedSMILStyleProperties();
806     return 0;
807 }
808
809 MutableStyleProperties& SVGElement::ensureAnimatedSMILStyleProperties()
810 {
811     return ensureSVGRareData().ensureAnimatedSMILStyleProperties();
812 }
813
814 void SVGElement::setUseOverrideComputedStyle(bool value)
815 {
816     if (m_svgRareData)
817         m_svgRareData->setUseOverrideComputedStyle(value);
818 }
819
820 RenderStyle* SVGElement::computedStyle(PseudoId pseudoElementSpecifier)
821 {
822     if (!m_svgRareData || !m_svgRareData->useOverrideComputedStyle())
823         return Element::computedStyle(pseudoElementSpecifier);
824
825     RenderStyle* parentStyle = nullptr;
826     if (Element* parent = parentOrShadowHostElement()) {
827         if (auto renderer = parent->renderer())
828             parentStyle = &renderer->style();
829     }
830
831     return m_svgRareData->overrideComputedStyle(this, parentStyle);
832 }
833
834 static void addQualifiedName(HashMap<AtomicString, QualifiedName>& map, const QualifiedName& name)
835 {
836     HashMap<AtomicString, QualifiedName>::AddResult addResult = map.add(name.localName(), name);
837     ASSERT_UNUSED(addResult, addResult.isNewEntry);
838 }
839
840 QualifiedName SVGElement::animatableAttributeForName(const AtomicString& localName)
841 {
842     static NeverDestroyed<HashMap<AtomicString, QualifiedName>> neverDestroyedAnimatableAttributes;
843     HashMap<AtomicString, QualifiedName>& animatableAttributes = neverDestroyedAnimatableAttributes;
844
845     if (animatableAttributes.isEmpty()) {
846         addQualifiedName(animatableAttributes, HTMLNames::classAttr);
847         addQualifiedName(animatableAttributes, SVGNames::amplitudeAttr);
848         addQualifiedName(animatableAttributes, SVGNames::azimuthAttr);
849         addQualifiedName(animatableAttributes, SVGNames::baseFrequencyAttr);
850         addQualifiedName(animatableAttributes, SVGNames::biasAttr);
851         addQualifiedName(animatableAttributes, SVGNames::clipPathUnitsAttr);
852         addQualifiedName(animatableAttributes, SVGNames::cxAttr);
853         addQualifiedName(animatableAttributes, SVGNames::cyAttr);
854         addQualifiedName(animatableAttributes, SVGNames::diffuseConstantAttr);
855         addQualifiedName(animatableAttributes, SVGNames::divisorAttr);
856         addQualifiedName(animatableAttributes, SVGNames::dxAttr);
857         addQualifiedName(animatableAttributes, SVGNames::dyAttr);
858         addQualifiedName(animatableAttributes, SVGNames::edgeModeAttr);
859         addQualifiedName(animatableAttributes, SVGNames::elevationAttr);
860         addQualifiedName(animatableAttributes, SVGNames::exponentAttr);
861         addQualifiedName(animatableAttributes, SVGNames::externalResourcesRequiredAttr);
862         addQualifiedName(animatableAttributes, SVGNames::filterResAttr);
863         addQualifiedName(animatableAttributes, SVGNames::filterUnitsAttr);
864         addQualifiedName(animatableAttributes, SVGNames::fxAttr);
865         addQualifiedName(animatableAttributes, SVGNames::fyAttr);
866         addQualifiedName(animatableAttributes, SVGNames::gradientTransformAttr);
867         addQualifiedName(animatableAttributes, SVGNames::gradientUnitsAttr);
868         addQualifiedName(animatableAttributes, SVGNames::heightAttr);
869         addQualifiedName(animatableAttributes, SVGNames::in2Attr);
870         addQualifiedName(animatableAttributes, SVGNames::inAttr);
871         addQualifiedName(animatableAttributes, SVGNames::interceptAttr);
872         addQualifiedName(animatableAttributes, SVGNames::k1Attr);
873         addQualifiedName(animatableAttributes, SVGNames::k2Attr);
874         addQualifiedName(animatableAttributes, SVGNames::k3Attr);
875         addQualifiedName(animatableAttributes, SVGNames::k4Attr);
876         addQualifiedName(animatableAttributes, SVGNames::kernelMatrixAttr);
877         addQualifiedName(animatableAttributes, SVGNames::kernelUnitLengthAttr);
878         addQualifiedName(animatableAttributes, SVGNames::lengthAdjustAttr);
879         addQualifiedName(animatableAttributes, SVGNames::limitingConeAngleAttr);
880         addQualifiedName(animatableAttributes, SVGNames::markerHeightAttr);
881         addQualifiedName(animatableAttributes, SVGNames::markerUnitsAttr);
882         addQualifiedName(animatableAttributes, SVGNames::markerWidthAttr);
883         addQualifiedName(animatableAttributes, SVGNames::maskContentUnitsAttr);
884         addQualifiedName(animatableAttributes, SVGNames::maskUnitsAttr);
885         addQualifiedName(animatableAttributes, SVGNames::methodAttr);
886         addQualifiedName(animatableAttributes, SVGNames::modeAttr);
887         addQualifiedName(animatableAttributes, SVGNames::numOctavesAttr);
888         addQualifiedName(animatableAttributes, SVGNames::offsetAttr);
889         addQualifiedName(animatableAttributes, SVGNames::operatorAttr);
890         addQualifiedName(animatableAttributes, SVGNames::orderAttr);
891         addQualifiedName(animatableAttributes, SVGNames::orientAttr);
892         addQualifiedName(animatableAttributes, SVGNames::pathLengthAttr);
893         addQualifiedName(animatableAttributes, SVGNames::patternContentUnitsAttr);
894         addQualifiedName(animatableAttributes, SVGNames::patternTransformAttr);
895         addQualifiedName(animatableAttributes, SVGNames::patternUnitsAttr);
896         addQualifiedName(animatableAttributes, SVGNames::pointsAtXAttr);
897         addQualifiedName(animatableAttributes, SVGNames::pointsAtYAttr);
898         addQualifiedName(animatableAttributes, SVGNames::pointsAtZAttr);
899         addQualifiedName(animatableAttributes, SVGNames::preserveAlphaAttr);
900         addQualifiedName(animatableAttributes, SVGNames::preserveAspectRatioAttr);
901         addQualifiedName(animatableAttributes, SVGNames::primitiveUnitsAttr);
902         addQualifiedName(animatableAttributes, SVGNames::radiusAttr);
903         addQualifiedName(animatableAttributes, SVGNames::rAttr);
904         addQualifiedName(animatableAttributes, SVGNames::refXAttr);
905         addQualifiedName(animatableAttributes, SVGNames::refYAttr);
906         addQualifiedName(animatableAttributes, SVGNames::resultAttr);
907         addQualifiedName(animatableAttributes, SVGNames::rotateAttr);
908         addQualifiedName(animatableAttributes, SVGNames::rxAttr);
909         addQualifiedName(animatableAttributes, SVGNames::ryAttr);
910         addQualifiedName(animatableAttributes, SVGNames::scaleAttr);
911         addQualifiedName(animatableAttributes, SVGNames::seedAttr);
912         addQualifiedName(animatableAttributes, SVGNames::slopeAttr);
913         addQualifiedName(animatableAttributes, SVGNames::spacingAttr);
914         addQualifiedName(animatableAttributes, SVGNames::specularConstantAttr);
915         addQualifiedName(animatableAttributes, SVGNames::specularExponentAttr);
916         addQualifiedName(animatableAttributes, SVGNames::spreadMethodAttr);
917         addQualifiedName(animatableAttributes, SVGNames::startOffsetAttr);
918         addQualifiedName(animatableAttributes, SVGNames::stdDeviationAttr);
919         addQualifiedName(animatableAttributes, SVGNames::stitchTilesAttr);
920         addQualifiedName(animatableAttributes, SVGNames::surfaceScaleAttr);
921         addQualifiedName(animatableAttributes, SVGNames::tableValuesAttr);
922         addQualifiedName(animatableAttributes, SVGNames::targetAttr);
923         addQualifiedName(animatableAttributes, SVGNames::targetXAttr);
924         addQualifiedName(animatableAttributes, SVGNames::targetYAttr);
925         addQualifiedName(animatableAttributes, SVGNames::transformAttr);
926         addQualifiedName(animatableAttributes, SVGNames::typeAttr);
927         addQualifiedName(animatableAttributes, SVGNames::valuesAttr);
928         addQualifiedName(animatableAttributes, SVGNames::viewBoxAttr);
929         addQualifiedName(animatableAttributes, SVGNames::widthAttr);
930         addQualifiedName(animatableAttributes, SVGNames::x1Attr);
931         addQualifiedName(animatableAttributes, SVGNames::x2Attr);
932         addQualifiedName(animatableAttributes, SVGNames::xAttr);
933         addQualifiedName(animatableAttributes, SVGNames::xChannelSelectorAttr);
934         addQualifiedName(animatableAttributes, SVGNames::y1Attr);
935         addQualifiedName(animatableAttributes, SVGNames::y2Attr);
936         addQualifiedName(animatableAttributes, SVGNames::yAttr);
937         addQualifiedName(animatableAttributes, SVGNames::yChannelSelectorAttr);
938         addQualifiedName(animatableAttributes, SVGNames::zAttr);
939         addQualifiedName(animatableAttributes, XLinkNames::hrefAttr);
940     }
941     return animatableAttributes.get(localName);
942 }
943
944 #ifndef NDEBUG
945 bool SVGElement::isAnimatableAttribute(const QualifiedName& name) const
946 {
947     if (SVGElement::animatableAttributeForName(name.localName()) == name)
948         return !filterOutAnimatableAttribute(name);
949     return false;
950 }
951
952 bool SVGElement::filterOutAnimatableAttribute(const QualifiedName&) const
953 {
954     return false;
955 }
956 #endif
957
958 String SVGElement::title() const
959 {
960     // According to spec, for stand-alone SVG documents we should not return a title when
961     // hovering over the rootmost SVG element (the first <title> element is the title of
962     // the document, not a tooltip) so we instantly return.
963     if (isOutermostSVGSVGElement() && document().topDocument().isSVGDocument())
964         return String();
965     auto firstTitle = childrenOfType<SVGTitleElement>(*this).first();
966     return firstTitle ? const_cast<SVGTitleElement*>(firstTitle)->innerText() : String();
967 }
968
969 bool SVGElement::rendererIsNeeded(const RenderStyle& style)
970 {
971     // http://www.w3.org/TR/SVG/extend.html#PrivateData
972     // Prevent anything other than SVG renderers from appearing in our render tree
973     // Spec: SVG allows inclusion of elements from foreign namespaces anywhere
974     // with the SVG content. In general, the SVG user agent will include the unknown
975     // elements in the DOM but will otherwise ignore unknown elements.
976     if (!parentOrShadowHostElement() || parentOrShadowHostElement()->isSVGElement())
977         return StyledElement::rendererIsNeeded(style);
978
979     return false;
980 }
981
982 CSSPropertyID SVGElement::cssPropertyIdForSVGAttributeName(const QualifiedName& attrName)
983 {
984     if (!attrName.namespaceURI().isNull())
985         return CSSPropertyInvalid;
986
987     static NeverDestroyed<HashMap<AtomicStringImpl*, CSSPropertyID>> properties;
988     if (properties.get().isEmpty())
989         populateAttributeNameToCSSPropertyIDMap(properties.get());
990
991     return properties.get().get(attrName.localName().impl());
992 }
993
994 bool SVGElement::isAnimatableCSSProperty(const QualifiedName& attributeName)
995 {
996     return attributeNameToAnimatedPropertyTypeMap().contains(attributeName.impl())
997         || cssPropertyWithSVGDOMNameToAnimatedPropertyTypeMap().contains(attributeName.impl());
998 }
999
1000 bool SVGElement::isPresentationAttributeWithSVGDOM(const QualifiedName& attributeName)
1001 {
1002     return !localAttributeToPropertyMap().types(attributeName).isEmpty();
1003 }
1004
1005 bool SVGElement::isPresentationAttribute(const QualifiedName& name) const
1006 {
1007     if (cssPropertyIdForSVGAttributeName(name) > 0)
1008         return true;
1009     return StyledElement::isPresentationAttribute(name);
1010 }
1011
1012 void SVGElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStyleProperties& style)
1013 {
1014     CSSPropertyID propertyID = cssPropertyIdForSVGAttributeName(name);
1015     if (propertyID > 0)
1016         addPropertyToPresentationAttributeStyle(style, propertyID, value);
1017 }
1018
1019 bool SVGElement::isKnownAttribute(const QualifiedName& attrName)
1020 {
1021     return attrName == HTMLNames::idAttr;
1022 }
1023
1024 void SVGElement::svgAttributeChanged(const QualifiedName& attrName)
1025 {
1026     CSSPropertyID propId = cssPropertyIdForSVGAttributeName(attrName);
1027     if (propId > 0) {
1028         invalidateInstances();
1029         return;
1030     }
1031
1032     if (attrName == HTMLNames::classAttr) {
1033         classAttributeChanged(className());
1034         invalidateInstances();
1035         return;
1036     }
1037
1038     if (attrName == HTMLNames::idAttr) {
1039         auto renderer = this->renderer();
1040         // Notify resources about id changes, this is important as we cache resources by id in SVGDocumentExtensions
1041         if (is<RenderSVGResourceContainer>(renderer))
1042             downcast<RenderSVGResourceContainer>(*renderer).idChanged();
1043         if (inDocument())
1044             buildPendingResourcesIfNeeded();
1045         invalidateInstances();
1046         return;
1047     }
1048 }
1049
1050 Node::InsertionNotificationRequest SVGElement::insertedInto(ContainerNode& rootParent)
1051 {
1052     StyledElement::insertedInto(rootParent);
1053     updateRelativeLengthsInformation();
1054     buildPendingResourcesIfNeeded();
1055     return InsertionDone;
1056 }
1057
1058 void SVGElement::buildPendingResourcesIfNeeded()
1059 {
1060     if (!needsPendingResourceHandling() || !inDocument() || isInShadowTree())
1061         return;
1062
1063     SVGDocumentExtensions& extensions = document().accessSVGExtensions();
1064     String resourceId = getIdAttribute();
1065     if (!extensions.isIdOfPendingResource(resourceId))
1066         return;
1067
1068     // Mark pending resources as pending for removal.
1069     extensions.markPendingResourcesForRemoval(resourceId);
1070
1071     // Rebuild pending resources for each client of a pending resource that is being removed.
1072     while (Element* clientElement = extensions.removeElementFromPendingResourcesForRemovalMap(resourceId)) {
1073         ASSERT(clientElement->hasPendingResources());
1074         if (clientElement->hasPendingResources()) {
1075             clientElement->buildPendingResource();
1076             extensions.clearHasPendingResourcesIfPossible(clientElement);
1077         }
1078     }
1079 }
1080
1081 void SVGElement::childrenChanged(const ChildChange& change)
1082 {
1083     StyledElement::childrenChanged(change);
1084
1085     if (change.source == ChildChangeSourceParser)
1086         return;
1087     invalidateInstances();
1088 }
1089
1090 RefPtr<CSSValue> SVGElement::getPresentationAttribute(const String& name)
1091 {
1092     if (!hasAttributesWithoutUpdate())
1093         return 0;
1094
1095     QualifiedName attributeName(nullAtom, name, nullAtom);
1096     const Attribute* attribute = findAttributeByName(attributeName);
1097     if (!attribute)
1098         return 0;
1099
1100     RefPtr<MutableStyleProperties> style = MutableStyleProperties::create(SVGAttributeMode);
1101     CSSPropertyID propertyID = cssPropertyIdForSVGAttributeName(attribute->name());
1102     style->setProperty(propertyID, attribute->value());
1103     RefPtr<CSSValue> cssValue = style->getPropertyCSSValue(propertyID);
1104     return cssValue ? cssValue->cloneForCSSOM() : nullptr;
1105 }
1106
1107 bool SVGElement::instanceUpdatesBlocked() const
1108 {
1109     return m_svgRareData && m_svgRareData->instanceUpdatesBlocked();
1110 }
1111
1112 void SVGElement::setInstanceUpdatesBlocked(bool value)
1113 {
1114     // Catch any callers that calls setInstanceUpdatesBlocked(true) twice in a row.
1115     // That probably indicates nested use of InstanceUpdateBlocker and a bug.
1116     ASSERT(!value || !instanceUpdatesBlocked());
1117
1118     if (m_svgRareData)
1119         m_svgRareData->setInstanceUpdatesBlocked(value);
1120 }
1121
1122 AffineTransform SVGElement::localCoordinateSpaceTransform(SVGLocatable::CTMScope) const
1123 {
1124     // To be overriden by SVGGraphicsElement (or as special case SVGTextElement and SVGPatternElement)
1125     return AffineTransform();
1126 }
1127
1128 void SVGElement::updateRelativeLengthsInformation(bool hasRelativeLengths, SVGElement* element)
1129 {
1130     // If we're not yet in a document, this function will be called again from insertedInto(). Do nothing now.
1131     if (!inDocument())
1132         return;
1133
1134     // An element wants to notify us that its own relative lengths state changed.
1135     // Register it in the relative length map, and register us in the parent relative length map.
1136     // Register the parent in the grandparents map, etc. Repeat procedure until the root of the SVG tree.
1137
1138     if (hasRelativeLengths)
1139         m_elementsWithRelativeLengths.add(element);
1140     else {
1141         if (!m_elementsWithRelativeLengths.contains(element)) {
1142             // We were never registered. Do nothing.
1143             return;
1144         }
1145
1146         m_elementsWithRelativeLengths.remove(element);
1147     }
1148
1149     if (!element->isSVGGraphicsElement())
1150         return;
1151
1152     // Find first styled parent node, and notify it that we've changed our relative length state.
1153     ContainerNode* node = parentNode();
1154     while (node) {
1155         if (!node->isSVGElement())
1156             break;
1157
1158         // Register us in the parent element map.
1159         downcast<SVGElement>(*node).updateRelativeLengthsInformation(hasRelativeLengths, this);
1160         break;
1161     }
1162 }
1163
1164 bool SVGElement::hasFocusEventListeners() const
1165 {
1166     Element* eventTarget = const_cast<SVGElement*>(this);
1167     return eventTarget->hasEventListeners(eventNames().focusinEvent)
1168         || eventTarget->hasEventListeners(eventNames().focusoutEvent)
1169         || eventTarget->hasEventListeners(eventNames().focusEvent)
1170         || eventTarget->hasEventListeners(eventNames().blurEvent);
1171 }
1172
1173 bool SVGElement::isMouseFocusable() const
1174 {
1175     if (!isFocusable())
1176         return false;
1177     Element* eventTarget = const_cast<SVGElement*>(this);
1178     return hasFocusEventListeners()
1179         || eventTarget->hasEventListeners(eventNames().keydownEvent)
1180         || eventTarget->hasEventListeners(eventNames().keyupEvent)
1181         || eventTarget->hasEventListeners(eventNames().keypressEvent);
1182 }
1183     
1184 void SVGElement::accessKeyAction(bool sendMouseEvents)
1185 {
1186     dispatchSimulatedClick(0, sendMouseEvents ? SendMouseUpDownEvents : SendNoEvents);
1187 }
1188
1189 void SVGElement::invalidateInstances()
1190 {
1191     if (instanceUpdatesBlocked())
1192         return;
1193
1194     auto& instances = this->instances();
1195     while (!instances.isEmpty()) {
1196         SVGElement* instance = *instances.begin();
1197         if (SVGUseElement* useElement = instance->correspondingUseElement())
1198             useElement->invalidateShadowTree();
1199         instance->setCorrespondingElement(nullptr);
1200     } while (!instances.isEmpty());
1201 }
1202
1203 }