r184718 and r184725 caused four tests to begin crashing
[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     auto end = m_timeContainers.end();
105     for (auto it = m_timeContainers.begin(); it != end; ++it)
106         (*it)->pauseAnimations();
107 }
108
109 void SVGDocumentExtensions::unpauseAnimations()
110 {
111     auto end = m_timeContainers.end();
112     for (auto it = m_timeContainers.begin(); it != end; ++it)
113         (*it)->unpauseAnimations();
114 }
115
116 void SVGDocumentExtensions::dispatchSVGLoadEventToOutermostSVGElements()
117 {
118     Vector<RefPtr<SVGSVGElement>> timeContainers;
119     timeContainers.appendRange(m_timeContainers.begin(), m_timeContainers.end());
120
121     auto end = timeContainers.end();
122     for (auto it = timeContainers.begin(); it != end; ++it) {
123         SVGSVGElement* outerSVG = (*it).get();
124         if (!outerSVG->isOutermostSVGSVGElement())
125             continue;
126         outerSVG->sendSVGLoadEventIfPossible();
127     }
128 }
129
130 static void reportMessage(Document* document, MessageLevel level, const String& message)
131 {
132     if (document->frame())
133         document->addConsoleMessage(MessageSource::Rendering, level, message);
134 }
135
136 void SVGDocumentExtensions::reportWarning(const String& message)
137 {
138     reportMessage(m_document, MessageLevel::Warning, "Warning: " + message);
139 }
140
141 void SVGDocumentExtensions::reportError(const String& message)
142 {
143     reportMessage(m_document, MessageLevel::Error, "Error: " + message);
144 }
145
146 void SVGDocumentExtensions::addPendingResource(const AtomicString& id, Element* element)
147 {
148     ASSERT(element);
149
150     if (id.isEmpty())
151         return;
152
153     auto result = m_pendingResources.add(id, nullptr);
154     if (result.isNewEntry)
155         result.iterator->value = std::make_unique<PendingElements>();
156     result.iterator->value->add(element);
157
158     element->setHasPendingResources();
159 }
160
161 bool SVGDocumentExtensions::isIdOfPendingResource(const AtomicString& id) const
162 {
163     if (id.isEmpty())
164         return false;
165
166     return m_pendingResources.contains(id);
167 }
168
169 bool SVGDocumentExtensions::isElementWithPendingResources(Element* element) const
170 {
171     // This algorithm takes time proportional to the number of pending resources and need not.
172     // If performance becomes an issue we can keep a counted set of elements and answer the question efficiently.
173     ASSERT(element);
174     auto end = m_pendingResources.end();
175     for (auto it = m_pendingResources.begin(); it != end; ++it) {
176         PendingElements* elements = it->value.get();
177         ASSERT(elements);
178
179         if (elements->contains(element))
180             return true;
181     }
182     return false;
183 }
184
185 bool SVGDocumentExtensions::isPendingResource(Element* element, const AtomicString& id) const
186 {
187     ASSERT(element);
188
189     if (!isIdOfPendingResource(id))
190         return false;
191
192     return m_pendingResources.get(id)->contains(element);
193 }
194
195 void SVGDocumentExtensions::clearHasPendingResourcesIfPossible(Element* element)
196 {
197     if (!isElementWithPendingResources(element))
198         element->clearHasPendingResources();
199 }
200
201 void SVGDocumentExtensions::removeElementFromPendingResources(Element* element)
202 {
203     ASSERT(element);
204
205     // Remove the element from pending resources.
206     if (!m_pendingResources.isEmpty() && element->hasPendingResources()) {
207         Vector<AtomicString> toBeRemoved;
208         auto end = m_pendingResources.end();
209         for (auto it = m_pendingResources.begin(); it != end; ++it) {
210             PendingElements* elements = it->value.get();
211             ASSERT(elements);
212             ASSERT(!elements->isEmpty());
213
214             elements->remove(element);
215             if (elements->isEmpty())
216                 toBeRemoved.append(it->key);
217         }
218
219         clearHasPendingResourcesIfPossible(element);
220
221         // We use the removePendingResource function here because it deals with set lifetime correctly.
222         auto vectorEnd = toBeRemoved.end();
223         for (auto it = toBeRemoved.begin(); it != vectorEnd; ++it)
224             removePendingResource(*it);
225     }
226
227     // Remove the element from pending resources that were scheduled for removal.
228     if (!m_pendingResourcesForRemoval.isEmpty()) {
229         Vector<AtomicString> toBeRemoved;
230         auto end = m_pendingResourcesForRemoval.end();
231         for (auto it = m_pendingResourcesForRemoval.begin(); it != end; ++it) {
232             PendingElements* elements = it->value.get();
233             ASSERT(elements);
234             ASSERT(!elements->isEmpty());
235
236             elements->remove(element);
237             if (elements->isEmpty())
238                 toBeRemoved.append(it->key);
239         }
240
241         // We use the removePendingResourceForRemoval function here because it deals with set lifetime correctly.
242         auto vectorEnd = toBeRemoved.end();
243         for (auto it = toBeRemoved.begin(); it != vectorEnd; ++it)
244             removePendingResourceForRemoval(*it);
245     }
246 }
247
248 std::unique_ptr<SVGDocumentExtensions::PendingElements> SVGDocumentExtensions::removePendingResource(const AtomicString& id)
249 {
250     ASSERT(m_pendingResources.contains(id));
251     return m_pendingResources.take(id);
252 }
253
254 std::unique_ptr<SVGDocumentExtensions::PendingElements> SVGDocumentExtensions::removePendingResourceForRemoval(const AtomicString& id)
255 {
256     ASSERT(m_pendingResourcesForRemoval.contains(id));
257     return m_pendingResourcesForRemoval.take(id);
258 }
259
260 void SVGDocumentExtensions::markPendingResourcesForRemoval(const AtomicString& id)
261 {
262     if (id.isEmpty())
263         return;
264
265     ASSERT(!m_pendingResourcesForRemoval.contains(id));
266
267     std::unique_ptr<PendingElements> existing = m_pendingResources.take(id);
268     if (existing && !existing->isEmpty())
269         m_pendingResourcesForRemoval.add(id, WTF::move(existing));
270 }
271
272 Element* SVGDocumentExtensions::removeElementFromPendingResourcesForRemovalMap(const AtomicString& id)
273 {
274     if (id.isEmpty())
275         return 0;
276
277     PendingElements* resourceSet = m_pendingResourcesForRemoval.get(id);
278     if (!resourceSet || resourceSet->isEmpty())
279         return 0;
280
281     auto firstElement = resourceSet->begin();
282     Element* element = *firstElement;
283
284     resourceSet->remove(firstElement);
285
286     if (resourceSet->isEmpty())
287         removePendingResourceForRemoval(id);
288
289     return element;
290 }
291
292 HashSet<SVGElement*>* SVGDocumentExtensions::setOfElementsReferencingTarget(SVGElement* referencedElement) const
293 {
294     ASSERT(referencedElement);
295     const auto it = m_elementDependencies.find(referencedElement);
296     if (it == m_elementDependencies.end())
297         return 0;
298     return it->value.get();
299 }
300
301 void SVGDocumentExtensions::addElementReferencingTarget(SVGElement* referencingElement, SVGElement* referencedElement)
302 {
303     ASSERT(referencingElement);
304     ASSERT(referencedElement);
305
306     if (HashSet<SVGElement*>* elements = m_elementDependencies.get(referencedElement)) {
307         elements->add(referencingElement);
308         return;
309     }
310
311     auto elements = std::make_unique<HashSet<SVGElement*>>();
312     elements->add(referencingElement);
313     m_elementDependencies.set(referencedElement, WTF::move(elements));
314 }
315
316 void SVGDocumentExtensions::removeAllTargetReferencesForElement(SVGElement* referencingElement)
317 {
318     Vector<SVGElement*> toBeRemoved;
319
320     auto end = m_elementDependencies.end();
321     for (auto it = m_elementDependencies.begin(); it != end; ++it) {
322         SVGElement* referencedElement = it->key;
323         HashSet<SVGElement*>& referencingElements = *it->value;
324         referencingElements.remove(referencingElement);
325         if (referencingElements.isEmpty())
326             toBeRemoved.append(referencedElement);
327     }
328
329     auto vectorEnd = toBeRemoved.end();
330     for (auto it = toBeRemoved.begin(); it != vectorEnd; ++it)
331         m_elementDependencies.remove(*it);
332 }
333
334 void SVGDocumentExtensions::rebuildElements()
335 {
336     Vector<SVGElement*> shadowRebuildElements = WTF::move(m_rebuildElements);
337     for (auto* element : shadowRebuildElements)
338         element->svgAttributeChanged(XLinkNames::hrefAttr);
339 }
340
341 void SVGDocumentExtensions::clearTargetDependencies(SVGElement& referencedElement)
342 {
343     auto it = m_elementDependencies.find(&referencedElement);
344     if (it == m_elementDependencies.end())
345         return;
346     ASSERT(it->key == &referencedElement);
347     HashSet<SVGElement*>* referencingElements = it->value.get();
348     for (auto* element : *referencingElements) {
349         m_rebuildElements.append(element);
350         element->callClearTarget();
351     }
352 }
353
354 void SVGDocumentExtensions::rebuildAllElementReferencesForTarget(SVGElement& referencedElement)
355 {
356     auto it = m_elementDependencies.find(&referencedElement);
357     if (it == m_elementDependencies.end())
358         return;
359     ASSERT(it->key == &referencedElement);
360
361     HashSet<SVGElement*>* referencingElements = it->value.get();
362     Vector<SVGElement*> elementsToRebuild;
363     elementsToRebuild.reserveInitialCapacity(referencingElements->size());
364     for (auto* element : *referencingElements)
365         elementsToRebuild.uncheckedAppend(element);
366
367     for (auto* element : elementsToRebuild)
368         element->svgAttributeChanged(XLinkNames::hrefAttr);
369 }
370
371 void SVGDocumentExtensions::removeAllElementReferencesForTarget(SVGElement* referencedElement)
372 {
373     m_elementDependencies.remove(referencedElement);
374     m_rebuildElements.removeFirst(referencedElement);
375 }
376
377 #if ENABLE(SVG_FONTS)
378 void SVGDocumentExtensions::registerSVGFontFaceElement(SVGFontFaceElement* element)
379 {
380     m_svgFontFaceElements.add(element);
381 }
382
383 void SVGDocumentExtensions::unregisterSVGFontFaceElement(SVGFontFaceElement* element)
384 {
385     ASSERT(m_svgFontFaceElements.contains(element));
386     m_svgFontFaceElements.remove(element);
387 }
388 #endif
389
390 }