d2f69490bd5a67f4d420352b4cfc01c873999883
[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 "Attr.h"
30 #include "CSSCursorImageValue.h"
31 #include "CSSParser.h"
32 #include "DOMImplementation.h"
33 #include "Document.h"
34 #include "ElementIterator.h"
35 #include "Event.h"
36 #include "EventNames.h"
37 #include "HTMLElement.h"
38 #include "HTMLNames.h"
39 #include "HTMLParserIdioms.h"
40 #include "RenderObject.h"
41 #include "RenderSVGResource.h"
42 #include "RenderSVGResourceClipper.h"
43 #include "RenderSVGResourceFilter.h"
44 #include "RenderSVGResourceMasker.h"
45 #include "SVGCursorElement.h"
46 #include "SVGDocumentExtensions.h"
47 #include "SVGElementInstance.h"
48 #include "SVGElementRareData.h"
49 #include "SVGGraphicsElement.h"
50 #include "SVGImageElement.h"
51 #include "SVGNames.h"
52 #include "SVGRenderStyle.h"
53 #include "SVGRenderSupport.h"
54 #include "SVGSVGElement.h"
55 #include "SVGTitleElement.h"
56 #include "SVGUseElement.h"
57 #include "ShadowRoot.h"
58 #include "XLinkNames.h"
59 #include "XMLNames.h"
60 #include <wtf/Assertions.h>
61 #include <wtf/HashMap.h>
62 #include <wtf/NeverDestroyed.h>
63 #include <wtf/StdLibExtras.h>
64 #include <wtf/text/WTFString.h>
65
66
67 namespace WebCore {
68
69 // Animated property definitions
70 DEFINE_ANIMATED_STRING(SVGElement, HTMLNames::classAttr, ClassName, className)
71
72 BEGIN_REGISTER_ANIMATED_PROPERTIES(SVGElement)
73     REGISTER_LOCAL_ANIMATED_PROPERTY(className)
74 END_REGISTER_ANIMATED_PROPERTIES
75
76 using namespace HTMLNames;
77 using namespace SVGNames;
78
79 static NEVER_INLINE void populateAttributeNameToCSSPropertyIDMap(HashMap<AtomicStringImpl*, CSSPropertyID>& map)
80 {
81     // This list should include all base CSS and SVG CSS properties which are exposed as SVG XML attributes.
82     static const QualifiedName* const attributeNames[] = {
83         &alignment_baselineAttr,
84         &baseline_shiftAttr,
85         &buffered_renderingAttr,
86         &clipAttr,
87         &clip_pathAttr,
88         &clip_ruleAttr,
89         &SVGNames::colorAttr,
90         &color_interpolationAttr,
91         &color_interpolation_filtersAttr,
92         &color_profileAttr,
93         &color_renderingAttr,
94         &cursorAttr,
95         &cxAttr,
96         &cyAttr,
97         &SVGNames::directionAttr,
98         &displayAttr,
99         &dominant_baselineAttr,
100         &enable_backgroundAttr,
101         &fillAttr,
102         &fill_opacityAttr,
103         &fill_ruleAttr,
104         &filterAttr,
105         &flood_colorAttr,
106         &flood_opacityAttr,
107         &font_familyAttr,
108         &font_sizeAttr,
109         &font_stretchAttr,
110         &font_styleAttr,
111         &font_variantAttr,
112         &font_weightAttr,
113         &glyph_orientation_horizontalAttr,
114         &glyph_orientation_verticalAttr,
115         &image_renderingAttr,
116         &SVGNames::heightAttr,
117         &kerningAttr,
118         &letter_spacingAttr,
119         &lighting_colorAttr,
120         &marker_endAttr,
121         &marker_midAttr,
122         &marker_startAttr,
123         &maskAttr,
124         &mask_typeAttr,
125         &opacityAttr,
126         &overflowAttr,
127         &paint_orderAttr,
128         &pointer_eventsAttr,
129         &rAttr,
130         &rxAttr,
131         &ryAttr,
132         &shape_renderingAttr,
133         &stop_colorAttr,
134         &stop_opacityAttr,
135         &strokeAttr,
136         &stroke_dasharrayAttr,
137         &stroke_dashoffsetAttr,
138         &stroke_linecapAttr,
139         &stroke_linejoinAttr,
140         &stroke_miterlimitAttr,
141         &stroke_opacityAttr,
142         &stroke_widthAttr,
143         &text_anchorAttr,
144         &text_decorationAttr,
145         &text_renderingAttr,
146         &unicode_bidiAttr,
147         &vector_effectAttr,
148         &visibilityAttr,
149         &SVGNames::widthAttr,
150         &word_spacingAttr,
151         &writing_modeAttr,
152         &xAttr,
153         &yAttr,
154     };
155
156     for (unsigned i = 0; i < WTF_ARRAY_LENGTH(attributeNames); ++i) {
157         const AtomicString& localName = attributeNames[i]->localName();
158         map.add(localName.impl(), cssPropertyID(localName));
159     }
160
161     // FIXME: When CSS supports "transform-origin" this special case can be removed,
162     // and we can add transform_originAttr to the table above instead.
163     map.add(transform_originAttr.localName().impl(), CSSPropertyWebkitTransformOrigin);
164 }
165
166 static NEVER_INLINE void populateAttributeNameToAnimatedPropertyTypeMap(HashMap<QualifiedName::QualifiedNameImpl*, AnimatedPropertyType>& map)
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 (unsigned i = 0; i < WTF_ARRAY_LENGTH(table); ++i)
233         map.add(table[i].attributeName.impl(), table[i].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     struct TableEntry {
247         const QualifiedName& attributeName;
248         AnimatedPropertyType type;
249     };
250
251     static const TableEntry table[] = {
252         { cxAttr, AnimatedLength },
253         { cyAttr, AnimatedLength },
254         { rAttr, AnimatedLength },
255         { rxAttr, AnimatedLength },
256         { ryAttr, AnimatedLength },
257         { SVGNames::heightAttr, AnimatedLength },
258         { SVGNames::widthAttr, AnimatedLength },
259         { xAttr, AnimatedLength },
260         { yAttr, AnimatedLength },
261     };
262
263     for (unsigned i = 0; i < WTF_ARRAY_LENGTH(table); ++i)
264         map.add(table[i].attributeName.impl(), table[i].type);
265 }
266
267 static inline HashMap<QualifiedName::QualifiedNameImpl*, AnimatedPropertyType>& cssPropertyWithSVGDOMNameToAnimatedPropertyTypeMap()
268 {
269     static NeverDestroyed<HashMap<QualifiedName::QualifiedNameImpl*, AnimatedPropertyType>> map;
270     if (map.get().isEmpty())
271         populateCSSPropertyWithSVGDOMNameToAnimatedPropertyTypeMap(map);
272     return map;
273 }
274
275 SVGElement::SVGElement(const QualifiedName& tagName, Document& document)
276     : StyledElement(tagName, document, CreateSVGElement)
277 {
278     registerAnimatedPropertiesForSVGElement();
279 }
280
281 SVGElement::~SVGElement()
282 {
283     if (m_svgRareData) {
284         m_svgRareData->destroyAnimatedSMILStyleProperties();
285         if (SVGCursorElement* cursorElement = m_svgRareData->cursorElement())
286             cursorElement->removeClient(this);
287         if (CSSCursorImageValue* cursorImageValue = m_svgRareData->cursorImageValue())
288             cursorImageValue->removeReferencedElement(this);
289
290         m_svgRareData = nullptr;
291     }
292     document().accessSVGExtensions()->rebuildAllElementReferencesForTarget(*this);
293     document().accessSVGExtensions()->removeAllElementReferencesForTarget(this);
294 }
295
296 short SVGElement::tabIndex() const
297 {
298     if (supportsFocus())
299         return Element::tabIndex();
300     return -1;
301 }
302
303 bool SVGElement::willRecalcStyle(Style::Change change)
304 {
305     if (!m_svgRareData || styleChangeType() == SyntheticStyleChange)
306         return true;
307     // If the style changes because of a regular property change (not induced by SMIL animations themselves)
308     // reset the "computed style without SMIL style properties", so the base value change gets reflected.
309     if (change > Style::NoChange || needsStyleRecalc())
310         m_svgRareData->setNeedsOverrideComputedStyleUpdate();
311     return true;
312 }
313
314 SVGElementRareData& SVGElement::ensureSVGRareData()
315 {
316     if (!m_svgRareData)
317         m_svgRareData = std::make_unique<SVGElementRareData>();
318     return *m_svgRareData;
319 }
320
321 bool SVGElement::isOutermostSVGSVGElement() const
322 {
323     if (!isSVGSVGElement(this))
324         return false;
325
326     // If we're living in a shadow tree, we're a <svg> element that got created as replacement
327     // for a <symbol> element or a cloned <svg> element in the referenced tree. In that case
328     // we're always an inner <svg> element.
329     if (isInShadowTree() && parentOrShadowHostElement() && parentOrShadowHostElement()->isSVGElement())
330         return false;
331
332     // Element may not be in the document, pretend we're outermost for viewport(), getCTM(), etc.
333     if (!parentNode())
334         return true;
335
336     // We act like an outermost SVG element, if we're a direct child of a <foreignObject> element.
337     if (parentNode()->hasTagName(SVGNames::foreignObjectTag))
338         return true;
339
340     // This is true whenever this is the outermost SVG, even if there are HTML elements outside it
341     return !parentNode()->isSVGElement();
342 }
343
344 void SVGElement::reportAttributeParsingError(SVGParsingError error, const QualifiedName& name, const AtomicString& value)
345 {
346     if (error == NoError)
347         return;
348
349     String errorString = "<" + tagName() + "> attribute " + name.toString() + "=\"" + value + "\"";
350     SVGDocumentExtensions* extensions = document().accessSVGExtensions();
351
352     if (error == NegativeValueForbiddenError) {
353         extensions->reportError("Invalid negative value for " + errorString);
354         return;
355     }
356
357     if (error == ParsingAttributeFailedError) {
358         extensions->reportError("Invalid value for " + errorString);
359         return;
360     }
361
362     ASSERT_NOT_REACHED();
363 }
364
365 bool SVGElement::isSupported(StringImpl* feature, StringImpl* version) const
366 {
367     return DOMImplementation::hasFeature(feature, version);
368 }
369
370 String SVGElement::xmlbase() const
371 {
372     return fastGetAttribute(XMLNames::baseAttr);
373 }
374
375 void SVGElement::setXmlbase(const String& value, ExceptionCode&)
376 {
377     setAttribute(XMLNames::baseAttr, value);
378 }
379
380 void SVGElement::removedFrom(ContainerNode& rootParent)
381 {
382     bool wasInDocument = rootParent.inDocument();
383     if (wasInDocument)
384         updateRelativeLengthsInformation(false, this);
385
386     StyledElement::removedFrom(rootParent);
387
388     if (wasInDocument) {
389         document().accessSVGExtensions()->clearTargetDependencies(*this);
390         document().accessSVGExtensions()->removeAllElementReferencesForTarget(this);
391     }
392     SVGElementInstance::invalidateAllInstancesOfElement(this);
393 }
394
395 SVGSVGElement* SVGElement::ownerSVGElement() const
396 {
397     ContainerNode* node = parentOrShadowHostNode();
398     while (node) {
399         if (isSVGSVGElement(node))
400             return downcast<SVGSVGElement>(node);
401
402         node = node->parentOrShadowHostNode();
403     }
404
405     return nullptr;
406 }
407
408 SVGElement* SVGElement::viewportElement() const
409 {
410     // This function needs shadow tree support - as RenderSVGContainer uses this function
411     // to determine the "overflow" property. <use> on <symbol> wouldn't work otherwhise.
412     ContainerNode* node = parentOrShadowHostNode();
413     while (node) {
414         if (isSVGSVGElement(node) || isSVGImageElement(node) || node->hasTagName(SVGNames::symbolTag))
415             return downcast<SVGElement>(node);
416
417         node = node->parentOrShadowHostNode();
418     }
419
420     return nullptr;
421 }
422
423 SVGDocumentExtensions* SVGElement::accessDocumentSVGExtensions()
424 {
425     // This function is provided for use by SVGAnimatedProperty to avoid
426     // global inclusion of Document.h in SVG code.
427     return document().accessSVGExtensions();
428 }
429  
430 void SVGElement::mapInstanceToElement(SVGElementInstance* instance)
431 {
432     ASSERT(instance);
433
434     HashSet<SVGElementInstance*>& instances = ensureSVGRareData().elementInstances();
435     ASSERT(!instances.contains(instance));
436
437     instances.add(instance);
438 }
439  
440 void SVGElement::removeInstanceMapping(SVGElementInstance* instance)
441 {
442     ASSERT(instance);
443     ASSERT(m_svgRareData);
444
445     HashSet<SVGElementInstance*>& instances = m_svgRareData->elementInstances();
446     ASSERT(instances.contains(instance));
447
448     instances.remove(instance);
449 }
450
451 const HashSet<SVGElementInstance*>& SVGElement::instancesForElement() const
452 {
453     if (!m_svgRareData) {
454         static NeverDestroyed<HashSet<SVGElementInstance*>> emptyInstances;
455         return emptyInstances;
456     }
457     return m_svgRareData->elementInstances();
458 }
459
460 bool SVGElement::getBoundingBox(FloatRect& rect, SVGLocatable::StyleUpdateStrategy styleUpdateStrategy)
461 {
462     if (isSVGGraphicsElement()) {
463         rect = toSVGGraphicsElement(*this).getBBox(styleUpdateStrategy);
464         return true;
465     }
466     return false;
467 }
468
469 void SVGElement::setCursorElement(SVGCursorElement* cursorElement)
470 {
471     SVGElementRareData& rareData = ensureSVGRareData();
472     if (SVGCursorElement* oldCursorElement = rareData.cursorElement()) {
473         if (cursorElement == oldCursorElement)
474             return;
475         oldCursorElement->removeReferencedElement(this);
476     }
477     rareData.setCursorElement(cursorElement);
478 }
479
480 void SVGElement::cursorElementRemoved() 
481 {
482     ASSERT(m_svgRareData);
483     m_svgRareData->setCursorElement(0);
484 }
485
486 void SVGElement::setCursorImageValue(CSSCursorImageValue* cursorImageValue)
487 {
488     SVGElementRareData& rareData = ensureSVGRareData();
489     if (CSSCursorImageValue* oldCursorImageValue = rareData.cursorImageValue()) {
490         if (cursorImageValue == oldCursorImageValue)
491             return;
492         oldCursorImageValue->removeReferencedElement(this);
493     }
494     rareData.setCursorImageValue(cursorImageValue);
495 }
496
497 void SVGElement::cursorImageValueRemoved()
498 {
499     ASSERT(m_svgRareData);
500     m_svgRareData->setCursorImageValue(0);
501 }
502
503 SVGElement* SVGElement::correspondingElement()
504 {
505     ASSERT(!m_svgRareData || !m_svgRareData->correspondingElement() || containingShadowRoot());
506     return m_svgRareData ? m_svgRareData->correspondingElement() : 0;
507 }
508
509 void SVGElement::setCorrespondingElement(SVGElement* correspondingElement)
510 {
511     ensureSVGRareData().setCorrespondingElement(correspondingElement);
512 }
513
514 void SVGElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
515 {
516     if (name == HTMLNames::classAttr)
517         setClassNameBaseValue(value);
518     else if (name == 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     } else if (SVGLangSpace::parseAttribute(name, value))
527         return;
528     else {
529         // FIXME: Can we do this even faster by checking the local name "on" prefix before we do anything with the map?
530         // See HTMLElement::parseAttribute().
531         static NeverDestroyed<HashMap<AtomicStringImpl*, AtomicString>> eventNamesGlobal;
532         auto& eventNames = eventNamesGlobal.get();
533         if (eventNames.isEmpty())
534             HTMLElement::populateEventNameForAttributeLocalNameMap(eventNames);
535         const AtomicString& eventName = eventNames.get(name.localName().impl());
536         if (!eventName.isNull())
537             setAttributeEventListener(eventName, name, value);
538         else
539             StyledElement::parseAttribute(name, value);
540     }
541 }
542
543 void SVGElement::animatedPropertyTypeForAttribute(const QualifiedName& attributeName, Vector<AnimatedPropertyType>& propertyTypes)
544 {
545     localAttributeToPropertyMap().animatedPropertyTypeForAttribute(attributeName, propertyTypes);
546     if (!propertyTypes.isEmpty())
547         return;
548
549     auto& map = attributeNameToAnimatedPropertyTypeMap();
550     auto it = map.find(attributeName.impl());
551     if (it != map.end()) {
552         propertyTypes.append(it->value);
553         return;
554     }
555
556     auto& cssPropertyWithSVGDOMMap = cssPropertyWithSVGDOMNameToAnimatedPropertyTypeMap();
557     auto svgPropertyIterator = cssPropertyWithSVGDOMMap.find(attributeName.impl());
558     if (svgPropertyIterator != cssPropertyWithSVGDOMMap.end())
559         propertyTypes.append(svgPropertyIterator->value);
560 }
561
562 bool SVGElement::haveLoadedRequiredResources()
563 {
564     for (auto& child : childrenOfType<SVGElement>(*this)) {
565         if (!child.haveLoadedRequiredResources())
566             return false;
567     }
568     return true;
569 }
570
571 bool SVGElement::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> prpListener, bool useCapture)
572 {
573     RefPtr<EventListener> listener = prpListener;
574     
575     // Add event listener to regular DOM element
576     if (!Node::addEventListener(eventType, listener, useCapture))
577         return false;
578
579     if (containingShadowRoot())
580         return true;
581
582     // Add event listener to all shadow tree DOM element instances
583     ASSERT(!instanceUpdatesBlocked());
584     for (auto& instance : instancesForElement()) {
585         ASSERT(instance->shadowTreeElement());
586         ASSERT(instance->correspondingElement() == this);
587
588         bool result = instance->shadowTreeElement()->Node::addEventListener(eventType, listener, useCapture);
589         ASSERT_UNUSED(result, result);
590     }
591
592     return true;
593 }
594
595 bool SVGElement::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
596 {
597     if (containingShadowRoot())
598         return Node::removeEventListener(eventType, listener, useCapture);
599
600     // EventTarget::removeEventListener creates a PassRefPtr around the given EventListener
601     // object when creating a temporary RegisteredEventListener object used to look up the
602     // event listener in a cache. If we want to be able to call removeEventListener() multiple
603     // times on different nodes, we have to delay its immediate destruction, which would happen
604     // after the first call below.
605     RefPtr<EventListener> protector(listener);
606
607     // Remove event listener from regular DOM element
608     if (!Node::removeEventListener(eventType, listener, useCapture))
609         return false;
610
611     // Remove event listener from all shadow tree DOM element instances
612     ASSERT(!instanceUpdatesBlocked());
613     for (auto& instance : instancesForElement()) {
614         ASSERT(instance->correspondingElement() == this);
615
616         SVGElement* shadowTreeElement = instance->shadowTreeElement();
617         ASSERT(shadowTreeElement);
618
619         if (shadowTreeElement->Node::removeEventListener(eventType, listener, useCapture))
620             continue;
621
622         // This case can only be hit for event listeners created from markup
623         ASSERT(listener->wasCreatedFromMarkup());
624
625         // If the event listener 'listener' has been created from markup and has been fired before
626         // then JSLazyEventListener::parseCode() has been called and m_jsFunction of that listener
627         // has been created (read: it's not 0 anymore). During shadow tree creation, the event
628         // listener DOM attribute has been cloned, and another event listener has been setup in
629         // the shadow tree. If that event listener has not been used yet, m_jsFunction is still 0,
630         // and tryRemoveEventListener() above will fail. Work around that very seldom problem.
631         EventTargetData* data = shadowTreeElement->eventTargetData();
632         ASSERT(data);
633
634         data->eventListenerMap.removeFirstEventListenerCreatedFromMarkup(eventType);
635     }
636
637     return true;
638 }
639
640 static bool hasLoadListener(Element* element)
641 {
642     if (element->hasEventListeners(eventNames().loadEvent))
643         return true;
644
645     for (element = element->parentOrShadowHostElement(); element; element = element->parentOrShadowHostElement()) {
646         const EventListenerVector& entry = element->getEventListeners(eventNames().loadEvent);
647         for (size_t i = 0; i < entry.size(); ++i) {
648             if (entry[i].useCapture)
649                 return true;
650         }
651     }
652
653     return false;
654 }
655
656 #if ENABLE(CSS_REGIONS)
657 bool SVGElement::shouldMoveToFlowThread(const RenderStyle& styleToUse) const
658 {
659     // Allow only svg root elements to be directly collected by a render flow thread.
660     return parentNode() && !parentNode()->isSVGElement() && hasTagName(SVGNames::svgTag) && Element::shouldMoveToFlowThread(styleToUse);
661 }
662 #endif
663
664 void SVGElement::sendSVGLoadEventIfPossible(bool sendParentLoadEvents)
665 {
666     RefPtr<SVGElement> currentTarget = this;
667     while (currentTarget && currentTarget->haveLoadedRequiredResources()) {
668         RefPtr<Element> parent;
669         if (sendParentLoadEvents)
670             parent = currentTarget->parentOrShadowHostElement(); // save the next parent to dispatch too incase dispatching the event changes the tree
671         if (hasLoadListener(currentTarget.get()))
672             currentTarget->dispatchEvent(Event::create(eventNames().loadEvent, false, false));
673         currentTarget = (parent && parent->isSVGElement()) ? static_pointer_cast<SVGElement>(parent) : RefPtr<SVGElement>();
674         SVGElement* element = currentTarget.get();
675         if (!element || !element->isOutermostSVGSVGElement())
676             continue;
677
678         // Consider <svg onload="foo()"><image xlink:href="foo.png" externalResourcesRequired="true"/></svg>.
679         // If foo.png is not yet loaded, the first SVGLoad event will go to the <svg> element, sent through
680         // Document::implicitClose(). Then the SVGLoad event will fire for <image>, once its loaded.
681         ASSERT(sendParentLoadEvents);
682
683         // If the load event was not sent yet by Document::implicitClose(), but the <image> from the example
684         // above, just appeared, don't send the SVGLoad event to the outermost <svg>, but wait for the document
685         // to be "ready to render", first.
686         if (!document().loadEventFinished())
687             break;
688     }
689 }
690
691 void SVGElement::sendSVGLoadEventIfPossibleAsynchronously()
692 {
693     svgLoadEventTimer()->startOneShot(0);
694 }
695
696 void SVGElement::svgLoadEventTimerFired(Timer<SVGElement>*)
697 {
698     sendSVGLoadEventIfPossible();
699 }
700
701 Timer<SVGElement>* SVGElement::svgLoadEventTimer()
702 {
703     ASSERT_NOT_REACHED();
704     return 0;
705 }
706
707 void SVGElement::finishParsingChildren()
708 {
709     StyledElement::finishParsingChildren();
710
711     // The outermost SVGSVGElement SVGLoad event is fired through Document::dispatchWindowLoadEvent.
712     if (isOutermostSVGSVGElement())
713         return;
714
715     // finishParsingChildren() is called when the close tag is reached for an element (e.g. </svg>)
716     // we send SVGLoad events here if we can, otherwise they'll be sent when any required loads finish
717     sendSVGLoadEventIfPossible();
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 PassRefPtr<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, we should not return titles when hovering over root <svg> elements (those
961     // <title> elements are the title of the document, not a tooltip) so we instantly return.
962     if (isOutermostSVGSVGElement())
963         return String();
964
965     // Walk up the tree, to find out whether we're inside a <use> shadow tree, to find the right title.
966     if (isInShadowTree()) {
967         Element* shadowHostElement = toShadowRoot(treeScope().rootNode()).hostElement();
968         // At this time, SVG nodes are not allowed in non-<use> shadow trees, so any shadow root we do
969         // have should be a use. The assert and following test is here to catch future shadow DOM changes
970         // that do enable SVG in a shadow tree.
971         ASSERT(!shadowHostElement || shadowHostElement->hasTagName(SVGNames::useTag));
972         if (shadowHostElement && shadowHostElement->hasTagName(SVGNames::useTag)) {
973             SVGUseElement& useElement = downcast<SVGUseElement>(*shadowHostElement);
974
975             // If the <use> title is not empty we found the title to use.
976             String useTitle(useElement.title());
977             if (!useTitle.isEmpty())
978                 return useTitle;
979         }
980     }
981
982     // If we aren't an instance in a <use> or the <use> title was not found, then find the first
983     // <title> child of this element.
984     auto firstTitle = descendantsOfType<SVGTitleElement>(*this).first();
985     return firstTitle ? const_cast<SVGTitleElement*>(firstTitle)->innerText() : String();
986 }
987
988 bool SVGElement::rendererIsNeeded(const RenderStyle& style)
989 {
990     // http://www.w3.org/TR/SVG/extend.html#PrivateData
991     // Prevent anything other than SVG renderers from appearing in our render tree
992     // Spec: SVG allows inclusion of elements from foreign namespaces anywhere
993     // with the SVG content. In general, the SVG user agent will include the unknown
994     // elements in the DOM but will otherwise ignore unknown elements.
995     if (!parentOrShadowHostElement() || parentOrShadowHostElement()->isSVGElement())
996         return StyledElement::rendererIsNeeded(style);
997
998     return false;
999 }
1000
1001 CSSPropertyID SVGElement::cssPropertyIdForSVGAttributeName(const QualifiedName& attrName)
1002 {
1003     if (!attrName.namespaceURI().isNull())
1004         return CSSPropertyInvalid;
1005
1006     static NeverDestroyed<HashMap<AtomicStringImpl*, CSSPropertyID>> properties;
1007     if (properties.get().isEmpty())
1008         populateAttributeNameToCSSPropertyIDMap(properties.get());
1009
1010     return properties.get().get(attrName.localName().impl());
1011 }
1012
1013 bool SVGElement::isAnimatableCSSProperty(const QualifiedName& attributeName)
1014 {
1015     return attributeNameToAnimatedPropertyTypeMap().contains(attributeName.impl())
1016         || cssPropertyWithSVGDOMNameToAnimatedPropertyTypeMap().contains(attributeName.impl());
1017 }
1018
1019 bool SVGElement::isPresentationAttributeWithSVGDOM(const QualifiedName& attributeName)
1020 {
1021     Vector<AnimatedPropertyType> propertyTypes;
1022     localAttributeToPropertyMap().animatedPropertyTypeForAttribute(attributeName, propertyTypes);
1023     return !propertyTypes.isEmpty();
1024 }
1025
1026 bool SVGElement::isPresentationAttribute(const QualifiedName& name) const
1027 {
1028     if (cssPropertyIdForSVGAttributeName(name) > 0)
1029         return true;
1030     return StyledElement::isPresentationAttribute(name);
1031 }
1032
1033 void SVGElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStyleProperties& style)
1034 {
1035     CSSPropertyID propertyID = cssPropertyIdForSVGAttributeName(name);
1036     if (propertyID > 0)
1037         addPropertyToPresentationAttributeStyle(style, propertyID, value);
1038 }
1039
1040 bool SVGElement::isKnownAttribute(const QualifiedName& attrName)
1041 {
1042     return attrName == HTMLNames::idAttr;
1043 }
1044
1045 void SVGElement::svgAttributeChanged(const QualifiedName& attrName)
1046 {
1047     CSSPropertyID propId = cssPropertyIdForSVGAttributeName(attrName);
1048     if (propId > 0) {
1049         SVGElementInstance::invalidateAllInstancesOfElement(this);
1050         return;
1051     }
1052
1053     if (attrName == HTMLNames::classAttr) {
1054         classAttributeChanged(className());
1055         SVGElementInstance::invalidateAllInstancesOfElement(this);
1056         return;
1057     }
1058
1059     if (attrName == HTMLNames::idAttr) {
1060         auto renderer = this->renderer();
1061         // Notify resources about id changes, this is important as we cache resources by id in SVGDocumentExtensions
1062         if (renderer && renderer->isSVGResourceContainer())
1063             toRenderSVGResourceContainer(*renderer).idChanged();
1064         if (inDocument())
1065             buildPendingResourcesIfNeeded();
1066         SVGElementInstance::invalidateAllInstancesOfElement(this);
1067         return;
1068     }
1069 }
1070
1071 Node::InsertionNotificationRequest SVGElement::insertedInto(ContainerNode& rootParent)
1072 {
1073     StyledElement::insertedInto(rootParent);
1074     updateRelativeLengthsInformation();
1075     buildPendingResourcesIfNeeded();
1076     return InsertionDone;
1077 }
1078
1079 void SVGElement::buildPendingResourcesIfNeeded()
1080 {
1081     if (!needsPendingResourceHandling() || !inDocument() || isInShadowTree())
1082         return;
1083
1084     SVGDocumentExtensions* extensions = document().accessSVGExtensions();
1085     String resourceId = getIdAttribute();
1086     if (!extensions->isIdOfPendingResource(resourceId))
1087         return;
1088
1089     // Mark pending resources as pending for removal.
1090     extensions->markPendingResourcesForRemoval(resourceId);
1091
1092     // Rebuild pending resources for each client of a pending resource that is being removed.
1093     while (Element* clientElement = extensions->removeElementFromPendingResourcesForRemovalMap(resourceId)) {
1094         ASSERT(clientElement->hasPendingResources());
1095         if (clientElement->hasPendingResources()) {
1096             clientElement->buildPendingResource();
1097             extensions->clearHasPendingResourcesIfPossible(clientElement);
1098         }
1099     }
1100 }
1101
1102 void SVGElement::childrenChanged(const ChildChange& change)
1103 {
1104     StyledElement::childrenChanged(change);
1105
1106     if (change.source == ChildChangeSourceParser)
1107         return;
1108     SVGElementInstance::invalidateAllInstancesOfElement(this);
1109 }
1110
1111 PassRefPtr<CSSValue> SVGElement::getPresentationAttribute(const String& name)
1112 {
1113     if (!hasAttributesWithoutUpdate())
1114         return 0;
1115
1116     QualifiedName attributeName(nullAtom, name, nullAtom);
1117     const Attribute* attribute = findAttributeByName(attributeName);
1118     if (!attribute)
1119         return 0;
1120
1121     RefPtr<MutableStyleProperties> style = MutableStyleProperties::create(SVGAttributeMode);
1122     CSSPropertyID propertyID = cssPropertyIdForSVGAttributeName(attribute->name());
1123     style->setProperty(propertyID, attribute->value());
1124     RefPtr<CSSValue> cssValue = style->getPropertyCSSValue(propertyID);
1125     return cssValue ? cssValue->cloneForCSSOM() : 0;
1126 }
1127
1128 bool SVGElement::instanceUpdatesBlocked() const
1129 {
1130     return m_svgRareData && m_svgRareData->instanceUpdatesBlocked();
1131 }
1132
1133 void SVGElement::setInstanceUpdatesBlocked(bool value)
1134 {
1135     if (m_svgRareData)
1136         m_svgRareData->setInstanceUpdatesBlocked(value);
1137 }
1138
1139 AffineTransform SVGElement::localCoordinateSpaceTransform(SVGLocatable::CTMScope) const
1140 {
1141     // To be overriden by SVGGraphicsElement (or as special case SVGTextElement and SVGPatternElement)
1142     return AffineTransform();
1143 }
1144
1145 void SVGElement::updateRelativeLengthsInformation(bool hasRelativeLengths, SVGElement* element)
1146 {
1147     // If we're not yet in a document, this function will be called again from insertedInto(). Do nothing now.
1148     if (!inDocument())
1149         return;
1150
1151     // An element wants to notify us that its own relative lengths state changed.
1152     // Register it in the relative length map, and register us in the parent relative length map.
1153     // Register the parent in the grandparents map, etc. Repeat procedure until the root of the SVG tree.
1154
1155     if (hasRelativeLengths)
1156         m_elementsWithRelativeLengths.add(element);
1157     else {
1158         if (!m_elementsWithRelativeLengths.contains(element)) {
1159             // We were never registered. Do nothing.
1160             return;
1161         }
1162
1163         m_elementsWithRelativeLengths.remove(element);
1164     }
1165
1166     if (!element->isSVGGraphicsElement())
1167         return;
1168
1169     // Find first styled parent node, and notify it that we've changed our relative length state.
1170     ContainerNode* node = parentNode();
1171     while (node) {
1172         if (!node->isSVGElement())
1173             break;
1174
1175         // Register us in the parent element map.
1176         downcast<SVGElement>(*node).updateRelativeLengthsInformation(hasRelativeLengths, this);
1177         break;
1178     }
1179 }
1180
1181 bool SVGElement::hasFocusEventListeners() const
1182 {
1183     Element* eventTarget = const_cast<SVGElement*>(this);
1184     return eventTarget->hasEventListeners(eventNames().focusinEvent)
1185         || eventTarget->hasEventListeners(eventNames().focusoutEvent)
1186         || eventTarget->hasEventListeners(eventNames().focusEvent)
1187         || eventTarget->hasEventListeners(eventNames().blurEvent);
1188 }
1189
1190 bool SVGElement::isMouseFocusable() const
1191 {
1192     if (!isFocusable())
1193         return false;
1194     Element* eventTarget = const_cast<SVGElement*>(this);
1195     return hasFocusEventListeners()
1196         || eventTarget->hasEventListeners(eventNames().keydownEvent)
1197         || eventTarget->hasEventListeners(eventNames().keyupEvent)
1198         || eventTarget->hasEventListeners(eventNames().keypressEvent);
1199 }
1200     
1201 void SVGElement::accessKeyAction(bool sendMouseEvents)
1202 {
1203     dispatchSimulatedClick(0, sendMouseEvents ? SendMouseUpDownEvents : SendNoEvents);
1204 }
1205
1206 }