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