Improve use of NeverDestroyed
[WebKit-https.git] / Source / WebCore / svg / SVGTextPathElement.cpp
1 /*
2  * Copyright (C) 2007 Nikolas Zimmermann <zimmermann@kde.org>
3  * Copyright (C) 2010 Rob Buis <rwlbuis@gmail.com>
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Library General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Library General Public License for more details.
14  *
15  * You should have received a copy of the GNU Library General Public License
16  * along with this library; see the file COPYING.LIB.  If not, write to
17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  * Boston, MA 02110-1301, USA.
19  */
20
21 #include "config.h"
22 #include "SVGTextPathElement.h"
23
24 #include "RenderSVGResource.h"
25 #include "RenderSVGTextPath.h"
26 #include "SVGDocumentExtensions.h"
27 #include "SVGNames.h"
28 #include "XLinkNames.h"
29 #include <wtf/NeverDestroyed.h>
30
31 namespace WebCore {
32
33 // Animated property definitions
34 DEFINE_ANIMATED_LENGTH(SVGTextPathElement, SVGNames::startOffsetAttr, StartOffset, startOffset)
35 DEFINE_ANIMATED_ENUMERATION(SVGTextPathElement, SVGNames::methodAttr, Method, method, SVGTextPathMethodType)
36 DEFINE_ANIMATED_ENUMERATION(SVGTextPathElement, SVGNames::spacingAttr, Spacing, spacing, SVGTextPathSpacingType)
37 DEFINE_ANIMATED_STRING(SVGTextPathElement, XLinkNames::hrefAttr, Href, href)
38
39 BEGIN_REGISTER_ANIMATED_PROPERTIES(SVGTextPathElement)
40     REGISTER_LOCAL_ANIMATED_PROPERTY(startOffset)
41     REGISTER_LOCAL_ANIMATED_PROPERTY(method)
42     REGISTER_LOCAL_ANIMATED_PROPERTY(spacing)
43     REGISTER_LOCAL_ANIMATED_PROPERTY(href)
44     REGISTER_PARENT_ANIMATED_PROPERTIES(SVGTextContentElement)
45 END_REGISTER_ANIMATED_PROPERTIES
46
47 inline SVGTextPathElement::SVGTextPathElement(const QualifiedName& tagName, Document& document)
48     : SVGTextContentElement(tagName, document)
49     , m_startOffset(LengthModeOther)
50     , m_method(SVGTextPathMethodAlign)
51     , m_spacing(SVGTextPathSpacingExact)
52 {
53     ASSERT(hasTagName(SVGNames::textPathTag));
54     registerAnimatedPropertiesForSVGTextPathElement();
55 }
56
57 Ref<SVGTextPathElement> SVGTextPathElement::create(const QualifiedName& tagName, Document& document)
58 {
59     return adoptRef(*new SVGTextPathElement(tagName, document));
60 }
61
62 SVGTextPathElement::~SVGTextPathElement()
63 {
64     clearResourceReferences();
65 }
66
67 void SVGTextPathElement::clearResourceReferences()
68 {
69     document().accessSVGExtensions().removeAllTargetReferencesForElement(this);
70 }
71
72 bool SVGTextPathElement::isSupportedAttribute(const QualifiedName& attrName)
73 {
74     static const auto supportedAttributes = makeNeverDestroyed([] {
75         HashSet<QualifiedName> set;
76         SVGURIReference::addSupportedAttributes(set);
77         set.add({ SVGNames::startOffsetAttr, SVGNames::methodAttr, SVGNames::spacingAttr });
78         return set;
79     }());
80     return supportedAttributes.get().contains<SVGAttributeHashTranslator>(attrName);
81 }
82
83 void SVGTextPathElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
84 {
85     SVGParsingError parseError = NoError;
86
87     if (name == SVGNames::startOffsetAttr)
88         setStartOffsetBaseValue(SVGLengthValue::construct(LengthModeOther, value, parseError));
89     else if (name == SVGNames::methodAttr) {
90         SVGTextPathMethodType propertyValue = SVGPropertyTraits<SVGTextPathMethodType>::fromString(value);
91         if (propertyValue > 0)
92             setMethodBaseValue(propertyValue);
93     } else if (name == SVGNames::spacingAttr) {
94         SVGTextPathSpacingType propertyValue = SVGPropertyTraits<SVGTextPathSpacingType>::fromString(value);
95         if (propertyValue > 0)
96             setSpacingBaseValue(propertyValue);
97     }
98
99     reportAttributeParsingError(parseError, name, value);
100
101     SVGTextContentElement::parseAttribute(name, value);
102     SVGURIReference::parseAttribute(name, value);
103 }
104
105 void SVGTextPathElement::svgAttributeChanged(const QualifiedName& attrName)
106 {
107     if (!isSupportedAttribute(attrName)) {
108         SVGTextContentElement::svgAttributeChanged(attrName);
109         return;
110     }
111
112     InstanceInvalidationGuard guard(*this);
113
114     if (SVGURIReference::isKnownAttribute(attrName)) {
115         buildPendingResource();
116         return;
117     }
118
119     if (attrName == SVGNames::startOffsetAttr)
120         updateRelativeLengthsInformation();
121
122     if (auto renderer = this->renderer())
123         RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
124 }
125
126 RenderPtr<RenderElement> SVGTextPathElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
127 {
128     return createRenderer<RenderSVGTextPath>(*this, WTFMove(style));
129 }
130
131 bool SVGTextPathElement::childShouldCreateRenderer(const Node& child) const
132 {
133     if (child.isTextNode()
134         || child.hasTagName(SVGNames::aTag)
135         || child.hasTagName(SVGNames::trefTag)
136         || child.hasTagName(SVGNames::tspanTag))
137         return true;
138
139     return false;
140 }
141
142 bool SVGTextPathElement::rendererIsNeeded(const RenderStyle& style)
143 {
144     if (parentNode()
145         && (parentNode()->hasTagName(SVGNames::aTag)
146             || parentNode()->hasTagName(SVGNames::textTag)))
147         return StyledElement::rendererIsNeeded(style);
148
149     return false;
150 }
151
152 void SVGTextPathElement::buildPendingResource()
153 {
154     clearResourceReferences();
155     if (!isConnected())
156         return;
157
158     String id;
159     Element* target = SVGURIReference::targetElementFromIRIString(href(), document(), &id);
160     if (!target) {
161         // Do not register as pending if we are already pending this resource.
162         if (document().accessSVGExtensions().isPendingResource(this, id))
163             return;
164
165         if (!id.isEmpty()) {
166             document().accessSVGExtensions().addPendingResource(id, this);
167             ASSERT(hasPendingResources());
168         }
169     } else if (target->hasTagName(SVGNames::pathTag)) {
170         // Register us with the target in the dependencies map. Any change of hrefElement
171         // that leads to relayout/repainting now informs us, so we can react to it.
172         document().accessSVGExtensions().addElementReferencingTarget(this, downcast<SVGElement>(target));
173     }
174 }
175
176 Node::InsertionNotificationRequest SVGTextPathElement::insertedInto(ContainerNode& rootParent)
177 {
178     SVGTextContentElement::insertedInto(rootParent);
179     return InsertionShouldCallFinishedInsertingSubtree;
180 }
181
182 void SVGTextPathElement::finishedInsertingSubtree()
183 {
184     buildPendingResource();
185 }
186
187 void SVGTextPathElement::removedFrom(ContainerNode& rootParent)
188 {
189     SVGTextContentElement::removedFrom(rootParent);
190     if (rootParent.isConnected())
191         clearResourceReferences();
192 }
193
194 bool SVGTextPathElement::selfHasRelativeLengths() const
195 {
196     return startOffset().isRelative()
197         || SVGTextContentElement::selfHasRelativeLengths();
198 }
199
200 }