mirror of
https://github.com/servo/servo.git
synced 2025-10-15 07:50:20 +01:00
493 lines
No EOL
18 KiB
HTML
493 lines
No EOL
18 KiB
HTML
<!DOCTYPE html>
|
|
<meta charset=utf-8>
|
|
<title>Finishing an animation</title>
|
|
<link rel="help"
|
|
href="https://drafts.csswg.org/web-animations/#finishing-an-animation-section">
|
|
<script src="/resources/testharness.js"></script>
|
|
<script src="/resources/testharnessreport.js"></script>
|
|
<script src="/web-animations/testcommon.js"></script>
|
|
<script src="testcommon.js"></script>
|
|
<style>
|
|
.scroller {
|
|
overflow: auto;
|
|
height: 200px;
|
|
width: 100px;
|
|
will-change: transform;
|
|
}
|
|
|
|
.contents {
|
|
height: 1000px;
|
|
width: 100%;
|
|
}
|
|
</style>
|
|
<body>
|
|
<div id="log"></div>
|
|
<script>
|
|
'use strict';
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
animation.play();
|
|
animation.playbackRate = 0;
|
|
|
|
assert_throws_dom('InvalidStateError', () => {
|
|
animation.finish();
|
|
});
|
|
}, 'Finishing an animation with a zero playback rate throws');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
animation.effect.updateTiming({ iterations : Infinity });
|
|
animation.play();
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
|
|
assert_throws_dom('InvalidStateError', () => {
|
|
animation.finish();
|
|
});
|
|
}, 'Finishing an infinite animation throws');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
animation.play();
|
|
animation.finish();
|
|
|
|
assert_times_equal(animation.currentTime, 1000,
|
|
'After finishing, the currentTime should be set to the end of the'
|
|
+ ' active duration');
|
|
}, 'Finishing an animation seeks to the end time');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
animation.play();
|
|
// 1s past effect end
|
|
animation.currentTime =
|
|
animation.effect.getComputedTiming().endTime + 1;
|
|
animation.finish();
|
|
|
|
assert_time_equals_literal(animation.currentTime, 1000,
|
|
'After finishing, the currentTime should be set back to the end of the'
|
|
+ ' active duration');
|
|
}, 'Finishing an animation with a current time past the effect end jumps'
|
|
+ ' back to the end');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
animation.play();
|
|
animation.currentTime = 1000;
|
|
await animation.finished;
|
|
|
|
animation.playbackRate = -1;
|
|
animation.finish();
|
|
|
|
assert_equals(animation.currentTime, 0,
|
|
'After finishing a reversed animation the currentTime ' +
|
|
'should be set to zero');
|
|
}, 'Finishing a reversed animation jumps to zero time');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
animation.play();
|
|
animation.currentTime = 1000;
|
|
await animation.finished;
|
|
|
|
animation.playbackRate = -1;
|
|
animation.currentTime = -10000;
|
|
animation.finish();
|
|
|
|
assert_equals(animation.currentTime, 0,
|
|
'After finishing a reversed animation the currentTime ' +
|
|
'should be set back to zero');
|
|
}, 'Finishing a reversed animation with a current time less than zero'
|
|
+ ' makes it jump back to zero');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
animation.play();
|
|
animation.playbackRate = 0.5;
|
|
animation.finish();
|
|
|
|
assert_false(animation.pending);
|
|
assert_equals(animation.playState, 'finished',
|
|
'The play state of a play-pending animation should become ' +
|
|
'"finished"');
|
|
assert_times_equal(animation.startTime,
|
|
animation.timeline.currentTime - 1000 / 0.5,
|
|
'The start time of a play-pending animation should ' +
|
|
'be set');
|
|
}, 'Finishing an animation while play-pending resolves the pending'
|
|
+ ' task immediately');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
const scroller = animation.timeline.scrollSource;
|
|
// Make the scroll timeline inactive.
|
|
scroller.style.overflow = 'visible';
|
|
scroller.scrollTop;
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
animation.play();
|
|
animation.finish();
|
|
|
|
await animation.finished;
|
|
|
|
assert_true(animation.pending);
|
|
assert_equals(animation.playState, 'finished',
|
|
'The play state of a play-pending animation should become ' +
|
|
'"finished"');
|
|
assert_times_equal(animation.currentTime, 1000,
|
|
'The current time of a play-pending animation should ' +
|
|
'be set to the end of the active duration');
|
|
assert_equals(animation.startTime, null,
|
|
'The start time of a finished play-pending animation' +
|
|
' should be be unresolved');
|
|
}, 'Finishing an animation attached to inactive timeline while play-pending '
|
|
+ 'doesn\'t resolves the pending task');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
animation.play();
|
|
let resolvedFinished = false;
|
|
animation.finished.then(() => {
|
|
resolvedFinished = true;
|
|
});
|
|
|
|
await animation.ready;
|
|
|
|
animation.finish();
|
|
await Promise.resolve();
|
|
|
|
assert_true(resolvedFinished, 'finished promise should be resolved');
|
|
}, 'Finishing an animation resolves the finished promise synchronously');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
animation.play();
|
|
const promise = animation.ready;
|
|
let readyResolved = false;
|
|
|
|
animation.finish();
|
|
animation.ready.then(() => { readyResolved = true; });
|
|
|
|
const promiseResult = await animation.finished;
|
|
await animation.ready;
|
|
|
|
assert_equals(promiseResult, animation);
|
|
assert_equals(animation.ready, promise);
|
|
assert_true(readyResolved);
|
|
}, 'A pending ready promise is resolved and not replaced when the animation'
|
|
+ ' is finished');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
animation.play();
|
|
animation.effect.target.remove();
|
|
|
|
const eventWatcher = new EventWatcher(t, animation, 'finish');
|
|
|
|
await animation.ready;
|
|
animation.finish();
|
|
|
|
await eventWatcher.wait_for('finish');
|
|
assert_equals(animation.effect.target.parentNode, null,
|
|
'finish event should be fired for the animation on an orphaned element');
|
|
}, 'Finishing an animation fires finish event on orphaned element');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
animation.play();
|
|
await animation.ready;
|
|
|
|
const originalFinishPromise = animation.finished;
|
|
|
|
animation.cancel();
|
|
assert_equals(animation.startTime, null);
|
|
assert_equals(animation.currentTime, null);
|
|
|
|
const resolvedFinishPromise = animation.finished;
|
|
assert_true(originalFinishPromise != resolvedFinishPromise,
|
|
'Canceling an animation should create a new finished promise');
|
|
|
|
animation.finish();
|
|
assert_equals(animation.playState, 'finished',
|
|
'The play state of a canceled animation should become ' +
|
|
'"finished"');
|
|
assert_times_equal(animation.startTime,
|
|
animation.timeline.currentTime - 1000,
|
|
'The start time of a finished animation should be set');
|
|
assert_times_equal(animation.currentTime, 1000,
|
|
'Hold time should be set to end boundary of the animation');
|
|
|
|
}, 'Finishing a canceled animation sets the current and start times');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
const scroller = animation.timeline.scrollSource;
|
|
const maxScroll = scroller.scrollHeight - scroller.clientHeight;
|
|
scroller.scrollTop = 0.25 * maxScroll;
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
|
|
const eventWatcher = new EventWatcher(t, animation, 'finish');
|
|
animation.finish();
|
|
await animation.finished;
|
|
const finishEvent = await eventWatcher.wait_for('finish');
|
|
assert_equals(animation.playState, 'finished',
|
|
'Animation is finished.');
|
|
assert_equals(animation.currentTime, 1000,
|
|
'The current time is the end of the active duration in finished state.');
|
|
assert_equals(animation.startTime, -750,
|
|
'The start time is calculated to match the current time.');
|
|
assert_equals(finishEvent.currentTime, 1000,
|
|
'event.currentTime is the animation current time.');
|
|
assert_equals(finishEvent.timelineTime, 250,
|
|
'event.timelineTime is timeline.currentTime');
|
|
}, 'Finishing idle animation produces correct state and fires finish event.');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
const scroller = animation.timeline.scrollSource;
|
|
// Make the scroll timeline inactive.
|
|
scroller.style.overflow = 'visible';
|
|
await waitForNextFrame();
|
|
assert_equals(animation.timeline.currentTime, null,
|
|
'Sanity check the timeline is inactive.');
|
|
animation.finish();
|
|
assert_equals(animation.playState, 'paused', 'Animation is paused.');
|
|
}, 'Finishing idle animation attached to inactive timeline pauses the ' +
|
|
'animation.');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
const scroller = animation.timeline.scrollSource;
|
|
const maxScroll = scroller.scrollHeight - scroller.clientHeight;
|
|
scroller.scrollTop = 0.25 * maxScroll;
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
animation.play();
|
|
await animation.ready;
|
|
|
|
const eventWatcher = new EventWatcher(t, animation, 'finish');
|
|
animation.finish();
|
|
await animation.finished;
|
|
const finishEvent = await eventWatcher.wait_for('finish');
|
|
assert_equals(animation.playState, 'finished',
|
|
'Animation is finished.');
|
|
assert_equals(animation.currentTime, 1000,
|
|
'The current time is the end of active duration in finished state.');
|
|
assert_equals(animation.startTime, -750,
|
|
'The start time is calculated to match animation current time.');
|
|
assert_equals(finishEvent.currentTime, 1000,
|
|
'event.currentTime is the animation current time.');
|
|
assert_equals(finishEvent.timelineTime, 250,
|
|
'event.timelineTime is timeline.currentTime');
|
|
}, 'Finishing running animation produces correct state and fires finish event.');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
const scroller = animation.timeline.scrollSource;
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
animation.play();
|
|
await animation.ready;
|
|
|
|
// Make the scroll timeline inactive.
|
|
scroller.style.overflow = 'visible';
|
|
scroller.scrollTop;
|
|
await waitForNextFrame();
|
|
assert_equals(animation.timeline.currentTime, null,
|
|
'Sanity check the timeline is inactive.');
|
|
assert_equals(animation.playState, 'running',
|
|
'Sanity check the animation is running.');
|
|
|
|
animation.finish();
|
|
assert_equals(animation.playState, 'paused', 'Animation is paused.');
|
|
}, 'Finishing running animation attached to inactive timeline pauses the ' +
|
|
'animation.');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
animation.pause();
|
|
await animation.ready;
|
|
|
|
animation.finish();
|
|
|
|
assert_equals(animation.playState, 'finished',
|
|
'The play state of a paused animation should become ' +
|
|
'"finished"');
|
|
assert_times_equal(animation.startTime,
|
|
animation.timeline.currentTime - 1000,
|
|
'The start time of a paused animation should be set');
|
|
}, 'Finishing a paused animation resolves the start time');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
animation.play();
|
|
// Update playbackRate so we can test that the calculated startTime
|
|
// respects it
|
|
animation.playbackRate = 2;
|
|
animation.pause();
|
|
// While animation is still pause-pending call finish()
|
|
animation.finish();
|
|
|
|
assert_false(animation.pending);
|
|
assert_equals(animation.playState, 'finished',
|
|
'The play state of a pause-pending animation should become ' +
|
|
'"finished"');
|
|
assert_times_equal(animation.startTime,
|
|
animation.timeline.currentTime - 1000 / 2,
|
|
'The start time of a pause-pending animation should ' +
|
|
'be set');
|
|
}, 'Finishing a pause-pending animation resolves the pending task'
|
|
+ ' immediately and update the start time');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
animation.play();
|
|
animation.playbackRate = -2;
|
|
animation.pause();
|
|
animation.finish();
|
|
|
|
assert_false(animation.pending);
|
|
assert_equals(animation.playState, 'finished',
|
|
'The play state of a pause-pending animation should become ' +
|
|
'"finished"');
|
|
assert_times_equal(animation.startTime, animation.timeline.currentTime,
|
|
'The start time of a pause-pending animation should be ' +
|
|
'set');
|
|
}, 'Finishing a pause-pending animation with negative playback rate'
|
|
+ ' resolves the pending task immediately');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
animation.play();
|
|
await animation.ready;
|
|
|
|
animation.pause();
|
|
animation.play();
|
|
// We are now in the unusual situation of being play-pending whilst having
|
|
// a resolved start time. Check that finish() still triggers a transition
|
|
// to the finished state immediately.
|
|
animation.finish();
|
|
|
|
assert_equals(animation.playState, 'finished',
|
|
'After aborting a pause then finishing an animation its play ' +
|
|
'state should become "finished" immediately');
|
|
}, 'Finishing an animation during an aborted pause makes it finished'
|
|
+ ' immediately');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
animation.play();
|
|
await animation.ready;
|
|
|
|
animation.updatePlaybackRate(2);
|
|
assert_true(animation.pending);
|
|
|
|
animation.finish();
|
|
assert_false(animation.pending);
|
|
assert_equals(animation.playbackRate, 2);
|
|
assert_times_equal(animation.currentTime, 1000);
|
|
}, 'A pending playback rate should be applied immediately when an animation'
|
|
+ ' is finished');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
animation.play();
|
|
await animation.ready;
|
|
|
|
animation.updatePlaybackRate(0);
|
|
|
|
assert_throws_dom('InvalidStateError', () => {
|
|
animation.finish();
|
|
});
|
|
}, 'An exception should be thrown if the effective playback rate is zero');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
animation.effect.updateTiming({ iterations: Infinity });
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
animation.play();
|
|
animation.currentTime = 500;
|
|
animation.playbackRate = -1;
|
|
await animation.ready;
|
|
|
|
animation.updatePlaybackRate(1);
|
|
|
|
assert_throws_dom('InvalidStateError', () => {
|
|
animation.finish();
|
|
});
|
|
}, 'An exception should be thrown when finishing if the effective playback rate'
|
|
+ ' is positive and the target effect end is infinity');
|
|
|
|
promise_test(async t => {
|
|
const animation = createScrollLinkedAnimation(t);
|
|
animation.effect.updateTiming({ iterations: Infinity });
|
|
// Wait for new animation frame which allows the timeline to compute new
|
|
// current time.
|
|
await waitForNextFrame();
|
|
animation.play();
|
|
await animation.ready;
|
|
|
|
animation.updatePlaybackRate(-1);
|
|
|
|
animation.finish();
|
|
// Should not have thrown
|
|
}, 'An exception is NOT thrown when finishing if the effective playback rate'
|
|
+ ' is negative and the target effect end is infinity');
|
|
</script>
|
|
</body> |