Replace WTF::move with WTFMove
[WebKit-https.git] / Source / WebCore / svg / SVGDocumentExtensions.cpp
1 /*
2  * Copyright (C) 2006 Apple Inc. All rights reserved.
3  * Copyright (C) 2006 Nikolas Zimmermann <zimmermann@kde.org>
4  * Copyright (C) 2007 Rob Buis <buis@kde.org>
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public License
17  * along with this library; see the file COPYING.LIB.  If not, write to
18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  * Boston, MA 02110-1301, USA.
20  */
21
22 #include "config.h"
23 #include "SVGDocumentExtensions.h"
24
25 #include "DOMWindow.h"
26 #include "Document.h"
27 #include "EventListener.h"
28 #include "Frame.h"
29 #include "FrameLoader.h"
30 #include "Page.h"
31 #include "SMILTimeContainer.h"
32 #include "SVGElement.h"
33 #include "SVGResourcesCache.h"
34 #include "SVGSMILElement.h"
35 #include "SVGSVGElement.h"
36 #include "ScriptableDocumentParser.h"
37 #include "ShadowRoot.h"
38 #include "XLinkNames.h"
39 #include <wtf/text/AtomicString.h>
40
41 namespace WebCore {
42
43 SVGDocumentExtensions::SVGDocumentExtensions(Document* document)
44     : m_document(document)
45     , m_resourcesCache(std::make_unique<SVGResourcesCache>())
46 {
47 }
48
49 SVGDocumentExtensions::~SVGDocumentExtensions()
50 {
51 }
52
53 void SVGDocumentExtensions::addTimeContainer(SVGSVGElement* element)
54 {
55     m_timeContainers.add(element);
56 }
57
58 void SVGDocumentExtensions::removeTimeContainer(SVGSVGElement* element)
59 {
60     m_timeContainers.remove(element);
61 }
62
63 void SVGDocumentExtensions::addResource(const AtomicString& id, RenderSVGResourceContainer* resource)
64 {
65     ASSERT(resource);
66
67     if (id.isEmpty())
68         return;
69
70     // Replaces resource if already present, to handle potential id changes
71     m_resources.set(id, resource);
72 }
73
74 void SVGDocumentExtensions::removeResource(const AtomicString& id)
75 {
76     if (id.isEmpty())
77         return;
78
79     m_resources.remove(id);
80 }
81
82 RenderSVGResourceContainer* SVGDocumentExtensions::resourceById(const AtomicString& id) const
83 {
84     if (id.isEmpty())
85         return 0;
86
87     return m_resources.get(id);
88 }
89
90 void SVGDocumentExtensions::startAnimations()
91 {
92     // FIXME: Eventually every "Time Container" will need a way to latch on to some global timer
93     // starting animations for a document will do this "latching"
94     // FIXME: We hold a ref pointers to prevent a shadow tree from getting removed out from underneath us.
95     // In the future we should refactor the use-element to avoid this. See https://webkit.org/b/53704
96     Vector<RefPtr<SVGSVGElement>> timeContainers;
97     timeContainers.appendRange(m_timeContainers.begin(), m_timeContainers.end());
98     for (auto& element : timeContainers)
99         element->timeContainer().begin();
100 }
101
102 void SVGDocumentExtensions::pauseAnimations()
103 {
104     for (auto& container : m_timeContainers)
105         container->pauseAnimations();
106 }
107
108 void SVGDocumentExtensions::unpauseAnimations()
109 {
110     for (auto& container : m_timeContainers)
111         container->unpauseAnimations();
112 }
113
114 void SVGDocumentExtensions::dispatchSVGLoadEventToOutermostSVGElements()
115 {
116     Vector<RefPtr<SVGSVGElement>> timeContainers;
117     timeContainers.appendRange(m_timeContainers.begin(), m_timeContainers.end());
118
119     for (auto& container : timeContainers) {
120         if (!container->isOutermostSVGSVGElement())
121             continue;
122         container->sendSVGLoadEventIfPossible();
123     }
124 }
125
126 static void reportMessage(Document* document, MessageLevel level, const String& message)
127 {
128     if (document->frame())
129         document->addConsoleMessage(MessageSource::Rendering, level, message);
130 }
131
132 void SVGDocumentExtensions::reportWarning(const String& message)
133 {
134     reportMessage(m_document, MessageLevel::Warning, "Warning: " + message);
135 }
136
137 void SVGDocumentExtensions::reportError(const String& message)
138 {
139     reportMessage(m_document, MessageLevel::Error, "Error: " + message);
140 }
141
142 void SVGDocumentExtensions::addPendingResource(const AtomicString& id, Element* element)
143 {
144     ASSERT(element);
145
146     if (id.isEmpty())
147         return;
148
149     auto result = m_pendingResources.add(id, nullptr);
150     if (result.isNewEntry)
151         result.iterator->value = std::make_unique<PendingElements>();
152     result.iterator->value->add(element);
153
154     element->setHasPendingResources();
155 }
156
157 bool SVGDocumentExtensions::isIdOfPendingResource(const AtomicString& id) const
158 {
159     if (id.isEmpty())
160         return false;
161
162     return m_pendingResources.contains(id);
163 }
164
165 bool SVGDocumentExtensions::isElementWithPendingResources(Element* element) const
166 {
167     // This algorithm takes time proportional to the number of pending resources and need not.
168     // If performance becomes an issue we can keep a counted set of elements and answer the question efficiently.
169     ASSERT(element);
170     for (auto& elements : m_pendingResources.values()) {
171         ASSERT(elements);
172
173         if (elements->contains(element))
174             return true;
175     }
176     return false;
177 }
178
179 bool SVGDocumentExtensions::isPendingResource(Element* element, const AtomicString& id) const
180 {
181     ASSERT(element);
182
183     if (!isIdOfPendingResource(id))
184         return false;
185
186     return m_pendingResources.get(id)->contains(element);
187 }
188
189 void SVGDocumentExtensions::clearHasPendingResourcesIfPossible(Element* element)
190 {
191     if (!isElementWithPendingResources(element))
192         element->clearHasPendingResources();
193 }
194
195 void SVGDocumentExtensions::removeElementFromPendingResources(Element* element)
196 {
197     ASSERT(element);
198
199     // Remove the element from pending resources.
200     if (!m_pendingResources.isEmpty() && element->hasPendingResources()) {
201         Vector<AtomicString> toBeRemoved;
202         for (auto& resource : m_pendingResources) {
203             PendingElements* elements = resource.value.get();
204             ASSERT(elements);
205             ASSERT(!elements->isEmpty());
206
207             elements->remove(element);
208             if (elements->isEmpty())
209                 toBeRemoved.append(resource.key);
210         }
211
212         clearHasPendingResourcesIfPossible(element);
213
214         // We use the removePendingResource function here because it deals with set lifetime correctly.
215         for (auto& resource : toBeRemoved)
216             removePendingResource(resource);
217     }
218
219     // Remove the element from pending resources that were scheduled for removal.
220     if (!m_pendingResourcesForRemoval.isEmpty()) {
221         Vector<AtomicString> toBeRemoved;
222         for (auto& resource : m_pendingResourcesForRemoval) {
223             PendingElements* elements = resource.value.get();
224             ASSERT(elements);
225             ASSERT(!elements->isEmpty());
226
227             elements->remove(element);
228             if (elements->isEmpty())
229                 toBeRemoved.append(resource.key);
230         }
231
232         // We use the removePendingResourceForRemoval function here because it deals with set lifetime correctly.
233         for (auto& resource : toBeRemoved)
234             removePendingResourceForRemoval(resource);
235     }
236 }
237
238 std::unique_ptr<SVGDocumentExtensions::PendingElements> SVGDocumentExtensions::removePendingResource(const AtomicString& id)
239 {
240     ASSERT(m_pendingResources.contains(id));
241     return m_pendingResources.take(id);
242 }
243
244 std::unique_ptr<SVGDocumentExtensions::PendingElements> SVGDocumentExtensions::removePendingResourceForRemoval(const AtomicString& id)
245 {
246     ASSERT(m_pendingResourcesForRemoval.contains(id));
247     return m_pendingResourcesForRemoval.take(id);
248 }
249
250 void SVGDocumentExtensions::markPendingResourcesForRemoval(const AtomicString& id)
251 {
252     if (id.isEmpty())
253         return;
254
255     ASSERT(!m_pendingResourcesForRemoval.contains(id));
256
257     std::unique_ptr<PendingElements> existing = m_pendingResources.take(id);
258     if (existing && !existing->isEmpty())
259         m_pendingResourcesForRemoval.add(id, WTFMove(existing));
260 }
261
262 Element* SVGDocumentExtensions::removeElementFromPendingResourcesForRemovalMap(const AtomicString& id)
263 {
264     if (id.isEmpty())
265         return 0;
266
267     PendingElements* resourceSet = m_pendingResourcesForRemoval.get(id);
268     if (!resourceSet || resourceSet->isEmpty())
269         return 0;
270
271     auto firstElement = resourceSet->begin();
272     Element* element = *firstElement;
273
274     resourceSet->remove(firstElement);
275
276     if (resourceSet->isEmpty())
277         removePendingResourceForRemoval(id);
278
279     return element;
280 }
281
282 HashSet<SVGElement*>* SVGDocumentExtensions::setOfElementsReferencingTarget(SVGElement* referencedElement) const
283 {
284     ASSERT(referencedElement);
285     const auto it = m_elementDependencies.find(referencedElement);
286     if (it == m_elementDependencies.end())
287         return 0;
288     return it->value.get();
289 }
290
291 void SVGDocumentExtensions::addElementReferencingTarget(SVGElement* referencingElement, SVGElement* referencedElement)
292 {
293     ASSERT(referencingElement);
294     ASSERT(referencedElement);
295
296     if (HashSet<SVGElement*>* elements = m_elementDependencies.get(referencedElement)) {
297         elements->add(referencingElement);
298         return;
299     }
300
301     auto elements = std::make_unique<HashSet<SVGElement*>>();
302     elements->add(referencingElement);
303     m_elementDependencies.set(referencedElement, WTFMove(elements));
304 }
305
306 void SVGDocumentExtensions::removeAllTargetReferencesForElement(SVGElement* referencingElement)
307 {
308     Vector<SVGElement*> toBeRemoved;
309
310     for (auto& dependency : m_elementDependencies) {
311         SVGElement* referencedElement = dependency.key;
312         HashSet<SVGElement*>& referencingElements = *dependency.value;
313         referencingElements.remove(referencingElement);
314         if (referencingElements.isEmpty())
315             toBeRemoved.append(referencedElement);
316     }
317
318     for (auto& element : toBeRemoved)
319         m_elementDependencies.remove(element);
320 }
321
322 void SVGDocumentExtensions::rebuildElements()
323 {
324     Vector<SVGElement*> shadowRebuildElements = WTFMove(m_rebuildElements);
325     for (auto* element : shadowRebuildElements)
326         element->svgAttributeChanged(XLinkNames::hrefAttr);
327 }
328
329 void SVGDocumentExtensions::clearTargetDependencies(SVGElement& referencedElement)
330 {
331     auto it = m_elementDependencies.find(&referencedElement);
332     if (it == m_elementDependencies.end())
333         return;
334     ASSERT(it->key == &referencedElement);
335     HashSet<SVGElement*>* referencingElements = it->value.get();
336     for (auto* element : *referencingElements) {
337         m_rebuildElements.append(element);
338         element->callClearTarget();
339     }
340 }
341
342 void SVGDocumentExtensions::rebuildAllElementReferencesForTarget(SVGElement& referencedElement)
343 {
344     auto it = m_elementDependencies.find(&referencedElement);
345     if (it == m_elementDependencies.end())
346         return;
347     ASSERT(it->key == &referencedElement);
348
349     HashSet<SVGElement*>* referencingElements = it->value.get();
350     Vector<SVGElement*> elementsToRebuild;
351     elementsToRebuild.reserveInitialCapacity(referencingElements->size());
352     for (auto* element : *referencingElements)
353         elementsToRebuild.uncheckedAppend(element);
354
355     for (auto* element : elementsToRebuild)
356         element->svgAttributeChanged(XLinkNames::hrefAttr);
357 }
358
359 void SVGDocumentExtensions::removeAllElementReferencesForTarget(SVGElement* referencedElement)
360 {
361     m_elementDependencies.remove(referencedElement);
362     m_rebuildElements.removeFirst(referencedElement);
363 }
364
365 #if ENABLE(SVG_FONTS)
366 void SVGDocumentExtensions::registerSVGFontFaceElement(SVGFontFaceElement* element)
367 {
368     m_svgFontFaceElements.add(element);
369 }
370
371 void SVGDocumentExtensions::unregisterSVGFontFaceElement(SVGFontFaceElement* element)
372 {
373     ASSERT(m_svgFontFaceElements.contains(element));
374     m_svgFontFaceElements.remove(element);
375 }
376 #endif
377
378 }