Remove unnecessary #include SVGResourcesCache.h in SVGDocumentExtensions.h; use forwa...
[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
24 #if ENABLE(SVG)
25 #include "SVGDocumentExtensions.h"
26
27 #include "Console.h"
28 #include "DOMWindow.h"
29 #include "Document.h"
30 #include "EventListener.h"
31 #include "Frame.h"
32 #include "FrameLoader.h"
33 #include "Page.h"
34 #include "SMILTimeContainer.h"
35 #include "SVGElement.h"
36 #include "SVGResourcesCache.h"
37 #include "SVGSMILElement.h"
38 #include "SVGSVGElement.h"
39 #include "ScriptableDocumentParser.h"
40 #include <wtf/text/AtomicString.h>
41
42 namespace WebCore {
43
44 SVGDocumentExtensions::SVGDocumentExtensions(Document* document)
45     : m_document(document)
46     , m_resourcesCache(adoptPtr(new SVGResourcesCache))
47 {
48 }
49
50 SVGDocumentExtensions::~SVGDocumentExtensions()
51 {
52     deleteAllValues(m_animatedElements);
53     deleteAllValues(m_pendingResources);
54 }
55
56 void SVGDocumentExtensions::addTimeContainer(SVGSVGElement* element)
57 {
58     m_timeContainers.add(element);
59 }
60
61 void SVGDocumentExtensions::removeTimeContainer(SVGSVGElement* element)
62 {
63     m_timeContainers.remove(element);
64 }
65
66 void SVGDocumentExtensions::addResource(const AtomicString& id, RenderSVGResourceContainer* resource)
67 {
68     ASSERT(resource);
69
70     if (id.isEmpty())
71         return;
72
73     // Replaces resource if already present, to handle potential id changes
74     m_resources.set(id, resource);
75 }
76
77 void SVGDocumentExtensions::removeResource(const AtomicString& id)
78 {
79     if (id.isEmpty() || !m_resources.contains(id))
80         return;
81
82     m_resources.remove(id);
83 }
84
85 RenderSVGResourceContainer* SVGDocumentExtensions::resourceById(const AtomicString& id) const
86 {
87     if (id.isEmpty())
88         return 0;
89
90     return m_resources.get(id);
91 }
92
93 void SVGDocumentExtensions::startAnimations()
94 {
95     // FIXME: Eventually every "Time Container" will need a way to latch on to some global timer
96     // starting animations for a document will do this "latching"
97     // FIXME: We hold a ref pointers to prevent a shadow tree from getting removed out from underneath us.
98     // In the future we should refactor the use-element to avoid this. See https://webkit.org/b/53704
99     Vector<RefPtr<SVGSVGElement> > timeContainers;
100     timeContainers.appendRange(m_timeContainers.begin(), m_timeContainers.end());
101     Vector<RefPtr<SVGSVGElement> >::iterator end = timeContainers.end();
102     for (Vector<RefPtr<SVGSVGElement> >::iterator itr = timeContainers.begin(); itr != end; ++itr)
103         (*itr)->timeContainer()->begin();
104 }
105     
106 void SVGDocumentExtensions::pauseAnimations()
107 {
108     HashSet<SVGSVGElement*>::iterator end = m_timeContainers.end();
109     for (HashSet<SVGSVGElement*>::iterator itr = m_timeContainers.begin(); itr != end; ++itr)
110         (*itr)->pauseAnimations();
111 }
112
113 void SVGDocumentExtensions::unpauseAnimations()
114 {
115     HashSet<SVGSVGElement*>::iterator end = m_timeContainers.end();
116     for (HashSet<SVGSVGElement*>::iterator itr = m_timeContainers.begin(); itr != end; ++itr)
117         (*itr)->unpauseAnimations();
118 }
119
120 bool SVGDocumentExtensions::sampleAnimationAtTime(const String& elementId, SVGSMILElement* element, double time)
121 {
122     ASSERT(element);
123     SMILTimeContainer* container = element->timeContainer();
124     if (!container || container->isPaused())
125         return false;
126
127     container->sampleAnimationAtTime(elementId, time);
128     return true;
129 }
130
131 void SVGDocumentExtensions::addAnimationElementToTarget(SVGSMILElement* animationElement, SVGElement* targetElement)
132 {
133     ASSERT(targetElement);
134     ASSERT(animationElement);
135
136     if (HashSet<SVGSMILElement*>* animationElementsForTarget = m_animatedElements.get(targetElement)) {
137         animationElementsForTarget->add(animationElement);
138         return;
139     }
140
141     HashSet<SVGSMILElement*>* animationElementsForTarget = new HashSet<SVGSMILElement*>;
142     animationElementsForTarget->add(animationElement);
143     m_animatedElements.set(targetElement, animationElementsForTarget);
144 }
145
146 void SVGDocumentExtensions::removeAnimationElementFromTarget(SVGSMILElement* animationElement, SVGElement* targetElement)
147 {
148     ASSERT(targetElement);
149     ASSERT(animationElement);
150
151     HashMap<SVGElement*, HashSet<SVGSMILElement*>* >::iterator it = m_animatedElements.find(targetElement);
152     ASSERT(it != m_animatedElements.end());
153     
154     HashSet<SVGSMILElement*>* animationElementsForTarget = it->second;
155     ASSERT(!animationElementsForTarget->isEmpty());
156
157     animationElementsForTarget->remove(animationElement);
158     if (animationElementsForTarget->isEmpty()) {
159         m_animatedElements.remove(it);
160         delete animationElementsForTarget;
161     }
162 }
163
164 void SVGDocumentExtensions::removeAllAnimationElementsFromTarget(SVGElement* targetElement)
165 {
166     ASSERT(targetElement);
167     HashSet<SVGSMILElement*>* animationElementsForTarget = m_animatedElements.take(targetElement);
168     if (!animationElementsForTarget)
169         return;
170     HashSet<SVGSMILElement*>::iterator it = animationElementsForTarget->begin();
171     HashSet<SVGSMILElement*>::iterator end = animationElementsForTarget->end();
172     for (; it != end; ++it)
173         (*it)->resetTargetElement();
174     delete animationElementsForTarget;
175 }
176
177 // FIXME: Callers should probably use ScriptController::eventHandlerLineNumber()
178 static int parserLineNumber(Document* document)
179 {
180     ScriptableDocumentParser* parser = document->scriptableDocumentParser();
181     if (!parser)
182         return 1;
183     return parser->lineNumber().oneBasedInt();
184 }
185
186 static void reportMessage(Document* document, MessageLevel level, const String& message)
187 {
188     if (Frame* frame = document->frame())
189         frame->domWindow()->console()->addMessage(JSMessageSource, LogMessageType, level, message, parserLineNumber(document), document->documentURI());
190 }
191
192 void SVGDocumentExtensions::reportWarning(const String& message)
193 {
194     reportMessage(m_document, WarningMessageLevel, "Warning: " + message);
195 }
196
197 void SVGDocumentExtensions::reportError(const String& message)
198 {
199     reportMessage(m_document, ErrorMessageLevel, "Error: " + message);
200 }
201
202 void SVGDocumentExtensions::addPendingResource(const AtomicString& id, SVGStyledElement* element)
203 {
204     ASSERT(element);
205
206     if (id.isEmpty())
207         return;
208
209     // The HashMap add function leaves the map alone and returns a pointer to the element in the
210     // map if the element already exists. So we add with a value of 0, and it either finds the
211     // existing element or adds a new one in a single operation. The ".first->second" idiom gets
212     // us to the iterator from add's result, and then to the value inside the hash table.
213     SVGPendingElements*& set = m_pendingResources.add(id, 0).first->second;
214     if (!set)
215         set = new SVGPendingElements;
216     set->add(element);
217
218     element->setHasPendingResources();
219 }
220
221 bool SVGDocumentExtensions::hasPendingResources(const AtomicString& id) const
222 {
223     if (id.isEmpty())
224         return false;
225
226     return m_pendingResources.contains(id);
227 }
228
229 bool SVGDocumentExtensions::isElementInPendingResources(SVGStyledElement* element) const
230 {
231     // This algorithm takes time proportional to the number of pending resources and need not.
232     // If performance becomes an issue we can keep a counted set of elements and answer the question efficiently.
233
234     ASSERT(element);
235
236     HashMap<AtomicString, SVGPendingElements*>::const_iterator end = m_pendingResources.end();
237     for (HashMap<AtomicString, SVGPendingElements*>::const_iterator it = m_pendingResources.begin(); it != end; ++it) {
238         SVGPendingElements* elements = it->second;
239         ASSERT(elements);
240
241         if (elements->contains(element))
242             return true;
243     }
244     return false;
245 }
246
247 void SVGDocumentExtensions::removeElementFromPendingResources(SVGStyledElement* element)
248 {
249     ASSERT(element);
250
251     if (m_pendingResources.isEmpty() || !element->hasPendingResources())
252         return;
253
254     Vector<AtomicString> toBeRemoved;
255     HashMap<AtomicString, SVGPendingElements*>::iterator end = m_pendingResources.end();
256     for (HashMap<AtomicString, SVGPendingElements*>::iterator it = m_pendingResources.begin(); it != end; ++it) {
257         SVGPendingElements* elements = it->second;
258         ASSERT(elements);
259         ASSERT(!elements->isEmpty());
260
261         elements->remove(element);
262         if (elements->isEmpty())
263             toBeRemoved.append(it->first);
264     }
265
266     element->clearHasPendingResourcesIfPossible();
267
268     // We use the removePendingResource function here because it deals with set lifetime correctly.
269     Vector<AtomicString>::iterator endVector = toBeRemoved.end();
270     for (Vector<AtomicString>::iterator it = toBeRemoved.begin(); it != endVector; ++it)
271         removePendingResource(*it);
272 }
273
274 PassOwnPtr<SVGDocumentExtensions::SVGPendingElements> SVGDocumentExtensions::removePendingResource(const AtomicString& id)
275 {
276     ASSERT(m_pendingResources.contains(id));
277     return adoptPtr(m_pendingResources.take(id));
278 }
279
280 }
281
282 #endif