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