Add a stubbed out StorageAreaMap class
[WebKit-https.git] / Source / WebCore / page / animation / AnimationController.cpp
1 /*
2  * Copyright (C) 2007, 2008, 2009 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer. 
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution. 
13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission. 
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #include "config.h"
30 #include "AnimationController.h"
31
32 #include "AnimationBase.h"
33 #include "AnimationControllerPrivate.h"
34 #include "CSSParser.h"
35 #include "CSSPropertyAnimation.h"
36 #include "CompositeAnimation.h"
37 #include "EventNames.h"
38 #include "Frame.h"
39 #include "FrameView.h"
40 #include "PseudoElement.h"
41 #include "RenderView.h"
42 #include "TransitionEvent.h"
43 #include "WebKitAnimationEvent.h"
44 #include "WebKitTransitionEvent.h"
45 #include <wtf/CurrentTime.h>
46 #include <wtf/UnusedParam.h>
47
48 namespace WebCore {
49
50 static const double cAnimationTimerDelay = 0.025;
51 static const double cBeginAnimationUpdateTimeNotSet = -1;
52
53 AnimationControllerPrivate::AnimationControllerPrivate(Frame* frame)
54     : m_animationTimer(this, &AnimationControllerPrivate::animationTimerFired)
55     , m_updateStyleIfNeededDispatcher(this, &AnimationControllerPrivate::updateStyleIfNeededDispatcherFired)
56     , m_frame(frame)
57     , m_beginAnimationUpdateTime(cBeginAnimationUpdateTimeNotSet)
58     , m_animationsWaitingForStyle()
59     , m_animationsWaitingForStartTimeResponse()
60     , m_waitingForAsyncStartNotification(false)
61 {
62 }
63
64 AnimationControllerPrivate::~AnimationControllerPrivate()
65 {
66 }
67
68 PassRefPtr<CompositeAnimation> AnimationControllerPrivate::accessCompositeAnimation(RenderObject* renderer)
69 {
70     RefPtr<CompositeAnimation> animation = m_compositeAnimations.get(renderer);
71     if (!animation) {
72         animation = CompositeAnimation::create(this);
73         m_compositeAnimations.set(renderer, animation);
74     }
75     return animation;
76 }
77
78 bool AnimationControllerPrivate::clear(RenderObject* renderer)
79 {
80     // Return false if we didn't do anything OR we are suspended (so we don't try to
81     // do a setNeedsStyleRecalc() when suspended).
82     PassRefPtr<CompositeAnimation> animation = m_compositeAnimations.take(renderer);
83     if (!animation)
84         return false;
85     animation->clearRenderer();
86     return animation->suspended();
87 }
88
89 double AnimationControllerPrivate::updateAnimations(SetChanged callSetChanged/* = DoNotCallSetChanged*/)
90 {
91     double timeToNextService = -1;
92     bool calledSetChanged = false;
93
94     RenderObjectAnimationMap::const_iterator animationsEnd = m_compositeAnimations.end();
95     for (RenderObjectAnimationMap::const_iterator it = m_compositeAnimations.begin(); it != animationsEnd; ++it) {
96         CompositeAnimation* compAnim = it->value.get();
97         if (!compAnim->suspended() && compAnim->hasAnimations()) {
98             double t = compAnim->timeToNextService();
99             if (t != -1 && (t < timeToNextService || timeToNextService == -1))
100                 timeToNextService = t;
101             if (!timeToNextService) {
102                 if (callSetChanged == CallSetChanged) {
103                     Node* node = it->key->node();
104                     ASSERT(!node || (node->document() && !node->document()->inPageCache()));
105                     node->setNeedsStyleRecalc(SyntheticStyleChange);
106                     calledSetChanged = true;
107                 }
108                 else
109                     break;
110             }
111         }
112     }
113
114     if (calledSetChanged)
115         m_frame->document()->updateStyleIfNeeded();
116
117     return timeToNextService;
118 }
119
120 void AnimationControllerPrivate::updateAnimationTimerForRenderer(RenderObject* renderer)
121 {
122     double timeToNextService = 0;
123
124     RefPtr<CompositeAnimation> compAnim = m_compositeAnimations.get(renderer);
125     if (!compAnim->suspended() && compAnim->hasAnimations())
126         timeToNextService = compAnim->timeToNextService();
127
128     if (m_animationTimer.isActive() && (m_animationTimer.repeatInterval() || m_animationTimer.nextFireInterval() <= timeToNextService))
129         return;
130
131     m_animationTimer.startOneShot(timeToNextService);
132 }
133
134 void AnimationControllerPrivate::updateAnimationTimer(SetChanged callSetChanged/* = DoNotCallSetChanged*/)
135 {
136     double timeToNextService = updateAnimations(callSetChanged);
137
138     // If we want service immediately, we start a repeating timer to reduce the overhead of starting
139     if (!timeToNextService) {
140         if (!m_animationTimer.isActive() || m_animationTimer.repeatInterval() == 0)
141             m_animationTimer.startRepeating(cAnimationTimerDelay);
142         return;
143     }
144
145     // If we don't need service, we want to make sure the timer is no longer running
146     if (timeToNextService < 0) {
147         if (m_animationTimer.isActive())
148             m_animationTimer.stop();
149         return;
150     }
151
152     // Otherwise, we want to start a one-shot timer so we get here again
153     m_animationTimer.startOneShot(timeToNextService);
154 }
155
156 void AnimationControllerPrivate::updateStyleIfNeededDispatcherFired(Timer<AnimationControllerPrivate>*)
157 {
158     fireEventsAndUpdateStyle();
159 }
160
161 void AnimationControllerPrivate::fireEventsAndUpdateStyle()
162 {
163     // Protect the frame from getting destroyed in the event handler
164     RefPtr<Frame> protector = m_frame;
165
166     bool updateStyle = !m_eventsToDispatch.isEmpty() || !m_nodeChangesToDispatch.isEmpty();
167
168     // fire all the events
169     Vector<EventToDispatch> eventsToDispatch = m_eventsToDispatch;
170     m_eventsToDispatch.clear();
171     Vector<EventToDispatch>::const_iterator eventsToDispatchEnd = eventsToDispatch.end();
172     for (Vector<EventToDispatch>::const_iterator it = eventsToDispatch.begin(); it != eventsToDispatchEnd; ++it) {
173         Element* element = it->element.get();
174         if (it->eventType == eventNames().transitionendEvent)
175             element->dispatchEvent(TransitionEvent::create(it->eventType, it->name, it->elapsedTime, PseudoElement::pseudoElementNameForEvents(element->pseudoId())));
176         else
177             element->dispatchEvent(WebKitAnimationEvent::create(it->eventType, it->name, it->elapsedTime));
178     }
179
180     // call setChanged on all the elements
181     Vector<RefPtr<Node> >::const_iterator nodeChangesToDispatchEnd = m_nodeChangesToDispatch.end();
182     for (Vector<RefPtr<Node> >::const_iterator it = m_nodeChangesToDispatch.begin(); it != nodeChangesToDispatchEnd; ++it)
183         (*it)->setNeedsStyleRecalc(SyntheticStyleChange);
184
185     m_nodeChangesToDispatch.clear();
186
187     if (updateStyle && m_frame)
188         m_frame->document()->updateStyleIfNeeded();
189 }
190
191 void AnimationControllerPrivate::startUpdateStyleIfNeededDispatcher()
192 {
193     if (!m_updateStyleIfNeededDispatcher.isActive())
194         m_updateStyleIfNeededDispatcher.startOneShot(0);
195 }
196
197 void AnimationControllerPrivate::addEventToDispatch(PassRefPtr<Element> element, const AtomicString& eventType, const String& name, double elapsedTime)
198 {
199     m_eventsToDispatch.grow(m_eventsToDispatch.size()+1);
200     EventToDispatch& event = m_eventsToDispatch[m_eventsToDispatch.size()-1];
201     event.element = element;
202     event.eventType = eventType;
203     event.name = name;
204     event.elapsedTime = elapsedTime;
205     
206     startUpdateStyleIfNeededDispatcher();
207 }
208
209 void AnimationControllerPrivate::addNodeChangeToDispatch(PassRefPtr<Node> node)
210 {
211     ASSERT(!node || (node->document() && !node->document()->inPageCache()));
212     if (!node)
213         return;
214
215     m_nodeChangesToDispatch.append(node);
216     startUpdateStyleIfNeededDispatcher();
217 }
218
219 #if ENABLE(REQUEST_ANIMATION_FRAME)
220 void AnimationControllerPrivate::animationFrameCallbackFired()
221 {
222     double timeToNextService = updateAnimations(CallSetChanged);
223
224     if (timeToNextService >= 0)
225         m_frame->document()->view()->scheduleAnimation();
226 }
227 #endif
228
229 void AnimationControllerPrivate::animationTimerFired(Timer<AnimationControllerPrivate>*)
230 {
231     // Make sure animationUpdateTime is updated, so that it is current even if no
232     // styleChange has happened (e.g. accelerated animations)
233     setBeginAnimationUpdateTime(cBeginAnimationUpdateTimeNotSet);
234
235     // When the timer fires, all we do is call setChanged on all DOM nodes with running animations and then do an immediate
236     // updateStyleIfNeeded.  It will then call back to us with new information.
237     updateAnimationTimer(CallSetChanged);
238
239     // Fire events right away, to avoid a flash of unanimated style after an animation completes, and before
240     // the 'end' event fires.
241     fireEventsAndUpdateStyle();
242 }
243
244 bool AnimationControllerPrivate::isRunningAnimationOnRenderer(RenderObject* renderer, CSSPropertyID property, bool isRunningNow) const
245 {
246     RefPtr<CompositeAnimation> animation = m_compositeAnimations.get(renderer);
247     if (!animation)
248         return false;
249
250     return animation->isAnimatingProperty(property, false, isRunningNow);
251 }
252
253 bool AnimationControllerPrivate::isRunningAcceleratedAnimationOnRenderer(RenderObject* renderer, CSSPropertyID property, bool isRunningNow) const
254 {
255     RefPtr<CompositeAnimation> animation = m_compositeAnimations.get(renderer);
256     if (!animation)
257         return false;
258
259     return animation->isAnimatingProperty(property, true, isRunningNow);
260 }
261
262 void AnimationControllerPrivate::suspendAnimations()
263 {
264     suspendAnimationsForDocument(m_frame->document());
265     
266     // Traverse subframes
267     for (Frame* child = m_frame->tree()->firstChild(); child; child = child->tree()->nextSibling())
268         child->animation()->suspendAnimations();
269 }
270
271 void AnimationControllerPrivate::resumeAnimations()
272 {
273     resumeAnimationsForDocument(m_frame->document());
274     
275     // Traverse subframes
276     for (Frame* child = m_frame->tree()->firstChild(); child; child = child->tree()->nextSibling())
277         child->animation()->resumeAnimations();
278 }
279
280 void AnimationControllerPrivate::suspendAnimationsForDocument(Document* document)
281 {
282     setBeginAnimationUpdateTime(cBeginAnimationUpdateTimeNotSet);
283     
284     RenderObjectAnimationMap::const_iterator animationsEnd = m_compositeAnimations.end();
285     for (RenderObjectAnimationMap::const_iterator it = m_compositeAnimations.begin(); it != animationsEnd; ++it) {
286         RenderObject* renderer = it->key;
287         if (renderer->document() == document) {
288             CompositeAnimation* compAnim = it->value.get();
289             compAnim->suspendAnimations();
290         }
291     }
292     
293     updateAnimationTimer();
294 }
295
296 void AnimationControllerPrivate::resumeAnimationsForDocument(Document* document)
297 {
298     setBeginAnimationUpdateTime(cBeginAnimationUpdateTimeNotSet);
299     
300     RenderObjectAnimationMap::const_iterator animationsEnd = m_compositeAnimations.end();
301     for (RenderObjectAnimationMap::const_iterator it = m_compositeAnimations.begin(); it != animationsEnd; ++it) {
302         RenderObject* renderer = it->key;
303         if (renderer->document() == document) {
304             CompositeAnimation* compAnim = it->value.get();
305             compAnim->resumeAnimations();
306         }
307     }
308     
309     updateAnimationTimer();
310 }
311
312 bool AnimationControllerPrivate::pauseAnimationAtTime(RenderObject* renderer, const AtomicString& name, double t)
313 {
314     if (!renderer)
315         return false;
316
317     RefPtr<CompositeAnimation> compAnim = accessCompositeAnimation(renderer);
318     if (!compAnim)
319         return false;
320
321     if (compAnim->pauseAnimationAtTime(name, t)) {
322         renderer->node()->setNeedsStyleRecalc(SyntheticStyleChange);
323         startUpdateStyleIfNeededDispatcher();
324         return true;
325     }
326
327     return false;
328 }
329
330 bool AnimationControllerPrivate::pauseTransitionAtTime(RenderObject* renderer, const String& property, double t)
331 {
332     if (!renderer)
333         return false;
334
335     RefPtr<CompositeAnimation> compAnim = accessCompositeAnimation(renderer);
336     if (!compAnim)
337         return false;
338
339     if (compAnim->pauseTransitionAtTime(cssPropertyID(property), t)) {
340         renderer->node()->setNeedsStyleRecalc(SyntheticStyleChange);
341         startUpdateStyleIfNeededDispatcher();
342         return true;
343     }
344
345     return false;
346 }
347
348 double AnimationControllerPrivate::beginAnimationUpdateTime()
349 {
350     if (m_beginAnimationUpdateTime == cBeginAnimationUpdateTimeNotSet)
351         m_beginAnimationUpdateTime = currentTime();
352     return m_beginAnimationUpdateTime;
353 }
354
355 void AnimationControllerPrivate::endAnimationUpdate()
356 {
357     styleAvailable();
358     if (!m_waitingForAsyncStartNotification)
359         startTimeResponse(beginAnimationUpdateTime());
360 }
361
362 void AnimationControllerPrivate::receivedStartTimeResponse(double time)
363 {
364     m_waitingForAsyncStartNotification = false;
365     startTimeResponse(time);
366 }
367
368 PassRefPtr<RenderStyle> AnimationControllerPrivate::getAnimatedStyleForRenderer(RenderObject* renderer)
369 {
370     if (!renderer)
371         return 0;
372
373     RefPtr<CompositeAnimation> rendererAnimations = m_compositeAnimations.get(renderer);
374     if (!rendererAnimations)
375         return renderer->style();
376     
377     RefPtr<RenderStyle> animatingStyle = rendererAnimations->getAnimatedStyle();
378     if (!animatingStyle)
379         animatingStyle = renderer->style();
380     
381     return animatingStyle.release();
382 }
383
384 unsigned AnimationControllerPrivate::numberOfActiveAnimations(Document* document) const
385 {
386     unsigned count = 0;
387     
388     RenderObjectAnimationMap::const_iterator animationsEnd = m_compositeAnimations.end();
389     for (RenderObjectAnimationMap::const_iterator it = m_compositeAnimations.begin(); it != animationsEnd; ++it) {
390         RenderObject* renderer = it->key;
391         CompositeAnimation* compAnim = it->value.get();
392         if (renderer->document() == document)
393             count += compAnim->numberOfActiveAnimations();
394     }
395     
396     return count;
397 }
398
399 void AnimationControllerPrivate::addToAnimationsWaitingForStyle(AnimationBase* animation)
400 {
401     // Make sure this animation is not in the start time waiters
402     m_animationsWaitingForStartTimeResponse.remove(animation);
403
404     m_animationsWaitingForStyle.add(animation);
405 }
406
407 void AnimationControllerPrivate::removeFromAnimationsWaitingForStyle(AnimationBase* animationToRemove)
408 {
409     m_animationsWaitingForStyle.remove(animationToRemove);
410 }
411
412 void AnimationControllerPrivate::styleAvailable()
413 {
414     // Go through list of waiters and send them on their way
415     WaitingAnimationsSet::const_iterator it = m_animationsWaitingForStyle.begin();
416     WaitingAnimationsSet::const_iterator end = m_animationsWaitingForStyle.end();
417     for (; it != end; ++it)
418         (*it)->styleAvailable();
419
420     m_animationsWaitingForStyle.clear();
421 }
422
423 void AnimationControllerPrivate::addToAnimationsWaitingForStartTimeResponse(AnimationBase* animation, bool willGetResponse)
424 {
425     // If willGetResponse is true, it means this animation is actually waiting for a response
426     // (which will come in as a call to notifyAnimationStarted()).
427     // In that case we don't need to add it to this list. We just set a waitingForAResponse flag 
428     // which says we are waiting for the response. If willGetResponse is false, this animation 
429     // is not waiting for a response for itself, but rather for a notifyXXXStarted() call for 
430     // another animation to which it will sync.
431     //
432     // When endAnimationUpdate() is called we check to see if the waitingForAResponse flag is
433     // true. If so, we just return and will do our work when the first notifyXXXStarted() call
434     // comes in. If it is false, we will not be getting a notifyXXXStarted() call, so we will
435     // do our work right away. In both cases we call the onAnimationStartResponse() method
436     // on each animation. In the first case we send in the time we got from notifyXXXStarted().
437     // In the second case, we just pass in the beginAnimationUpdateTime().
438     //
439     // This will synchronize all software and accelerated animations started in the same 
440     // updateStyleIfNeeded cycle.
441     //
442     
443     if (willGetResponse)
444         m_waitingForAsyncStartNotification = true;
445     
446     m_animationsWaitingForStartTimeResponse.add(animation);
447 }
448
449 void AnimationControllerPrivate::removeFromAnimationsWaitingForStartTimeResponse(AnimationBase* animationToRemove)
450 {
451     m_animationsWaitingForStartTimeResponse.remove(animationToRemove);
452     
453     if (m_animationsWaitingForStartTimeResponse.isEmpty())
454         m_waitingForAsyncStartNotification = false;
455 }
456
457 void AnimationControllerPrivate::startTimeResponse(double time)
458 {
459     // Go through list of waiters and send them on their way
460
461     WaitingAnimationsSet::const_iterator it = m_animationsWaitingForStartTimeResponse.begin();
462     WaitingAnimationsSet::const_iterator end = m_animationsWaitingForStartTimeResponse.end();
463     for (; it != end; ++it)
464         (*it)->onAnimationStartResponse(time);
465     
466     m_animationsWaitingForStartTimeResponse.clear();
467     m_waitingForAsyncStartNotification = false;
468 }
469
470 void AnimationControllerPrivate::animationWillBeRemoved(AnimationBase* animation)
471 {
472     removeFromAnimationsWaitingForStyle(animation);
473     removeFromAnimationsWaitingForStartTimeResponse(animation);
474 }
475
476 AnimationController::AnimationController(Frame* frame)
477     : m_data(adoptPtr(new AnimationControllerPrivate(frame)))
478     , m_beginAnimationUpdateCount(0)
479 {
480 }
481
482 AnimationController::~AnimationController()
483 {
484 }
485
486 void AnimationController::cancelAnimations(RenderObject* renderer)
487 {
488     if (!m_data->hasAnimations())
489         return;
490
491     if (m_data->clear(renderer)) {
492         Node* node = renderer->node();
493         ASSERT(!node || (node->document() && !node->document()->inPageCache()));
494         if (node)
495             node->setNeedsStyleRecalc(SyntheticStyleChange);
496     }
497 }
498
499 PassRefPtr<RenderStyle> AnimationController::updateAnimations(RenderObject* renderer, RenderStyle* newStyle)
500 {
501     // Don't do anything if we're in the cache
502     if (!renderer->document() || renderer->document()->inPageCache())
503         return newStyle;
504
505     RenderStyle* oldStyle = renderer->style();
506
507     if ((!oldStyle || (!oldStyle->animations() && !oldStyle->transitions())) && (!newStyle->animations() && !newStyle->transitions()))
508         return newStyle;
509
510     // Don't run transitions when printing.
511     if (renderer->view()->printing())
512         return newStyle;
513
514     // Fetch our current set of implicit animations from a hashtable.  We then compare them
515     // against the animations in the style and make sure we're in sync.  If destination values
516     // have changed, we reset the animation.  We then do a blend to get new values and we return
517     // a new style.
518
519     // We don't support anonymous pseudo elements like :first-line or :first-letter.
520     ASSERT(renderer->node());
521
522     RefPtr<CompositeAnimation> rendererAnimations = m_data->accessCompositeAnimation(renderer);
523     RefPtr<RenderStyle> blendedStyle = rendererAnimations->animate(renderer, oldStyle, newStyle);
524
525     if (renderer->parent() || newStyle->animations() || (oldStyle && oldStyle->animations())) {
526         m_data->updateAnimationTimerForRenderer(renderer);
527 #if ENABLE(REQUEST_ANIMATION_FRAME)
528         if (FrameView* view = renderer->document()->view())
529             view->scheduleAnimation();
530 #endif
531     }
532
533     if (blendedStyle != newStyle) {
534         // If the animations/transitions change opacity or transform, we need to update
535         // the style to impose the stacking rules. Note that this is also
536         // done in StyleResolver::adjustRenderStyle().
537         if (blendedStyle->hasAutoZIndex() && (blendedStyle->opacity() < 1.0f || blendedStyle->hasTransform()))
538             blendedStyle->setZIndex(0);
539     }
540     return blendedStyle.release();
541 }
542
543 PassRefPtr<RenderStyle> AnimationController::getAnimatedStyleForRenderer(RenderObject* renderer)
544 {
545     return m_data->getAnimatedStyleForRenderer(renderer);
546 }
547
548 void AnimationController::notifyAnimationStarted(RenderObject*, double startTime)
549 {
550     m_data->receivedStartTimeResponse(startTime);
551 }
552
553 bool AnimationController::pauseAnimationAtTime(RenderObject* renderer, const AtomicString& name, double t)
554 {
555     return m_data->pauseAnimationAtTime(renderer, name, t);
556 }
557
558 unsigned AnimationController::numberOfActiveAnimations(Document* document) const
559 {
560     return m_data->numberOfActiveAnimations(document);
561 }
562
563 bool AnimationController::pauseTransitionAtTime(RenderObject* renderer, const String& property, double t)
564 {
565     return m_data->pauseTransitionAtTime(renderer, property, t);
566 }
567
568 bool AnimationController::isRunningAnimationOnRenderer(RenderObject* renderer, CSSPropertyID property, bool isRunningNow) const
569 {
570     return m_data->isRunningAnimationOnRenderer(renderer, property, isRunningNow);
571 }
572
573 bool AnimationController::isRunningAcceleratedAnimationOnRenderer(RenderObject* renderer, CSSPropertyID property, bool isRunningNow) const
574 {
575     return m_data->isRunningAcceleratedAnimationOnRenderer(renderer, property, isRunningNow);
576 }
577
578 void AnimationController::suspendAnimations()
579 {
580     m_data->suspendAnimations();
581 }
582
583 void AnimationController::resumeAnimations()
584 {
585     m_data->resumeAnimations();
586 }
587
588 #if ENABLE(REQUEST_ANIMATION_FRAME)
589 void AnimationController::serviceAnimations()
590 {
591     m_data->animationFrameCallbackFired();
592 }
593 #endif
594
595 void AnimationController::suspendAnimationsForDocument(Document* document)
596 {
597     m_data->suspendAnimationsForDocument(document);
598 }
599
600 void AnimationController::resumeAnimationsForDocument(Document* document)
601 {
602     m_data->resumeAnimationsForDocument(document);
603 }
604
605 void AnimationController::beginAnimationUpdate()
606 {
607     if (!m_beginAnimationUpdateCount)
608         m_data->setBeginAnimationUpdateTime(cBeginAnimationUpdateTimeNotSet);
609     ++m_beginAnimationUpdateCount;
610 }
611
612 void AnimationController::endAnimationUpdate()
613 {
614     ASSERT(m_beginAnimationUpdateCount > 0);
615     --m_beginAnimationUpdateCount;
616     if (!m_beginAnimationUpdateCount)
617         m_data->endAnimationUpdate();
618 }
619
620 bool AnimationController::supportsAcceleratedAnimationOfProperty(CSSPropertyID property)
621 {
622 #if USE(ACCELERATED_COMPOSITING)
623     return CSSPropertyAnimation::animationOfPropertyIsAccelerated(property);
624 #else
625     UNUSED_PARAM(property);
626     return false;
627 #endif
628 }
629
630 } // namespace WebCore