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