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