[Web Animations] Ensure we don't update an animation's finished state twice when...
[WebKit-https.git] / Source / WebCore / animation / WebAnimation.cpp
1 /*
2  * Copyright (C) 2017 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  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "WebAnimation.h"
28
29 #include "AnimationEffect.h"
30 #include "AnimationPlaybackEvent.h"
31 #include "AnimationTimeline.h"
32 #include "Document.h"
33 #include "DocumentTimeline.h"
34 #include "EventNames.h"
35 #include "JSWebAnimation.h"
36 #include "KeyframeEffect.h"
37 #include "Microtasks.h"
38 #include "WebAnimationUtilities.h"
39 #include <wtf/text/WTFString.h>
40
41 namespace WebCore {
42
43 Ref<WebAnimation> WebAnimation::create(Document& document, AnimationEffect* effect)
44 {
45     auto result = adoptRef(*new WebAnimation(document));
46     result->setEffect(effect);
47     result->setTimeline(&document.timeline());
48     return result;
49 }
50
51 Ref<WebAnimation> WebAnimation::create(Document& document, AnimationEffect* effect, AnimationTimeline* timeline)
52 {
53     auto result = adoptRef(*new WebAnimation(document));
54     result->setEffect(effect);
55     if (timeline)
56         result->setTimeline(timeline);
57     return result;
58 }
59
60 WebAnimation::WebAnimation(Document& document)
61     : ActiveDOMObject(&document)
62     , m_readyPromise(makeUniqueRef<ReadyPromise>(*this, &WebAnimation::readyPromiseResolve))
63     , m_finishedPromise(makeUniqueRef<FinishedPromise>(*this, &WebAnimation::finishedPromiseResolve))
64 {
65     m_readyPromise->resolve(*this);
66     suspendIfNeeded();
67 }
68
69 WebAnimation::~WebAnimation()
70 {
71     if (m_timeline)
72         m_timeline->forgetAnimation(this);
73 }
74
75 void WebAnimation::remove()
76 {
77     // This object could be deleted after either clearing the effect or timeline relationship.
78     auto protectedThis = makeRef(*this);
79     setEffectInternal(nullptr);
80     setTimelineInternal(nullptr);
81 }
82
83 void WebAnimation::suspendEffectInvalidation()
84 {
85     ++m_suspendCount;
86 }
87
88 void WebAnimation::unsuspendEffectInvalidation()
89 {
90     ASSERT(m_suspendCount > 0);
91     --m_suspendCount;
92 }
93
94 void WebAnimation::effectTimingDidChange()
95 {
96     timingDidChange(DidSeek::No, SynchronouslyNotify::Yes);
97 }
98
99 void WebAnimation::setEffect(RefPtr<AnimationEffect>&& newEffect)
100 {
101     // 3.4.3. Setting the target effect of an animation
102     // https://drafts.csswg.org/web-animations-1/#setting-the-target-effect
103
104     // 1. Let old effect be the current target effect of animation, if any.
105     auto oldEffect = m_effect;
106
107     // 2. If new effect is the same object as old effect, abort this procedure.
108     if (newEffect == oldEffect)
109         return;
110
111     // 3. If animation has a pending pause task, reschedule that task to run as soon as animation is ready.
112     if (hasPendingPauseTask())
113         m_timeToRunPendingPauseTask = TimeToRunPendingTask::WhenReady;
114
115     // 4. If animation has a pending play task, reschedule that task to run as soon as animation is ready to play new effect.
116     if (hasPendingPlayTask())
117         m_timeToRunPendingPlayTask = TimeToRunPendingTask::WhenReady;
118
119     // 5. If new effect is not null and if new effect is the target effect of another animation, previous animation, run the
120     // procedure to set the target effect of an animation (this procedure) on previous animation passing null as new effect.
121     if (newEffect && newEffect->animation())
122         newEffect->animation()->setEffect(nullptr);
123
124     // 6. Let the target effect of animation be new effect.
125     // In the case of a declarative animation, we don't want to remove the animation from the relevant maps because
126     // while the effect was set via the API, the element still has a transition or animation set up and we must
127     // not break the timeline-to-animation relationship.
128
129     invalidateEffect();
130
131     // This object could be deleted after clearing the effect relationship.
132     auto protectedThis = makeRef(*this);
133     setEffectInternal(WTFMove(newEffect), isDeclarativeAnimation());
134
135     // 7. Run the procedure to update an animation's finished state for animation with the did seek flag set to false,
136     // and the synchronously notify flag set to false.
137     timingDidChange(DidSeek::No, SynchronouslyNotify::No);
138
139     invalidateEffect();
140 }
141
142 void WebAnimation::setEffectInternal(RefPtr<AnimationEffect>&& newEffect, bool doNotRemoveFromTimeline)
143 {
144     if (m_effect == newEffect)
145         return;
146
147     auto oldEffect = std::exchange(m_effect, WTFMove(newEffect));
148
149     Element* previousTarget = nullptr;
150     if (is<KeyframeEffect>(oldEffect))
151         previousTarget = downcast<KeyframeEffect>(oldEffect.get())->target();
152
153     Element* newTarget = nullptr;
154     if (is<KeyframeEffect>(m_effect))
155         newTarget = downcast<KeyframeEffect>(m_effect.get())->target();
156
157     // Update the effect-to-animation relationships and the timeline's animation map.
158     if (oldEffect) {
159         oldEffect->setAnimation(nullptr);
160         if (!doNotRemoveFromTimeline && m_timeline && previousTarget && previousTarget != newTarget)
161             m_timeline->animationWasRemovedFromElement(*this, *previousTarget);
162         updateRelevance();
163     }
164
165     if (m_effect) {
166         m_effect->setAnimation(this);
167         if (m_timeline && newTarget && previousTarget != newTarget)
168             m_timeline->animationWasAddedToElement(*this, *newTarget);
169     }
170 }
171
172 void WebAnimation::setTimeline(RefPtr<AnimationTimeline>&& timeline)
173 {
174     // 3.4.1. Setting the timeline of an animation
175     // https://drafts.csswg.org/web-animations-1/#setting-the-timeline
176
177     // 2. If new timeline is the same object as old timeline, abort this procedure.
178     if (timeline == m_timeline)
179         return;
180
181     // 4. If the animation start time of animation is resolved, make animation's hold time unresolved.
182     if (m_startTime)
183         m_holdTime = std::nullopt;
184
185     if (is<KeyframeEffect>(m_effect)) {
186         auto* keyframeEffect = downcast<KeyframeEffect>(m_effect.get());
187         auto* target = keyframeEffect->target();
188         if (target) {
189             // In the case of a declarative animation, we don't want to remove the animation from the relevant maps because
190             // while the timeline was set via the API, the element still has a transition or animation set up and we must
191             // not break the relationship.
192             if (m_timeline && !isDeclarativeAnimation())
193                 m_timeline->animationWasRemovedFromElement(*this, *target);
194             if (timeline)
195                 timeline->animationWasAddedToElement(*this, *target);
196         }
197     }
198
199     // This object could be deleted after clearing the timeline relationship.
200     auto protectedThis = makeRef(*this);
201     setTimelineInternal(WTFMove(timeline));
202
203     setSuspended(is<DocumentTimeline>(m_timeline) && downcast<DocumentTimeline>(*m_timeline).animationsAreSuspended());
204
205     // 5. Run the procedure to update an animation's finished state for animation with the did seek flag set to false,
206     // and the synchronously notify flag set to false.
207     timingDidChange(DidSeek::No, SynchronouslyNotify::No);
208
209     invalidateEffect();
210 }
211
212 void WebAnimation::setTimelineInternal(RefPtr<AnimationTimeline>&& timeline)
213 {
214     if (m_timeline == timeline)
215         return;
216
217     if (m_timeline)
218         m_timeline->removeAnimation(*this);
219
220     m_timeline = WTFMove(timeline);
221 }
222
223 void WebAnimation::effectTargetDidChange(Element* previousTarget, Element* newTarget)
224 {
225     if (!m_timeline)
226         return;
227
228     if (previousTarget)
229         m_timeline->animationWasRemovedFromElement(*this, *previousTarget);
230
231     if (newTarget)
232         m_timeline->animationWasAddedToElement(*this, *newTarget);
233 }
234
235 std::optional<double> WebAnimation::startTime() const
236 {
237     if (!m_startTime)
238         return std::nullopt;
239     return secondsToWebAnimationsAPITime(m_startTime.value());
240 }
241
242 void WebAnimation::setStartTime(std::optional<double> startTime)
243 {
244     // 3.4.6 The procedure to set the start time of animation, animation, to new start time, is as follows:
245     // https://drafts.csswg.org/web-animations/#setting-the-start-time-of-an-animation
246
247     std::optional<Seconds> newStartTime;
248     if (!startTime)
249         newStartTime = std::nullopt;
250     else
251         newStartTime = Seconds::fromMilliseconds(startTime.value());
252
253     // 1. Let timeline time be the current time value of the timeline that animation is associated with. If
254     //    there is no timeline associated with animation or the associated timeline is inactive, let the timeline
255     //    time be unresolved.
256     auto timelineTime = m_timeline ? m_timeline->currentTime() : std::nullopt;
257
258     // 2. If timeline time is unresolved and new start time is resolved, make animation's hold time unresolved.
259     if (!timelineTime && newStartTime)
260         m_holdTime = std::nullopt;
261
262     // 3. Let previous current time be animation's current time.
263     auto previousCurrentTime = currentTime();
264
265     // 4. Apply any pending playback rate on animation.
266     applyPendingPlaybackRate();
267
268     // 5. Set animation's start time to new start time.
269     m_startTime = newStartTime;
270
271     // 6. Update animation's hold time based on the first matching condition from the following,
272     if (newStartTime) {
273         // If new start time is resolved,
274         // If animation's playback rate is not zero, make animation's hold time unresolved.
275         if (m_playbackRate)
276             m_holdTime = std::nullopt;
277     } else {
278         // Otherwise (new start time is unresolved),
279         // Set animation's hold time to previous current time even if previous current time is unresolved.
280         m_holdTime = previousCurrentTime;
281     }
282
283     // 7. If animation has a pending play task or a pending pause task, cancel that task and resolve animation's current ready promise with animation.
284     if (pending()) {
285         m_timeToRunPendingPauseTask = TimeToRunPendingTask::NotScheduled;
286         m_timeToRunPendingPlayTask = TimeToRunPendingTask::NotScheduled;
287         m_readyPromise->resolve(*this);
288     }
289
290     // 8. Run the procedure to update an animation's finished state for animation with the did seek flag set to true, and the synchronously notify flag set to false.
291     timingDidChange(DidSeek::Yes, SynchronouslyNotify::No);
292
293     invalidateEffect();
294 }
295
296 std::optional<double> WebAnimation::bindingsCurrentTime() const
297 {
298     auto time = currentTime();
299     if (!time)
300         return std::nullopt;
301     return secondsToWebAnimationsAPITime(time.value());
302 }
303
304 ExceptionOr<void> WebAnimation::setBindingsCurrentTime(std::optional<double> currentTime)
305 {
306     if (!currentTime)
307         return setCurrentTime(std::nullopt);
308     return setCurrentTime(Seconds::fromMilliseconds(currentTime.value()));
309 }
310
311 std::optional<Seconds> WebAnimation::currentTime() const
312 {
313     return currentTime(RespectHoldTime::Yes);
314 }
315
316 std::optional<Seconds> WebAnimation::currentTime(RespectHoldTime respectHoldTime) const
317 {
318     // 3.4.4. The current time of an animation
319     // https://drafts.csswg.org/web-animations-1/#the-current-time-of-an-animation
320
321     // The current time is calculated from the first matching condition from below:
322
323     // If the animation's hold time is resolved, the current time is the animation's hold time.
324     if (respectHoldTime == RespectHoldTime::Yes && m_holdTime)
325         return m_holdTime;
326
327     // If any of the following are true:
328     //     1. the animation has no associated timeline, or
329     //     2. the associated timeline is inactive, or
330     //     3. the animation's start time is unresolved.
331     // The current time is an unresolved time value.
332     if (!m_timeline || !m_timeline->currentTime() || !m_startTime)
333         return std::nullopt;
334
335     // Otherwise, current time = (timeline time - start time) * playback rate
336     return (m_timeline->currentTime().value() - m_startTime.value()) * m_playbackRate;
337 }
338
339 ExceptionOr<void> WebAnimation::silentlySetCurrentTime(std::optional<Seconds> seekTime)
340 {
341     // 3.4.5. Setting the current time of an animation
342     // https://drafts.csswg.org/web-animations-1/#setting-the-current-time-of-an-animation
343
344     // 1. If seek time is an unresolved time value, then perform the following steps.
345     if (!seekTime) {
346         // 1. If the current time is resolved, then throw a TypeError.
347         if (currentTime())
348             return Exception { TypeError };
349         // 2. Abort these steps.
350         return { };
351     }
352
353     // 2. Update either animation's hold time or start time as follows:
354     // If any of the following conditions are true:
355     //     - animation's hold time is resolved, or
356     //     - animation's start time is unresolved, or
357     //     - animation has no associated timeline or the associated timeline is inactive, or
358     //     - animation's playback rate is 0,
359     // Set animation's hold time to seek time.
360     // Otherwise, set animation's start time to the result of evaluating timeline time - (seek time / playback rate)
361     // where timeline time is the current time value of timeline associated with animation.
362     if (m_holdTime || !m_startTime || !m_timeline || !m_timeline->currentTime() || !m_playbackRate)
363         m_holdTime = seekTime;
364     else
365         m_startTime = m_timeline->currentTime().value() - (seekTime.value() / m_playbackRate);
366
367     // 3. If animation has no associated timeline or the associated timeline is inactive, make animation's start time unresolved.
368     if (!m_timeline || !m_timeline->currentTime())
369         m_startTime = std::nullopt;
370
371     // 4. Make animation's previous current time unresolved.
372     m_previousCurrentTime = std::nullopt;
373
374     return { };
375 }
376
377 ExceptionOr<void> WebAnimation::setCurrentTime(std::optional<Seconds> seekTime)
378 {
379     // 3.4.5. Setting the current time of an animation
380     // https://drafts.csswg.org/web-animations-1/#setting-the-current-time-of-an-animation
381
382     // 1. Run the steps to silently set the current time of animation to seek time.
383     auto silentResult = silentlySetCurrentTime(seekTime);
384     if (silentResult.hasException())
385         return silentResult.releaseException();
386
387     // 2. If animation has a pending pause task, synchronously complete the pause operation by performing the following steps:
388     if (hasPendingPauseTask()) {
389         // 1. Set animation's hold time to seek time.
390         m_holdTime = seekTime;
391         // 2. Apply any pending playback rate to animation.
392         applyPendingPlaybackRate();
393         // 3. Make animation's start time unresolved.
394         m_startTime = std::nullopt;
395         // 4. Cancel the pending pause task.
396         m_timeToRunPendingPauseTask = TimeToRunPendingTask::NotScheduled;
397         // 5. Resolve animation's current ready promise with animation.
398         m_readyPromise->resolve(*this);
399     }
400
401     // 3. Run the procedure to update an animation's finished state for animation with the did seek flag set to true, and the synchronously notify flag set to false.
402     timingDidChange(DidSeek::Yes, SynchronouslyNotify::No);
403
404     if (m_effect)
405         m_effect->animationDidSeek();
406
407     invalidateEffect();
408
409     return { };
410 }
411
412 double WebAnimation::effectivePlaybackRate() const
413 {
414     // https://drafts.csswg.org/web-animations/#effective-playback-rate
415     // The effective playback rate of an animation is its pending playback rate, if set, otherwise it is the animation's playback rate.
416     return (m_pendingPlaybackRate ? m_pendingPlaybackRate.value() : m_playbackRate);
417 }
418
419 void WebAnimation::setPlaybackRate(double newPlaybackRate)
420 {
421     // 3.4.17.1. Updating the playback rate of an animation
422     // https://drafts.csswg.org/web-animations-1/#updating-the-playback-rate-of-an-animation
423
424     // 1. Clear any pending playback rate on animation.
425     m_pendingPlaybackRate = std::nullopt;
426     
427     // 2. Let previous time be the value of the current time of animation before changing the playback rate.
428     auto previousTime = currentTime();
429
430     // 3. Set the playback rate to new playback rate.
431     m_playbackRate = newPlaybackRate;
432
433     // 4. If previous time is resolved, set the current time of animation to previous time.
434     if (previousTime)
435         setCurrentTime(previousTime);
436 }
437
438 void WebAnimation::updatePlaybackRate(double newPlaybackRate)
439 {
440     // https://drafts.csswg.org/web-animations/#seamlessly-update-the-playback-rate
441
442     // The procedure to seamlessly update the playback rate an animation, animation, to new playback rate preserving its current time is as follows:
443
444     // 1. Let previous play state be animation's play state.
445     //    Note: It is necessary to record the play state before updating animation's effective playback rate since, in the following logic,
446     //    we want to immediately apply the pending playback rate of animation if it is currently finished regardless of whether or not it will
447     //    still be finished after we apply the pending playback rate.
448     auto previousPlayState = playState();
449
450     // 2. Let animation's pending playback rate be new playback rate.
451     m_pendingPlaybackRate = newPlaybackRate;
452
453     // 3. Perform the steps corresponding to the first matching condition from below:
454     if (pending()) {
455         // If animation has a pending play task or a pending pause task,
456         // Abort these steps.
457         // Note: The different types of pending tasks will apply the pending playback rate when they run so there is no further action required in this case.
458         return;
459     }
460
461     if (previousPlayState == PlayState::Idle || previousPlayState == PlayState::Paused) {
462         // If previous play state is idle or paused,
463         // Apply any pending playback rate on animation.
464         applyPendingPlaybackRate();
465     } else if (previousPlayState == PlayState::Finished) {
466         // If previous play state is finished,
467         // 1. Let the unconstrained current time be the result of calculating the current time of animation substituting an unresolved time value for the hold time.
468         auto unconstrainedCurrentTime = currentTime(RespectHoldTime::No);
469         // 2. Let animation's start time be the result of evaluating the following expression:
470         // timeline time - (unconstrained current time / pending playback rate)
471         // Where timeline time is the current time value of the timeline associated with animation.
472         // If pending playback rate is zero, let animation's start time be timeline time.
473         auto newStartTime = m_timeline->currentTime().value();
474         if (m_pendingPlaybackRate)
475             newStartTime -= (unconstrainedCurrentTime.value() / m_pendingPlaybackRate.value());
476         m_startTime = newStartTime;
477         // 3. Apply any pending playback rate on animation.
478         applyPendingPlaybackRate();
479         // 4. Run the procedure to update an animation's finished state for animation with the did seek flag set to false, and the synchronously notify flag set to false.
480         timingDidChange(DidSeek::No, SynchronouslyNotify::No);
481
482         invalidateEffect();
483     } else {
484         // Otherwise,
485         // Run the procedure to play an animation for animation with the auto-rewind flag set to false.
486         play(AutoRewind::No);
487     }
488 }
489
490 void WebAnimation::applyPendingPlaybackRate()
491 {
492     // https://drafts.csswg.org/web-animations/#apply-any-pending-playback-rate
493
494     // 1. If animation does not have a pending playback rate, abort these steps.
495     if (!m_pendingPlaybackRate)
496         return;
497
498     // 2. Set animation's playback rate to its pending playback rate.
499     m_playbackRate = m_pendingPlaybackRate.value();
500
501     // 3. Clear animation's pending playback rate.
502     m_pendingPlaybackRate = std::nullopt;
503 }
504
505 auto WebAnimation::playState() const -> PlayState
506 {
507     // 3.5.19 Play states
508     // https://drafts.csswg.org/web-animations/#play-states
509
510     // The play state of animation, animation, at a given moment is the state corresponding to the
511     // first matching condition from the following:
512
513     // The current time of animation is unresolved, and animation does not have either a pending
514     // play task or a pending pause task,
515     // → idle
516     auto animationCurrentTime = currentTime();
517     if (!animationCurrentTime && !pending())
518         return PlayState::Idle;
519
520     // Animation has a pending pause task, or both the start time of animation is unresolved and it does not
521     // have a pending play task,
522     // → paused
523     if (hasPendingPauseTask() || (!m_startTime && !hasPendingPlayTask()))
524         return PlayState::Paused;
525
526     // For animation, current time is resolved and either of the following conditions are true:
527     // animation's effective playback rate > 0 and current time ≥ target effect end; or
528     // animation's effective playback rate < 0 and current time ≤ 0,
529     // → finished
530     if (animationCurrentTime && ((effectivePlaybackRate() > 0 && animationCurrentTime.value() >= effectEndTime()) || (effectivePlaybackRate() < 0 && animationCurrentTime.value() <= 0_s)))
531         return PlayState::Finished;
532
533     // Otherwise → running
534     return PlayState::Running;
535 }
536
537 Seconds WebAnimation::effectEndTime() const
538 {
539     // The target effect end of an animation is equal to the end time of the animation's target effect.
540     // If the animation has no target effect, the target effect end is zero.
541     return m_effect ? m_effect->endTime() : 0_s;
542 }
543
544 void WebAnimation::cancel()
545 {
546     cancel(Silently::No);
547     invalidateEffect();
548 }
549
550 void WebAnimation::cancel(Silently silently)
551 {
552     // 3.4.16. Canceling an animation
553     // https://drafts.csswg.org/web-animations-1/#canceling-an-animation-section
554     //
555     // An animation can be canceled which causes the current time to become unresolved hence removing any effects caused by the target effect.
556     //
557     // The procedure to cancel an animation for animation is as follows:
558     //
559     // 1. If animation's play state is not idle, perform the following steps:
560     if (playState() != PlayState::Idle) {
561         // 1. Run the procedure to reset an animation's pending tasks on animation.
562         resetPendingTasks(silently);
563
564         // 2. Reject the current finished promise with a DOMException named "AbortError".
565         if (silently == Silently::No && !m_finishedPromise->isFulfilled())
566             m_finishedPromise->reject(Exception { AbortError });
567
568         // 3. Let current finished promise be a new (pending) Promise object.
569         m_finishedPromise = makeUniqueRef<FinishedPromise>(*this, &WebAnimation::finishedPromiseResolve);
570
571         // 4. Create an AnimationPlaybackEvent, cancelEvent.
572         // 5. Set cancelEvent's type attribute to cancel.
573         // 6. Set cancelEvent's currentTime to null.
574         // 7. Let timeline time be the current time of the timeline with which animation is associated. If animation is not associated with an
575         //    active timeline, let timeline time be n unresolved time value.
576         // 8. Set cancelEvent's timelineTime to timeline time. If timeline time is unresolved, set it to null.
577         // 9. If animation has a document for timing, then append cancelEvent to its document for timing's pending animation event queue along
578         //    with its target, animation. If animation is associated with an active timeline that defines a procedure to convert timeline times
579         //    to origin-relative time, let the scheduled event time be the result of applying that procedure to timeline time. Otherwise, the
580         //    scheduled event time is an unresolved time value.
581         // Otherwise, queue a task to dispatch cancelEvent at animation. The task source for this task is the DOM manipulation task source.
582         if (silently == Silently::No)
583             enqueueAnimationPlaybackEvent(eventNames().cancelEvent, std::nullopt, m_timeline ? m_timeline->currentTime() : std::nullopt);
584     }
585
586     // 2. Make animation's hold time unresolved.
587     m_holdTime = std::nullopt;
588
589     // 3. Make animation's start time unresolved.
590     m_startTime = std::nullopt;
591
592     timingDidChange(DidSeek::No, SynchronouslyNotify::No);
593
594     invalidateEffect();
595 }
596
597 void WebAnimation::enqueueAnimationPlaybackEvent(const AtomicString& type, std::optional<Seconds> currentTime, std::optional<Seconds> timelineTime)
598 {
599     auto event = AnimationPlaybackEvent::create(type, currentTime, timelineTime);
600     event->setTarget(this);
601
602     if (is<DocumentTimeline>(m_timeline)) {
603         // If animation has a document for timing, then append event to its document for timing's pending animation event queue along
604         // with its target, animation. If animation is associated with an active timeline that defines a procedure to convert timeline times
605         // to origin-relative time, let the scheduled event time be the result of applying that procedure to timeline time. Otherwise, the
606         // scheduled event time is an unresolved time value.
607         downcast<DocumentTimeline>(*m_timeline).enqueueAnimationPlaybackEvent(WTFMove(event));
608     } else {
609         // Otherwise, queue a task to dispatch event at animation. The task source for this task is the DOM manipulation task source.
610         callOnMainThread([this, pendingActivity = makePendingActivity(*this), event = WTFMove(event)]() {
611             if (!m_isStopped)
612                 this->dispatchEvent(event);
613         });
614     }
615 }
616
617 void WebAnimation::resetPendingTasks(Silently silently)
618 {
619     // The procedure to reset an animation's pending tasks for animation is as follows:
620     // https://drafts.csswg.org/web-animations-1/#reset-an-animations-pending-tasks
621     //
622     // 1. If animation does not have a pending play task or a pending pause task, abort this procedure.
623     if (!pending())
624         return;
625
626     // 2. If animation has a pending play task, cancel that task.
627     if (hasPendingPlayTask())
628         m_timeToRunPendingPlayTask = TimeToRunPendingTask::NotScheduled;
629
630     // 3. If animation has a pending pause task, cancel that task.
631     if (hasPendingPauseTask())
632         m_timeToRunPendingPauseTask = TimeToRunPendingTask::NotScheduled;
633
634     // 4. Apply any pending playback rate on animation.
635     applyPendingPlaybackRate();
636
637     // 5. Reject animation's current ready promise with a DOMException named "AbortError".
638     if (silently == Silently::No)
639         m_readyPromise->reject(Exception { AbortError });
640
641     // 6. Let animation's current ready promise be the result of creating a new resolved Promise object.
642     m_readyPromise = makeUniqueRef<ReadyPromise>(*this, &WebAnimation::readyPromiseResolve);
643     m_readyPromise->resolve(*this);
644 }
645
646 ExceptionOr<void> WebAnimation::finish()
647 {
648     // 3.4.15. Finishing an animation
649     // https://drafts.csswg.org/web-animations-1/#finishing-an-animation-section
650
651     // An animation can be advanced to the natural end of its current playback direction by using the procedure to finish an animation for animation defined below:
652     //
653     // 1. If animation's effective playback rate is zero, or if animation's effective playback rate > 0 and target effect end is infinity, throw an InvalidStateError and abort these steps.
654     if (!effectivePlaybackRate() || (effectivePlaybackRate() > 0 && effectEndTime() == Seconds::infinity()))
655         return Exception { InvalidStateError };
656
657     // 2. Apply any pending playback rate to animation.
658     applyPendingPlaybackRate();
659
660     // 3. Set limit as follows:
661     // If animation playback rate > 0, let limit be target effect end.
662     // Otherwise, let limit be zero.
663     auto limit = m_playbackRate > 0 ? effectEndTime() : 0_s;
664
665     // 4. Silently set the current time to limit.
666     silentlySetCurrentTime(limit);
667
668     // 5. If animation's start time is unresolved and animation has an associated active timeline, let the start time be the result of
669     //    evaluating timeline time - (limit / playback rate) where timeline time is the current time value of the associated timeline.
670     if (!m_startTime && m_timeline && m_timeline->currentTime())
671         m_startTime = m_timeline->currentTime().value() - (limit / m_playbackRate);
672
673     // 6. If there is a pending pause task and start time is resolved,
674     if (hasPendingPauseTask() && m_startTime) {
675         // 1. Let the hold time be unresolved.
676         m_holdTime = std::nullopt;
677         // 2. Cancel the pending pause task.
678         m_timeToRunPendingPauseTask = TimeToRunPendingTask::NotScheduled;
679         // 3. Resolve the current ready promise of animation with animation.
680         m_readyPromise->resolve(*this);
681     }
682
683     // 7. If there is a pending play task and start time is resolved, cancel that task and resolve the current ready promise of animation with animation.
684     if (hasPendingPlayTask() && m_startTime) {
685         m_timeToRunPendingPlayTask = TimeToRunPendingTask::NotScheduled;
686         m_readyPromise->resolve(*this);
687     }
688
689     // 8. Run the procedure to update an animation's finished state animation with the did seek flag set to true, and the synchronously notify flag set to true.
690     timingDidChange(DidSeek::Yes, SynchronouslyNotify::Yes);
691
692     invalidateEffect();
693
694     return { };
695 }
696
697 void WebAnimation::timingDidChange(DidSeek didSeek, SynchronouslyNotify synchronouslyNotify)
698 {
699     m_shouldSkipUpdatingFinishedStateWhenResolving = false;
700     updateFinishedState(didSeek, synchronouslyNotify);
701     if (m_timeline)
702         m_timeline->animationTimingDidChange(*this);
703 };
704
705 void WebAnimation::invalidateEffect()
706 {
707     if (!isEffectInvalidationSuspended() && m_effect)
708         m_effect->invalidate();
709 }
710
711 void WebAnimation::updateFinishedState(DidSeek didSeek, SynchronouslyNotify synchronouslyNotify)
712 {
713     // 3.4.14. Updating the finished state
714     // https://drafts.csswg.org/web-animations-1/#updating-the-finished-state
715
716     // 1. Let the unconstrained current time be the result of calculating the current time substituting an unresolved time value
717     // for the hold time if did seek is false. If did seek is true, the unconstrained current time is equal to the current time.
718     auto unconstrainedCurrentTime = currentTime(didSeek == DidSeek::Yes ? RespectHoldTime::Yes : RespectHoldTime::No);
719     auto endTime = effectEndTime();
720
721     // 2. If all three of the following conditions are true,
722     //    - the unconstrained current time is resolved, and
723     //    - animation's start time is resolved, and
724     //    - animation does not have a pending play task or a pending pause task,
725     if (unconstrainedCurrentTime && m_startTime && !pending()) {
726         // then update animation's hold time based on the first matching condition for animation from below, if any:
727         if (m_playbackRate > 0 && unconstrainedCurrentTime >= endTime) {
728             // If animation playback rate > 0 and unconstrained current time is greater than or equal to target effect end,
729             // If did seek is true, let the hold time be the value of unconstrained current time.
730             if (didSeek == DidSeek::Yes)
731                 m_holdTime = unconstrainedCurrentTime;
732             // If did seek is false, let the hold time be the maximum value of previous current time and target effect end. If the previous current time is unresolved, let the hold time be target effect end.
733             else if (!m_previousCurrentTime)
734                 m_holdTime = endTime;
735             else
736                 m_holdTime = std::max(m_previousCurrentTime.value(), endTime);
737         } else if (m_playbackRate < 0 && unconstrainedCurrentTime <= 0_s) {
738             // If animation playback rate < 0 and unconstrained current time is less than or equal to 0,
739             // If did seek is true, let the hold time be the value of unconstrained current time.
740             if (didSeek == DidSeek::Yes)
741                 m_holdTime = unconstrainedCurrentTime;
742             // If did seek is false, let the hold time be the minimum value of previous current time and zero. If the previous current time is unresolved, let the hold time be zero.
743             else if (!m_previousCurrentTime)
744                 m_holdTime = 0_s;
745             else
746                 m_holdTime = std::min(m_previousCurrentTime.value(), 0_s);
747         } else if (m_playbackRate && m_timeline && m_timeline->currentTime()) {
748             // If animation playback rate ≠ 0, and animation is associated with an active timeline,
749             // Perform the following steps:
750             // 1. If did seek is true and the hold time is resolved, let animation's start time be equal to the result of evaluating timeline time - (hold time / playback rate)
751             //    where timeline time is the current time value of timeline associated with animation.
752             if (didSeek == DidSeek::Yes && m_holdTime)
753                 m_startTime = m_timeline->currentTime().value() - (m_holdTime.value() / m_playbackRate);
754             // 2. Let the hold time be unresolved.
755             m_holdTime = std::nullopt;
756         }
757     }
758
759     // 3. Set the previous current time of animation be the result of calculating its current time.
760     m_previousCurrentTime = currentTime();
761
762     // 4. Let current finished state be true if the play state of animation is finished. Otherwise, let it be false.
763     auto currentFinishedState = playState() == PlayState::Finished;
764
765     // 5. If current finished state is true and the current finished promise is not yet resolved, perform the following steps:
766     if (currentFinishedState && !m_finishedPromise->isFulfilled()) {
767         if (synchronouslyNotify == SynchronouslyNotify::Yes) {
768             // If synchronously notify is true, cancel any queued microtask to run the finish notification steps for this animation,
769             // and run the finish notification steps immediately.
770             m_finishNotificationStepsMicrotaskPending = false;
771             finishNotificationSteps();
772         } else if (!m_finishNotificationStepsMicrotaskPending) {
773             // Otherwise, if synchronously notify is false, queue a microtask to run finish notification steps for animation unless there
774             // is already a microtask queued to run those steps for animation.
775             m_finishNotificationStepsMicrotaskPending = true;
776             scheduleMicrotaskIfNeeded();
777         }
778     }
779
780     // 6. If current finished state is false and animation's current finished promise is already resolved, set animation's current
781     // finished promise to a new (pending) Promise object.
782     if (!currentFinishedState && m_finishedPromise->isFulfilled())
783         m_finishedPromise = makeUniqueRef<FinishedPromise>(*this, &WebAnimation::finishedPromiseResolve);
784
785     updateRelevance();
786 }
787
788 void WebAnimation::scheduleMicrotaskIfNeeded()
789 {
790     if (m_scheduledMicrotask)
791         return;
792
793     m_scheduledMicrotask = true;
794     MicrotaskQueue::mainThreadQueue().append(std::make_unique<VoidMicrotask>([this, protectedThis = makeRef(*this)] () {
795         this->performMicrotask();
796     }));
797 }
798
799 void WebAnimation::performMicrotask()
800 {
801     m_scheduledMicrotask = false;
802     if (!m_finishNotificationStepsMicrotaskPending)
803         return;
804
805     m_finishNotificationStepsMicrotaskPending = false;
806     finishNotificationSteps();
807 }
808
809 void WebAnimation::finishNotificationSteps()
810 {
811     // 3.4.14. Updating the finished state
812     // https://drafts.csswg.org/web-animations-1/#finish-notification-steps
813
814     // Let finish notification steps refer to the following procedure:
815     // 1. If animation's play state is not equal to finished, abort these steps.
816     if (playState() != PlayState::Finished)
817         return;
818
819     // 2. Resolve animation's current finished promise object with animation.
820     m_finishedPromise->resolve(*this);
821
822     // 3. Create an AnimationPlaybackEvent, finishEvent.
823     // 4. Set finishEvent's type attribute to finish.
824     // 5. Set finishEvent's currentTime attribute to the current time of animation.
825     // 6. Set finishEvent's timelineTime attribute to the current time of the timeline with which animation is associated.
826     //    If animation is not associated with a timeline, or the timeline is inactive, let timelineTime be null.
827     // 7. If animation has a document for timing, then append finishEvent to its document for timing's pending animation event
828     //    queue along with its target, animation. For the scheduled event time, use the result of converting animation's target
829     //    effect end to an origin-relative time.
830     //    Otherwise, queue a task to dispatch finishEvent at animation. The task source for this task is the DOM manipulation task source.
831     enqueueAnimationPlaybackEvent(eventNames().finishEvent, currentTime(), m_timeline ? m_timeline->currentTime() : std::nullopt);
832 }
833
834 ExceptionOr<void> WebAnimation::play()
835 {
836     return play(AutoRewind::Yes);
837 }
838
839 ExceptionOr<void> WebAnimation::play(AutoRewind autoRewind)
840 {
841     // 3.4.10. Playing an animation
842     // https://drafts.csswg.org/web-animations-1/#play-an-animation
843
844     auto localTime = currentTime();
845     auto endTime = effectEndTime();
846
847     // 1. Let aborted pause be a boolean flag that is true if animation has a pending pause task, and false otherwise.
848     bool abortedPause = hasPendingPauseTask();
849
850     // 2. Let has pending ready promise be a boolean flag that is initially false.
851     bool hasPendingReadyPromise = false;
852
853     // 3. Perform the steps corresponding to the first matching condition from the following, if any:
854     if (effectivePlaybackRate() > 0 && autoRewind == AutoRewind::Yes && (!localTime || localTime.value() < 0_s || localTime.value() >= endTime)) {
855         // If animation's effective playback rate > 0, the auto-rewind flag is true and either animation's:
856         //     - current time is unresolved, or
857         //     - current time < zero, or
858         //     - current time ≥ target effect end,
859         // Set animation's hold time to zero.
860         m_holdTime = 0_s;
861     } else if (effectivePlaybackRate() < 0 && autoRewind == AutoRewind::Yes && (!localTime || localTime.value() <= 0_s || localTime.value() > endTime)) {
862         // If animation's effective playback rate < 0, the auto-rewind flag is true and either animation's:
863         //     - current time is unresolved, or
864         //     - current time ≤ zero, or
865         //     - current time > target effect end
866         // If target effect end is positive infinity, throw an InvalidStateError and abort these steps.
867         if (endTime == Seconds::infinity())
868             return Exception { InvalidStateError };
869         m_holdTime = endTime;
870     } else if (!effectivePlaybackRate() && !localTime) {
871         // If animation's effective playback rate = 0 and animation's current time is unresolved,
872         // Set animation's hold time to zero.
873         m_holdTime = 0_s;
874     }
875
876     // 4. If animation has a pending play task or a pending pause task,
877     if (pending()) {
878         // 1. Cancel that task.
879         m_timeToRunPendingPauseTask = TimeToRunPendingTask::NotScheduled;
880         m_timeToRunPendingPlayTask = TimeToRunPendingTask::NotScheduled;
881         // 2. Set has pending ready promise to true.
882         hasPendingReadyPromise = true;
883     }
884
885     // 5. If the following three conditions are all satisfied:
886     //    - animation's hold time is unresolved, and
887     //    - aborted pause is false, and
888     //    - animation does not have a pending playback rate,
889     // abort this procedure.
890     if (!m_holdTime && !abortedPause && !m_pendingPlaybackRate)
891         return { };
892
893     // 6. If animation's hold time is resolved, let its start time be unresolved.
894     if (m_holdTime)
895         m_startTime = std::nullopt;
896
897     // 7. If has pending ready promise is false, let animation's current ready promise be a new (pending) Promise object.
898     if (!hasPendingReadyPromise)
899         m_readyPromise = makeUniqueRef<ReadyPromise>(*this, &WebAnimation::readyPromiseResolve);
900
901     // 8. Schedule a task to run as soon as animation is ready.
902     m_timeToRunPendingPlayTask = TimeToRunPendingTask::WhenReady;
903
904     // 9. Run the procedure to update an animation's finished state for animation with the did seek flag set to false, and the synchronously notify flag set to false.
905     timingDidChange(DidSeek::No, SynchronouslyNotify::No);
906
907     invalidateEffect();
908
909     return { };
910 }
911
912 void WebAnimation::runPendingPlayTask()
913 {
914     // 3.4.10. Playing an animation, step 8.
915     // https://drafts.csswg.org/web-animations-1/#play-an-animation
916
917     m_timeToRunPendingPlayTask = TimeToRunPendingTask::NotScheduled;
918
919     // 1. Assert that at least one of animation's start time or hold time is resolved.
920     ASSERT(m_startTime || m_holdTime);
921
922     // 2. Let ready time be the time value of the timeline associated with animation at the moment when animation became ready.
923     auto readyTime = m_timeline->currentTime();
924
925     // 3. Perform the steps corresponding to the first matching condition below, if any:
926     if (m_holdTime) {
927         // If animation's hold time is resolved,
928         // 1. Apply any pending playback rate on animation.
929         applyPendingPlaybackRate();
930         // 2. Let new start time be the result of evaluating ready time - hold time / animation playback rate for animation.
931         // If the animation playback rate is zero, let new start time be simply ready time.
932         // FIXME: Implementation cannot guarantee an active timeline at the point of this async dispatch.
933         // Subsequently, the resulting readyTime value can be null. Unify behavior between C++17 and
934         // C++14 builds (the latter using WTF's std::optional) and avoid null std::optional dereferencing
935         // by defaulting to a Seconds(0) value. See https://bugs.webkit.org/show_bug.cgi?id=186189.
936         auto newStartTime = readyTime.value_or(0_s);
937         if (m_playbackRate)
938             newStartTime -= m_holdTime.value() / m_playbackRate;
939         // 3. Set the start time of animation to new start time.
940         m_startTime = newStartTime;
941         // 4. If animation's playback rate is not 0, make animation's hold time unresolved.
942         if (m_playbackRate)
943             m_holdTime = std::nullopt;
944     } else if (m_startTime && m_pendingPlaybackRate) {
945         // If animation's start time is resolved and animation has a pending playback rate,
946         // 1. Let current time to match be the result of evaluating (ready time - start time) × playback rate for animation.
947         auto currentTimeToMatch = (readyTime.value_or(0_s) - m_startTime.value()) * m_playbackRate;
948         // 2. Apply any pending playback rate on animation.
949         applyPendingPlaybackRate();
950         // 3. If animation's playback rate is zero, let animation's hold time be current time to match.
951         if (m_playbackRate)
952             m_holdTime = currentTimeToMatch;
953         // 4. Let new start time be the result of evaluating ready time - current time to match / playback rate for animation.
954         // If the playback rate is zero, let new start time be simply ready time.
955         auto newStartTime = readyTime.value_or(0_s);
956         if (m_playbackRate)
957             newStartTime -= currentTimeToMatch / m_playbackRate;
958         // 5. Set the start time of animation to new start time.
959         m_startTime = newStartTime;
960     }
961
962     // 4. Resolve animation's current ready promise with animation.
963     if (!m_readyPromise->isFulfilled())
964         m_readyPromise->resolve(*this);
965
966     // 5. Run the procedure to update an animation's finished state for animation with the did seek flag set to false, and the synchronously notify flag set to false.
967     timingDidChange(DidSeek::No, SynchronouslyNotify::No);
968
969     invalidateEffect();
970 }
971
972 ExceptionOr<void> WebAnimation::pause()
973 {
974     // 3.4.11. Pausing an animation
975     // https://drafts.csswg.org/web-animations-1/#pause-an-animation
976
977     // 1. If animation has a pending pause task, abort these steps.
978     if (hasPendingPauseTask())
979         return { };
980
981     // 2. If the play state of animation is paused, abort these steps.
982     if (playState() == PlayState::Paused)
983         return { };
984
985     auto localTime = currentTime();
986
987     // 3. If the animation's current time is unresolved, perform the steps according to the first matching condition from below:
988     if (!localTime) {
989         if (m_playbackRate >= 0) {
990             // If animation's playback rate is ≥ 0, let animation's hold time be zero.
991             m_holdTime = 0_s;
992         } else if (effectEndTime() == Seconds::infinity()) {
993             // Otherwise, if target effect end for animation is positive infinity, throw an InvalidStateError and abort these steps.
994             return Exception { InvalidStateError };
995         } else {
996             // Otherwise, let animation's hold time be target effect end.
997             m_holdTime = effectEndTime();
998         }
999     }
1000
1001     // 4. Let has pending ready promise be a boolean flag that is initially false.
1002     bool hasPendingReadyPromise = false;
1003
1004     // 5. If animation has a pending play task, cancel that task and let has pending ready promise be true.
1005     if (hasPendingPlayTask()) {
1006         m_timeToRunPendingPlayTask = TimeToRunPendingTask::NotScheduled;
1007         hasPendingReadyPromise = true;
1008     }
1009
1010     // 6. If has pending ready promise is false, set animation's current ready promise to a new (pending) Promise object.
1011     if (!hasPendingReadyPromise)
1012         m_readyPromise = makeUniqueRef<ReadyPromise>(*this, &WebAnimation::readyPromiseResolve);
1013
1014     // 7. Schedule a task to be executed at the first possible moment after the user agent has performed any processing necessary
1015     //    to suspend the playback of animation's target effect, if any.
1016     m_timeToRunPendingPauseTask = TimeToRunPendingTask::ASAP;
1017
1018     // 8. Run the procedure to update an animation's finished state for animation with the did seek flag set to false, and the synchronously notify flag set to false.
1019     timingDidChange(DidSeek::No, SynchronouslyNotify::No);
1020
1021     invalidateEffect();
1022
1023     return { };
1024 }
1025
1026 ExceptionOr<void> WebAnimation::reverse()
1027 {
1028     // 3.4.18. Reversing an animation
1029     // https://drafts.csswg.org/web-animations-1/#reverse-an-animation
1030
1031     // The procedure to reverse an animation of animation animation is as follows:
1032
1033     // 1. If there is no timeline associated with animation, or the associated timeline is inactive
1034     //    throw an InvalidStateError and abort these steps.
1035     if (!m_timeline || !m_timeline->currentTime())
1036         return Exception { InvalidStateError };
1037
1038     // 2. Let original pending playback rate be animation's pending playback rate.
1039     auto originalPendingPlaybackRate = m_pendingPlaybackRate;
1040
1041     // 3. Let animation's pending playback rate be the additive inverse of its effective playback rate (i.e. -effective playback rate).
1042     m_pendingPlaybackRate = -effectivePlaybackRate();
1043
1044     // 4. Run the steps to play an animation for animation with the auto-rewind flag set to true.
1045     auto playResult = play(AutoRewind::Yes);
1046
1047     // If the steps to play an animation throw an exception, set animation's pending playback rate to original
1048     // pending playback rate and propagate the exception.
1049     if (playResult.hasException()) {
1050         m_pendingPlaybackRate = originalPendingPlaybackRate;
1051         return playResult.releaseException();
1052     }
1053
1054     return { };
1055 }
1056
1057 void WebAnimation::runPendingPauseTask()
1058 {
1059     // 3.4.11. Pausing an animation, step 7.
1060     // https://drafts.csswg.org/web-animations-1/#pause-an-animation
1061
1062     m_timeToRunPendingPauseTask = TimeToRunPendingTask::NotScheduled;
1063
1064     // 1. Let ready time be the time value of the timeline associated with animation at the moment when the user agent
1065     //    completed processing necessary to suspend playback of animation's target effect.
1066     auto readyTime = m_timeline->currentTime();
1067     auto animationStartTime = m_startTime;
1068
1069     // 2. If animation's start time is resolved and its hold time is not resolved, let animation's hold time be the result of
1070     //    evaluating (ready time - start time) × playback rate.
1071     //    Note: The hold time might be already set if the animation is finished, or if the animation is pending, waiting to begin
1072     //    playback. In either case we want to preserve the hold time as we enter the paused state.
1073     if (animationStartTime && !m_holdTime) {
1074         // FIXME: Implementation cannot guarantee an active timeline at the point of this async dispatch.
1075         // Subsequently, the resulting readyTime value can be null. Unify behavior between C++17 and
1076         // C++14 builds (the latter using WTF's std::optional) and avoid null std::optional dereferencing
1077         // by defaulting to a Seconds(0) value. See https://bugs.webkit.org/show_bug.cgi?id=186189.
1078         m_holdTime = (readyTime.value_or(0_s) - animationStartTime.value()) * m_playbackRate;
1079     }
1080
1081     // 3. Apply any pending playback rate on animation.
1082     applyPendingPlaybackRate();
1083
1084     // 4. Make animation's start time unresolved.
1085     m_startTime = std::nullopt;
1086
1087     // 5. Resolve animation's current ready promise with animation.
1088     if (!m_readyPromise->isFulfilled())
1089         m_readyPromise->resolve(*this);
1090
1091     // 6. Run the procedure to update an animation's finished state for animation with the did seek flag set to false, and the
1092     //    synchronously notify flag set to false.
1093     timingDidChange(DidSeek::No, SynchronouslyNotify::No);
1094
1095     invalidateEffect();
1096 }
1097
1098 bool WebAnimation::isRunningAccelerated() const
1099 {
1100     return is<KeyframeEffect>(m_effect) && downcast<KeyframeEffect>(*m_effect).isRunningAccelerated();
1101 }
1102
1103 bool WebAnimation::needsTick() const
1104 {
1105     return pending() || playState() == PlayState::Running;
1106 }
1107
1108 void WebAnimation::tick()
1109 {
1110     updateFinishedState(DidSeek::No, SynchronouslyNotify::Yes);
1111     m_shouldSkipUpdatingFinishedStateWhenResolving = true;
1112
1113     // Run pending tasks, if any.
1114     if (hasPendingPauseTask())
1115         runPendingPauseTask();
1116     if (hasPendingPlayTask())
1117         runPendingPlayTask();
1118
1119     invalidateEffect();
1120 }
1121
1122 void WebAnimation::resolve(RenderStyle& targetStyle)
1123 {
1124     if (!m_shouldSkipUpdatingFinishedStateWhenResolving)
1125         updateFinishedState(DidSeek::No, SynchronouslyNotify::Yes);
1126     m_shouldSkipUpdatingFinishedStateWhenResolving = false;
1127
1128     if (m_effect)
1129         m_effect->apply(targetStyle);
1130 }
1131
1132 void WebAnimation::setSuspended(bool isSuspended)
1133 {
1134     if (m_isSuspended == isSuspended)
1135         return;
1136
1137     m_isSuspended = isSuspended;
1138
1139     if (m_effect && playState() == PlayState::Running)
1140         m_effect->animationSuspensionStateDidChange(isSuspended);
1141 }
1142
1143 void WebAnimation::acceleratedStateDidChange()
1144 {
1145     if (is<DocumentTimeline>(m_timeline))
1146         downcast<DocumentTimeline>(*m_timeline).animationAcceleratedRunningStateDidChange(*this);
1147 }
1148
1149 void WebAnimation::applyPendingAcceleratedActions()
1150 {
1151     if (is<KeyframeEffect>(m_effect))
1152         downcast<KeyframeEffect>(*m_effect).applyPendingAcceleratedActions();
1153 }
1154
1155 WebAnimation& WebAnimation::readyPromiseResolve()
1156 {
1157     return *this;
1158 }
1159
1160 WebAnimation& WebAnimation::finishedPromiseResolve()
1161 {
1162     return *this;
1163 }
1164
1165 const char* WebAnimation::activeDOMObjectName() const
1166 {
1167     return "Animation";
1168 }
1169
1170 bool WebAnimation::canSuspendForDocumentSuspension() const
1171 {
1172     return !hasPendingActivity();
1173 }
1174
1175 void WebAnimation::stop()
1176 {
1177     m_isStopped = true;
1178     removeAllEventListeners();
1179 }
1180
1181 void WebAnimation::updateRelevance()
1182 {
1183     m_isRelevant = computeRelevance();
1184 }
1185
1186 bool WebAnimation::computeRelevance()
1187 {
1188     // To be listed in getAnimations() an animation needs a target effect which is current or in effect.
1189     if (!m_effect)
1190         return false;
1191
1192     // An animation effect is in effect if its active time is not unresolved.
1193     if (m_effect->activeTime())
1194         return true;
1195
1196     // An animation effect is current if either of the following conditions is true:
1197     // - the animation effect is in the before phase, or
1198     // - the animation effect is in play.
1199
1200     // An animation effect is in play if all of the following conditions are met:
1201     // - the animation effect is in the active phase, and
1202     // - the animation effect is associated with an animation that is not finished.
1203     auto phase = m_effect->phase();
1204     return phase == AnimationEffect::Phase::Before || (phase == AnimationEffect::Phase::Active && playState() != PlayState::Finished);
1205 }
1206
1207 Seconds WebAnimation::timeToNextTick() const
1208 {
1209     ASSERT(isRunningAccelerated());
1210
1211     if (pending())
1212         return 0_s;
1213
1214     // If we're not running, there's no telling when we'll end.
1215     if (playState() != PlayState::Running)
1216         return Seconds::infinity();
1217
1218     // CSS Animations dispatch events for each iteration, so compute the time until
1219     // the end of this iteration. Any other animation only cares about remaning total time.
1220     if (isCSSAnimation()) {
1221         // If we're actively running, we need the time until the next iteration.
1222         if (auto iterationProgress = effect()->simpleIterationProgress())
1223             return effect()->iterationDuration() * (1 - iterationProgress.value());
1224
1225         // Otherwise we're probably in the before phase waiting to reach our start time.
1226         if (auto animationCurrentTime = currentTime()) {
1227             // If our current time is negative, we need to be scheduled to be resolved at the inverse
1228             // of our current time, unless we fill backwards, in which case we want to invalidate as
1229             // soon as possible.
1230             auto localTime = animationCurrentTime.value();
1231             if (localTime < 0_s)
1232                 return -localTime;
1233             if (localTime < effect()->delay())
1234                 return effect()->delay() - localTime;
1235         }
1236     } else if (auto animationCurrentTime = currentTime())
1237         return effect()->endTime() - animationCurrentTime.value();
1238
1239     ASSERT_NOT_REACHED();
1240     return Seconds::infinity();
1241 }
1242
1243 } // namespace WebCore