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