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