[Web Animations] Update WPT tests related to Web Animations and remove imported Mozil...
authorcommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 24 Oct 2019 13:25:16 +0000 (13:25 +0000)
committercommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 24 Oct 2019 13:25:16 +0000 (13:25 +0000)
https://bugs.webkit.org/show_bug.cgi?id=203291

Patch by Antoine Quint <graouts@apple.com> on 2019-10-24
Reviewed by Youenn Fablet.

LayoutTests/imported/mozilla:

* css-animations/test_animation-cancel-expected.txt: Removed.
* css-animations/test_animation-cancel.html: Removed.
* css-animations/test_animation-currenttime-expected.txt: Removed.
* css-animations/test_animation-currenttime.html: Removed.
* css-animations/test_animation-finish-expected.txt: Removed.
* css-animations/test_animation-finish.html: Removed.
* css-animations/test_animation-finished-expected.txt: Removed.
* css-animations/test_animation-finished.html: Removed.
* css-animations/test_animation-id.html: Removed.
* css-animations/test_animation-pausing.html: Removed.
* css-animations/test_animation-playstate.html: Removed.
* css-animations/test_animation-ready.html: Removed.
* css-animations/test_animation-reverse-expected.txt: Removed.
* css-animations/test_animation-reverse.html: Removed.
* css-animations/test_animation-starttime-expected.txt: Removed.
* css-animations/test_animation-starttime.html: Removed.
* css-animations/test_animations-dynamic-changes.html: Removed.
* css-animations/test_event-dispatch.html: Removed.
* css-animations/test_event-order-expected.txt: Removed.
* css-animations/test_event-order.html: Removed.
* css-animations/test_setting-effect.html: Removed.
* css-transitions/test_animation-cancel.html: Removed.
* css-transitions/test_animation-currenttime-expected.txt: Removed.
* css-transitions/test_animation-currenttime.html: Removed.
* css-transitions/test_animation-finished-expected.txt: Removed.
* css-transitions/test_animation-finished.html: Removed.
* css-transitions/test_animation-pausing-expected.txt: Removed.
* css-transitions/test_animation-pausing.html: Removed.
* css-transitions/test_animation-ready-expected.txt: Removed.
* css-transitions/test_animation-ready.html: Removed.
* css-transitions/test_animation-starttime-expected.txt: Removed.
* css-transitions/test_animation-starttime.html: Removed.
* css-transitions/test_csstransition-transitionproperty.html: Removed.
* css-transitions/test_document-get-animations-expected.txt: Removed.
* css-transitions/test_document-get-animations.html: Removed.
* css-transitions/test_element-get-animations-expected.txt: Removed.
* css-transitions/test_element-get-animations.html: Removed.
* css-transitions/test_event-dispatch.html: Removed.
* css-transitions/test_keyframeeffect-getkeyframes-expected.txt: Removed.
* css-transitions/test_keyframeeffect-getkeyframes.html: Removed.
* css-transitions/test_setting-effect-expected.txt: Removed.
* css-transitions/test_setting-effect.html: Removed.

LayoutTests/imported/w3c:

* resources/import-expectations.json:
* web-platform-tests/css/css-animations: Resynced.
* web-platform-tests/css/css-transitions: Imported.
* web-platform-tests/web-animations: Resynced.

LayoutTests:

* TestExpectations:
* platform/gtk/TestExpectations:
* platform/gtk/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/accumulation-per-property-expected.txt:
* platform/gtk/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/addition-per-property-expected.txt:
* platform/ios/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/accumulation-per-property-expected.txt:
* platform/ios/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/addition-per-property-expected.txt:
* platform/ios/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/interpolation-per-property-expected.txt:
* platform/mac-wk1/TestExpectations:
* platform/mac-sierra/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/accumulation-per-property-expected.txt:
* platform/mac-sierra/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/addition-per-property-expected.txt:
* platform/win/TestExpectations:
* platform/wpe/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/accumulation-per-property-expected.txt:
* platform/wpe/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/addition-per-property-expected.txt:
* tests-options.json:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@251536 268f45cc-cd09-0410-ab3c-d52691b4dbfc

422 files changed:
LayoutTests/ChangeLog
LayoutTests/TestExpectations
LayoutTests/imported/mozilla/ChangeLog
LayoutTests/imported/mozilla/css-animations/test_animation-cancel-expected.txt [deleted file]
LayoutTests/imported/mozilla/css-animations/test_animation-cancel.html [deleted file]
LayoutTests/imported/mozilla/css-animations/test_animation-currenttime-expected.txt [deleted file]
LayoutTests/imported/mozilla/css-animations/test_animation-currenttime.html [deleted file]
LayoutTests/imported/mozilla/css-animations/test_animation-finish-expected.txt [deleted file]
LayoutTests/imported/mozilla/css-animations/test_animation-finish.html [deleted file]
LayoutTests/imported/mozilla/css-animations/test_animation-finished-expected.txt [deleted file]
LayoutTests/imported/mozilla/css-animations/test_animation-finished.html [deleted file]
LayoutTests/imported/mozilla/css-animations/test_animation-id.html [deleted file]
LayoutTests/imported/mozilla/css-animations/test_animation-pausing.html [deleted file]
LayoutTests/imported/mozilla/css-animations/test_animation-playstate.html [deleted file]
LayoutTests/imported/mozilla/css-animations/test_animation-ready.html [deleted file]
LayoutTests/imported/mozilla/css-animations/test_animation-reverse-expected.txt [deleted file]
LayoutTests/imported/mozilla/css-animations/test_animation-reverse.html [deleted file]
LayoutTests/imported/mozilla/css-animations/test_animation-starttime-expected.txt [deleted file]
LayoutTests/imported/mozilla/css-animations/test_animation-starttime.html [deleted file]
LayoutTests/imported/mozilla/css-animations/test_animations-dynamic-changes.html [deleted file]
LayoutTests/imported/mozilla/css-animations/test_event-dispatch.html [deleted file]
LayoutTests/imported/mozilla/css-animations/test_event-order-expected.txt [deleted file]
LayoutTests/imported/mozilla/css-animations/test_event-order.html [deleted file]
LayoutTests/imported/mozilla/css-animations/test_setting-effect.html [deleted file]
LayoutTests/imported/mozilla/css-transitions/test_animation-cancel.html [deleted file]
LayoutTests/imported/mozilla/css-transitions/test_animation-currenttime-expected.txt [deleted file]
LayoutTests/imported/mozilla/css-transitions/test_animation-currenttime.html [deleted file]
LayoutTests/imported/mozilla/css-transitions/test_animation-finished-expected.txt [deleted file]
LayoutTests/imported/mozilla/css-transitions/test_animation-finished.html [deleted file]
LayoutTests/imported/mozilla/css-transitions/test_animation-pausing-expected.txt [deleted file]
LayoutTests/imported/mozilla/css-transitions/test_animation-pausing.html [deleted file]
LayoutTests/imported/mozilla/css-transitions/test_animation-ready-expected.txt [deleted file]
LayoutTests/imported/mozilla/css-transitions/test_animation-ready.html [deleted file]
LayoutTests/imported/mozilla/css-transitions/test_animation-starttime-expected.txt [deleted file]
LayoutTests/imported/mozilla/css-transitions/test_animation-starttime.html [deleted file]
LayoutTests/imported/mozilla/css-transitions/test_csstransition-transitionproperty.html [deleted file]
LayoutTests/imported/mozilla/css-transitions/test_document-get-animations-expected.txt [deleted file]
LayoutTests/imported/mozilla/css-transitions/test_document-get-animations.html [deleted file]
LayoutTests/imported/mozilla/css-transitions/test_element-get-animations-expected.txt [deleted file]
LayoutTests/imported/mozilla/css-transitions/test_element-get-animations.html [deleted file]
LayoutTests/imported/mozilla/css-transitions/test_event-dispatch.html [deleted file]
LayoutTests/imported/mozilla/css-transitions/test_keyframeeffect-getkeyframes-expected.txt [deleted file]
LayoutTests/imported/mozilla/css-transitions/test_keyframeeffect-getkeyframes.html [deleted file]
LayoutTests/imported/mozilla/css-transitions/test_setting-effect-expected.txt [deleted file]
LayoutTests/imported/mozilla/css-transitions/test_setting-effect.html [deleted file]
LayoutTests/imported/w3c/ChangeLog
LayoutTests/imported/w3c/resources/import-expectations.json
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/AnimationEffect-getComputedTiming.tentative-expected.txt [moved from LayoutTests/imported/mozilla/css-animations/test_animation-computed-timing-expected.txt with 100% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/AnimationEffect-getComputedTiming.tentative.html [moved from LayoutTests/imported/mozilla/css-animations/test_animation-computed-timing.html with 67% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-animationName.tentative-expected.txt [moved from LayoutTests/imported/mozilla/css-animations/test_cssanimation-animationname-expected.txt with 100% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-animationName.tentative.html [moved from LayoutTests/imported/mozilla/css-animations/test_cssanimation-animationname.html with 65% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-canceling.tentative-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-canceling.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-effect.tentative-expected.txt [moved from LayoutTests/imported/mozilla/css-animations/test_setting-effect-expected.txt with 80% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-effect.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-finished.tentative-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-finished.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-getCurrentTime.tentative-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-getCurrentTime.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-id.tentative-expected.txt [moved from LayoutTests/imported/mozilla/css-animations/test_animation-id-expected.txt with 100% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-id.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-pausing.tentative-expected.txt [moved from LayoutTests/imported/mozilla/css-animations/test_animation-pausing-expected.txt with 100% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-pausing.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-playState.tentative-expected.txt [moved from LayoutTests/imported/mozilla/css-animations/test_animation-playstate-expected.txt with 61% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-playState.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-ready.tentative-expected.txt [moved from LayoutTests/imported/mozilla/css-animations/test_animation-ready-expected.txt with 55% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-ready.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-startTime.tentative-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-startTime.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSPseudoElement-getAnimations.tentative-expected.txt [moved from LayoutTests/imported/mozilla/css-animations/test_pseudoElement-get-animations-expected.txt with 60% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSPseudoElement-getAnimations.tentative.html [moved from LayoutTests/imported/mozilla/css-animations/test_pseudoElement-get-animations.html with 65% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/Document-getAnimations.tentative-expected.txt [moved from LayoutTests/imported/mozilla/css-animations/test_document-get-animations-expected.txt with 59% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/Document-getAnimations.tentative.html [moved from LayoutTests/imported/mozilla/css-animations/test_document-get-animations.html with 64% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/Element-getAnimations-dynamic-changes.tentative-expected.txt [moved from LayoutTests/imported/mozilla/css-animations/test_animations-dynamic-changes-expected.txt with 100% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/Element-getAnimations-dynamic-changes.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/Element-getAnimations.tentative-expected.txt [moved from LayoutTests/imported/mozilla/css-animations/test_element-get-animations-expected.txt with 57% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/Element-getAnimations.tentative.html [moved from LayoutTests/imported/mozilla/css-animations/test_element-get-animations.html with 59% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/KeyframeEffect-getKeyframes.tentative-expected.txt [moved from LayoutTests/imported/mozilla/css-animations/test_keyframeeffect-getkeyframes-expected.txt with 99% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/KeyframeEffect-getKeyframes.tentative.html [moved from LayoutTests/imported/mozilla/css-animations/test_keyframeeffect-getkeyframes.html with 84% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/KeyframeEffect-target.tentative-expected.txt [moved from LayoutTests/imported/mozilla/css-animations/test_effect-target-expected.txt with 100% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/KeyframeEffect-target.tentative.html [moved from LayoutTests/imported/mozilla/css-animations/test_effect-target.html with 63% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/META.yml [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/OWNERS [deleted file]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/animation-opacity-pause-and-set-time-expected.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/animation-opacity-pause-and-set-time.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/animation-pseudo-dynamic-001-expected.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/animation-pseudo-dynamic-001.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/animation-transform-pause-and-set-time-expected.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/animation-transform-pause-and-set-time.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/animationevent-interface-expected.txt
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/animationevent-interface.js
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/animationevent-marker-pseudoelement-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/animationevent-marker-pseudoelement.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/computed-style-animation-parsing-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/computed-style-animation-parsing.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/event-dispatch.tentative-expected.txt [moved from LayoutTests/imported/mozilla/css-animations/test_event-dispatch-expected.txt with 60% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/event-dispatch.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/event-order.tentative-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/event-order.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/historical-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/historical.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/idlharness-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/idlharness.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/inheritance-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/inheritance.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/keyframes-remove-documentElement-crash-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/keyframes-remove-documentElement-crash.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-computed-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-computed.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-delay-computed-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-delay-computed.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-delay-invalid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-delay-invalid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-delay-valid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-delay-valid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-direction-computed-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-direction-computed.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-direction-invalid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-direction-invalid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-direction-valid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-direction-valid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-duration-computed-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-duration-computed.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-duration-invalid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-duration-invalid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-duration-valid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-duration-valid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-fill-mode-computed-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-fill-mode-computed.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-fill-mode-invalid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-fill-mode-invalid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-fill-mode-valid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-fill-mode-valid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-invalid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-invalid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-iteration-count-computed-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-iteration-count-computed.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-iteration-count-invalid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-iteration-count-invalid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-iteration-count-valid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-iteration-count-valid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-name-computed-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-name-computed.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-name-invalid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-name-invalid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-name-valid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-name-valid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-play-state-computed-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-play-state-computed.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-play-state-invalid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-play-state-invalid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-play-state-valid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-play-state-valid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-shorthand-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-shorthand.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-timing-function-computed-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-timing-function-computed.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-timing-function-invalid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-timing-function-invalid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-timing-function-valid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-timing-function-valid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-valid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/animation-valid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/parsing/w3c-import.log [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/responsive/column-rule-color-001-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/responsive/column-rule-color-001.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/responsive/column-width-001-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/responsive/column-width-001.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/responsive/w3c-import.log [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/style-animation-parsing-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/style-animation-parsing.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/support/testcommon.js
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/support/w3c-import.log
LayoutTests/imported/w3c/web-platform-tests/css/css-animations/w3c-import.log
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/AnimationEffect-getComputedTiming.tentative-expected.txt [moved from LayoutTests/imported/mozilla/css-transitions/test_animation-computed-timing-expected.txt with 79% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/AnimationEffect-getComputedTiming.tentative.html [moved from LayoutTests/imported/mozilla/css-transitions/test_animation-computed-timing.html with 56% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/CSSPseudoElement-getAnimations.tentative-expected.txt [moved from LayoutTests/imported/mozilla/css-transitions/test_pseudoElement-get-animations-expected.txt with 100% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/CSSPseudoElement-getAnimations.tentative.html [moved from LayoutTests/imported/mozilla/css-transitions/test_pseudoElement-get-animations.html with 65% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/CSSTransition-canceling.tentative-expected.txt [moved from LayoutTests/imported/mozilla/css-transitions/test_animation-cancel-expected.txt with 68% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/CSSTransition-canceling.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/CSSTransition-currentTime.tentative-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/CSSTransition-currentTime.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/CSSTransition-effect.tentative-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/CSSTransition-effect.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/CSSTransition-finished.tentative-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/CSSTransition-finished.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/CSSTransition-ready.tentative-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/CSSTransition-ready.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/CSSTransition-startTime.tentative-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/CSSTransition-startTime.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/CSSTransition-transitionProperty.tentative-expected.txt [moved from LayoutTests/imported/mozilla/css-transitions/test_csstransition-transitionproperty-expected.txt with 100% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/CSSTransition-transitionProperty.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/Document-getAnimations.tentative-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/Document-getAnimations.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/Element-getAnimations.tentative-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/Element-getAnimations.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/KeyframeEffect-getKeyframes.tentative-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/KeyframeEffect-getKeyframes.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/KeyframeEffect-target.tentative-expected.txt [moved from LayoutTests/imported/mozilla/css-transitions/test_effect-target-expected.txt with 100% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/KeyframeEffect-target.tentative.html [moved from LayoutTests/imported/mozilla/css-transitions/test_effect-target.html with 66% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/META.yml [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/README.md [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/before-load-001-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/before-load-001.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/changing-while-transition-001-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/changing-while-transition-001.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/changing-while-transition-002-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/changing-while-transition-002.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/changing-while-transition-003-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/changing-while-transition-003.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/currentcolor-animation-001-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/currentcolor-animation-001.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/disconnected-element-001-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/disconnected-element-001.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/event-dispatch.tentative-expected.txt [moved from LayoutTests/imported/mozilla/css-transitions/test_event-dispatch-expected.txt with 85% similarity]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/event-dispatch.tentative.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/events-001-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/events-001.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/events-002-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/events-002.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/events-003-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/events-003.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/events-004-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/events-004.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/events-005-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/events-005.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/events-006-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/events-006.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/events-007-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/events-007.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/historical-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/historical.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/idlharness-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/idlharness.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/inherit-height-transition-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/inherit-height-transition.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/inheritance-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/inheritance.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/no-transition-from-ua-to-blocking-stylesheet-expected.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/no-transition-from-ua-to-blocking-stylesheet.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/non-rendered-element-001-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/non-rendered-element-001.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/non-rendered-element-002-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/non-rendered-element-002.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-computed-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-computed.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-delay-computed-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-delay-computed.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-delay-invalid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-delay-invalid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-delay-valid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-delay-valid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-duration-computed-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-duration-computed.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-duration-invalid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-duration-invalid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-duration-valid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-duration-valid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-invalid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-invalid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-property-computed-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-property-computed.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-property-invalid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-property-invalid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-property-valid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-property-valid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-shorthand-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-shorthand.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-timing-function-computed-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-timing-function-computed.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-timing-function-invalid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-timing-function-invalid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-timing-function-valid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-timing-function-valid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-valid-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/transition-valid.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/parsing/w3c-import.log [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/properties-value-001-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/properties-value-001.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/properties-value-002-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/properties-value-002.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/properties-value-003-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/properties-value-003.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/properties-value-auto-001-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/properties-value-auto-001.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/properties-value-implicit-001-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/properties-value-implicit-001.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/properties-value-inherit-001-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/properties-value-inherit-001.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/properties-value-inherit-002-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/properties-value-inherit-002.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/properties-value-inherit-003-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/properties-value-inherit-003.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/pseudo-elements-001-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/pseudo-elements-001.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/pseudo-elements-002-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/pseudo-elements-002.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/starting-of-transitions-001-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/starting-of-transitions-001.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/1x1-green.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/1x1-lime.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/1x1-maroon.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/1x1-navy.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/1x1-red.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/1x1-white.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/60x60-gg-rr.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/60x60-green.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/60x60-red.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/README [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/a-green-transition.css [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/a-green.css [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/b-green.css [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/c-red.css [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/cat.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/generalParallelTest.js [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/helper.js [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/import-green.css [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/import-red.css [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/one.gif [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/pattern-grg-rgr-grg.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/pattern-grg-rrg-rgg.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/pattern-rgr-grg-rgr.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/pattern-tr.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/properties.js [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/ruler-h-50%.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/ruler-h-50px.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/ruler-v-100px.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/ruler-v-50px.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/runParallelAsyncHarness.js [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/square-purple.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/square-teal.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/square-white.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/support/README [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/support/swatch-green.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/support/swatch-red.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/support/w3c-import.log [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/swatch-blue.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/swatch-green.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/swatch-lime.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/swatch-orange.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/swatch-red.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/swatch-teal.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/swatch-white.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/swatch-yellow.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/test-bl.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/test-br.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/test-inner-half-size.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/test-outer.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/test-tl.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/test-tr.png [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/two.gif [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/vendorPrefix.js [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/support/w3c-import.log [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/transition-001-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/transition-001.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/transition-background-position-with-edge-offset-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/transition-background-position-with-edge-offset.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/transition-delay-001-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/transition-delay-001.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/transition-duration-001-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/transition-duration-001.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/transition-property-001-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/transition-property-001.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/transition-property-002-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/transition-property-002.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/transition-reparented-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/transition-reparented.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/transition-test-expected.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/transition-test.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/transitioncancel-001-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/transitioncancel-001.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/transitionevent-interface-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/transitionevent-interface.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/w3c-import.log [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/zero-duration-multiple-transition-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/css-transitions/zero-duration-multiple-transition.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/accumulation-per-property-expected.txt
LayoutTests/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/addition-per-property-expected.txt
LayoutTests/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/interpolation-per-property-expected.txt
LayoutTests/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/property-types.js
LayoutTests/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/w3c-import.log [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/animation-model/combining-effects/w3c-import.log [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/animation-model/keyframe-effects/w3c-import.log [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/interfaces/Animatable/w3c-import.log [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/interfaces/Animation/idlharness.window-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/interfaces/Animation/idlharness.window.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/interfaces/Animation/oncancel.html
LayoutTests/imported/w3c/web-platform-tests/web-animations/interfaces/Animation/w3c-import.log [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/interfaces/AnimationEffect/w3c-import.log [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/interfaces/AnimationPlaybackEvent/idlharness.window-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/interfaces/AnimationPlaybackEvent/idlharness.window.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/interfaces/AnimationPlaybackEvent/w3c-import.log [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/interfaces/Document/getAnimations-expected.txt
LayoutTests/imported/w3c/web-platform-tests/web-animations/interfaces/Document/getAnimations.html
LayoutTests/imported/w3c/web-platform-tests/web-animations/interfaces/Document/w3c-import.log [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/interfaces/DocumentTimeline/idlharness.window-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/interfaces/DocumentTimeline/idlharness.window.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/interfaces/DocumentTimeline/w3c-import.log [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/interfaces/KeyframeEffect/idlharness.window-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/interfaces/KeyframeEffect/idlharness.window.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/interfaces/KeyframeEffect/processing-a-keyframes-argument-001-expected.txt
LayoutTests/imported/w3c/web-platform-tests/web-animations/interfaces/KeyframeEffect/processing-a-keyframes-argument-001.html
LayoutTests/imported/w3c/web-platform-tests/web-animations/interfaces/KeyframeEffect/w3c-import.log [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/resources/w3c-import.log [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/timing-model/animation-effects/w3c-import.log [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/timing-model/animations/w3c-import.log [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/timing-model/time-transformations/w3c-import.log [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/timing-model/timelines/w3c-import.log [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/web-animations/w3c-import.log [new file with mode: 0644]
LayoutTests/platform/gtk/TestExpectations
LayoutTests/platform/gtk/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/accumulation-per-property-expected.txt
LayoutTests/platform/gtk/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/addition-per-property-expected.txt
LayoutTests/platform/ios/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/accumulation-per-property-expected.txt
LayoutTests/platform/ios/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/addition-per-property-expected.txt
LayoutTests/platform/ios/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/interpolation-per-property-expected.txt
LayoutTests/platform/mac-sierra/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/accumulation-per-property-expected.txt
LayoutTests/platform/mac-sierra/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/addition-per-property-expected.txt
LayoutTests/platform/mac-wk1/TestExpectations
LayoutTests/platform/win/TestExpectations
LayoutTests/platform/wpe/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/accumulation-per-property-expected.txt
LayoutTests/platform/wpe/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/addition-per-property-expected.txt
LayoutTests/tests-options.json

index b82b2cb..41f7ff8 100644 (file)
@@ -1,3 +1,25 @@
+2019-10-24  Antoine Quint  <graouts@apple.com>
+
+        [Web Animations] Update WPT tests related to Web Animations and remove imported Mozilla tests
+        https://bugs.webkit.org/show_bug.cgi?id=203291
+
+        Reviewed by Youenn Fablet.
+
+        * TestExpectations:
+        * platform/gtk/TestExpectations:
+        * platform/gtk/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/accumulation-per-property-expected.txt:
+        * platform/gtk/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/addition-per-property-expected.txt:
+        * platform/ios/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/accumulation-per-property-expected.txt:
+        * platform/ios/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/addition-per-property-expected.txt:
+        * platform/ios/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/interpolation-per-property-expected.txt:
+        * platform/mac-wk1/TestExpectations:
+        * platform/mac-sierra/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/accumulation-per-property-expected.txt:
+        * platform/mac-sierra/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/addition-per-property-expected.txt:
+        * platform/win/TestExpectations:
+        * platform/wpe/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/accumulation-per-property-expected.txt:
+        * platform/wpe/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/addition-per-property-expected.txt:
+        * tests-options.json:
+
 2019-10-23  Devin Rousso  <drousso@apple.com>
 
         Web Inspector: provide a way to inject "bootstrap" JavaScript into the page as the first script executed
index def8825..ef34f7c 100644 (file)
@@ -2801,13 +2801,6 @@ webkit.org/b/202107 imported/w3c/web-platform-tests/web-animations/interfaces/An
 webkit.org/b/202108 imported/w3c/web-platform-tests/web-animations/interfaces/DocumentTimeline/style-change-events.html [ Pass Failure ]
 webkit.org/b/202109 imported/w3c/web-platform-tests/web-animations/timing-model/timelines/update-and-send-events.html [ Pass Failure ]
 
-webkit.org/b/183836 imported/mozilla/css-animations/test_animations-dynamic-changes.html [ Pass Failure Timeout ]
-webkit.org/b/183844 imported/mozilla/css-animations/test_element-get-animations.html [ Pass Failure Timeout ]
-webkit.org/b/183846 imported/mozilla/css-transitions/test_pseudoElement-get-animations.html [ Pass Failure Timeout ]
-webkit.org/b/183847 imported/mozilla/css-animations/test_event-order.html [ Pass Failure Timeout ]
-
-webkit.org/b/183848 imported/mozilla/css-animations/test_keyframeeffect-getkeyframes.html [ Skip ]
-
 webkit.org/b/157068 [ Debug ] imported/w3c/web-platform-tests/fetch/nosniff/importscripts.html [ Pass Crash ]
 webkit.org/b/157068 [ Release ] imported/w3c/web-platform-tests/fetch/nosniff/importscripts.html [ Pass Failure ]
 
@@ -3885,6 +3878,8 @@ webkit.org/b/200207 imported/w3c/web-platform-tests/css/css-images/css-image-fal
 webkit.org/b/200208 imported/w3c/web-platform-tests/css/css-images/gradients-with-transparent.html [ ImageOnlyFailure ]
 webkit.org/b/200209 imported/w3c/web-platform-tests/css/css-images/multiple-position-color-stop-radial.html [ ImageOnlyFailure ]
 
+webkit.org/b/203296 imported/w3c/web-platform-tests/css/css-animations/keyframes-remove-documentElement-crash.html [ Skip ]
+
 # wpt css-values failures
 webkit.org/b/203320 imported/w3c/web-platform-tests/css/css-values/percentage-rem-low.html [ ImageOnlyFailure ]
 webkit.org/b/203321 imported/w3c/web-platform-tests/css/css-values/q-unit-case-insensitivity-001.html [ ImageOnlyFailure ]
index f2edaed..708c2b6 100644 (file)
@@ -1,3 +1,53 @@
+2019-10-24  Antoine Quint  <graouts@apple.com>
+
+        [Web Animations] Update WPT tests related to Web Animations and remove imported Mozilla tests
+        https://bugs.webkit.org/show_bug.cgi?id=203291
+
+        Reviewed by Youenn Fablet.
+
+        * css-animations/test_animation-cancel-expected.txt: Removed.
+        * css-animations/test_animation-cancel.html: Removed.
+        * css-animations/test_animation-currenttime-expected.txt: Removed.
+        * css-animations/test_animation-currenttime.html: Removed.
+        * css-animations/test_animation-finish-expected.txt: Removed.
+        * css-animations/test_animation-finish.html: Removed.
+        * css-animations/test_animation-finished-expected.txt: Removed.
+        * css-animations/test_animation-finished.html: Removed.
+        * css-animations/test_animation-id.html: Removed.
+        * css-animations/test_animation-pausing.html: Removed.
+        * css-animations/test_animation-playstate.html: Removed.
+        * css-animations/test_animation-ready.html: Removed.
+        * css-animations/test_animation-reverse-expected.txt: Removed.
+        * css-animations/test_animation-reverse.html: Removed.
+        * css-animations/test_animation-starttime-expected.txt: Removed.
+        * css-animations/test_animation-starttime.html: Removed.
+        * css-animations/test_animations-dynamic-changes.html: Removed.
+        * css-animations/test_event-dispatch.html: Removed.
+        * css-animations/test_event-order-expected.txt: Removed.
+        * css-animations/test_event-order.html: Removed.
+        * css-animations/test_setting-effect.html: Removed.
+        * css-transitions/test_animation-cancel.html: Removed.
+        * css-transitions/test_animation-currenttime-expected.txt: Removed.
+        * css-transitions/test_animation-currenttime.html: Removed.
+        * css-transitions/test_animation-finished-expected.txt: Removed.
+        * css-transitions/test_animation-finished.html: Removed.
+        * css-transitions/test_animation-pausing-expected.txt: Removed.
+        * css-transitions/test_animation-pausing.html: Removed.
+        * css-transitions/test_animation-ready-expected.txt: Removed.
+        * css-transitions/test_animation-ready.html: Removed.
+        * css-transitions/test_animation-starttime-expected.txt: Removed.
+        * css-transitions/test_animation-starttime.html: Removed.
+        * css-transitions/test_csstransition-transitionproperty.html: Removed.
+        * css-transitions/test_document-get-animations-expected.txt: Removed.
+        * css-transitions/test_document-get-animations.html: Removed.
+        * css-transitions/test_element-get-animations-expected.txt: Removed.
+        * css-transitions/test_element-get-animations.html: Removed.
+        * css-transitions/test_event-dispatch.html: Removed.
+        * css-transitions/test_keyframeeffect-getkeyframes-expected.txt: Removed.
+        * css-transitions/test_keyframeeffect-getkeyframes.html: Removed.
+        * css-transitions/test_setting-effect-expected.txt: Removed.
+        * css-transitions/test_setting-effect.html: Removed.
+
 2018-11-06  Antoine Quint  <graouts@apple.com>
 
         [Web Animations] Update all tests to match the latest API changes
diff --git a/LayoutTests/imported/mozilla/css-animations/test_animation-cancel-expected.txt b/LayoutTests/imported/mozilla/css-animations/test_animation-cancel-expected.txt
deleted file mode 100644 (file)
index d68b752..0000000
+++ /dev/null
@@ -1,11 +0,0 @@
-
-PASS Animated style is cleared after cancelling a running CSS animation 
-PASS Animated style is cleared after cancelling a filling CSS animation 
-PASS After canceling an animation, it can still be seeked 
-PASS After cancelling an animation, it can still be re-used 
-PASS After cancelling an animation, updating animation properties doesn't make it live again 
-PASS After cancelling an animation, updating animation-play-state doesn't make it live again 
-PASS Setting animation-name to 'none' cancels the animation 
-PASS Setting display:none on an element cancel its animations 
-PASS Setting display:none on an ancestor element cancels animations on descendants 
-
diff --git a/LayoutTests/imported/mozilla/css-animations/test_animation-cancel.html b/LayoutTests/imported/mozilla/css-animations/test_animation-cancel.html
deleted file mode 100644 (file)
index fa877a2..0000000
+++ /dev/null
@@ -1,193 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<style>
-@keyframes translateAnim {
-  to { transform: translate(100px) }
-}
-@keyframes marginLeftAnim {
-  to { margin-left: 100px }
-}
-@keyframes marginLeftAnim100To200 {
-  from { margin-left: 100px }
-  to { margin-left: 200px }
-}
-</style>
-<body>
-<div id="log"></div>
-<script>
-'use strict';
-
-promise_test(function(t) {
-  var div = addDiv(t, { style: 'animation: translateAnim 100s' });
-  var animation = div.getAnimations()[0];
-
-  return animation.ready.then(function() {
-    assert_not_equals(getComputedStyle(div).transform, 'none',
-                      'transform style is animated before cancelling');
-    animation.cancel();
-    assert_equals(getComputedStyle(div).transform, 'none',
-                  'transform style is no longer animated after cancelling');
-  });
-}, 'Animated style is cleared after cancelling a running CSS animation');
-
-promise_test(function(t) {
-  var div = addDiv(t, { style: 'animation: translateAnim 100s forwards' });
-  var animation = div.getAnimations()[0];
-  animation.finish();
-
-  return animation.ready.then(function() {
-    assert_not_equals(getComputedStyle(div).transform, 'none',
-                      'transform style is filling before cancelling');
-    animation.cancel();
-    assert_equals(getComputedStyle(div).transform, 'none',
-                  'fill style is cleared after cancelling');
-  });
-}, 'Animated style is cleared after cancelling a filling CSS animation');
-
-test(function(t) {
-  var div = addDiv(t, { style: 'animation: marginLeftAnim 100s linear' });
-  var animation = div.getAnimations()[0];
-  animation.cancel();
-
-  assert_equals(getComputedStyle(div).marginLeft, '0px',
-                'margin-left style is not animated after cancelling');
-
-  animation.currentTime = 50 * 1000;
-  assert_equals(getComputedStyle(div).marginLeft, '50px',
-                'margin-left style is updated when cancelled animation is'
-                + ' seeked');
-}, 'After canceling an animation, it can still be seeked');
-
-promise_test(function(t) {
-  var div =
-    addDiv(t, { style: 'animation: marginLeftAnim100To200 100s linear' });
-  var animation = div.getAnimations()[0];
-
-  return animation.ready.then(function() {
-    animation.cancel();
-    assert_equals(getComputedStyle(div).marginLeft, '0px',
-                  'margin-left style is not animated after cancelling');
-    animation.play();
-    assert_equals(getComputedStyle(div).marginLeft, '100px',
-                  'margin-left style is animated after re-starting animation');
-    return animation.ready;
-  }).then(function() {
-    assert_equals(animation.playState, 'running',
-                  'Animation succeeds in running after being re-started');
-  });
-}, 'After cancelling an animation, it can still be re-used');
-
-test(function(t) {
-  var div =
-    addDiv(t, { style: 'animation: marginLeftAnim100To200 100s linear' });
-  var animation = div.getAnimations()[0];
-  animation.cancel();
-  assert_equals(getComputedStyle(div).marginLeft, '0px',
-                'margin-left style is not animated after cancelling');
-
-  // Trigger a change to some animation properties and check that this
-  // doesn't cause the animation to become live again
-  div.style.animationDuration = '200s';
-  assert_equals(getComputedStyle(div).marginLeft, '0px',
-                'margin-left style is still not animated after updating'
-                + ' animation-duration');
-  assert_equals(animation.playState, 'idle',
-                'Animation is still idle after updating animation-duration');
-}, 'After cancelling an animation, updating animation properties doesn\'t make'
-   + ' it live again');
-
-test(function(t) {
-  var div =
-    addDiv(t, { style: 'animation: marginLeftAnim100To200 100s linear' });
-  var animation = div.getAnimations()[0];
-  animation.cancel();
-  assert_equals(getComputedStyle(div).marginLeft, '0px',
-                'margin-left style is not animated after cancelling');
-
-  // Make some changes to animation-play-state and check that the
-  // animation doesn't become live again. This is because it should be
-  // possible to cancel an animation from script such that all future
-  // changes to style are ignored.
-
-  // Redundant change
-  div.style.animationPlayState = 'running';
-  assert_equals(animation.playState, 'idle',
-                'Animation is still idle after a redundant change to'
-                + ' animation-play-state');
-
-  // Pause
-  div.style.animationPlayState = 'paused';
-  assert_equals(animation.playState, 'idle',
-                'Animation is still idle after setting'
-                + ' animation-play-state: paused');
-
-  // Play
-  div.style.animationPlayState = 'running';
-  assert_equals(animation.playState, 'idle',
-                'Animation is still idle after re-setting'
-                + ' animation-play-state: running');
-
-}, 'After cancelling an animation, updating animation-play-state doesn\'t'
-   + ' make it live again');
-
-promise_test(function(t) {
-  var div = addDiv(t, { style: 'animation: translateAnim 10s both' });
-  div.style.marginLeft = '0px';
-
-  var animation = div.getAnimations()[0];
-
-  return animation.ready.then(function() {
-    assert_equals(animation.playState, 'running');
-
-    div.style.animationName = 'none';
-    flushComputedStyle(div);
-    return waitForFrame();
-  }).then(function() {
-    assert_equals(animation.playState, 'idle');
-    assert_equals(getComputedStyle(div).marginLeft, '0px');
-  });
-}, 'Setting animation-name to \'none\' cancels the animation');
-
-promise_test(function(t) {
-  var div = addDiv(t, { style: 'animation: translateAnim 10s both' });
-  var animation = div.getAnimations()[0];
-
-  return animation.ready.then(function() {
-    assert_equals(animation.playState, 'running');
-
-    div.style.display = 'none';
-    return waitForFrame();
-  }).then(function() {
-    assert_equals(animation.playState, 'idle');
-    assert_equals(getComputedStyle(div).marginLeft, '0px');
-  });
-}, 'Setting display:none on an element cancel its animations');
-
-promise_test(function(t) {
-  var parentDiv = addDiv(t);
-  var childDiv  = document.createElement('div');
-  parentDiv.appendChild(childDiv);
-
-  childDiv.setAttribute('style', 'animation: translateAnim 10s both');
-  flushComputedStyle(childDiv);
-
-  var animation = childDiv.getAnimations()[0];
-
-  return animation.ready.then(function() {
-    assert_equals(animation.playState, 'running');
-
-    parentDiv.style.display = 'none';
-    return waitForFrame();
-  }).then(function() {
-    assert_equals(animation.playState, 'idle');
-    assert_equals(getComputedStyle(childDiv).marginLeft, '0px');
-  });
-}, 'Setting display:none on an ancestor element cancels animations on ' +
-   'descendants');
-
-</script>
-</body>
-</html>
diff --git a/LayoutTests/imported/mozilla/css-animations/test_animation-currenttime-expected.txt b/LayoutTests/imported/mozilla/css-animations/test_animation-currenttime-expected.txt
deleted file mode 100644 (file)
index b2b6d40..0000000
+++ /dev/null
@@ -1,18 +0,0 @@
-
-PASS Sanity test to check round-tripping assigning to new animation's currentTime 
-PASS Skipping forward through animation 
-PASS Skipping backwards through animation 
-PASS Redundant change, before -> active, then back 
-PASS Redundant change, before -> after, then back 
-PASS Redundant change, active -> before, then back 
-PASS Redundant change, active -> after, then back 
-PASS Redundant change, after -> before, then back 
-PASS Redundant change, after -> active, then back 
-PASS Seeking finished -> paused dispatches animationstart 
-PASS Setting currentTime to null 
-PASS Animation.currentTime after pausing 
-PASS Animation.currentTime clamping 
-PASS Animation.currentTime clamping for reversed animation 
-PASS Animation.currentTime after cancelling 
-PASS After aborting a pause when finished, the call to play() should rewind the current time 
-
diff --git a/LayoutTests/imported/mozilla/css-animations/test_animation-currenttime.html b/LayoutTests/imported/mozilla/css-animations/test_animation-currenttime.html
deleted file mode 100644 (file)
index e867fa7..0000000
+++ /dev/null
@@ -1,347 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <meta charset=utf-8>
-    <title>Tests for the effect of setting a CSS animation's
-           Animation.currentTime</title>
-    <style>
-
-.animated-div {
-  margin-left: 10px;
-  /* Make it easier to calculate expected values: */
-  animation-timing-function: linear ! important;
-}
-
-@keyframes anim {
-  from { margin-left: 100px; }
-  to { margin-left: 200px; }
-}
-
-    </style>
-    <script src="../../../resources/testharness.js"></script>
-    <script src="../../../resources/testharnessreport.js"></script>
-    <script src="../resources/testcommon.js"></script>
-  </head>
-  <body>
-    <div id="log"></div>
-    <script type="text/javascript">
-
-'use strict';
-
-// TODO: We should separate this test(Testing for CSS Animation events /
-// Testing for currentTime of Web Animation).
-// e.g:
-//  CSS Animation events test :
-//    - check the firing an event using Animation.currentTime
-//  The current Time of Web Animation test :
-//    - check an current time value on several situation(init / processing..)
-//    - Based on W3C Spec, check the behavior of setting current time.
-
-// TODO: Once the computedTiming property is implemented, add checks to the
-// checker helpers to ensure that computedTiming's properties are updated as
-// expected.
-// See https://bugzilla.mozilla.org/show_bug.cgi?id=1108055
-
-const CSS_ANIM_EVENTS =
-  ['animationstart', 'animationiteration', 'animationend'];
-
-test(function(t)
-{
-  var div = addDiv(t, {'class': 'animated-div'});
-  div.style.animation = "anim 100s";
-  var animation = div.getAnimations()[0];
-
-  // Animations shouldn't start until the next paint tick, so:
-  assert_equals(animation.currentTime, 0,
-    'Animation.currentTime should be zero when an animation ' +
-    'is initially created');
-
-  // Make sure the animation is running before we set the current time.
-  animation.startTime = animation.timeline.currentTime;
-
-  animation.currentTime = 50 * MS_PER_SEC;
-  assert_time_equals_literal(animation.currentTime, 50 * MS_PER_SEC,
-    'Check setting of currentTime actually works');
-}, 'Sanity test to check round-tripping assigning to new animation\'s ' +
-   'currentTime');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  var eventWatcher = new EventWatcher(t, div, CSS_ANIM_EVENTS);
-  div.style.animation = "anim 100s 100s";
-  var animation = div.getAnimations()[0];
-
-  return animation.ready.then(function() {
-    // the 0.0001 here is for rounding error
-    assert_less_than_equal(animation.currentTime,
-      animation.timeline.currentTime - animation.startTime + 0.0001,
-      'Animation.currentTime should be less than the local time ' +
-      'equivalent of the timeline\'s currentTime on the first paint tick ' +
-      'after animation creation');
-
-    animation.currentTime = 100 * MS_PER_SEC;
-    return eventWatcher.wait_for('animationstart');
-  }).then(function() {
-    animation.currentTime = 200 * MS_PER_SEC;
-    return eventWatcher.wait_for('animationend');
-  });
-}, 'Skipping forward through animation');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  var eventWatcher = new EventWatcher(t, div, CSS_ANIM_EVENTS);
-  div.style.animation = "anim 100s 100s";
-  var animation = div.getAnimations()[0];
-  animation.currentTime = 200 * MS_PER_SEC;
-  var previousTimelineTime = animation.timeline.currentTime;
-
-  return eventWatcher.wait_for(['animationstart',
-                                'animationend']).then(function() {
-    assert_true(document.timeline.currentTime - previousTimelineTime <
-                100 * MS_PER_SEC,
-                'Sanity check that seeking worked rather than the events ' +
-                'firing after normal playback through the very long ' +
-                'animation duration');
-
-    animation.currentTime = 150 * MS_PER_SEC;
-    return eventWatcher.wait_for('animationstart');
-  }).then(function() {
-    animation.currentTime = 0;
-    return eventWatcher.wait_for('animationend');
-  });
-}, 'Skipping backwards through animation');
-
-// Next we have multiple tests to check that redundant currentTime changes do
-// NOT dispatch events. It's impossible to distinguish between events not being
-// dispatched and events just taking an incredibly long time to dispatch
-// without waiting an infinitely long time. Obviously we don't want to do that
-// (block this test from finishing forever), so instead we just listen for
-// events until two animation frames (i.e. requestAnimationFrame callbacks)
-// have happened, then assume that no events will ever be dispatched for the
-// redundant changes if no events were detected in that time.
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  var eventWatcher = new EventWatcher(t, div, CSS_ANIM_EVENTS);
-  div.style.animation = "anim 100s 100s";
-  var animation = div.getAnimations()[0];
-
-  animation.currentTime = 150 * MS_PER_SEC;
-  animation.currentTime = 50 * MS_PER_SEC;
-
-  return waitForAnimationFrames(2);
-}, 'Redundant change, before -> active, then back');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  var eventWatcher = new EventWatcher(t, div, CSS_ANIM_EVENTS);
-  div.style.animation = "anim 100s 100s";
-  var animation = div.getAnimations()[0];
-
-  animation.currentTime = 250 * MS_PER_SEC;
-  animation.currentTime = 50 * MS_PER_SEC;
-
-  return waitForAnimationFrames(2);
-}, 'Redundant change, before -> after, then back');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  var eventWatcher = new EventWatcher(t, div, CSS_ANIM_EVENTS);
-  div.style.animation = "anim 100s 100s";
-  var animation = div.getAnimations()[0];
-
-  var retPromise = eventWatcher.wait_for('animationstart').then(function() {
-    animation.currentTime = 50 * MS_PER_SEC;
-    animation.currentTime = 150 * MS_PER_SEC;
-
-    return waitForAnimationFrames(2);
-  });
-  // get us into the initial state:
-  animation.currentTime = 150 * MS_PER_SEC;
-
-  return retPromise;
-}, 'Redundant change, active -> before, then back');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  var eventWatcher = new EventWatcher(t, div, CSS_ANIM_EVENTS);
-  div.style.animation = "anim 100s 100s";
-  var animation = div.getAnimations()[0];
-
-  var retPromise = eventWatcher.wait_for('animationstart').then(function() {
-    animation.currentTime = 250 * MS_PER_SEC;
-    animation.currentTime = 150 * MS_PER_SEC;
-
-    return waitForAnimationFrames(2);
-  });
-  // get us into the initial state:
-  animation.currentTime = 150 * MS_PER_SEC;
-
-  return retPromise;
-}, 'Redundant change, active -> after, then back');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  var eventWatcher = new EventWatcher(t, div, CSS_ANIM_EVENTS);
-  div.style.animation = "anim 100s 100s";
-  var animation = div.getAnimations()[0];
-
-  var retPromise =  eventWatcher.wait_for(['animationstart',
-                                           'animationend']).then(function() {
-    animation.currentTime = 50 * MS_PER_SEC;
-    animation.currentTime = 250 * MS_PER_SEC;
-
-    return waitForAnimationFrames(2);
-  });
-  // get us into the initial state:
-  animation.currentTime = 250 * MS_PER_SEC;
-
-  return retPromise;
-}, 'Redundant change, after -> before, then back');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  var eventWatcher = new EventWatcher(t, div, CSS_ANIM_EVENTS);
-  div.style.animation = "anim 100s 100s";
-  var animation = div.getAnimations()[0];
-
-  var retPromise =  eventWatcher.wait_for(['animationstart',
-                                           'animationend']).then(function() {
-    animation.currentTime = 150 * MS_PER_SEC;
-    animation.currentTime = 250 * MS_PER_SEC;
-
-    return waitForAnimationFrames(2);
-  });
-  // get us into the initial state:
-  animation.currentTime = 250 * MS_PER_SEC;
-
-  return retPromise;
-}, 'Redundant change, after -> active, then back');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  var eventWatcher = new EventWatcher(t, div, CSS_ANIM_EVENTS);
-  div.style.animation = "anim 100s"
-  var animation = div.getAnimations()[0];
-
-  animation.pause();
-  animation.currentTime = 150 * MS_PER_SEC;
-
-  return eventWatcher.wait_for(['animationstart',
-                                'animationend']).then(function() {
-    animation.currentTime = 50 * MS_PER_SEC;
-    return eventWatcher.wait_for('animationstart');
-  });
-}, 'Seeking finished -> paused dispatches animationstart');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  div.style.animation = "anim 100s";
-
-  var animation = div.getAnimations()[0];
-
-  return animation.ready.then(function() {
-    var exception;
-    try {
-      animation.currentTime = null;
-    } catch (e) {
-      exception = e;
-    }
-    assert_equals(exception.name, 'TypeError',
-      'Expect TypeError exception on trying to set ' +
-      'Animation.currentTime to null');
-  });
-}, 'Setting currentTime to null');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  div.style.animation = 'anim 100s';
-
-  var animation = div.getAnimations()[0];
-  var pauseTime;
-
-  return animation.ready.then(function() {
-    assert_not_equals(animation.currentTime, null,
-      'Animation.currentTime not null on ready Promise resolve');
-    animation.pause();
-    return animation.ready;
-  }).then(function() {
-    pauseTime = animation.currentTime;
-    return waitForFrame();
-  }).then(function() {
-    assert_equals(animation.currentTime, pauseTime,
-      'Animation.currentTime is unchanged after pausing');
-  });
-}, 'Animation.currentTime after pausing');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  div.style.animation = "anim 100s";
-  var animation = div.getAnimations()[0];
-
-  return animation.ready.then(function() {
-    // just before animation ends:
-    animation.currentTime = 100 * MS_PER_SEC - 1;
-    return waitForAnimationFrames(2);
-  }).then(function() {
-    assert_equals(animation.currentTime, 100 * MS_PER_SEC,
-      'Animation.currentTime should not continue to increase after the ' +
-      'animation has finished');
-  });
-}, 'Animation.currentTime clamping');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  div.style.animation = "anim 100s";
-  var animation = div.getAnimations()[0];
-
-  return animation.ready.then(function() {
-    // play backwards:
-    animation.playbackRate = -1;
-
-    // just before animation ends (at the "start"):
-    animation.currentTime = 1;
-
-    return waitForAnimationFrames(2);
-  }).then(function() {
-    assert_equals(animation.currentTime, 0,
-      'Animation.currentTime should not continue to decrease after an ' +
-      'animation running in reverse has finished and currentTime is zero');
-  });
-}, 'Animation.currentTime clamping for reversed animation');
-
-test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  div.style.animation = 'anim 100s';
-  var animation = div.getAnimations()[0];
-  animation.cancel();
-
-  assert_equals(animation.currentTime, null,
-                'The currentTime of a cancelled animation should be null');
-}, 'Animation.currentTime after cancelling');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  div.style.animation = 'anim 100s';
-  var animation = div.getAnimations()[0];
-
-  return animation.ready.then(function() {
-    animation.finish();
-
-    // Initiate a pause then abort it
-    animation.pause();
-    animation.play();
-
-    // Wait to return to running state
-    return animation.ready;
-  }).then(function() {
-    assert_true(animation.currentTime < 100 * 1000,
-                'After aborting a pause when finished, the currentTime should'
-                + ' jump back towards the start of the animation');
-  });
-}, 'After aborting a pause when finished, the call to play() should rewind'
-   + ' the current time');
-
-    </script>
-  </body>
-</html>
diff --git a/LayoutTests/imported/mozilla/css-animations/test_animation-finish-expected.txt b/LayoutTests/imported/mozilla/css-animations/test_animation-finish-expected.txt
deleted file mode 100644 (file)
index 5a7cd5f..0000000
+++ /dev/null
@@ -1,6 +0,0 @@
-
-PASS Test exceptions when finishing infinite animation 
-PASS Test finish() while paused 
-PASS Test finish() while pause-pending with positive playbackRate 
-PASS Test finish() while pause-pending with negative playbackRate 
-
diff --git a/LayoutTests/imported/mozilla/css-animations/test_animation-finish.html b/LayoutTests/imported/mozilla/css-animations/test_animation-finish.html
deleted file mode 100644 (file)
index 99ed1f2..0000000
+++ /dev/null
@@ -1,97 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<style>
-@keyframes anim {
-  from { margin-left: 100px; }
-  to { margin-left: 200px; }
-}
-</style>
-<body>
-<div id="log"></div>
-<script>
-
-'use strict';
-
-const ANIM_PROP_VAL = 'anim 100s';
-const ANIM_DURATION = 100000; // ms
-
-test(function(t) {
-  var div = addDiv(t);
-  div.style.animation = ANIM_PROP_VAL;
-  div.style.animationIterationCount = 'infinite';
-  var animation = div.getAnimations()[0];
-
-  var threw = false;
-  try {
-    animation.finish();
-  } catch (e) {
-    threw = true;
-    assert_equals(e.name, 'InvalidStateError',
-                  'Exception should be an InvalidStateError exception when ' +
-                  'trying to finish an infinite animation');
-  }
-  assert_true(threw,
-              'Expect InvalidStateError exception trying to finish an ' +
-              'infinite animation');
-}, 'Test exceptions when finishing infinite animation');
-
-async_test(function(t) {
-  var div = addDiv(t);
-  div.style.animation = ANIM_PROP_VAL + ' paused';
-  var animation = div.getAnimations()[0];
-
-  animation.ready.then(t.step_func(function() {
-    animation.finish();
-    assert_equals(animation.playState, 'finished',
-                  'The play state of a paused animation should become ' +
-                  '"finished" after finish() is called');
-    assert_times_equal(animation.startTime,
-                       animation.timeline.currentTime - ANIM_DURATION,
-                       'The start time of a paused animation should be set ' +
-                       'after calling finish()');
-    t.done();
-  }));
-}, 'Test finish() while paused');
-
-test(function(t) {
-  var div = addDiv(t);
-  div.style.animation = ANIM_PROP_VAL + ' paused';
-  var animation = div.getAnimations()[0];
-
-  // Update playbackRate so we can test that the calculated startTime
-  // respects it
-  animation.playbackRate = 2;
-
-  // While animation is still pause-pending call finish()
-  animation.finish();
-
-  assert_equals(animation.playState, 'finished',
-                'The play state of a pause-pending animation should become ' +
-                '"finished" after finish() is called');
-  assert_times_equal(animation.startTime,
-                     animation.timeline.currentTime - ANIM_DURATION / 2,
-                     'The start time of a pause-pending animation should ' +
-                     'be set after calling finish()');
-}, 'Test finish() while pause-pending with positive playbackRate');
-
-test(function(t) {
-  var div = addDiv(t);
-  div.style.animation = ANIM_PROP_VAL + ' paused';
-  var animation = div.getAnimations()[0];
-
-  animation.playbackRate = -2;
-  animation.finish();
-
-  assert_equals(animation.playState, 'finished',
-                'The play state of a pause-pending animation should become ' +
-                '"finished" after finish() is called');
-  assert_equals(animation.startTime, animation.timeline.currentTime,
-                'The start time of a pause-pending animation should be ' +
-                'set after calling finish()');
-}, 'Test finish() while pause-pending with negative playbackRate');
-
-</script>
-</body>
diff --git a/LayoutTests/imported/mozilla/css-animations/test_animation-finished-expected.txt b/LayoutTests/imported/mozilla/css-animations/test_animation-finished-expected.txt
deleted file mode 100644 (file)
index 5583223..0000000
+++ /dev/null
@@ -1,5 +0,0 @@
-
-PASS finished promise is rejected when an animation is cancelled by resetting the animation property 
-PASS finished promise is rejected when an animation is cancelled by changing the animation property 
-PASS Test finished promise changes when animationPlayState set to running 
-
diff --git a/LayoutTests/imported/mozilla/css-animations/test_animation-finished.html b/LayoutTests/imported/mozilla/css-animations/test_animation-finished.html
deleted file mode 100644 (file)
index 21b2df0..0000000
+++ /dev/null
@@ -1,95 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<style>
-@keyframes abc {
-  to { transform: translate(10px) }
-}
-@keyframes def {}
-</style>
-<body>
-<div id="log"></div>
-<script>
-'use strict';
-
-const ANIM_PROP_VAL = 'abc 100s';
-const ANIM_DURATION = 100 * MS_PER_SEC;
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  // Set up pending animation
-  div.style.animation = ANIM_PROP_VAL;
-  var animation = div.getAnimations()[0];
-  var previousFinishedPromise = animation.finished;
-  // Set up listeners on finished promise
-  var retPromise = animation.finished.then(function() {
-    assert_unreached('finished promise is fulfilled');
-  }).catch(function(err) {
-    assert_equals(err.name, 'AbortError',
-                  'finished promise is rejected with AbortError');
-    assert_not_equals(animation.finished, previousFinishedPromise,
-                      'Finished promise should change after the original is ' +
-                      'rejected');
-  });
-
-  // Now cancel the animation and flush styles
-  div.style.animation = '';
-  getComputedStyle(div).animation;
-
-  return retPromise;
-}, 'finished promise is rejected when an animation is cancelled by resetting ' +
-   'the animation property');
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  // As before, but this time instead of removing all animations, simply update
-  // the list of animations. At least for Firefox, updating is a different
-  // code path.
-
-  // Set up pending animation
-  div.style.animation = ANIM_PROP_VAL;
-  var animation = div.getAnimations()[0];
-  var previousFinishedPromise = animation.finished;
-
-  // Set up listeners on finished promise
-  var retPromise = animation.finished.then(function() {
-    assert_unreached('finished promise was fulfilled');
-  }).catch(function(err) {
-    assert_equals(err.name, 'AbortError',
-                  'finished promise is rejected with AbortError');
-    assert_not_equals(animation.finished, previousFinishedPromise,
-                      'Finished promise should change after the original is ' +
-                      'rejected');
-  });
-
-  // Now update the animation and flush styles
-  div.style.animation = 'def 100s';
-  getComputedStyle(div).animation;
-
-  return retPromise;
-}, 'finished promise is rejected when an animation is cancelled by changing ' +
-   'the animation property');
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  div.style.animation = ANIM_PROP_VAL;
-  var animation = div.getAnimations()[0];
-  var previousFinishedPromise = animation.finished;
-  animation.currentTime = ANIM_DURATION;
-  return animation.finished.then(function() {
-    div.style.animationPlayState = 'running';
-    return waitForAnimationFrames(2);
-  }).then(function() {
-    assert_equals(animation.finished, previousFinishedPromise,
-                  'Should not replay when animation-play-state changes to ' +
-                  '"running" on finished animation');
-    assert_equals(animation.currentTime, ANIM_DURATION,
-                  'currentTime should not change when animation-play-state ' +
-                  'changes to "running" on finished animation');
-  });
-}, 'Test finished promise changes when animationPlayState set to running');
-
-</script>
-</body>
diff --git a/LayoutTests/imported/mozilla/css-animations/test_animation-id.html b/LayoutTests/imported/mozilla/css-animations/test_animation-id.html
deleted file mode 100644 (file)
index e7bb605..0000000
+++ /dev/null
@@ -1,26 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<style>
-@keyframes abc { }
-</style>
-<body>
-<div id="log"></div>
-<script>
-'use strict';
-
-test(function(t) {
-  var div = addDiv(t);
-  div.style.animation = 'abc 100s';
-  var animation = div.getAnimations()[0];
-  assert_equals(animation.id, '', 'id for CSS Animation is initially empty');
-  animation.id = 'anim'
-
-  assert_equals(animation.id, 'anim', 'animation.id reflects the value set');
-}, 'Animation.id for CSS Animations');
-
-</script>
-</body>
-</html>
diff --git a/LayoutTests/imported/mozilla/css-animations/test_animation-pausing.html b/LayoutTests/imported/mozilla/css-animations/test_animation-pausing.html
deleted file mode 100644 (file)
index 00c66df..0000000
+++ /dev/null
@@ -1,168 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<style>
-@keyframes anim {
-  0% { margin-left: 0px }
-  100% { margin-left: 10000px }
-}
-</style>
-<body>
-<div id="log"></div>
-<script>
-'use strict';
-
-function getMarginLeft(cs) {
-  return parseFloat(cs.marginLeft);
-}
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  var cs = getComputedStyle(div);
-  div.style.animation = 'anim 1000s paused';
-  var animation = div.getAnimations()[0];
-  assert_equals(getMarginLeft(cs), 0,
-                'Initial value of margin-left is zero');
-  animation.play();
-
-  return animation.ready.then(waitForNextFrame).then(function() {
-    assert_greater_than(getMarginLeft(cs), 0,
-                        'Playing value of margin-left is greater than zero');
-  });
-}, 'play() overrides animation-play-state');
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  var cs = getComputedStyle(div);
-  div.style.animation = 'anim 1000s paused';
-  var animation = div.getAnimations()[0];
-  assert_equals(getMarginLeft(cs), 0,
-                'Initial value of margin-left is zero');
-
-  animation.pause();
-  div.style.animationPlayState = 'running';
-
-  return animation.ready.then(waitForNextFrame).then(function() {
-    assert_equals(cs.animationPlayState, 'running',
-                  'animation-play-state is running');
-    assert_equals(getMarginLeft(cs), 0,
-                  'Paused value of margin-left is zero');
-  });
-}, 'pause() overrides animation-play-state');
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  var cs = getComputedStyle(div);
-  div.style.animation = 'anim 1000s paused';
-  var animation = div.getAnimations()[0];
-  assert_equals(getMarginLeft(cs), 0,
-                'Initial value of margin-left is zero');
-  animation.play();
-  var previousAnimVal;
-
-  return animation.ready.then(function() {
-    div.style.animationPlayState = 'running';
-    cs.animationPlayState; // Trigger style resolution
-    return waitForNextFrame();
-  }).then(function() {
-    assert_equals(cs.animationPlayState, 'running',
-                  'animation-play-state is running');
-    div.style.animationPlayState = 'paused';
-    return animation.ready;
-  }).then(function() {
-    assert_equals(cs.animationPlayState, 'paused',
-                  'animation-play-state is paused');
-    previousAnimVal = getMarginLeft(cs);
-    return waitForNextFrame();
-  }).then(function() {
-    assert_equals(getMarginLeft(cs), previousAnimVal,
-                  'Animated value of margin-left does not change when'
-                  + ' paused by style');
-  });
-}, 'play() is overridden by later setting "animation-play-state: paused"');
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  var cs = getComputedStyle(div);
-  div.style.animation = 'anim 1000s';
-  var animation = div.getAnimations()[0];
-  assert_equals(getMarginLeft(cs), 0,
-                'Initial value of margin-left is zero');
-
-  // Set the specified style first. If implementations fail to
-  // apply the style changes first, they will ignore the redundant
-  // call to play() and fail to correctly override the pause style.
-  div.style.animationPlayState = 'paused';
-  animation.play();
-  var previousAnimVal = getMarginLeft(cs);
-
-  return animation.ready.then(waitForNextFrame).then(function() {
-    assert_equals(cs.animationPlayState, 'paused',
-                  'animation-play-state is paused');
-    assert_greater_than(getMarginLeft(cs), previousAnimVal,
-                        'Playing value of margin-left is increasing');
-  });
-}, 'play() flushes pending changes to animation-play-state first');
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  var cs = getComputedStyle(div);
-  div.style.animation = 'anim 1000s paused';
-  var animation = div.getAnimations()[0];
-  assert_equals(getMarginLeft(cs), 0,
-                'Initial value of margin-left is zero');
-
-  // Unlike the previous test for play(), since calling pause() is sticky,
-  // we'll apply it even if the underlying style also says we're paused.
-  //
-  // We would like to test that implementations flush styles before running
-  // pause() but actually there's no style we can currently set that will
-  // change the behavior of pause(). That may change in the future
-  // (e.g. if we introduce animation-timeline or animation-playback-rate etc.).
-  //
-  // For now this just serves as a sanity check that we do the same thing
-  // even if we set style before calling the API.
-  div.style.animationPlayState = 'running';
-  animation.pause();
-  var previousAnimVal = getMarginLeft(cs);
-
-  return animation.ready.then(waitForNextFrame).then(function() {
-    assert_equals(cs.animationPlayState, 'running',
-                  'animation-play-state is running');
-    assert_equals(getMarginLeft(cs), previousAnimVal,
-                  'Paused value of margin-left does not change');
-  });
-}, 'pause() applies pending changes to animation-play-state first');
-// (Note that we can't actually test for this; see comment above, in test-body.)
-
-promise_test(function(t) {
-  var div = addDiv(t, { style: 'animation: anim 1000s' });
-  var animation = div.getAnimations()[0];
-  var readyPromiseRun = false;
-
-  return animation.ready.then(function() {
-    div.style.animationPlayState = 'paused';
-    assert_true(animation.pending && animation.playState === 'paused',
-                'Animation is pause-pending');
-
-    // Set current time
-    animation.currentTime = 5 * MS_PER_SEC;
-    assert_equals(animation.playState, 'paused',
-                  'Animation is paused immediately after setting currentTime');
-    assert_equals(animation.startTime, null,
-                  'Animation startTime is unresolved immediately after ' +
-                  'setting currentTime');
-    assert_equals(animation.currentTime, 5 * MS_PER_SEC,
-                  'Animation currentTime does not change when forcing a ' +
-                  'pause operation to complete');
-
-    // The ready promise should now be resolved. If it's not then test will
-    // probably time out before anything else happens that causes it to resolve.
-    return animation.ready;
-  });
-}, 'Setting the current time completes a pending pause');
-
-</script>
-</body>
diff --git a/LayoutTests/imported/mozilla/css-animations/test_animation-playstate.html b/LayoutTests/imported/mozilla/css-animations/test_animation-playstate.html
deleted file mode 100644 (file)
index 562f766..0000000
+++ /dev/null
@@ -1,61 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<style>
-@keyframes anim { }
-</style>
-<body>
-<div id="log"></div>
-<script>
-'use strict';
-
-test(function(t) {
-  var div = addDiv(t);
-  var cs = getComputedStyle(div);
-  div.style.animation = 'anim 1000s';
-  var animation = div.getAnimations()[0];
-  assert_equals(animation.playState, 'running');
-}, 'Animation returns correct playState when running');
-
-test(function(t) {
-  var div = addDiv(t);
-  var cs = getComputedStyle(div);
-  div.style.animation = 'anim 1000s paused';
-  var animation = div.getAnimations()[0];
-  assert_equals(animation.playState, 'paused');
-}, 'Animation returns correct playState when paused');
-
-test(function(t) {
-  var div = addDiv(t);
-  var cs = getComputedStyle(div);
-  div.style.animation = 'anim 1000s';
-  var animation = div.getAnimations()[0];
-  animation.pause();
-  assert_equals(animation.playState, 'paused');
-}, 'Animation.playState updates when paused by script');
-
-test(function(t) {
-  var div = addDiv(t);
-  var cs = getComputedStyle(div);
-  div.style.animation = 'anim 1000s paused';
-  var animation = div.getAnimations()[0];
-  div.style.animationPlayState = 'running';
-
-  // This test also checks that calling playState flushes style
-  assert_equals(animation.playState, 'running',
-                'Animation.playState reports running after updating'
-                + ' animation-play-state (got: ' + animation.playState + ')');
-}, 'Animation.playState updates when resumed by setting style');
-
-test(function(t) {
-  var div = addDiv(t);
-  div.style.animation = 'anim 1000s';
-  var animation = div.getAnimations()[0];
-  animation.cancel();
-  assert_equals(animation.playState, 'idle');
-}, 'Animation returns correct playState when cancelled');
-
-</script>
-</body>
diff --git a/LayoutTests/imported/mozilla/css-animations/test_animation-ready.html b/LayoutTests/imported/mozilla/css-animations/test_animation-ready.html
deleted file mode 100644 (file)
index cec2bdb..0000000
+++ /dev/null
@@ -1,149 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<style>
-@keyframes abc {
-  to { transform: translate(10px) }
-}
-</style>
-<body>
-<div id="log"></div>
-<script>
-'use strict';
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  div.style.animation = 'abc 100s paused';
-  var animation = div.getAnimations()[0];
-  var originalReadyPromise = animation.ready;
-
-  return animation.ready.then(function() {
-    div.style.animationPlayState = 'running';
-    assert_not_equals(animation.ready, originalReadyPromise,
-                      'After updating animation-play-state a new ready promise'
-                      + ' object is created');
-  });
-}, 'A new ready promise is created when setting animation-play-state: running');
-
-promise_test(function(t) {
-  var div = addDiv(t);
-
-  // Set up pending animation
-  div.style.animation = 'abc 100s';
-  var animation = div.getAnimations()[0];
-  assert_true(animation.pending, 'Animation is initially pending');
-
-  // Set up listeners on ready promise
-  var retPromise = animation.ready.then(function() {
-    assert_unreached('ready promise is fulfilled');
-  }).catch(function(err) {
-    assert_equals(err.name, 'AbortError',
-                  'ready promise is rejected with AbortError');
-  });
-
-  // Now cancel the animation and flush styles
-  div.style.animation = '';
-  getComputedStyle(div).animation;
-
-  return retPromise;
-}, 'ready promise is rejected when an animation is canceled by resetting'
-   + ' the animation property');
-
-promise_test(function(t) {
-  var div = addDiv(t);
-
-  // As before, but this time instead of removing all animations, simply update
-  // the list of animations. At least for Firefox, updating is a different
-  // code path.
-
-  // Set up pending animation
-  div.style.animation = 'abc 100s';
-  var animation = div.getAnimations()[0];
-  assert_true(animation.pending, 'Animation is initially pending');
-
-  // Set up listeners on ready promise
-  var retPromise = animation.ready.then(function() {
-    assert_unreached('ready promise was fulfilled');
-  }).catch(function(err) {
-    assert_equals(err.name, 'AbortError',
-                  'ready promise is rejected with AbortError');
-  });
-
-  // Now update the animation and flush styles
-  div.style.animation = 'def 100s';
-  getComputedStyle(div).animation;
-
-  return retPromise;
-}, 'ready promise is rejected when an animation is cancelled by updating'
-   + ' the animation property');
-
-promise_test(function(t) {
-  var div = addDiv(t, { style: 'animation: abc 100s' });
-  var animation = div.getAnimations()[0];
-  var originalReadyPromise = animation.ready;
-
-  return animation.ready.then(function() {
-    div.style.animationPlayState = 'paused';
-    assert_not_equals(animation.ready, originalReadyPromise,
-                      'A new Promise object is generated when setting'
-                      + ' animation-play-state: paused');
-  });
-}, 'A new ready promise is created when setting animation-play-state: paused');
-
-promise_test(function(t) {
-  var div = addDiv(t, { style: 'animation: abc 100s' });
-  var animation = div.getAnimations()[0];
-
-  return animation.ready.then(function() {
-    div.style.animationPlayState = 'paused';
-    var firstReadyPromise = animation.ready;
-    animation.pause();
-    assert_equals(animation.ready, firstReadyPromise,
-                  'Ready promise objects are identical after redundant pause');
-  });
-}, 'Pausing twice re-uses the same Promise');
-
-promise_test(function(t) {
-  var div = addDiv(t, { style: 'animation: abc 100s' });
-  var animation = div.getAnimations()[0];
-
-  return animation.ready.then(function() {
-    div.style.animationPlayState = 'paused';
-
-    // Flush style and verify we're pending at the same time
-    assert_true(animation.pending, 'Animation is pending');
-    var pauseReadyPromise = animation.ready;
-
-    // Now play again immediately
-    div.style.animationPlayState = 'running';
-    assert_true(animation.pending, 'Animation is still pending');
-    assert_equals(animation.ready, pauseReadyPromise,
-                  'The pause Promise is re-used when playing while waiting'
-                  + ' to pause');
-
-    return animation.ready;
-  }).then(function() {
-    assert_true(!animation.pending && animation.playState === 'running',
-                'Animation is running after aborting a pause');
-  });
-}, 'If a pause operation is interrupted, the ready promise is reused');
-
-promise_test(function(t) {
-  var div = addDiv(t, { style: 'animation: abc 100s' });
-  var animation = div.getAnimations()[0];
-
-  return animation.ready.then(function() {
-    div.style.animationPlayState = 'paused';
-    return animation.ready;
-  }).then(function(resolvedAnimation) {
-    assert_equals(resolvedAnimation, animation,
-                  'Promise received when ready Promise for a pause operation'
-                  + ' is completed is the animation on which the pause was'
-                  + ' performed');
-  });
-}, 'When a pause is complete the Promise callback gets the correct animation');
-
-</script>
-</body>
diff --git a/LayoutTests/imported/mozilla/css-animations/test_animation-reverse-expected.txt b/LayoutTests/imported/mozilla/css-animations/test_animation-reverse-expected.txt
deleted file mode 100644 (file)
index 7656fc4..0000000
+++ /dev/null
@@ -1,3 +0,0 @@
-
-PASS reverse() from idle state starts playing the animation 
-
diff --git a/LayoutTests/imported/mozilla/css-animations/test_animation-reverse.html b/LayoutTests/imported/mozilla/css-animations/test_animation-reverse.html
deleted file mode 100644 (file)
index 2f4a841..0000000
+++ /dev/null
@@ -1,30 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<style>
-@keyframes anim {
-  to { transform: translate(100px) }
-}
-</style>
-<body>
-<div id="log"></div>
-<script>
-'use strict';
-
-test(function(t) {
-  var div = addDiv(t, { style: 'animation: anim 100s' });
-  var animation = div.getAnimations()[0];
-  div.style.animation = "";
-  flushComputedStyle(div);
-
-  assert_equals(animation.currentTime, null);
-  animation.reverse();
-
-  assert_equals(animation.currentTime, 100 * MS_PER_SEC,
-    'animation.currentTime should be its effect end');
-}, 'reverse() from idle state starts playing the animation');
-
-</script>
-</body>
diff --git a/LayoutTests/imported/mozilla/css-animations/test_animation-starttime-expected.txt b/LayoutTests/imported/mozilla/css-animations/test_animation-starttime-expected.txt
deleted file mode 100644 (file)
index b98c9d1..0000000
+++ /dev/null
@@ -1,22 +0,0 @@
-
-PASS startTime of a newly created (play-pending) animation is unresolved 
-PASS startTime of a newly created (pause-pending) animation is unresolved 
-PASS startTime is resolved when running 
-PASS startTime is unresolved when paused 
-PASS startTime while pause-pending and play-pending 
-PASS startTime while play-pending from finished state 
-PASS startTime while play-pending from finished state using finish() 
-PASS Pausing should make the startTime become null 
-PASS Sanity test to check round-tripping assigning to a new animation's startTime 
-PASS Skipping forward through animation 
-PASS Skipping backwards through animation 
-PASS Redundant change, before -> active, then back 
-PASS Redundant change, before -> after, then back 
-PASS Redundant change, active -> before, then back 
-PASS Redundant change, active -> after, then back 
-PASS Redundant change, after -> before, then back 
-PASS Redundant change, after -> active, then back 
-PASS Setting startTime to null 
-PASS Animation.startTime after pausing 
-PASS Animation.startTime after cancelling 
-
diff --git a/LayoutTests/imported/mozilla/css-animations/test_animation-starttime.html b/LayoutTests/imported/mozilla/css-animations/test_animation-starttime.html
deleted file mode 100644 (file)
index 6ceb8ab..0000000
+++ /dev/null
@@ -1,385 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <meta charset=utf-8>
-    <title>Tests for the effect of setting a CSS animation's
-           Animation.startTime</title>
-    <style>
-
-.animated-div {
-  margin-left: 10px;
-  /* Make it easier to calculate expected values: */
-  animation-timing-function: linear ! important;
-}
-
-@keyframes anim {
-  from { margin-left: 100px; }
-  to { margin-left: 200px; }
-}
-
-    </style>
-    <script src="../../../resources/testharness.js"></script>
-    <script src="../../../resources/testharnessreport.js"></script>
-    <script src="../resources/testcommon.js"></script>
-  </head>
-  <body>
-    <div id="log"></div>
-    <script type="text/javascript">
-
-'use strict';
-
-// TODO: We should separate this test(Testing for CSS Animation events /
-// Testing for start time of Web Animation).
-// e.g:
-//  CSS Animation events test:
-//    - check the firing an event after setting an Animation.startTime
-//  The start time of Web Animation test:
-//    - check an start time value on several situation(init / processing..)
-//    - Based on W3C Spec, check the behavior of setting current time.
-
-// TODO: Once the computedTiming property is implemented, add checks to the
-// checker helpers to ensure that computedTiming's properties are updated as
-// expected.
-// See https://bugzilla.mozilla.org/show_bug.cgi?id=1108055
-
-const CSS_ANIM_EVENTS =
-  ['animationstart', 'animationiteration', 'animationend'];
-
-test(function(t)
-{
-  var div = addDiv(t, { 'style': 'animation: anim 100s' });
-  var animation = div.getAnimations()[0];
-
-  assert_equals(animation.startTime, null, 'startTime is unresolved');
-}, 'startTime of a newly created (play-pending) animation is unresolved');
-
-test(function(t)
-{
-  var div = addDiv(t, { 'style': 'animation: anim 100s paused' });
-  var animation = div.getAnimations()[0];
-  assert_equals(animation.startTime, null, 'startTime is unresolved');
-}, 'startTime of a newly created (pause-pending) animation is unresolved');
-
-promise_test(function(t)
-{
-  var div = addDiv(t, { 'style': 'animation: anim 100s' });
-  var animation = div.getAnimations()[0];
-
-  return animation.ready.then(function() {
-    assert_true(animation.startTime > 0,
-                'startTime is resolved when running');
-  });
-}, 'startTime is resolved when running');
-
-promise_test(function(t)
-{
-  var div = addDiv(t, { 'style': 'animation: anim 100s paused' });
-  var animation = div.getAnimations()[0];
-
-  return animation.ready.then(function() {
-    assert_equals(animation.startTime, null,
-                  'startTime is unresolved when paused');
-  });
-}, 'startTime is unresolved when paused');
-
-promise_test(function(t)
-{
-  var div = addDiv(t, { 'style': 'animation: anim 100s' });
-  var animation = div.getAnimations()[0];
-
-  return animation.ready.then(function() {
-    div.style.animationPlayState = 'paused';
-    getComputedStyle(div).animationPlayState;
-
-    assert_not_equals(animation.startTime, null,
-                      'startTime is resolved when pause-pending');
-
-    div.style.animationPlayState = 'running';
-    getComputedStyle(div).animationPlayState;
-
-    assert_not_equals(animation.startTime, null,
-                      'startTime is preserved when a pause is aborted');
-  });
-}, 'startTime while pause-pending and play-pending');
-
-promise_test(function(t) {
-  var div = addDiv(t, { 'style': 'animation: anim 100s' });
-  var animation = div.getAnimations()[0];
-  // Seek to end to put us in the finished state
-  animation.currentTime = 100 * MS_PER_SEC;
-
-  return animation.ready.then(function() {
-    // Call play() which puts us back in the running state
-    animation.play();
-
-    assert_equals(animation.startTime, null, 'startTime is unresolved');
-  });
-}, 'startTime while play-pending from finished state');
-
-test(function(t) {
-  var div = addDiv(t, { 'style': 'animation: anim 100s' });
-  var animation = div.getAnimations()[0];
-  animation.finish();
-  // Call play() which puts us back in the running state
-  animation.play();
-
-  assert_equals(animation.startTime, null, 'startTime is unresolved');
-}, 'startTime while play-pending from finished state using finish()');
-
-promise_test(function(t) {
-  var div = addDiv(t, { style: 'animation: anim 100s' });
-  var animation = div.getAnimations()[0];
-
-  assert_equals(animation.startTime, null, 'The initial startTime is null');
-  var initialTimelineTime = document.timeline.currentTime;
-
-  return animation.ready.then(function() {
-    assert_true(animation.startTime > initialTimelineTime,
-                'After the animation has started, startTime is greater than ' +
-                'the time when it was started');
-    var startTimeBeforePausing = animation.startTime;
-
-    div.style.animationPlayState = 'paused';
-    // Flush styles just in case querying animation.startTime doesn't flush
-    // styles (which would be a bug in of itself and could mask a further bug
-    // by causing startTime to appear to not change).
-    getComputedStyle(div).animationPlayState;
-
-    assert_equals(animation.startTime, startTimeBeforePausing,
-                  'The startTime does not change when pausing-pending');
-    return animation.ready;
-  }).then(function() {
-    assert_equals(animation.startTime, null,
-                  'After actually pausing, the startTime of an animation ' +
-                  'is null');
-  });
-}, 'Pausing should make the startTime become null');
-
-test(function(t)
-{
-  var div = addDiv(t, {'class': 'animated-div'});
-  div.style.animation = 'anim 100s 100s';
-  var animation = div.getAnimations()[0];
-  var currentTime = animation.timeline.currentTime;
-  animation.startTime = currentTime;
-
-  assert_times_equal(animation.startTime, currentTime,
-    'Check setting of startTime actually works');
-}, 'Sanity test to check round-tripping assigning to a new animation\'s ' +
-   'startTime');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  var eventWatcher = new EventWatcher(t, div, CSS_ANIM_EVENTS);
-  div.style.animation = 'anim 100s 100s';
-  var animation = div.getAnimations()[0];
-
-  return animation.ready.then(function() {
-    assert_less_than_equal(animation.startTime, animation.timeline.currentTime,
-      'Animation.startTime should be less than the timeline\'s ' +
-      'currentTime on the first paint tick after animation creation');
-
-    animation.startTime = animation.timeline.currentTime - 100 * MS_PER_SEC;
-    return eventWatcher.wait_for('animationstart');
-  }).then(function() {
-    animation.startTime = animation.timeline.currentTime - 200 * MS_PER_SEC;
-    return eventWatcher.wait_for('animationend');
-  });
-}, 'Skipping forward through animation');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  var eventWatcher = new EventWatcher(t, div, CSS_ANIM_EVENTS);
-  div.style.animation = 'anim 100s 100s';
-  var animation = div.getAnimations()[0];
-  animation.startTime = animation.timeline.currentTime - 200 * MS_PER_SEC;
-  var previousTimelineTime = animation.timeline.currentTime;
-
-  return eventWatcher.wait_for(['animationstart',
-                                'animationend']).then(function() {
-    assert_true(document.timeline.currentTime - previousTimelineTime <
-                  100 * MS_PER_SEC,
-                'Sanity check that seeking worked rather than the events ' +
-                'firing after normal playback through the very long ' +
-                'animation duration');
-
-    animation.startTime = animation.timeline.currentTime - 150 * MS_PER_SEC;
-
-    // Despite going backwards from after the end of the animation (to being
-    // in the active interval), we now expect an 'animationstart' event
-    // because the animation should go from being inactive to active.
-    return eventWatcher.wait_for('animationstart');
-  }).then(function() {
-    animation.startTime = animation.timeline.currentTime;
-
-    // Despite going backwards from just after the active interval starts to
-    // the animation start time, we now expect an animationend event
-    // because we went from inside to outside the active interval.
-    return eventWatcher.wait_for('animationend');
-  }).then(function() {
-    assert_less_than_equal(animation.startTime, animation.timeline.currentTime,
-      'Animation.startTime should be less than the timeline\'s ' +
-      'currentTime on the first paint tick after animation creation');
-  });
-}, 'Skipping backwards through animation');
-
-// Next we have multiple tests to check that redundant startTime changes do NOT
-// dispatch events. It's impossible to distinguish between events not being
-// dispatched and events just taking an incredibly long time to dispatch
-// without waiting an infinitely long time. Obviously we don't want to do that
-// (block this test from finishing forever), so instead we just listen for
-// events until two animation frames (i.e. requestAnimationFrame callbacks)
-// have happened, then assume that no events will ever be dispatched for the
-// redundant changes if no events were detected in that time.
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  var eventWatcher = new EventWatcher(t, div, CSS_ANIM_EVENTS);
-  div.style.animation = "anim 100s 100s";
-  var animation = div.getAnimations()[0];
-
-  animation.startTime = animation.timeline.currentTime - 150 * MS_PER_SEC;
-  animation.startTime = animation.timeline.currentTime - 50 * MS_PER_SEC;
-
-  return waitForAnimationFrames(2);
-}, 'Redundant change, before -> active, then back');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  var eventWatcher = new EventWatcher(t, div, CSS_ANIM_EVENTS);
-  div.style.animation = "anim 100s 100s";
-  var animation = div.getAnimations()[0];
-
-  animation.startTime = animation.timeline.currentTime - 250 * MS_PER_SEC;
-  animation.startTime = animation.timeline.currentTime - 50 * MS_PER_SEC;
-
-  return waitForAnimationFrames(2);
-}, 'Redundant change, before -> after, then back');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  var eventWatcher = new EventWatcher(t, div, CSS_ANIM_EVENTS);
-  div.style.animation = "anim 100s 100s";
-  var animation = div.getAnimations()[0];
-
-  var retPromise =  eventWatcher.wait_for('animationstart').then(function() {
-    animation.startTime = animation.timeline.currentTime - 50 * MS_PER_SEC;
-    animation.startTime = animation.timeline.currentTime - 150 * MS_PER_SEC;
-
-    return waitForAnimationFrames(2);
-  });
-  // get us into the initial state:
-  animation.startTime = animation.timeline.currentTime - 150 * MS_PER_SEC;
-
-  return retPromise;
-}, 'Redundant change, active -> before, then back');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  var eventWatcher = new EventWatcher(t, div, CSS_ANIM_EVENTS);
-  div.style.animation = "anim 100s 100s";
-  var animation = div.getAnimations()[0];
-
-  var retPromise = eventWatcher.wait_for('animationstart').then(function() {
-    animation.startTime = animation.timeline.currentTime - 250 * MS_PER_SEC;
-    animation.startTime = animation.timeline.currentTime - 150 * MS_PER_SEC;
-
-    return waitForAnimationFrames(2);
-  });
-  // get us into the initial state:
-  animation.startTime = animation.timeline.currentTime - 150 * MS_PER_SEC;
-
-  return retPromise;
-}, 'Redundant change, active -> after, then back');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  var eventWatcher = new EventWatcher(t, div, CSS_ANIM_EVENTS);
-  div.style.animation = "anim 100s 100s";
-  var animation = div.getAnimations()[0];
-
-  var retPromise = eventWatcher.wait_for(['animationstart',
-                                          'animationend']).then(function() {
-    animation.startTime = animation.timeline.currentTime - 50 * MS_PER_SEC;
-    animation.startTime = animation.timeline.currentTime - 250 * MS_PER_SEC;
-
-    return waitForAnimationFrames(2);
-  });
-  // get us into the initial state:
-  animation.startTime = animation.timeline.currentTime - 250 * MS_PER_SEC;
-
-  return retPromise;
-}, 'Redundant change, after -> before, then back');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  var eventWatcher = new EventWatcher(t, div, CSS_ANIM_EVENTS);
-  div.style.animation = "anim 100s 100s";
-  var animation = div.getAnimations()[0];
-
-  var retPromise = eventWatcher.wait_for(['animationstart',
-                                          'animationend']).then(function() {
-    animation.startTime = animation.timeline.currentTime - 150 * MS_PER_SEC;
-    animation.startTime = animation.timeline.currentTime - 250 * MS_PER_SEC;
-
-    return waitForAnimationFrames(2);
-
-  });
-  // get us into the initial state:
-  animation.startTime = animation.timeline.currentTime - 250 * MS_PER_SEC;
-
-  return retPromise;
-}, 'Redundant change, after -> active, then back');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  div.style.animation = 'anim 100s 100s';
-  var animation = div.getAnimations()[0];
-  var storedCurrentTime;
-
-  return animation.ready.then(function() {
-    storedCurrentTime = animation.currentTime;
-    animation.startTime = null;
-    return animation.ready;
-  }).then(function() {
-    assert_equals(animation.currentTime, storedCurrentTime,
-      'Test that hold time is correct');
-  });
-}, 'Setting startTime to null');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  div.style.animation = 'anim 100s';
-  var animation = div.getAnimations()[0];
-
-  return animation.ready.then(function() {
-    var savedStartTime = animation.startTime;
-
-    assert_not_equals(animation.startTime, null,
-      'Animation.startTime not null on ready Promise resolve');
-
-    animation.pause();
-    return animation.ready;
-  }).then(function() {
-    assert_equals(animation.startTime, null,
-      'Animation.startTime is null after paused');
-    assert_equals(animation.playState, 'paused',
-      'Animation.playState is "paused" after pause() call');
-  });
-}, 'Animation.startTime after pausing');
-
-promise_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  div.style.animation = 'anim 100s';
-  var animation = div.getAnimations()[0];
-
-  return animation.ready.then(function() {
-    animation.cancel();
-    assert_equals(animation.startTime, null,
-                  'The startTime of a cancelled animation should be null');
-  });
-}, 'Animation.startTime after cancelling');
-
-    </script>
-  </body>
-</html>
diff --git a/LayoutTests/imported/mozilla/css-animations/test_animations-dynamic-changes.html b/LayoutTests/imported/mozilla/css-animations/test_animations-dynamic-changes.html
deleted file mode 100644 (file)
index d213b09..0000000
+++ /dev/null
@@ -1,158 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<style>
-@keyframes anim1 {
-  to { left: 100px }
-}
-@keyframes anim2 { }
-</style>
-<body>
-<div id="log"></div>
-<script>
-'use strict';
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  div.style.animation = 'anim1 100s';
-  var originalAnimation = div.getAnimations()[0];
-  var originalStartTime;
-  var originalCurrentTime;
-
-  // Wait a moment so we can confirm the startTime doesn't change (and doesn't
-  // simply reflect the current time).
-  return originalAnimation.ready.then(function() {
-    originalStartTime = originalAnimation.startTime;
-    originalCurrentTime = originalAnimation.currentTime;
-
-    // Wait a moment so we can confirm the startTime doesn't change (and
-    // doesn't simply reflect the current time).
-    return waitForNextFrame();
-  }).then(function() {
-    div.style.animationDuration = '200s';
-    var animation = div.getAnimations()[0];
-    assert_equals(animation, originalAnimation,
-                  'The same Animation is returned after updating'
-                  + ' animation duration');
-    assert_equals(animation.startTime, originalStartTime,
-                  'Animations returned by getAnimations preserve'
-                  + ' their startTime even when they are updated');
-    // Sanity check
-    assert_not_equals(animation.currentTime, originalCurrentTime,
-                      'Animation.currentTime has updated in next'
-                      + ' requestAnimationFrame callback');
-  });
-}, 'Animations preserve their startTime when changed');
-
-test(function(t) {
-  var div = addDiv(t);
-  div.style.animation = 'anim1 100s, anim1 100s';
-
-  // Store original state
-  var animations = div.getAnimations();
-  var animation1 = animations[0];
-  var animation2 = animations[1];
-
-  // Update first in list
-  div.style.animationDuration = '200s, 100s';
-  animations = div.getAnimations();
-  assert_equals(animations[0], animation1,
-                'First Animation is in same position after update');
-  assert_equals(animations[1], animation2,
-                'Second Animation is in same position after update');
-}, 'Updated Animations maintain their order in the list');
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  div.style.animation = 'anim1 200s, anim1 100s';
-
-  // Store original state
-  var animations = div.getAnimations();
-  var animation1 = animations[0];
-  var animation2 = animations[1];
-
-  // Wait before continuing so we can compare start times (otherwise the
-  // new Animation objects and existing Animation objects will all have the same
-  // start time).
-  return waitForAllAnimations(animations).then(waitForFrame).then(function() {
-    // Swap duration of first and second in list and prepend animation at the
-    // same time
-    div.style.animation = 'anim1 100s, anim1 100s, anim1 200s';
-    animations = div.getAnimations();
-    assert_true(animations[0] !== animation1 && animations[0] !== animation2,
-                'New Animation is prepended to start of list');
-    assert_equals(animations[1], animation1,
-                  'First Animation is in second position after update');
-    assert_equals(animations[2], animation2,
-                  'Second Animation is in third position after update');
-    assert_equals(animations[1].startTime, animations[2].startTime,
-                  'Old Animations have the same start time');
-    // TODO: Check that animations[0].startTime === null
-    return animations[0].ready;
-  }).then(function() {
-    assert_greater_than(animations[0].startTime, animations[1].startTime,
-                        'New Animation has later start time');
-  });
-}, 'Only the startTimes of existing animations are preserved');
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  div.style.animation = 'anim1 100s, anim1 100s';
-  var secondAnimation = div.getAnimations()[1];
-
-  // Wait before continuing so we can compare start times
-  return secondAnimation.ready.then(waitForNextFrame).then(function() {
-    // Trim list of animations
-    div.style.animationName = 'anim1';
-    var animations = div.getAnimations();
-    assert_equals(animations.length, 1, 'List of Animations was trimmed');
-    assert_equals(animations[0], secondAnimation,
-                  'Remaining Animation is the second one in the list');
-    assert_equals(typeof(animations[0].startTime), 'number',
-                  'Remaining Animation has resolved startTime');
-    assert_less_than(animations[0].startTime,
-                     animations[0].timeline.currentTime,
-                     'Remaining Animation preserves startTime');
-  });
-}, 'Animations are removed from the start of the list while preserving'
-   + ' the state of existing Animations');
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  div.style.animation = 'anim1 100s';
-  var firstAddedAnimation = div.getAnimations()[0],
-      secondAddedAnimation,
-      animations;
-
-  // Wait and add second Animation
-  return firstAddedAnimation.ready.then(waitForFrame).then(function() {
-    div.style.animation = 'anim1 100s, anim1 100s';
-    secondAddedAnimation = div.getAnimations()[0];
-
-    // Wait again and add another Animation
-    return secondAddedAnimation.ready.then(waitForFrame);
-  }).then(function() {
-    div.style.animation = 'anim1 100s, anim2 100s, anim1 100s';
-    animations = div.getAnimations();
-    assert_not_equals(firstAddedAnimation, secondAddedAnimation,
-                      'New Animations are added to start of the list');
-    assert_equals(animations[0], secondAddedAnimation,
-                  'Second Animation remains in same position after'
-                  + ' interleaving');
-    assert_equals(animations[2], firstAddedAnimation,
-                  'First Animation remains in same position after'
-                  + ' interleaving');
-    return animations[1].ready;
-  }).then(function() {
-    assert_greater_than(animations[1].startTime, animations[0].startTime,
-                        'Interleaved animation starts later than existing ' +
-                        'animations');
-    assert_greater_than(animations[0].startTime, animations[2].startTime,
-                        'Original animations retain their start time');
-  });
-}, 'Animation state is preserved when interleaving animations in list');
-
-</script>
-</body>
diff --git a/LayoutTests/imported/mozilla/css-animations/test_event-dispatch.html b/LayoutTests/imported/mozilla/css-animations/test_event-dispatch.html
deleted file mode 100644 (file)
index 9073755..0000000
+++ /dev/null
@@ -1,381 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<title>Tests for CSS animation event dispatch</title>
-<link rel="help" href="https://drafts.csswg.org/css-animations-2/#event-dispatch"/>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<style>
-  @keyframes anim {
-    from { margin-left: 0px; }
-    to { margin-left: 100px; }
-  }
-</style>
-<body>
-<div id="log"></div>
-<script>
-'use strict';
-
-/**
- * Helper class to record the elapsedTime member of each event.
- * The EventWatcher class in testharness.js allows us to wait on
- * multiple events in a certain order but only records the event
- * parameters of the most recent event.
- */
-function AnimationEventHandler(target) {
-  this.target = target;
-  this.target.onanimationstart = evt => {
-   this.animationstart = evt.elapsedTime;
-  };
-  this.target.onanimationiteration = evt => {
-    this.animationiteration = evt.elapsedTime;
-  };
-  this.target.onanimationend = evt => {
-    this.animationend = evt.elapsedTime;
-  };
-  this.target.onanimationcancel = evt => {
-    this.animationcancel = evt.elapsedTime;
-  };
-}
-AnimationEventHandler.prototype.clear = () => {
-  this.animationstart     = undefined;
-  this.animationiteration = undefined;
-  this.animationend       = undefined;
-  this.animationcancel    = undefined;
-}
-
-function setupAnimation(t, animationStyle) {
-  const div = addDiv(t, { style: 'animation: ' + animationStyle });
-  // Note that this AnimationEventHandler should be created before EventWatcher
-  // to capture all events in the handler prior to the EventWatcher since
-  // testharness.js proceeds when the EventWatcher received watching events.
-  const handler = new AnimationEventHandler(div);
-  const watcher = new EventWatcher(t, div, [ 'animationstart',
-                                           'animationiteration',
-                                           'animationend',
-                                           'animationcancel' ]);
-  const animation = div.getAnimations()[0];
-
-  return { animation, watcher, div, handler };
-}
-
-promise_test(t => {
-  // Add 1ms delay to ensure that the delay is not included in the elapsedTime.
-  const { animation, watcher } = setupAnimation(t, 'anim 100s 1ms');
-
-  return watcher.wait_for('animationstart').then(evt => {
-    assert_equals(evt.elapsedTime, 0.0);
-  });
-}, 'Idle -> Active');
-
-promise_test(t => {
-  const { animation, watcher, div, handler } = setupAnimation(t, 'anim 100s');
-
-  // Seek to After phase.
-  animation.finish();
-  return watcher.wait_for([ 'animationstart',
-                            'animationend' ]).then(() => {
-    assert_equals(handler.animationstart, 0.0);
-    assert_equals(handler.animationend, 100);
-  });
-}, 'Idle -> After');
-
-promise_test(t => {
-  const { animation, watcher } =
-    setupAnimation(t, 'anim 100s 100s paused');
-
-  return animation.ready.then(() => {
-    // Seek to Active phase.
-    animation.currentTime = 100 * MS_PER_SEC;
-    return watcher.wait_for('animationstart');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 0.0);
-  });
-}, 'Before -> Active');
-
-promise_test(t => {
-  const { animation, watcher, div, handler } =
-    setupAnimation(t, 'anim 100s 100s paused');
-
-  return animation.ready.then(() => {
-    // Seek to After phase.
-    animation.finish();
-    return watcher.wait_for([ 'animationstart', 'animationend' ]);
-  }).then(evt => {
-    assert_equals(handler.animationstart, 0.0);
-    assert_equals(handler.animationend, 100.0);
-  });
-}, 'Before -> After');
-
-promise_test(t => {
-  const { animation, watcher, div } = setupAnimation(t, 'anim 100s paused');
-
-  return watcher.wait_for('animationstart').then(evt => {
-    // Make idle
-    div.style.display = 'none';
-    return watcher.wait_for('animationcancel');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 0.0);
-  });
-}, 'Active -> Idle, display: none');
-
-promise_test(t => {
-  const { animation, watcher, div } = setupAnimation(t, 'anim 100s');
-
-  return watcher.wait_for('animationstart').then(evt => {
-    animation.currentTime = 100.0;
-    // Make idle
-    animation.timeline = null;
-    return watcher.wait_for('animationcancel');
-  }).then(evt => {
-    assert_time_equals_literal(evt.elapsedTime, 0.1);
-  });
-}, 'Active -> Idle, setting Animation.timeline = null');
-
-promise_test(t => {
-  // we should NOT pause animation since calling cancel synchronously.
-  const { animation, watcher, div } = setupAnimation(t, 'anim 100s');
-
-  return watcher.wait_for('animationstart').then(evt => {
-    animation.currentTime = 50.0;
-    animation.cancel();
-    return watcher.wait_for('animationcancel');
-  }).then(evt => {
-    assert_time_equals_literal(evt.elapsedTime, 0.05);
-  });
-}, 'Active -> Idle, calling Animation.cancel()');
-
-promise_test(t => {
-  const { animation, watcher } =
-    setupAnimation(t, 'anim 100s 100s paused');
-
-  // Seek to Active phase.
-  animation.currentTime = 100 * MS_PER_SEC;
-  return watcher.wait_for('animationstart').then(() => {
-    // Seek to Before phase.
-    animation.currentTime = 0;
-    return watcher.wait_for('animationend');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 0.0);
-  });
-}, 'Active -> Before');
-
-promise_test(t => {
-  const { animation, watcher } = setupAnimation(t, 'anim 100s paused');
-
-  return watcher.wait_for('animationstart').then(evt => {
-    // Seek to After phase.
-    animation.finish();
-    return watcher.wait_for('animationend');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 100.0);
-  });
-}, 'Active -> After');
-
-promise_test(t => {
-  const { animation, watcher, div, handler } =
-    setupAnimation(t, 'anim 100s 100s paused');
-
-  // Seek to After phase.
-  animation.finish();
-  return watcher.wait_for([ 'animationstart',
-                            'animationend' ]).then(() => {
-    // Seek to Before phase.
-    animation.currentTime = 0;
-    handler.clear();
-    return watcher.wait_for([ 'animationstart', 'animationend' ]);
-  }).then(() => {
-    assert_equals(handler.animationstart, 100.0);
-    assert_equals(handler.animationend, 0.0);
-  });
-}, 'After -> Before');
-
-promise_test(t => {
-  const { animation, watcher, div } =
-    setupAnimation(t, 'anim 100s 100s paused');
-
-  // Seek to After phase.
-  animation.finish();
-  return watcher.wait_for([ 'animationstart',
-                            'animationend' ]).then(() => {
-    // Seek to Active phase.
-    animation.currentTime = 100 * MS_PER_SEC;
-    return watcher.wait_for('animationstart');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 100.0);
-  });
-}, 'After -> Active');
-
-promise_test(t => {
-  const { animation, watcher, div }
-    = setupAnimation(t, 'anim 100s 100s 3 paused');
-
-  return animation.ready.then(() => {
-    // Seek to iteration 0 (no animationiteration event should be dispatched)
-    animation.currentTime = 100 * MS_PER_SEC;
-    return watcher.wait_for('animationstart');
-  }).then(evt => {
-    // Seek to iteration 2
-    animation.currentTime = 300 * MS_PER_SEC;
-    return watcher.wait_for('animationiteration');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 200);
-    // Seek to After phase (no animationiteration event should be dispatched)
-    animation.currentTime = 400 * MS_PER_SEC;
-    return watcher.wait_for('animationend');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 300);
-  });
-}, 'Active -> Active (forwards)');
-
-promise_test(t => {
-  const { animation, watcher } = setupAnimation(t, 'anim 100s 100s 3');
-
-  // Seek to After phase.
-  animation.finish();
-  return watcher.wait_for([ 'animationstart',
-                            'animationend' ]).then(() => {
-    // Seek to iteration 2 (no animationiteration event should be dispatched)
-    animation.pause();
-    animation.currentTime = 300 * MS_PER_SEC;
-    return watcher.wait_for('animationstart');
-  }).then(() => {
-    // Seek to mid of iteration 0 phase.
-    animation.currentTime = 200 * MS_PER_SEC;
-    return watcher.wait_for('animationiteration');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 200.0);
-    // Seek to before phase (no animationiteration event should be dispatched)
-    animation.currentTime = 0;
-    return watcher.wait_for('animationend');
-  });
-}, 'Active -> Active (backwards)');
-
-promise_test(t => {
-  const { animation, watcher, div } =
-    setupAnimation(t, 'anim 100s paused');
-  return watcher.wait_for('animationstart').then(evt => {
-    // Seek to Idle phase.
-    div.style.display = 'none';
-    flushComputedStyle(div);
-
-    return watcher.wait_for('animationcancel');
-  }).then(() => {
-    // Restart this animation.
-    div.style.display = '';
-    return watcher.wait_for('animationstart');
-  });
-}, 'Active -> Idle -> Active: animationstart is fired by restarting animation');
-
-promise_test(t => {
-  const { animation, watcher } =
-    setupAnimation(t, 'anim 100s 100s 2 paused');
-
-  // Make After.
-  animation.finish();
-  return watcher.wait_for([ 'animationstart',
-                            'animationend' ]).then(evt => {
-    animation.playbackRate = -1;
-    return watcher.wait_for('animationstart');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 200);
-    // Seek to 1st iteration
-    animation.currentTime = 200 * MS_PER_SEC - 1;
-    return watcher.wait_for('animationiteration');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 100);
-    // Seek to before
-    animation.currentTime = 100 * MS_PER_SEC - 1;
-    return watcher.wait_for('animationend');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 0);
-    assert_equals(animation.playState, 'running'); // delay
-  });
-}, 'Negative playbackRate sanity test(Before -> Active -> Before)');
-
-promise_test(t => {
-  const { animation, watcher } = setupAnimation(t, 'anim 100s');
-
-  return watcher.wait_for('animationstart').then(evt => {
-    // Make idle
-    animation.cancel();
-    return watcher.wait_for('animationcancel');
-  }).then(evt => {
-    animation.cancel();
-    // Then wait a couple of frames and check that no event was dispatched.
-    return waitForAnimationFrames(2);
-  });
-}, 'Call Animation.cancel after cancelling animation.');
-
-promise_test(t => {
-  const { animation, watcher, div } = setupAnimation(t, 'anim 1s');
-
-  return watcher.wait_for('animationstart').then(evt => {
-    // Make idle
-
-    animation.cancel();
-    animation.play();
-    return watcher.wait_for([ 'animationcancel',
-                              'animationstart' ]);
-  });
-}, 'Restart animation after cancelling animation immediately.');
-
-promise_test(t => {
-  const { animation, watcher } = setupAnimation(t, 'anim 100s');
-
-  return watcher.wait_for('animationstart').then(evt => {
-    // Make idle
-    animation.cancel();
-    animation.play();
-    animation.cancel();
-    return watcher.wait_for('animationcancel');
-  }).then(evt => {
-    // Then wait a couple of frames and check that no event was dispatched.
-    return waitForAnimationFrames(2);
-  });
-}, 'Call Animation.cancel after restarting animation immediately.');
-
-promise_test(t => {
-  const { animation, watcher } = setupAnimation(t, 'anim 100s');
-
-  return watcher.wait_for('animationstart').then(evt => {
-    // Make idle
-    animation.timeline = null;
-    return watcher.wait_for('animationcancel');
-  }).then(evt => {
-    animation.timeline = document.timeline;
-    animation.play();
-    return watcher.wait_for('animationstart');
-  });
-}, 'Set timeline and play transition after clearing the timeline.');
-
-promise_test(t => {
-  const { animation, watcher } = setupAnimation(t, 'anim 100s');
-
-  return watcher.wait_for('animationstart').then(evt => {
-    // Make idle
-    animation.cancel();
-    return watcher.wait_for('animationcancel');
-  }).then(evt => {
-    animation.effect = null;
-    // Then wait a couple of frames and check that no event was dispatched.
-    return waitForAnimationFrames(2);
-  });
-}, 'Set null target effect after cancelling the animation.');
-
-promise_test(t => {
-  const { animation, watcher } = setupAnimation(t, 'anim 100s');
-
-  return watcher.wait_for('animationstart').then(evt => {
-    animation.effect = null;
-    return watcher.wait_for('animationend');
-  }).then(evt => {
-    animation.cancel();
-    // Then wait a couple of frames and check that no event was dispatched.
-    return waitForAnimationFrames(2);
-  });
-}, 'Cancel the animation after clearing the target effect.');
-
-</script>
-</body>
-</html>
diff --git a/LayoutTests/imported/mozilla/css-animations/test_event-order-expected.txt b/LayoutTests/imported/mozilla/css-animations/test_event-order-expected.txt
deleted file mode 100644 (file)
index bfd3031..0000000
+++ /dev/null
@@ -1,6 +0,0 @@
-
-PASS Test same events are ordered by elements. 
-FAIL Test start and iteration events are ordered by time. assert_equals: Event type should match expected "animationstart" but got "animationiteration"
-FAIL Test iteration and end events are ordered by time. assert_equals: Event type should match expected "animationend" but got "animationiteration"
-FAIL Test start and end events are sorted correctly when fired simultaneously assert_equals: Event target should match expected Element node <div style="animation: anim 100s 100s"></div> but got Element node <div style="animation: anim 100s 2"></div>
-
diff --git a/LayoutTests/imported/mozilla/css-animations/test_event-order.html b/LayoutTests/imported/mozilla/css-animations/test_event-order.html
deleted file mode 100644 (file)
index 9e65fe8..0000000
+++ /dev/null
@@ -1,163 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<title>Tests for CSS animation event order</title>
-<link rel="help" href="https://drafts.csswg.org/css-animations-2/#event-dispatch"/>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<style>
-  @keyframes anim {
-    from { margin-left: 0px; }
-    to { margin-left: 100px; }
-  }
-</style>
-<body>
-<div id="log"></div>
-<script type='text/javascript'>
-'use strict';
-
-/**
- * Asserts that the set of actual and received events match.
- * @param actualEvents   An array of the received AnimationEvent objects.
- * @param expectedEvents A series of array objects representing the expected
- *        events, each having the form:
- *          [ event type, target element, elapsed time ]
- */
-function checkEvents(actualEvents, ...expectedEvents) {
-  assert_equals(actualEvents.length, expectedEvents.length,
-                `Number of actual events (${actualEvents.length}: \
-${actualEvents.map(event => event.type).join(', ')}) should match expected \
-events (${expectedEvents.map(event => event.type).join(', ')})`);
-
-  actualEvents.forEach((actualEvent, i) => {
-    assert_equals(expectedEvents[i][0], actualEvent.type,
-                  'Event type should match');
-    assert_equals(expectedEvents[i][1], actualEvent.target,
-                  'Event target should match');
-    assert_equals(expectedEvents[i][2], actualEvent.elapsedTime,
-                  'Event\'s elapsed time should match');
-  });
-}
-
-function setupAnimation(t, animationStyle, receiveEvents) {
-  const div = addDiv(t, { style: "animation: " + animationStyle });
-
-  ['start', 'iteration', 'end'].forEach(name => {
-    div['onanimation' + name] = evt => {
-    receiveEvents.push({ type:        evt.type,
-                         target:      evt.target,
-                         elapsedTime: evt.elapsedTime });
-    };
-  });
-
-  const watcher = new EventWatcher(t, div, [ 'animationstart',
-                                             'animationiteration',
-                                             'animationend' ]);
-
-  const animation = div.getAnimations()[0];
-
-  return [animation, watcher, div];
-}
-
-promise_test(t => {
-  let events = [];
-  const [animation1, watcher1, div1] =
-    setupAnimation(t, 'anim 100s 2 paused', events);
-  const [animation2, watcher2, div2] =
-    setupAnimation(t, 'anim 100s 2 paused', events);
-
-  return Promise.all([ watcher1.wait_for('animationstart'),
-                       watcher2.wait_for('animationstart') ]).then(() => {
-    checkEvents(events, ['animationstart', div1, 0],
-                        ['animationstart', div2, 0]);
-
-    events.length = 0;  // Clear received event array
-
-    animation1.currentTime = 100 * MS_PER_SEC;
-    animation2.currentTime = 100 * MS_PER_SEC;
-    return Promise.all([ watcher1.wait_for('animationiteration'),
-                         watcher2.wait_for('animationiteration') ]);
-  }).then(() => {
-    checkEvents(events, ['animationiteration', div1, 100],
-                        ['animationiteration', div2, 100]);
-
-    events.length = 0;  // Clear received event array
-
-    animation1.finish();
-    animation2.finish();
-
-    return Promise.all([ watcher1.wait_for('animationend'),
-                         watcher2.wait_for('animationend') ]);
-  }).then(() => {
-    checkEvents(events, ['animationend', div1, 200],
-                        ['animationend', div2, 200]);
-  });
-}, 'Test same events are ordered by elements.');
-
-promise_test(t => {
-  let events = [];
-  const [animation1, watcher1, div1] =
-    setupAnimation(t, 'anim 200s 400s', events);
-  const [animation2, watcher2, div2] =
-    setupAnimation(t, 'anim 300s 2', events);
-
-  return watcher2.wait_for('animationstart').then(evt => {
-    animation1.currentTime = 400 * MS_PER_SEC;
-    animation2.currentTime = 400 * MS_PER_SEC;
-
-    events.length = 0;  // Clear received event array
-
-    return Promise.all([ watcher1.wait_for('animationstart'),
-                         watcher2.wait_for('animationiteration') ]);
-  }).then(() => {
-    checkEvents(events, ['animationiteration', div2, 300],
-                        ['animationstart',     div1, 0]);
-  });
-}, 'Test start and iteration events are ordered by time.');
-
-promise_test(t => {
-  let events = [];
-  const [animation1, watcher1, div1] =
-    setupAnimation(t, 'anim 150s', events);
-  const [animation2, watcher2, div2] =
-    setupAnimation(t, 'anim 100s 2', events);
-
-  return Promise.all([ watcher1.wait_for('animationstart'),
-                       watcher2.wait_for('animationstart') ]).then(() => {
-    animation1.currentTime = 150 * MS_PER_SEC;
-    animation2.currentTime = 150 * MS_PER_SEC;
-
-    events.length = 0;  // Clear received event array
-
-    return Promise.all([ watcher1.wait_for('animationend'),
-                         watcher2.wait_for('animationiteration') ]);
-  }).then(() => {
-    checkEvents(events, ['animationiteration', div2, 100],
-                        ['animationend',       div1, 150]);
-  });
-}, 'Test iteration and end events are ordered by time.');
-
-promise_test(t => {
-  let events = [];
-  const [animation1, watcher1, div1] =
-    setupAnimation(t, 'anim 100s 100s', events);
-  const [animation2, watcher2, div2] =
-    setupAnimation(t, 'anim 100s 2', events);
-
-  animation1.finish();
-  animation2.finish();
-
-  return Promise.all([ watcher1.wait_for([ 'animationstart',
-                                           'animationend' ]),
-                       watcher2.wait_for([ 'animationstart',
-                                           'animationend' ]) ]).then(() => {
-    checkEvents(events, ['animationstart', div2, 0],
-                        ['animationstart', div1, 0],
-                        ['animationend',   div1, 100],
-                        ['animationend',   div2, 200]);
-  });
-}, 'Test start and end events are sorted correctly when fired simultaneously');
-
-</script>
-</body>
-</html>
diff --git a/LayoutTests/imported/mozilla/css-animations/test_setting-effect.html b/LayoutTests/imported/mozilla/css-animations/test_setting-effect.html
deleted file mode 100644 (file)
index 1789026..0000000
+++ /dev/null
@@ -1,132 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<style>
-  @keyframes anim {
-    from {
-      margin-left: 0px;
-    }
-    to {
-      margin-left: 100px;
-    }
-  }
-</style>
-<body>
-<div id="log"></div>
-<script>
-'use strict';
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  div.style.animation = 'anim 100s';
-
-  var watcher = new EventWatcher(t, div, [ 'animationend',
-                                           'animationcancel' ]);
-  var animation = div.getAnimations()[0];
-  return animation.ready.then(function() {
-    animation.currentTime = 50 * MS_PER_SEC;
-    animation.effect = null;
-    assert_equals(animation.playState, 'finished');
-    assert_equals(getComputedStyle(div).marginLeft, '0px');
-    return watcher.wait_for('animationend');
-  });
-}, 'Setting a null effect on a running animation fires an animationend event');
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  div.style.animation = 'anim 100s';
-
-  var animation = div.getAnimations()[0];
-  return animation.ready.then(function() {
-    animation.currentTime = 50 * MS_PER_SEC;
-    animation.effect = new KeyframeEffect(div,
-                                          { left: [ '0px' , '100px'] },
-                                          100 * MS_PER_SEC);
-    assert_equals(animation.playState, 'running');
-    assert_equals(getComputedStyle(div).marginLeft, '0px');
-    assert_equals(getComputedStyle(div).left, '50px');
-  });
-}, 'Replacing an animation\'s effect with an effect that targets a different ' +
-   'property should update both properties');
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  div.style.animation = 'anim 100s';
-
-  var animation = div.getAnimations()[0];
-  return animation.ready.then(function() {
-    animation.currentTime = 50 * MS_PER_SEC;
-    animation.effect = new KeyframeEffect(div,
-                                          { left: [ '0px' , '100px'] },
-                                          20 * MS_PER_SEC);
-    assert_equals(animation.playState, 'finished');
-  });
-}, 'Replacing an animation\'s effect with a shorter one that should have ' +
-   'already finished, the animation finishes immediately');
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  div.style.animation = 'anim 100s';
-
-  var animation = div.getAnimations()[0];
-  assert_true(animation.pending);
-
-  animation.effect = new KeyframeEffect(div,
-                                        { left: [ '0px' , '100px'] },
-                                        100 * MS_PER_SEC);
-  assert_true(animation.pending);
-
-  return animation.ready.then(function() {
-    assert_false(animation.pending);
-  });
-}, 'A play-pending animation\'s effect whose effect is replaced still exits ' +
-   'the pending state');
-
-promise_test(function(t) {
-  var div1 = addDiv(t);
-  var div2 = addDiv(t);
-
-  var watcher1 = new EventWatcher(t, div1, 'animationstart');
-  // Watch |div2| as well to ensure it does *not* get events.
-  var watcher2 = new EventWatcher(t, div2, 'animationstart');
-
-  div1.style.animation = 'anim 100s';
-
-  var animation = div1.getAnimations()[0];
-  animation.effect = new KeyframeEffect(div2,
-                                        { left: [ '0px', '100px' ] },
-                                        100 * MS_PER_SEC);
-
-  return watcher1.wait_for('animationstart').then(function() {
-    assert_equals(animation.effect.target, div2);
-
-    // Then wait a couple of frames and check that no event was dispatched.
-    return waitForAnimationFrames(2);
-  });
-}, 'The event is dispatched at the original element even after setting an ' +
-   'effect with a different target element');
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  var watcher = new EventWatcher(t, div, [ 'animationstart',
-                                           'animationend',
-                                           'animationcancel' ]);
-  div.style.animation = 'anim 100s';
-  var animation = div.getAnimations()[0];
-  animation.finish();
-
-  return watcher.wait_for([ 'animationstart',
-                            'animationend' ]).then(function(evt) {
-    // Set a longer effect
-    animation.effect = new KeyframeEffect(div,
-                                          { left: [ '0px', '100px' ] },
-                                          200 * MS_PER_SEC);
-    return watcher.wait_for('animationstart');
-  });
-}, 'After replacing a finished animation\'s effect with a longer one ' +
-   'it fires an animationstart event');
-
-</script>
-</body>
diff --git a/LayoutTests/imported/mozilla/css-transitions/test_animation-cancel.html b/LayoutTests/imported/mozilla/css-transitions/test_animation-cancel.html
deleted file mode 100644 (file)
index ec6f464..0000000
+++ /dev/null
@@ -1,235 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<body>
-<div id="log"></div>
-<script>
-'use strict';
-
-promise_test(function(t) {
-  var div = addDiv(t, { style: 'margin-left: 0px' });
-  flushComputedStyle(div);
-
-  div.style.transition = 'margin-left 100s';
-  div.style.marginLeft = '1000px';
-
-  var transition = div.getAnimations()[0];
-  return transition.ready.then(waitForFrame).then(function() {
-    assert_not_equals(getComputedStyle(div).marginLeft, '1000px',
-                      'transform style is animated before cancelling');
-    transition.cancel();
-    assert_equals(getComputedStyle(div).marginLeft, div.style.marginLeft,
-                  'transform style is no longer animated after cancelling');
-  });
-}, 'Animated style is cleared after cancelling a running CSS transition');
-
-promise_test(function(t) {
-  var div = addDiv(t, { style: 'margin-left: 0px' });
-  flushComputedStyle(div);
-
-  div.style.transition = 'margin-left 100s';
-  div.style.marginLeft = '1000px';
-
-  var transition = div.getAnimations()[0];
-  return transition.ready.then(function() {
-    transition.cancel();
-    assert_equals(getComputedStyle(div).marginLeft, '1000px',
-                  'margin-left style is not animated after cancelling');
-    transition.play();
-    assert_equals(getComputedStyle(div).marginLeft, '0px',
-                  'margin-left style is animated after re-starting transition');
-    return transition.ready;
-  }).then(function() {
-    assert_equals(transition.playState, 'running',
-                  'Transition succeeds in running after being re-started');
-  });
-}, 'After canceling a transition, it can still be re-used');
-
-promise_test(function(t) {
-  var div = addDiv(t, { style: 'margin-left: 0px' });
-  flushComputedStyle(div);
-
-  div.style.transition = 'margin-left 100s';
-  div.style.marginLeft = '1000px';
-
-  var transition = div.getAnimations()[0];
-  return transition.ready.then(function() {
-    transition.finish();
-    transition.cancel();
-    assert_equals(getComputedStyle(div).marginLeft, '1000px',
-                  'margin-left style is not animated after cancelling');
-    transition.play();
-    assert_equals(getComputedStyle(div).marginLeft, '0px',
-                  'margin-left style is animated after re-starting transition');
-    return transition.ready;
-  }).then(function() {
-    assert_equals(transition.playState, 'running',
-                  'Transition succeeds in running after being re-started');
-  });
-}, 'After cancelling a finished transition, it can still be re-used');
-
-test(function(t) {
-  var div = addDiv(t, { style: 'margin-left: 0px' });
-  flushComputedStyle(div);
-
-  div.style.transition = 'margin-left 100s';
-  div.style.marginLeft = '1000px';
-
-  var transition = div.getAnimations()[0];
-  transition.cancel();
-  assert_equals(getComputedStyle(div).marginLeft, '1000px',
-                'margin-left style is not animated after cancelling');
-
-  // Trigger a change to a transition property and check that this
-  // doesn't cause the animation to become live again
-  div.style.transitionDuration = '200s';
-  flushComputedStyle(div);
-  assert_equals(getComputedStyle(div).marginLeft, '1000px',
-                'margin-left style is still not animated after updating'
-                + ' transition-duration');
-  assert_equals(transition.playState, 'idle',
-                'Transition is still idle after updating transition-duration');
-}, 'After cancelling a transition, updating transition properties doesn\'t make'
-   + ' it live again');
-
-promise_test(function(t) {
-  var div = addDiv(t, { style: 'margin-left: 0px' });
-  flushComputedStyle(div);
-
-  div.style.transition = 'margin-left 100s';
-  div.style.marginLeft = '1000px';
-
-  var transition = div.getAnimations()[0];
-  return transition.ready.then(function() {
-    assert_equals(transition.playState, 'running');
-    div.style.display = 'none';
-    return waitForFrame();
-  }).then(function() {
-    assert_equals(transition.playState, 'idle');
-    assert_equals(getComputedStyle(div).marginLeft, '1000px');
-  });
-}, 'Setting display:none on an element cancels its transitions');
-
-promise_test(function(t) {
-  var parentDiv = addDiv(t);
-  var childDiv = document.createElement('div');
-  parentDiv.appendChild(childDiv);
-  childDiv.setAttribute('style', 'margin-left: 0px');
-
-  flushComputedStyle(childDiv);
-
-  childDiv.style.transition = 'margin-left 100s';
-  childDiv.style.marginLeft = '1000px';
-
-  var transition = childDiv.getAnimations()[0];
-  return transition.ready.then(function() {
-    assert_equals(transition.playState, 'running');
-    parentDiv.style.display = 'none';
-    return waitForFrame();
-  }).then(function() {
-    assert_equals(transition.playState, 'idle');
-    assert_equals(getComputedStyle(childDiv).marginLeft, '1000px');
-  });
-}, 'Setting display:none cancels transitions on a child element');
-
-promise_test(function(t) {
-  var div = addDiv(t, { style: 'margin-left: 0px' });
-  flushComputedStyle(div);
-
-  div.style.transition = 'margin-left 100s';
-  div.style.marginLeft = '1000px';
-
-  var transition = div.getAnimations()[0];
-  return transition.ready.then(function() {
-    assert_equals(transition.playState, 'running');
-    // Set an unrecognized property value
-    div.style.transitionProperty = 'none';
-    flushComputedStyle(div);
-    return waitForFrame();
-  }).then(function() {
-    assert_equals(transition.playState, 'idle');
-    assert_equals(getComputedStyle(div).marginLeft, '1000px');
-  });
-}, 'Removing a property from transition-property cancels transitions on that '+
-   'property');
-
-promise_test(function(t) {
-  var div = addDiv(t, { style: 'margin-left: 0px' });
-  flushComputedStyle(div);
-
-  div.style.transition = 'margin-left 100s';
-  div.style.marginLeft = '1000px';
-
-  var transition = div.getAnimations()[0];
-  return transition.ready.then(function() {
-    assert_equals(transition.playState, 'running');
-    div.style.transition = 'margin-top 10s -10s'; // combined duration is zero
-    flushComputedStyle(div);
-    return waitForFrame();
-  }).then(function() {
-    assert_equals(transition.playState, 'idle');
-    assert_equals(getComputedStyle(div).marginLeft, '1000px');
-  });
-}, 'Setting zero combined duration');
-
-promise_test(function(t) {
-  var div = addDiv(t, { style: 'margin-left: 0px' });
-  flushComputedStyle(div);
-
-  div.style.transition = 'margin-left 100s';
-  div.style.marginLeft = '1000px';
-
-  var transition = div.getAnimations()[0];
-  return transition.ready.then(function() {
-    assert_equals(transition.playState, 'running');
-    div.style.marginLeft = '2000px';
-    flushComputedStyle(div);
-    return waitForFrame();
-  }).then(function() {
-    assert_equals(transition.playState, 'idle');
-  });
-}, 'Changing style to another interpolable value cancels the original ' +
-   'transition');
-
-promise_test(function(t) {
-  var div = addDiv(t, { style: 'margin-left: 0px' });
-  flushComputedStyle(div);
-
-  div.style.transition = 'margin-left 100s';
-  div.style.marginLeft = '1000px';
-
-  var transition = div.getAnimations()[0];
-  return transition.ready.then(function() {
-    assert_equals(transition.playState, 'running');
-    div.style.marginLeft = 'auto';
-    flushComputedStyle(div);
-    return waitForFrame();
-  }).then(function() {
-    assert_equals(div.getAnimations().length, 0,
-                  'There should be no transitions');
-    assert_equals(transition.playState, 'idle');
-  });
-}, 'An after-change style value can\'t be interpolated');
-
-promise_test(function(t) {
-  var div = addDiv(t, { style: 'margin-left: 0px' });
-  flushComputedStyle(div);
-
-  div.style.transition = 'margin-left 100s';
-  div.style.marginLeft = '1000px';
-
-  var transition = div.getAnimations()[0];
-  return transition.ready.then(function() {
-    assert_equals(transition.playState, 'running');
-    div.style.marginLeft = '0px';
-    flushComputedStyle(div);
-    return waitForFrame();
-  }).then(function() {
-    assert_equals(transition.playState, 'idle');
-  });
-}, 'Reversing a running transition cancels the original transition');
-
-</script>
-</body>
diff --git a/LayoutTests/imported/mozilla/css-transitions/test_animation-currenttime-expected.txt b/LayoutTests/imported/mozilla/css-transitions/test_animation-currenttime-expected.txt
deleted file mode 100644 (file)
index 78f0fdf..0000000
+++ /dev/null
@@ -1,8 +0,0 @@
-
-PASS currentTime of a newly created transition is zero 
-PASS Sanity test to check round-tripping assigning to new animation's currentTime 
-PASS Skipping forward through transition 
-PASS Skipping backwards through transition 
-PASS Setting currentTime to null 
-PASS Animation.currentTime after pausing 
-
diff --git a/LayoutTests/imported/mozilla/css-transitions/test_animation-currenttime.html b/LayoutTests/imported/mozilla/css-transitions/test_animation-currenttime.html
deleted file mode 100644 (file)
index c165877..0000000
+++ /dev/null
@@ -1,309 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <meta charset=utf-8>
-    <title>Tests for the effect of setting a CSS transition's
-           Animation.currentTime</title>
-    <style>
-
-.animated-div {
-  margin-left: 100px;
-  transition: margin-left 1000s linear 1000s;
-}
-
-    </style>
-    <script src="../../../resources/testharness.js"></script>
-    <script src="../../../resources/testharnessreport.js"></script>
-    <script src="../resources/testcommon.js"></script>
-  </head>
-  <body>
-    <div id="log"></div>
-    <script type="text/javascript">
-
-'use strict';
-
-// TODO: Once the computedTiming property is implemented, add checks to the
-// checker helpers to ensure that computedTiming's properties are updated as
-// expected.
-// See https://bugzilla.mozilla.org/show_bug.cgi?id=1108055
-
-
-const ANIM_DELAY_MS = 1000000; // 1000s
-const ANIM_DUR_MS = 1000000; // 1000s
-
-/**
- * These helpers get the value that the currentTime needs to be set to, to put
- * an animation that uses the above ANIM_DELAY_MS and ANIM_DUR_MS values into
- * the middle of various phases or points through the active duration.
- */
-function currentTimeForBeforePhase() {
-  return ANIM_DELAY_MS / 2;
-}
-function currentTimeForActivePhase() {
-  return ANIM_DELAY_MS + ANIM_DUR_MS / 2;
-}
-function currentTimeForAfterPhase() {
-  return ANIM_DELAY_MS + ANIM_DUR_MS + ANIM_DELAY_MS / 2;
-}
-function currentTimeForStartOfActiveInterval() {
-  return ANIM_DELAY_MS;
-}
-function currentTimeForFiftyPercentThroughActiveInterval() {
-  return ANIM_DELAY_MS + ANIM_DUR_MS * 0.5;
-}
-function currentTimeForEndOfActiveInterval() {
-  return ANIM_DELAY_MS + ANIM_DUR_MS;
-}
-
-
-// Expected computed 'margin-left' values at points during the active interval:
-// When we assert_between_inclusive using these values we could in theory cause
-// intermittent failure due to very long delays between paints, but since the
-// active duration is 1000s long, a delay would need to be around 100s to cause
-// that. If that's happening then there are likely other issues that should be
-// fixed, so a failure to make us look into that seems like a good thing.
-const INITIAL_POSITION = 100;
-const TEN_PCT_POSITION = 110;
-const FIFTY_PCT_POSITION = 150;
-const END_POSITION = 200;
-
-
-// The terms used for the naming of the following helper functions refer to
-// terms used in the Web Animations specification for specific phases of an
-// animation. The terms can be found here:
-//
-//   http://drafts.csswg.org/web-animations/#animation-effect-phases-and-states
-
-// Called when currentTime is set to zero (the beginning of the start delay).
-function checkStateOnSettingCurrentTimeToZero(animation)
-{
-  // We don't test animation.currentTime since our caller just set it.
-
-  assert_equals(animation.playState, 'running',
-    'Animation.playState should be "running" at the start of ' +
-    'the start delay');
-
-  assert_equals(animation.effect.target.style.animationPlayState, 'running',
-    'Animation.effect.target.style.animationPlayState should be ' +
-    '"running" at the start of the start delay');
-
-  var div = animation.effect.target;
-  var marginLeft = parseFloat(getComputedStyle(div).marginLeft);
-  assert_equals(marginLeft, UNANIMATED_POSITION,
-                'the computed value of margin-left should be unaffected ' +
-                'at the beginning of the start delay');
-}
-
-// Called when the ready Promise's callbacks should happen
-function checkStateOnReadyPromiseResolved(animation)
-{
-  // the 0.0001 here is for rounding error
-  assert_less_than_equal(animation.currentTime,
-    animation.timeline.currentTime - animation.startTime + 0.0001,
-    'Animation.currentTime should be less than the local time ' +
-    'equivalent of the timeline\'s currentTime on the first paint tick ' +
-    'after animation creation');
-
-  assert_equals(animation.playState, 'running',
-    'Animation.playState should be "running" on the first paint ' +
-    'tick after animation creation');
-
-  var div = animation.effect.target;
-  var marginLeft = parseFloat(getComputedStyle(div).marginLeft);
-  assert_equals(marginLeft, INITIAL_POSITION,
-                'the computed value of margin-left should be unaffected ' +
-                'by an animation with a delay on ready Promise resolve');
-}
-
-// Called when currentTime is set to the time the active interval starts.
-function checkStateAtActiveIntervalStartTime(animation)
-{
-  // We don't test animation.currentTime since our caller just set it.
-
-  assert_equals(animation.playState, 'running',
-    'Animation.playState should be "running" at the start of ' +
-    'the active interval');
-
-  var div = animation.effect.target;
-  var marginLeft = parseFloat(getComputedStyle(div).marginLeft);
-  assert_between_inclusive(marginLeft, INITIAL_POSITION, TEN_PCT_POSITION,
-    'the computed value of margin-left should be close to the value at the ' +
-    'beginning of the animation');
-}
-
-function checkStateAtFiftyPctOfActiveInterval(animation)
-{
-  // We don't test animation.currentTime since our caller just set it.
-
-  var div = animation.effect.target;
-  var marginLeft = parseFloat(getComputedStyle(div).marginLeft);
-  assert_equals(marginLeft, FIFTY_PCT_POSITION,
-    'the computed value of margin-left should be half way through the ' +
-    'animation at the midpoint of the active interval');
-}
-
-// Called when currentTime is set to the time the active interval ends.
-function checkStateAtActiveIntervalEndTime(animation)
-{
-  // We don't test animation.currentTime since our caller just set it.
-
-  assert_equals(animation.playState, 'finished',
-    'Animation.playState should be "finished" at the end of ' +
-    'the active interval');
-
-  var div = animation.effect.target;
-  var marginLeft = parseFloat(getComputedStyle(div).marginLeft);
-  assert_equals(marginLeft, END_POSITION,
-    'the computed value of margin-left should be the final transitioned-to ' +
-    'value at the end of the active duration');
-}
-
-test(function(t)
-{
-  var div = addDiv(t, {'class': 'animated-div'});
-  flushComputedStyle(div);
-  div.style.marginLeft = '200px'; // initiate transition
-
-  var animation = div.getAnimations()[0];
-  assert_equals(animation.currentTime, 0, 'currentTime should be zero');
-}, 'currentTime of a newly created transition is zero');
-
-
-test(function(t)
-{
-  var div = addDiv(t, {'class': 'animated-div'});
-  flushComputedStyle(div);
-  div.style.marginLeft = '200px'; // initiate transition
-
-  var animation = div.getAnimations()[0];
-
-  // So that animation is running instead of paused when we set currentTime:
-  animation.startTime = animation.timeline.currentTime;
-
-  animation.currentTime = 10;
-  assert_equals(animation.currentTime, 10,
-    'Check setting of currentTime actually works');
-}, 'Sanity test to check round-tripping assigning to new animation\'s ' +
-   'currentTime');
-
-
-async_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  var eventWatcher = new EventWatcher(t, div, 'transitionend');
-
-  flushComputedStyle(div);
-  div.style.marginLeft = '200px'; // initiate transition
-
-  var animation = div.getAnimations()[0];
-
-  animation.ready.then(t.step_func(function() {
-    checkStateOnReadyPromiseResolved(animation);
-
-    animation.currentTime = currentTimeForStartOfActiveInterval();
-    checkStateAtActiveIntervalStartTime(animation);
-
-    animation.currentTime = currentTimeForFiftyPercentThroughActiveInterval();
-    checkStateAtFiftyPctOfActiveInterval(animation);
-
-    animation.currentTime = currentTimeForEndOfActiveInterval();
-    return eventWatcher.wait_for('transitionend');
-  })).then(t.step_func(function() {
-    checkStateAtActiveIntervalEndTime(animation);
-  })).catch(t.step_func(function(reason) {
-    assert_unreached(reason);
-  })).then(function() {
-    t.done();
-  });
-}, 'Skipping forward through transition');
-
-
-test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  var eventWatcher = new EventWatcher(t, div, 'transitionend');
-
-  flushComputedStyle(div);
-  div.style.marginLeft = '200px'; // initiate transition
-
-  var animation = div.getAnimations()[0];
-
-  // Unlike in the case of CSS animations, we cannot skip to the end and skip
-  // backwards since when we reach the end the transition effect is removed and
-  // changes to the Animation object no longer affect the element. For
-  // this reason we only skip forwards as far as the 50% through point.
-
-  animation.ready.then(t.step_func(function() {
-    animation.currentTime = currentTimeForFiftyPercentThroughActiveInterval();
-    checkStateAtFiftyPctOfActiveInterval(animation);
-
-    animation.currentTime = currentTimeForStartOfActiveInterval();
-
-    // Despite going backwards from being in the active interval to being
-    // before it, we now expect a 'transitionend' event because the transition
-    // should go from being active to inactive.
-    //
-    // Calling checkStateAtActiveIntervalStartTime will check computed style,
-    // causing computed style to be updated and the 'transitionend' event to
-    // be dispatched synchronously. We need to call wait_for first
-    // otherwise eventWatcher will assert that the event was unexpected.
-    eventWatcher.wait_for('transitionend').then(function() {
-      t.done();
-    });
-    checkStateAtActiveIntervalStartTime(animation);
-  }));
-}, 'Skipping backwards through transition');
-
-
-async_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  flushComputedStyle(div);
-  div.style.marginLeft = '200px'; // initiate transition
-
-  var animation = div.getAnimations()[0];
-
-  animation.ready.then(t.step_func(function() {
-    var exception;
-    try {
-      animation.currentTime = null;
-    } catch (e) {
-      exception = e;
-    }
-    assert_equals(exception.name, 'TypeError',
-      'Expect TypeError exception on trying to set ' +
-      'Animation.currentTime to null');
-  })).catch(t.step_func(function(reason) {
-    assert_unreached(reason);
-  })).then(function() {
-    t.done();
-  });
-}, 'Setting currentTime to null');
-
-
-async_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  flushComputedStyle(div);
-  div.style.marginLeft = '200px'; // initiate transition
-
-  var animation = div.getAnimations()[0];
-  var pauseTime;
-
-  animation.ready.then(t.step_func(function() {
-    assert_not_equals(animation.currentTime, null,
-      'Animation.currentTime not null on ready Promise resolve');
-    animation.pause();
-    return animation.ready;
-  })).then(t.step_func(function() {
-    pauseTime = animation.currentTime;
-    return waitForFrame();
-  })).then(t.step_func(function() {
-    assert_equals(animation.currentTime, pauseTime,
-      'Animation.currentTime is unchanged after pausing');
-  })).catch(t.step_func(function(reason) {
-    assert_unreached(reason);
-  })).then(function() {
-    t.done();
-  });
-}, 'Animation.currentTime after pausing');
-
-    </script>
-  </body>
-</html>
diff --git a/LayoutTests/imported/mozilla/css-transitions/test_animation-finished-expected.txt b/LayoutTests/imported/mozilla/css-transitions/test_animation-finished-expected.txt
deleted file mode 100644 (file)
index 1053a33..0000000
+++ /dev/null
@@ -1,4 +0,0 @@
-
-PASS Test restarting a finished transition 
-PASS Test restarting a reversed finished transition 
-
diff --git a/LayoutTests/imported/mozilla/css-transitions/test_animation-finished.html b/LayoutTests/imported/mozilla/css-transitions/test_animation-finished.html
deleted file mode 100644 (file)
index 61f761b..0000000
+++ /dev/null
@@ -1,63 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<style>
-
-.animated-div {
-  margin-left: 100px;
-  transition: margin-left 1000s linear 1000s;
-}
-
-</style>
-<body>
-<div id="log"></div>
-<script>
-
-'use strict';
-
-const ANIM_DELAY_MS = 1000000; // 1000s
-const ANIM_DUR_MS = 1000000; // 1000s
-
-async_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  flushComputedStyle(div);
-  div.style.marginLeft = '200px'; // initiate transition
-
-  var animation = div.getAnimations()[0];
-
-  animation.finish();
-
-  animation.finished.then(t.step_func(function() {
-    animation.play();
-    assert_equals(animation.currentTime, 0,
-                  'Replaying a finished transition should reset its ' +
-                  'currentTime');
-    t.done();
-  }));
-}, 'Test restarting a finished transition');
-
-async_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  flushComputedStyle(div);
-  div.style.marginLeft = '200px'; // initiate transition
-
-  var animation = div.getAnimations()[0];
-
-  animation.ready.then(function() {
-    animation.playbackRate = -1;
-    return animation.finished;
-  }).then(t.step_func(function() {
-    animation.play();
-    // FIXME: once animation.effect.computedTiming.endTime is available (bug
-    // 1108055) we should use that here.
-    assert_equals(animation.currentTime, ANIM_DELAY_MS + ANIM_DUR_MS,
-                  'Replaying a finished reversed transition should reset ' +
-                  'its currentTime to the end of the effect');
-    t.done();
-  }));
-}, 'Test restarting a reversed finished transition');
-
-</script>
-</body>
diff --git a/LayoutTests/imported/mozilla/css-transitions/test_animation-pausing-expected.txt b/LayoutTests/imported/mozilla/css-transitions/test_animation-pausing-expected.txt
deleted file mode 100644 (file)
index 8ab6d2d..0000000
+++ /dev/null
@@ -1,3 +0,0 @@
-
-PASS pause() and play() a transition 
-
diff --git a/LayoutTests/imported/mozilla/css-transitions/test_animation-pausing.html b/LayoutTests/imported/mozilla/css-transitions/test_animation-pausing.html
deleted file mode 100644 (file)
index ac1a8d3..0000000
+++ /dev/null
@@ -1,50 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<body>
-<div id="log"></div>
-<script>
-'use strict';
-
-async_test(function(t) {
-  var div = addDiv(t);
-  var cs = getComputedStyle(div);
-
-  div.style.marginLeft = '0px';
-  cs.marginLeft; // Flush style to set up transition start point
-  div.style.transition = 'margin-left 100s';
-  div.style.marginLeft = '10000px';
-  cs.marginLeft;
-
-  var animation = div.getAnimations()[0];
-  var previousProgress = animation.effect.getComputedTiming().progress;
-  assert_equals(previousProgress, 0, 'Initial value of progress is zero');
-
-  animation.ready.then(waitForNextFrame).then(t.step_func(function() {
-    assert_greater_than(animation.effect.getComputedTiming().progress,
-                        previousProgress,
-                        'Iteration progress is initially increasing');
-    animation.pause();
-    return animation.ready;
-  })).then(t.step_func(function() {
-    previousProgress = animation.effect.getComputedTiming().progress;
-    return waitForNextFrame();
-  })).then(t.step_func(function() {
-    assert_equals(animation.effect.getComputedTiming().progress,
-                  previousProgress,
-                  'Iteration progress does not increase after calling pause()');
-    previousProgress = animation.effect.getComputedTiming().progress;
-    animation.play();
-    return animation.ready.then(waitForNextFrame);
-  })).then(t.step_func(function() {
-    assert_greater_than(animation.effect.getComputedTiming().progress,
-                        previousProgress,
-                        'Iteration progress increases after calling play()');
-    t.done();
-  }));
-}, 'pause() and play() a transition');
-
-</script>
-</body>
diff --git a/LayoutTests/imported/mozilla/css-transitions/test_animation-ready-expected.txt b/LayoutTests/imported/mozilla/css-transitions/test_animation-ready-expected.txt
deleted file mode 100644 (file)
index fd3ad85..0000000
+++ /dev/null
@@ -1,5 +0,0 @@
-
-PASS A new ready promise is created each time play() is called the animation property 
-PASS ready promise is rejected when a transition is cancelled by updating transition-property 
-PASS ready promise is rejected when a transition is cancelled by changing the transition property to something not interpolable 
-
diff --git a/LayoutTests/imported/mozilla/css-transitions/test_animation-ready.html b/LayoutTests/imported/mozilla/css-transitions/test_animation-ready.html
deleted file mode 100644 (file)
index 07d5cf1..0000000
+++ /dev/null
@@ -1,98 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<body>
-<div id="log"></div>
-<script>
-'use strict';
-
-async_test(function(t) {
-  var div = addDiv(t);
-  div.style.transform = 'translate(0px)';
-  getComputedStyle(div).transform;
-  div.style.transition = 'transform 100s';
-  div.style.transform = 'translate(10px)';
-  getComputedStyle(div).transform;
-
-  var animation = div.getAnimations()[0];
-  var originalReadyPromise = animation.ready;
-
-  animation.ready.then(t.step_func(function() {
-    assert_equals(animation.ready, originalReadyPromise,
-                  'Ready promise is the same object when playing completes');
-    animation.pause();
-    assert_not_equals(animation.ready, originalReadyPromise,
-                      'Ready promise object identity differs when pausing');
-    t.done();
-  }));
-}, 'A new ready promise is created each time play() is called'
-   + ' the animation property');
-
-async_test(function(t) {
-  var div = addDiv(t);
-
-  // Set up pending transition
-  div.style.transform = 'translate(0px)';
-  getComputedStyle(div).transform;
-  div.style.transition = 'transform 100s';
-  div.style.transform = 'translate(10px)';
-  getComputedStyle(div).transform;
-
-  var animation = div.getAnimations()[0];
-  assert_true(animation.pending, 'Animation is initially pending');
-
-  // Set up listeners on ready promise
-  animation.ready.then(t.step_func(function() {
-    assert_unreached('ready promise was fulfilled');
-  })).catch(t.step_func(function(err) {
-    assert_equals(err.name, 'AbortError',
-                  'ready promise is rejected with AbortError');
-    assert_equals(animation.playState, 'idle',
-                  'Animation is idle after transition was cancelled');
-  })).then(t.step_func(function() {
-    t.done();
-  }));
-
-  // Now remove transform from transition-property and flush styles
-  div.style.transitionProperty = 'none';
-  getComputedStyle(div).transitionProperty;
-
-}, 'ready promise is rejected when a transition is cancelled by updating'
-   + ' transition-property');
-
-async_test(function(t) {
-  var div = addDiv(t);
-
-  // Set up pending transition
-  div.style.marginLeft = '0px';
-  getComputedStyle(div).marginLeft;
-  div.style.transition = 'margin-left 100s';
-  div.style.marginLeft = '100px';
-  getComputedStyle(div).marginLeft;
-
-  var animation = div.getAnimations()[0];
-  assert_true(animation.pending, 'Animation is initially pending');
-
-  // Set up listeners on ready promise
-  animation.ready.then(t.step_func(function() {
-    assert_unreached('ready promise was fulfilled');
-  })).catch(t.step_func(function(err) {
-    assert_equals(err.name, 'AbortError',
-                  'ready promise is rejected with AbortError');
-    assert_equals(animation.playState, 'idle',
-                  'Animation is idle after transition was cancelled');
-  })).then(t.step_func(function() {
-    t.done();
-  }));
-
-  // Now update the transition to animate to something not-interpolable
-  div.style.marginLeft = 'auto';
-  getComputedStyle(div).marginLeft;
-
-}, 'ready promise is rejected when a transition is cancelled by changing'
-   + ' the transition property to something not interpolable');
-
-</script>
-</body>
diff --git a/LayoutTests/imported/mozilla/css-transitions/test_animation-starttime-expected.txt b/LayoutTests/imported/mozilla/css-transitions/test_animation-starttime-expected.txt
deleted file mode 100644 (file)
index 596f313..0000000
+++ /dev/null
@@ -1,8 +0,0 @@
-
-PASS startTime of a newly created transition is unresolved 
-PASS Sanity test to check round-tripping assigning to new animation's startTime 
-PASS Skipping forward through animation 
-PASS Skipping backwards through transition 
-PASS Setting startTime to null 
-PASS Animation.startTime after paused 
-
diff --git a/LayoutTests/imported/mozilla/css-transitions/test_animation-starttime.html b/LayoutTests/imported/mozilla/css-transitions/test_animation-starttime.html
deleted file mode 100644 (file)
index ba4e0d2..0000000
+++ /dev/null
@@ -1,286 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <meta charset=utf-8>
-    <title>Tests for the effect of setting a CSS transition's
-           Animation.startTime</title>
-    <style>
-
-.animated-div {
-  margin-left: 100px;
-  transition: margin-left 1000s linear 1000s;
-}
-
-    </style>
-    <script src="../../../resources/testharness.js"></script>
-    <script src="../../../resources/testharnessreport.js"></script>
-    <script src="../resources/testcommon.js"></script>
-  </head>
-  <body>
-    <div id="log"></div>
-    <script type="text/javascript">
-
-'use strict';
-
-// TODO: Once the computedTiming property is implemented, add checks to the
-// checker helpers to ensure that computedTiming's properties are updated as
-// expected.
-// See https://bugzilla.mozilla.org/show_bug.cgi?id=1108055
-
-
-const ANIM_DELAY_MS = 1000000; // 1000s
-const ANIM_DUR_MS = 1000000; // 1000s
-
-/**
- * These helpers get the value that the startTime needs to be set to, to put an
- * animation that uses the above ANIM_DELAY_MS and ANIM_DUR_MS values into the
- * middle of various phases or points through the active duration.
- */
-function startTimeForBeforePhase(timeline) {
-  return timeline.currentTime - ANIM_DELAY_MS / 2;
-}
-function startTimeForActivePhase(timeline) {
-  return timeline.currentTime - ANIM_DELAY_MS - ANIM_DUR_MS / 2;
-}
-function startTimeForAfterPhase(timeline) {
-  return timeline.currentTime - ANIM_DELAY_MS - ANIM_DUR_MS - ANIM_DELAY_MS / 2;
-}
-function startTimeForStartOfActiveInterval(timeline) {
-  return timeline.currentTime - ANIM_DELAY_MS;
-}
-function startTimeForFiftyPercentThroughActiveInterval(timeline) {
-  return timeline.currentTime - ANIM_DELAY_MS - ANIM_DUR_MS * 0.5;
-}
-function startTimeForEndOfActiveInterval(timeline) {
-  return timeline.currentTime - ANIM_DELAY_MS - ANIM_DUR_MS;
-}
-
-
-// Expected computed 'margin-left' values at points during the active interval:
-// When we assert_between_inclusive using these values we could in theory cause
-// intermittent failure due to very long delays between paints, but since the
-// active duration is 1000s long, a delay would need to be around 100s to cause
-// that. If that's happening then there are likely other issues that should be
-// fixed, so a failure to make us look into that seems like a good thing.
-const INITIAL_POSITION = 100;
-const TEN_PCT_POSITION = 110;
-const FIFTY_PCT_POSITION = 150;
-const END_POSITION = 200;
-
-// The terms used for the naming of the following helper functions refer to
-// terms used in the Web Animations specification for specific phases of an
-// animation. The terms can be found here:
-//
-//   https://drafts.csswg.org/web-animations/#animation-effect-phases-and-states
-//
-// Note the distinction between the "animation start time" which occurs before
-// the start delay and the start of the active interval which occurs after it.
-
-// Called when the ready Promise's callbacks should happen
-function checkStateOnReadyPromiseResolved(animation)
-{
-  assert_less_than_equal(animation.startTime, animation.timeline.currentTime,
-    'Animation.startTime should be less than the timeline\'s ' +
-    'currentTime on the first paint tick after animation creation');
-
-  assert_equals(animation.playState, 'running',
-    'Animation.playState should be "running" on the first paint ' +
-    'tick after animation creation');
-
-  var div = animation.effect.target;
-  var marginLeft = parseFloat(getComputedStyle(div).marginLeft);
-  assert_equals(marginLeft, INITIAL_POSITION,
-                'the computed value of margin-left should be unaffected ' +
-                'by an animation with a delay on ready Promise resolve');
-}
-
-// Called when startTime is set to the time the active interval starts.
-function checkStateAtActiveIntervalStartTime(animation)
-{
-  // We don't test animation.startTime since our caller just set it.
-
-  assert_equals(animation.playState, 'running',
-    'Animation.playState should be "running" at the start of ' +
-    'the active interval');
-
-  var div = animation.effect.target;
-  var marginLeft = parseFloat(getComputedStyle(div).marginLeft);
-  assert_between_inclusive(marginLeft, INITIAL_POSITION, TEN_PCT_POSITION,
-    'the computed value of margin-left should be close to the value at the ' +
-    'beginning of the animation');
-}
-
-function checkStateAtFiftyPctOfActiveInterval(animation)
-{
-  // We don't test animation.startTime since our caller just set it.
-
-  var div = animation.effect.target;
-  var marginLeft = parseFloat(getComputedStyle(div).marginLeft);
-  assert_equals(marginLeft, FIFTY_PCT_POSITION,
-    'the computed value of margin-left should be half way through the ' +
-    'animation at the midpoint of the active interval');
-}
-
-// Called when startTime is set to the time the active interval ends.
-function checkStateAtActiveIntervalEndTime(animation)
-{
-  // We don't test animation.startTime since our caller just set it.
-
-  assert_equals(animation.playState, 'finished',
-    'Animation.playState should be "finished" at the end of ' +
-    'the active interval');
-
-  var div = animation.effect.target;
-  var marginLeft = parseFloat(getComputedStyle(div).marginLeft);
-  assert_equals(marginLeft, END_POSITION,
-    'the computed value of margin-left should be the final transitioned-to ' +
-    'value at the end of the active duration');
-}
-
-test(function(t)
-{
-  var div = addDiv(t, {'class': 'animated-div'});
-  flushComputedStyle(div);
-  div.style.marginLeft = '200px'; // initiate transition
-
-  var animation = div.getAnimations()[0];
-  assert_equals(animation.startTime, null, 'startTime is unresolved');
-}, 'startTime of a newly created transition is unresolved');
-
-
-test(function(t)
-{
-  var div = addDiv(t, {'class': 'animated-div'});
-  flushComputedStyle(div);
-  div.style.marginLeft = '200px'; // initiate transition
-
-  var animation = div.getAnimations()[0];
-  var currentTime = animation.timeline.currentTime;
-  animation.startTime = currentTime;
-  assert_times_equal(animation.startTime, currentTime,
-    'Check setting of startTime actually works');
-}, 'Sanity test to check round-tripping assigning to new animation\'s ' +
-   'startTime');
-
-
-async_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  var eventWatcher = new EventWatcher(t, div, 'transitionend');
-
-  flushComputedStyle(div);
-  div.style.marginLeft = '200px'; // initiate transition
-
-  var animation = div.getAnimations()[0];
-
-  animation.ready.then(t.step_func(function() {
-    checkStateOnReadyPromiseResolved(animation);
-
-    animation.startTime = startTimeForStartOfActiveInterval(animation.timeline);
-    checkStateAtActiveIntervalStartTime(animation);
-
-    animation.startTime =
-      startTimeForFiftyPercentThroughActiveInterval(animation.timeline);
-    checkStateAtFiftyPctOfActiveInterval(animation);
-
-    animation.startTime = startTimeForEndOfActiveInterval(animation.timeline);
-    return eventWatcher.wait_for('transitionend');
-  })).then(t.step_func(function() {
-    checkStateAtActiveIntervalEndTime(animation);
-  })).catch(t.step_func(function(reason) {
-    assert_unreached(reason);
-  })).then(function() {
-    t.done();
-  });
-}, 'Skipping forward through animation');
-
-
-test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-  var eventWatcher = new EventWatcher(t, div, 'transitionend');
-
-  flushComputedStyle(div);
-  div.style.marginLeft = '200px'; // initiate transition
-
-  var animation = div.getAnimations()[0];
-
-  // Unlike in the case of CSS animations, we cannot skip to the end and skip
-  // backwards since when we reach the end the transition effect is removed and
-  // changes to the Animation object no longer affect the element. For
-  // this reason we only skip forwards as far as the 90% through point.
-
-  animation.startTime =
-    startTimeForFiftyPercentThroughActiveInterval(animation.timeline);
-  checkStateAtFiftyPctOfActiveInterval(animation);
-
-  animation.startTime = startTimeForStartOfActiveInterval(animation.timeline);
-
-  // Despite going backwards from being in the active interval to being before
-  // it, we now expect an 'animationend' event because the animation should go
-  // from being active to inactive.
-  //
-  // Calling checkStateAtActiveIntervalStartTime will check computed style,
-  // causing computed style to be updated and the 'transitionend' event to
-  // be dispatched synchronously. We need to call waitForEvent first
-  // otherwise eventWatcher will assert that the event was unexpected.
-  eventWatcher.wait_for('transitionend').then(function() {
-    t.done();
-  });
-  checkStateAtActiveIntervalStartTime(animation);
-}, 'Skipping backwards through transition');
-
-
-async_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-
-  flushComputedStyle(div);
-  div.style.marginLeft = '200px'; // initiate transition
-
-  var animation = div.getAnimations()[0];
-
-  var storedCurrentTime;
-
-  animation.ready.then(t.step_func(function() {
-    storedCurrentTime = animation.currentTime;
-    animation.startTime = null;
-    return animation.ready;
-  })).catch(t.step_func(function(reason) {
-    assert_unreached(reason);
-  })).then(t.step_func(function() {
-    assert_equals(animation.currentTime, storedCurrentTime,
-      'Test that hold time is correct');
-    t.done();
-  }));
-}, 'Setting startTime to null');
-
-
-async_test(function(t) {
-  var div = addDiv(t, {'class': 'animated-div'});
-
-  flushComputedStyle(div);
-  div.style.marginLeft = '200px'; // initiate transition
-
-  var animation = div.getAnimations()[0];
-
-  animation.ready.then(t.step_func(function() {
-    var savedStartTime = animation.startTime;
-
-    assert_not_equals(animation.startTime, null,
-      'Animation.startTime not null on ready Promise resolve');
-
-    animation.pause();
-    return animation.ready;
-  })).then(t.step_func(function() {
-    assert_equals(animation.startTime, null,
-      'Animation.startTime is null after paused');
-    assert_equals(animation.playState, 'paused',
-      'Animation.playState is "paused" after pause() call');
-  })).catch(t.step_func(function(reason) {
-    assert_unreached(reason);
-  })).then(function() {
-    t.done();
-  });
-}, 'Animation.startTime after paused');
-
-    </script>
-  </body>
-</html>
diff --git a/LayoutTests/imported/mozilla/css-transitions/test_csstransition-transitionproperty.html b/LayoutTests/imported/mozilla/css-transitions/test_csstransition-transitionproperty.html
deleted file mode 100644 (file)
index 9aa2ede..0000000
+++ /dev/null
@@ -1,26 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<body>
-<div id="log"></div>
-<script>
-'use strict';
-
-test(function(t) {
-  var div = addDiv(t);
-
-  // Add a transition
-  div.style.left = '0px';
-  getComputedStyle(div).transitionProperty;
-  div.style.transition = 'all 100s';
-  div.style.left = '100px';
-
-  assert_equals(div.getAnimations()[0].transitionProperty, 'left',
-                'The transitionProperty for the corresponds to the specific ' +
-                'property being transitioned');
-}, 'CSSTransition.transitionProperty');
-
-</script>
-</body>
diff --git a/LayoutTests/imported/mozilla/css-transitions/test_document-get-animations-expected.txt b/LayoutTests/imported/mozilla/css-transitions/test_document-get-animations-expected.txt
deleted file mode 100644 (file)
index fd2bf55..0000000
+++ /dev/null
@@ -1,6 +0,0 @@
-
-PASS getAnimations for non-animated content 
-PASS getAnimations for CSS Transitions 
-PASS CSS Transitions targetting (pseudo-)elements should have correct order after sorting 
-PASS Transitions are not returned after they have finished 
-
diff --git a/LayoutTests/imported/mozilla/css-transitions/test_document-get-animations.html b/LayoutTests/imported/mozilla/css-transitions/test_document-get-animations.html
deleted file mode 100644 (file)
index 7cc63e5..0000000
+++ /dev/null
@@ -1,95 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<body>
-<div id="log"></div>
-<script>
-'use strict';
-
-test(function(t) {
-  assert_equals(document.getAnimations().length, 0,
-    'getAnimations returns an empty sequence for a document'
-    + ' with no animations');
-}, 'getAnimations for non-animated content');
-
-test(function(t) {
-  var div = addDiv(t);
-
-  // Add a couple of transitions
-  div.style.left = '0px';
-  div.style.top = '0px';
-  getComputedStyle(div).transitionProperty;
-
-  div.style.transition = 'all 100s';
-  div.style.left = '100px';
-  div.style.top = '100px';
-  assert_equals(document.getAnimations().length, 2,
-                'getAnimations returns two running CSS Transitions');
-
-  // Remove both
-  div.style.transitionProperty = 'none';
-  assert_equals(document.getAnimations().length, 0,
-                'getAnimations returns no running CSS Transitions');
-}, 'getAnimations for CSS Transitions');
-
-test(function(t) {
-  addStyle(t, { '.init::after': 'content: ""; width: 0px; ' +
-                                'transition: all 100s;',
-                '.init::before': 'content: ""; height: 0px; ' +
-                                 'transition: all 10s;',
-                '.change::after': 'width: 100px;',
-                '.change::before': 'height: 100px;' });
-  // create two divs with these arrangement:
-  //       parent
-  //     ::before,
-  //     ::after
-  //        |
-  //       child
-  var parent = addDiv(t);
-  var child = addDiv(t);
-  parent.appendChild(child);
-
-  parent.style.left = '0px';
-  parent.style.transition = 'left 10s';
-  parent.classList.add('init');
-  child.style.left = '0px';
-  child.style.transition = 'left 10s';
-  flushComputedStyle(parent);
-
-  parent.style.left = '100px';
-  parent.classList.add('change');
-  child.style.left = '100px';
-
-  var anims = document.getAnimations();
-  assert_equals(anims.length, 4,
-                'CSS transition on both pseudo-elements and elements ' +
-                'are returned');
-  assert_equals(anims[0].effect.target, parent,
-                'The animation targeting the parent element comes first');
-  assert_equals(anims[1].transitionProperty, 'height',
-                'The animation targeting the ::before element comes second');
-  assert_equals(anims[2].transitionProperty, 'width',
-                'The animation targeting the ::after element comes third');
-  assert_equals(anims[3].effect.target, child,
-                'The animation targeting the child element comes last');
-}, 'CSS Transitions targetting (pseudo-)elements should have correct order ' +
-   'after sorting');
-
-async_test(function(t) {
-  var div = addDiv(t, { style: 'left: 0px; transition: all 50ms' });
-  flushComputedStyle(div);
-
-  div.style.left = '100px';
-  var animations = div.getAnimations();
-  assert_equals(animations.length, 1, 'Got transition');
-  animations[0].finished.then(t.step_func(function() {
-    assert_equals(document.getAnimations().length, 0,
-                  'No animations returned');
-    t.done();
-  }));
-}, 'Transitions are not returned after they have finished');
-
-</script>
-</body>
diff --git a/LayoutTests/imported/mozilla/css-transitions/test_element-get-animations-expected.txt b/LayoutTests/imported/mozilla/css-transitions/test_element-get-animations-expected.txt
deleted file mode 100644 (file)
index 0ce5344..0000000
+++ /dev/null
@@ -1,9 +0,0 @@
-
-PASS getAnimations for CSS Transitions 
-PASS getAnimations returns CSSTransition objects for CSS Transitions 
-PASS getAnimations for CSS Transitions that have finished 
-PASS getAnimations for transition on non-animatable property 
-PASS getAnimations for transition on unsupported property 
-PASS getAnimations sorts simultaneous transitions by name 
-PASS getAnimations sorts transitions by when they were generated 
-
diff --git a/LayoutTests/imported/mozilla/css-transitions/test_element-get-animations.html b/LayoutTests/imported/mozilla/css-transitions/test_element-get-animations.html
deleted file mode 100644 (file)
index cb60096..0000000
+++ /dev/null
@@ -1,149 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<body>
-<div id="log"></div>
-<script>
-'use strict';
-
-async_test(function(t) {
-  var div = addDiv(t);
-
-  // FIXME: This test does too many things. It should be split up.
-
-  // Add a couple of transitions
-  div.style.left = '0px';
-  div.style.top = '0px';
-  getComputedStyle(div).transitionProperty;
-
-  div.style.transition = 'all 100s';
-  div.style.left = '100px';
-  div.style.top = '100px';
-
-  var animations = div.getAnimations();
-  assert_equals(animations.length, 2,
-    'getAnimations() returns one Animation per transitioning property');
-  waitForAllAnimations(animations).then(t.step_func(function() {
-    var startTime = animations[0].startTime;
-    assert_true(startTime > 0 && startTime <= document.timeline.currentTime,
-                'CSS transitions have sensible start times');
-    assert_equals(animations[0].startTime, animations[1].startTime,
-      'CSS transitions started together have the same start time');
-    // Wait a moment then add a third transition
-    return waitForFrame();
-  })).then(t.step_func(function() {
-    div.style.backgroundColor = 'green';
-    animations = div.getAnimations();
-    assert_equals(animations.length, 3,
-      'getAnimations returns Animations for all running CSS Transitions');
-    return waitForAllAnimations(animations);
-  })).then(t.step_func(function() {
-    assert_less_than(animations[1].startTime, animations[2].startTime,
-      'Animation for additional CSS transition starts after the original'
-      + ' transitions and appears later in the list');
-    t.done();
-  }));
-}, 'getAnimations for CSS Transitions');
-
-test(function(t) {
-  var div = addDiv(t, { style: 'left: 0px; transition: all 100s' });
-
-  flushComputedStyle(div);
-  div.style.left = '100px';
-
-  assert_class_string(div.getAnimations()[0], 'CSSTransition',
-                      'Interface of returned animation is CSSTransition');
-}, 'getAnimations returns CSSTransition objects for CSS Transitions');
-
-async_test(function(t) {
-  var div = addDiv(t);
-
-  // Set up event listener
-  div.addEventListener('transitionend', t.step_func(function() {
-    assert_equals(div.getAnimations().length, 0,
-      'getAnimations does not return finished CSS Transitions');
-    t.done();
-  }));
-
-  // Add a very short transition
-  div.style.left = '0px';
-  getComputedStyle(div).left;
-
-  div.style.transition = 'all 0.01s';
-  div.style.left = '100px';
-  getComputedStyle(div).left;
-}, 'getAnimations for CSS Transitions that have finished');
-
-test(function(t) {
-  var div = addDiv(t);
-
-  // Try to transition non-animatable property animation-duration
-  div.style.animationDuration = '10s';
-  getComputedStyle(div).animationDuration;
-
-  div.style.transition = 'all 100s';
-  div.style.animationDuration = '100s';
-
-  assert_equals(div.getAnimations().length, 0,
-    'getAnimations returns an empty sequence for a transition'
-    + ' of a non-animatable property');
-}, 'getAnimations for transition on non-animatable property');
-
-test(function(t) {
-  var div = addDiv(t);
-
-  div.style.setProperty('-vendor-unsupported', '0px', '');
-  getComputedStyle(div).transitionProperty;
-  div.style.transition = 'all 100s';
-  div.style.setProperty('-vendor-unsupported', '100px', '');
-
-  assert_equals(div.getAnimations().length, 0,
-    'getAnimations returns an empty sequence for a transition'
-    + ' of an unsupported property');
-}, 'getAnimations for transition on unsupported property');
-
-test(function(t) {
-  var div = addDiv(t, { style: 'transform: translate(0px); ' +
-                               'opacity: 0; ' +
-                               'border-width: 0px; ' + // Shorthand
-                               'border-style: solid' });
-  getComputedStyle(div).transform;
-
-  div.style.transition = 'all 100s';
-  div.style.transform = 'translate(100px)';
-  div.style.opacity = '1';
-  div.style.borderWidth = '1px';
-
-  var animations = div.getAnimations();
-  assert_equals(animations.length, 6,
-                'Generated expected number of transitions');
-  assert_equals(animations[0].transitionProperty, 'border-bottom-width');
-  assert_equals(animations[1].transitionProperty, 'border-left-width');
-  assert_equals(animations[2].transitionProperty, 'border-right-width');
-  assert_equals(animations[3].transitionProperty, 'border-top-width');
-  assert_equals(animations[4].transitionProperty, 'opacity');
-  assert_equals(animations[5].transitionProperty, 'transform');
-}, 'getAnimations sorts simultaneous transitions by name');
-
-test(function(t) {
-  var div = addDiv(t, { style: 'transform: translate(0px); ' +
-                               'opacity: 0' });
-  getComputedStyle(div).transform;
-
-  div.style.transition = 'all 100s';
-  div.style.transform = 'translate(100px)';
-  assert_equals(div.getAnimations().length, 1,
-                'Initially there is only one (transform) transition');
-  div.style.opacity = '1';
-  assert_equals(div.getAnimations().length, 2,
-                'Then a second (opacity) transition is added');
-
-  var animations = div.getAnimations();
-  assert_equals(animations[0].transitionProperty, 'transform');
-  assert_equals(animations[1].transitionProperty, 'opacity');
-}, 'getAnimations sorts transitions by when they were generated');
-
-</script>
-</body>
diff --git a/LayoutTests/imported/mozilla/css-transitions/test_event-dispatch.html b/LayoutTests/imported/mozilla/css-transitions/test_event-dispatch.html
deleted file mode 100644 (file)
index eed71cc..0000000
+++ /dev/null
@@ -1,477 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<title>Tests for CSS-Transition events</title>
-<link rel="help" href="https://drafts.csswg.org/css-transitions-2/#transition-events">
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<body>
-<div id="log"></div>
-<script>
-'use strict';
-
-/**
- * Helper class to record the elapsedTime member of each event.
- * The EventWatcher class in testharness.js allows us to wait on
- * multiple events in a certain order but only records the event
- * parameters of the most recent event.
- */
-function TransitionEventHandler(target) {
-  this.target = target;
-  this.target.ontransitionrun = evt => {
-    this.transitionrun = evt.elapsedTime;
-  };
-  this.target.ontransitionstart = evt => {
-    this.transitionstart = evt.elapsedTime;
-  };
-  this.target.ontransitionend = evt => {
-    this.transitionend = evt.elapsedTime;
-  };
-  this.target.ontransitioncancel = evt => {
-    this.transitioncancel = evt.elapsedTime;
-  };
-}
-
-TransitionEventHandler.prototype.clear = () => {
-  this.transitionrun    = undefined;
-  this.transitionstart  = undefined;
-  this.transitionend    = undefined;
-  this.transitioncancel = undefined;
-};
-
-function setupTransition(t, transitionStyle) {
-  const div = addDiv(t, { style: 'transition: ' + transitionStyle });
-  // Note that this TransitionEventHandler should be created before EventWatcher
-  // to capture all events in the handler prior to the EventWatcher since
-  // testharness.js proceeds when the EventWatcher received watching events.
-  const handler = new TransitionEventHandler(div);
-  const watcher = new EventWatcher(t, div, [ 'transitionrun',
-                                           'transitionstart',
-                                           'transitionend',
-                                           'transitioncancel' ]);
-  flushComputedStyle(div);
-
-  div.style.marginLeft = '100px';
-  const transition = div.getAnimations()[0];
-
-  return { transition, watcher, div, handler };
-}
-
-// On the next frame (i.e. when events are queued), whether or not the
-// transition is still pending depends on the implementation.
-promise_test(t => {
-  const { transition, watcher } =
-    setupTransition(t, 'margin-left 100s 100s');
-  return watcher.wait_for('transitionrun').then(evt => {
-    assert_equals(evt.elapsedTime, 0.0);
-  });
-}, 'Idle -> Pending or Before');
-
-promise_test(t => {
-  const { transition, watcher } =
-    setupTransition(t, 'margin-left 100s 100s');
-  // Force the transition to leave the idle phase
-  transition.startTime = document.timeline.currentTime;
-  return watcher.wait_for('transitionrun').then(evt => {
-    assert_equals(evt.elapsedTime, 0.0);
-  });
-}, 'Idle -> Before');
-
-promise_test(t => {
-  const { transition, watcher, div, handler } =
-    setupTransition(t, 'margin-left 100s 100s');
-
-  // Seek to Active phase.
-  transition.currentTime = 100 * MS_PER_SEC;
-  // transition.pause();
-  return watcher.wait_for([ 'transitionrun',
-                            'transitionstart' ]).then(evt => {
-    assert_equals(handler.transitionrun, 0.0);
-    assert_equals(handler.transitionstart, 0.0);
-  });
-}, 'Idle or Pending -> Active');
-
-promise_test(t => {
-  const { transition, watcher, div, handler } =
-    setupTransition(t, 'margin-left 100s 100s');
-
-  // Seek to After phase.
-  transition.finish();
-  return watcher.wait_for([ 'transitionrun',
-                            'transitionstart',
-                            'transitionend' ]).then(evt => {
-    assert_equals(handler.transitionrun, 0.0);
-    assert_equals(handler.transitionstart, 0.0);
-    assert_equals(handler.transitionend, 100.0);
-  });
-}, 'Idle or Pending -> After');
-
-// Timeout
-promise_test(t => {
-  const { transition, watcher, div } =
-    setupTransition(t, 'margin-left 100s 100s');
-
-  return Promise.all([ watcher.wait_for('transitionrun'),
-                       transition.ready ]).then(() => {
-    // Make idle
-    div.style.display = 'none';
-    flushComputedStyle(div);
-    return watcher.wait_for('transitioncancel');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 0.0);
-  });
-}, 'Before -> Idle (display: none)');
-
-promise_test(t => {
-  const { transition, watcher } =
-    setupTransition(t, 'margin-left 100s 100s');
-
-  return Promise.all([ watcher.wait_for('transitionrun'),
-                       transition.ready ]).then(() => {
-    // Make idle
-    transition.timeline = null;
-    return watcher.wait_for('transitioncancel');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 0.0);
-  });
-}, 'Before -> Idle (Animation.timeline = null)');
-
-promise_test(t => {
-  const { transition, watcher } =
-    setupTransition(t, 'margin-left 100s 100s');
-
-  return Promise.all([ watcher.wait_for('transitionrun'),
-                       transition.ready ]).then(() => {
-    transition.currentTime = 100 * MS_PER_SEC;
-    return watcher.wait_for('transitionstart');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 0.0);
-  });
-}, 'Before -> Active');
-
-promise_test(t => {
-  const { transition, watcher, div, handler } =
-    setupTransition(t, 'margin-left 100s 100s');
-
-  return Promise.all([ watcher.wait_for('transitionrun'),
-                       transition.ready ]).then(() => {
-    // Seek to After phase.
-    transition.currentTime = 200 * MS_PER_SEC;
-    return watcher.wait_for([ 'transitionstart', 'transitionend' ]);
-  }).then(evt => {
-    assert_equals(handler.transitionstart, 0.0);
-    assert_equals(handler.transitionend, 100.0);
-  });
-}, 'Before -> After');
-
-promise_test(t => {
-  const { transition, watcher, div } =
-    setupTransition(t, 'margin-left 100s');
-
-  // Seek to Active start position.
-  transition.pause();
-  return watcher.wait_for([ 'transitionrun',
-                            'transitionstart' ]).then(evt => {
-    // Make idle
-    div.style.display = 'none';
-    flushComputedStyle(div);
-    return watcher.wait_for('transitioncancel');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 0.0);
-  });
-}, 'Active -> Idle, no delay (display: none)');
-
-promise_test(t => {
-  const { transition, watcher } =
-    setupTransition(t, 'margin-left 100s');
-
-  return watcher.wait_for([ 'transitionrun',
-                            'transitionstart' ]).then(evt => {
-    // Make idle
-    transition.currentTime = 0;
-    transition.timeline = null;
-    return watcher.wait_for('transitioncancel');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 0.0);
-  });
-}, 'Active -> Idle, no delay (Animation.timeline = null)');
-
-promise_test(t => {
-  const { transition, watcher, div } =
-    setupTransition(t, 'margin-left 100s 100s');
-  // Pause so the currentTime is fixed and we can accurately compare the event
-  // time in transition cancel events.
-  transition.pause();
-
-  // Seek to Active phase.
-  transition.currentTime = 100 * MS_PER_SEC;
-  return watcher.wait_for([ 'transitionrun',
-                            'transitionstart' ]).then(evt => {
-    // Make idle
-    div.style.display = 'none';
-    flushComputedStyle(div);
-    return watcher.wait_for('transitioncancel');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 0.0);
-  });
-}, 'Active -> Idle, with positive delay (display: none)');
-
-promise_test(t => {
-  const { transition, watcher } =
-    setupTransition(t, 'margin-left 100s 100s');
-
-  // Seek to Active phase.
-  transition.currentTime = 100 * MS_PER_SEC;
-  return watcher.wait_for([ 'transitionrun',
-                            'transitionstart' ]).then(evt => {
-    // Make idle
-    transition.currentTime = 100 * MS_PER_SEC;
-    transition.timeline = null;
-    return watcher.wait_for('transitioncancel');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 0.0);
-  });
-}, 'Active -> Idle, with positive delay (Animation.timeline = null)');
-
-promise_test(t => {
-  const { transition, watcher, div } =
-    setupTransition(t, 'margin-left 100s -50s');
-
-  // Pause so the currentTime is fixed and we can accurately compare the event
-  // time in transition cancel events.
-  transition.pause();
-
-  return watcher.wait_for([ 'transitionrun',
-                            'transitionstart' ]).then(evt => {
-    // Make idle
-    div.style.display = 'none';
-    flushComputedStyle(div);
-    return watcher.wait_for('transitioncancel');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 50.0);
-  });
-}, 'Active -> Idle, with negative delay (display: none)');
-
-promise_test(t => {
-  const { transition, watcher } =
-    setupTransition(t, 'margin-left 100s -50s');
-
-  return watcher.wait_for([ 'transitionrun',
-                            'transitionstart' ]).then(evt => {
-    // Make idle
-    transition.currentTime = 50 * MS_PER_SEC;
-    transition.timeline = null;
-    return watcher.wait_for('transitioncancel');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 0.0);
-  });
-}, 'Active -> Idle, with negative delay (Animation.timeline = null)');
-
-promise_test(t => {
-  const { transition, watcher } =
-    setupTransition(t, 'margin-left 100s 100s');
-  // Seek to Active phase.
-  transition.currentTime = 100 * MS_PER_SEC;
-  return watcher.wait_for([ 'transitionrun',
-                            'transitionstart' ]).then(evt => {
-    // Seek to Before phase.
-    transition.currentTime = 0;
-    return watcher.wait_for('transitionend');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 0.0);
-  });
-}, 'Active -> Before');
-
-promise_test(t => {
-  const { transition, watcher } =
-    setupTransition(t, 'margin-left 100s 100s');
-  // Seek to Active phase.
-  transition.currentTime = 100 * MS_PER_SEC;
-  return watcher.wait_for([ 'transitionrun',
-                            'transitionstart' ]).then(evt => {
-    // Seek to After phase.
-    transition.currentTime = 200 * MS_PER_SEC;
-    return watcher.wait_for('transitionend');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 100.0);
-  });
-}, 'Active -> After');
-
-promise_test(t => {
-  const { transition, watcher, div, handler } =
-    setupTransition(t, 'margin-left 100s 100s');
-
-  // Seek to After phase.
-  transition.finish();
-  return watcher.wait_for([ 'transitionrun',
-                            'transitionstart',
-                            'transitionend' ]).then(evt => {
-    // Seek to Before phase.
-    transition.currentTime = 0;
-    return watcher.wait_for([ 'transitionstart', 'transitionend' ]);
-  }).then(evt => {
-    assert_equals(handler.transitionstart, 100.0);
-    assert_equals(handler.transitionend, 0.0);
-  });
-}, 'After -> Before');
-
-promise_test(t => {
-  const { transition, watcher } =
-    setupTransition(t, 'margin-left 100s 100s');
-  // Seek to After phase.
-  transition.finish();
-  return watcher.wait_for([ 'transitionrun',
-                            'transitionstart',
-                            'transitionend' ]).then(evt => {
-    // Seek to Active phase.
-    transition.currentTime = 100 * MS_PER_SEC;
-    return watcher.wait_for('transitionstart');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 100.0);
-  });
-}, 'After -> Active');
-
-promise_test(t => {
-  const { transition, watcher, div, handler } =
-    setupTransition(t, 'margin-left 100s -50s');
-
-  return watcher.wait_for([ 'transitionrun',
-                            'transitionstart' ]).then(() => {
-    assert_equals(handler.transitionrun, 50.0);
-    assert_equals(handler.transitionstart, 50.0);
-    transition.finish();
-    return watcher.wait_for('transitionend');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 100.0);
-  });
-}, 'Calculating the interval start and end time with negative start delay.');
-
-promise_test(t => {
-  const { transition, watcher, div, handler } =
-    setupTransition(t, 'margin-left 100s 100s');
-
-  return watcher.wait_for('transitionrun').then(evt => {
-    // We can't set the end delay via generated effect timing.
-    // Because CSS-Transition use the AnimationEffectTimingReadOnly.
-    transition.effect = new KeyframeEffect(div,
-                                           { marginleft: [ '0px', '100px' ]},
-                                           { duration: 100 * MS_PER_SEC,
-                                             endDelay: -50 * MS_PER_SEC });
-    // Seek to Before and play.
-    transition.cancel();
-    transition.play();
-    return watcher.wait_for([ 'transitioncancel',
-                              'transitionrun',
-                              'transitionstart' ]);
-  }).then(() => {
-    assert_equals(handler.transitionstart, 0.0);
-
-    // Seek to After phase.
-    transition.finish();
-    return watcher.wait_for('transitionend');
-  }).then(evt => {
-    assert_equals(evt.elapsedTime, 50.0);
-  });
-}, 'Calculating the interval start and end time with negative end delay.');
-
-promise_test(t => {
-  const { transition, watcher, div } =
-    setupTransition(t, 'margin-left 100s 100s');
-
-  return watcher.wait_for('transitionrun').then(() => {
-    // Make idle
-    div.style.display = 'none';
-    flushComputedStyle(div);
-    return watcher.wait_for('transitioncancel');
-  }).then(() => {
-    transition.cancel();
-    // Then wait a couple of frames and check that no event was dispatched
-    return waitForAnimationFrames(2);
-  });
-}, 'Call Animation.cancel after cancelling transition.');
-
-promise_test(t => {
-  const { transition, watcher, div } =
-    setupTransition(t, 'margin-left 100s 100s');
-
-  return watcher.wait_for('transitionrun').then(evt => {
-    // Make idle
-    div.style.display = 'none';
-    flushComputedStyle(div);
-    transition.play();
-    watcher.wait_for([ 'transitioncancel',
-                       'transitionrun',
-                       'transitionstart' ]);
-  });
-}, 'Restart transition after cancelling transition immediately');
-
-promise_test(t => {
-  const { transition, watcher, div } =
-    setupTransition(t, 'margin-left 100s 100s');
-
-  return watcher.wait_for('transitionrun').then(evt => {
-    // Make idle
-    div.style.display = 'none';
-    flushComputedStyle(div);
-    transition.play();
-    transition.cancel();
-    return watcher.wait_for('transitioncancel');
-  }).then(evt => {
-    // Then wait a couple of frames and check that no event was dispatched
-    return waitForAnimationFrames(2);
-  });
-}, 'Call Animation.cancel after restarting transition immediately');
-
-promise_test(t => {
-  const { transition, watcher } =
-    setupTransition(t, 'margin-left 100s');
-
-  return watcher.wait_for([ 'transitionrun',
-                            'transitionstart' ]).then(evt => {
-    // Make idle
-    transition.timeline = null;
-    return watcher.wait_for('transitioncancel');
-  }).then(evt => {
-    transition.timeline = document.timeline;
-    transition.play();
-
-    return watcher.wait_for(['transitionrun', 'transitionstart']);
-  });
-}, 'Set timeline and play transition after clear the timeline');
-
-promise_test(t => {
-  const { transition, watcher, div } =
-    setupTransition(t, 'margin-left 100s');
-
-  return watcher.wait_for([ 'transitionrun',
-                            'transitionstart' ]).then(() => {
-    transition.cancel();
-    return watcher.wait_for('transitioncancel');
-  }).then(() => {
-    // Make After phase
-    transition.effect = null;
-
-    // Then wait a couple of frames and check that no event was dispatched
-    return waitForAnimationFrames(2);
-  });
-}, 'Set null target effect after cancel the transition');
-
-promise_test(t => {
-  const { transition, watcher, div } =
-    setupTransition(t, 'margin-left 100s');
-
-  return watcher.wait_for([ 'transitionrun',
-                            'transitionstart' ]).then(evt => {
-    transition.effect = null;
-    return watcher.wait_for('transitionend');
-  }).then(evt => {
-    transition.cancel();
-
-    // Then wait a couple of frames and check that no event was dispatched
-    return waitForAnimationFrames(2);
-  });
-}, 'Cancel the transition after clearing the target effect');
-
-</script>
-</body>
-</html>
diff --git a/LayoutTests/imported/mozilla/css-transitions/test_keyframeeffect-getkeyframes-expected.txt b/LayoutTests/imported/mozilla/css-transitions/test_keyframeeffect-getkeyframes-expected.txt
deleted file mode 100644 (file)
index 56c05ac..0000000
+++ /dev/null
@@ -1,5 +0,0 @@
-
-PASS KeyframeEffect.getKeyframes() returns expected frames for a simple transition 
-PASS KeyframeEffect.getKeyframes() returns expected frames for a simple transition with a non-default easing function 
-PASS KeyframeEffect.getKeyframes() returns expected frames for a transition with a CSS variable endpoint 
-
diff --git a/LayoutTests/imported/mozilla/css-transitions/test_keyframeeffect-getkeyframes.html b/LayoutTests/imported/mozilla/css-transitions/test_keyframeeffect-getkeyframes.html
deleted file mode 100644 (file)
index 58d98da..0000000
+++ /dev/null
@@ -1,103 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<style>
-:root {
-  --var-100px: 100px;
-}
-</style>
-<body>
-<div id="log"></div>
-<script>
-'use strict';
-
-function getKeyframes(e) {
-  return e.getAnimations()[0].effect.getKeyframes();
-}
-
-function assert_frames_equal(a, b, name) {
-  assert_equals(Object.keys(a).sort().toString(),
-                Object.keys(b).sort().toString(),
-                "properties on " + name);
-  for (var p in a) {
-    assert_equals(a[p], b[p], "value for '" + p + "' on " + name);
-  }
-}
-
-test(function(t) {
-  var div = addDiv(t);
-
-  div.style.left = '0px';
-  getComputedStyle(div).transitionProperty;
-  div.style.transition = 'left 100s';
-  div.style.left = '100px';
-
-  var frames = getKeyframes(div);
-
-  assert_equals(frames.length, 2, "number of frames");
-
-  var expected = [
-    { offset: 0, computedOffset: 0, easing: "ease", composite: "auto",
-      left: "0px" },
-    { offset: 1, computedOffset: 1, easing: "linear", composite: "auto",
-      left: "100px" },
-  ];
-
-  for (var i = 0; i < frames.length; i++) {
-    assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
-  }
-}, 'KeyframeEffect.getKeyframes() returns expected frames for a simple'
-   + ' transition');
-
-test(function(t) {
-  var div = addDiv(t);
-
-  div.style.left = '0px';
-  getComputedStyle(div).transitionProperty;
-  div.style.transition = 'left 100s steps(2,end)';
-  div.style.left = '100px';
-
-  var frames = getKeyframes(div);
-
-  assert_equals(frames.length, 2, "number of frames");
-
-  var expected = [
-    { offset: 0, computedOffset: 0, easing: "steps(2)", composite: "auto",
-      left: "0px" },
-    { offset: 1, computedOffset: 1, easing: "linear", composite: "auto",
-      left: "100px" },
-  ];
-
-  for (var i = 0; i < frames.length; i++) {
-    assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
-  }
-}, 'KeyframeEffect.getKeyframes() returns expected frames for a simple'
-   + ' transition with a non-default easing function');
-
-test(function(t) {
-  var div = addDiv(t);
-  div.style.left = '0px';
-  getComputedStyle(div).transitionProperty;
-  div.style.transition = 'left 100s';
-  div.style.left = 'var(--var-100px)';
-
-  var frames = getKeyframes(div);
-
-  // CSS transition endpoints are based on the computed value so we
-  // shouldn't see the variable reference
-  var expected = [
-    { offset: 0, computedOffset: 0, easing: 'ease', composite: "auto",
-      left: '0px' },
-    { offset: 1, computedOffset: 1, easing: 'linear', composite: "auto",
-      left: '100px' },
-  ];
-  for (var i = 0; i < frames.length; i++) {
-    assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
-  }
-}, 'KeyframeEffect.getKeyframes() returns expected frames for a'
-   + ' transition with a CSS variable endpoint');
-
-</script>
-</body>
diff --git a/LayoutTests/imported/mozilla/css-transitions/test_setting-effect-expected.txt b/LayoutTests/imported/mozilla/css-transitions/test_setting-effect-expected.txt
deleted file mode 100644 (file)
index bc26fcf..0000000
+++ /dev/null
@@ -1,6 +0,0 @@
-
-PASS Test for removing a transition effect 
-PASS Test for replacing the transition effect by a new keyframe effect 
-PASS Test for setting a new keyframe effect with a shorter duration 
-PASS Test for setting a new keyframe effect to a pending transition 
-
diff --git a/LayoutTests/imported/mozilla/css-transitions/test_setting-effect.html b/LayoutTests/imported/mozilla/css-transitions/test_setting-effect.html
deleted file mode 100644 (file)
index 5e9ea5c..0000000
+++ /dev/null
@@ -1,102 +0,0 @@
-<!doctype html>
-<meta charset=utf-8>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
-<body>
-<div id="log"></div>
-<script>
-'use strict';
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  var watcher = new EventWatcher(t, div, [ 'transitionend',
-                                           'transitioncancel' ]);
-  div.style.left = '0px';
-
-  div.style.transition = 'left 100s';
-  flushComputedStyle(div);
-  div.style.left = '100px';
-
-  var transition = div.getAnimations()[0];
-  return transition.ready.then(function() {
-    transition.currentTime = 50 * MS_PER_SEC;
-    transition.effect = null;
-    assert_equals(transition.transitionProperty, 'left');
-    assert_equals(transition.playState, 'finished');
-    assert_equals(getComputedStyle(div).left, '100px');
-    return watcher.wait_for('transitionend');
-  });
-}, 'Test for removing a transition effect');
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  var watcher = new EventWatcher(t, div, [ 'transitionend',
-                                           'transitioncancel' ]);
-  div.style.left = '0px';
-
-  div.style.transition = 'left 100s';
-  flushComputedStyle(div);
-  div.style.left = '100px';
-
-  var transition = div.getAnimations()[0];
-  return transition.ready.then(function() {
-    transition.currentTime = 50 * MS_PER_SEC;
-    transition.effect = new KeyframeEffect(div,
-                                           { marginLeft: [ '0px' , '100px'] },
-                                           100 * MS_PER_SEC);
-    assert_equals(transition.transitionProperty, 'left');
-    assert_equals(transition.playState, 'running');
-    assert_equals(getComputedStyle(div).left, '100px');
-    assert_equals(getComputedStyle(div).marginLeft, '50px');
-  });
-}, 'Test for replacing the transition effect by a new keyframe effect');
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  var watcher = new EventWatcher(t, div, [ 'transitionend',
-                                           'transitioncancel' ]);
-  div.style.left = '0px';
-  div.style.width = '0px';
-
-  div.style.transition = 'left 100s';
-  flushComputedStyle(div);
-  div.style.left = '100px';
-
-  var transition = div.getAnimations()[0];
-  return transition.ready.then(function() {
-    transition.currentTime = 50 * MS_PER_SEC;
-    transition.effect = new KeyframeEffect(div,
-                                           { marginLeft: [ '0px' , '100px'] },
-                                           20 * MS_PER_SEC);
-    assert_equals(transition.playState, 'finished');
-  });
-}, 'Test for setting a new keyframe effect with a shorter duration');
-
-promise_test(function(t) {
-  var div = addDiv(t);
-  var watcher = new EventWatcher(t, div, [ 'transitionend',
-                                           'transitioncancel' ]);
-  div.style.left = '0px';
-  div.style.width = '0px';
-
-  div.style.transition = 'left 100s';
-  flushComputedStyle(div);
-  div.style.left = '100px';
-
-  var transition = div.getAnimations()[0];
-  assert_true(transition.pending);
-
-  transition.effect = new KeyframeEffect(div,
-                                         { marginLeft: [ '0px' , '100px'] },
-                                         100 * MS_PER_SEC);
-  assert_equals(transition.transitionProperty, 'left');
-  assert_true(transition.pending);
-
-  return transition.ready.then(function() {
-    assert_false(transition.pending);
-  });
-}, 'Test for setting a new keyframe effect to a pending transition');
-
-</script>
-</body>
index 0826d52..229a248 100644 (file)
@@ -1,3 +1,15 @@
+2019-10-24  Antoine Quint  <graouts@apple.com>
+
+        [Web Animations] Update WPT tests related to Web Animations and remove imported Mozilla tests
+        https://bugs.webkit.org/show_bug.cgi?id=203291
+
+        Reviewed by Youenn Fablet.
+
+        * resources/import-expectations.json:
+        * web-platform-tests/css/css-animations: Resynced.
+        * web-platform-tests/css/css-transitions: Imported.
+        * web-platform-tests/web-animations: Resynced.
+
 2019-10-23  Said Abou-Hallawa  <sabouhallawa@apple.com>
 
         [SVG2] Fix SVGSVGElement to conform with SVG2
index 6d5bf00..f921b33 100644 (file)
@@ -65,6 +65,7 @@
     "web-platform-tests/css-values": "skip", 
     "web-platform-tests/css/WOFF2": "import", 
     "web-platform-tests/css/css-align": "import", 
+    "web-platform-tests/css/css-animations": "import", 
     "web-platform-tests/css/css-animations/": "import", 
     "web-platform-tests/css/css-color": "import", 
     "web-platform-tests/css/css-display": "import", 
@@ -86,6 +87,7 @@
     "web-platform-tests/css/css-shapes": "import", 
     "web-platform-tests/css/css-shapes/test-plan/index.html": "skip", 
     "web-platform-tests/css/css-text": "import", 
+    "web-platform-tests/css/css-transitions": "import", 
     "web-platform-tests/css/css-ui": "import", 
     "web-platform-tests/css/cssom": "import", 
     "web-platform-tests/css/cssom-view/": "import", 
     "web-platform-tests/wai-aria": "skip", 
     "web-platform-tests/wasm": "skip", 
     "web-platform-tests/wasm/jsapi": "import", 
-    "web-platform-tests/web-animations": "skip", 
+    "web-platform-tests/web-animations": "import", 
     "web-platform-tests/web-nfc": "skip", 
     "web-platform-tests/webaudio": "import", 
     "web-platform-tests/webauthn": "skip", 
@@ -1,8 +1,11 @@
 <!doctype html>
 <meta charset=utf-8>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
+<title>AnimationEffect.getComputedTiming() for CSS animations</title>
+<!--  TODO: Add a more specific link for this once it is specified.  -->
+<link rel="help" href="https://drafts.csswg.org/css-animations-2/#cssanimation">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="support/testcommon.js"></script>
 <style>
 @keyframes moveAnimation {
   from { margin-left: 100px }
 // --------------------
 // delay
 // --------------------
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s'});
-  var effect = div.getAnimations()[0].effect;
-  assert_equals(effect.getComputedTiming().delay, 0,
-                'Initial value of delay');
+
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 100s' });
+  const effect = div.getAnimations()[0].effect;
+  assert_equals(effect.getComputedTiming().delay, 0, 'Initial value of delay');
 }, 'delay of a new animation');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s -10s'});
-  var effect = div.getAnimations()[0].effect;
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 100s -10s' });
+  const effect = div.getAnimations()[0].effect;
   assert_equals(effect.getComputedTiming().delay, -10 * MS_PER_SEC,
                 'Initial value of delay');
 }, 'Negative delay of a new animation');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s 10s'});
-  var effect = div.getAnimations()[0].effect;
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 100s 10s' });
+  const effect = div.getAnimations()[0].effect;
   assert_equals(effect.getComputedTiming().delay, 10 * MS_PER_SEC,
                 'Initial value of delay');
 }, 'Positive delay of a new animation');
@@ -43,9 +46,10 @@ test(function(t) {
 // --------------------
 // endDelay
 // --------------------
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s'});
-  var effect = div.getAnimations()[0].effect;
+
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 100s' });
+  const effect = div.getAnimations()[0].effect;
   assert_equals(effect.getComputedTiming().endDelay, 0,
                 'Initial value of endDelay');
 }, 'endDelay of a new animation');
@@ -54,13 +58,14 @@ test(function(t) {
 // --------------------
 // fill
 // --------------------
-test(function(t) {
-  var getEffectWithFill = function(fill) {
-    var div = addDiv(t, {style: 'animation: moveAnimation 100s ' + fill});
+
+test(t => {
+  const getEffectWithFill = fill => {
+    const div = addDiv(t, { style: 'animation: moveAnimation 100s ' + fill });
     return div.getAnimations()[0].effect;
   };
 
-  var effect = getEffectWithFill('');
+  let effect = getEffectWithFill('');
   assert_equals(effect.getComputedTiming().fill, 'none',
                 'Initial value of fill');
   effect = getEffectWithFill('forwards');
@@ -78,9 +83,10 @@ test(function(t) {
 // --------------------
 // iterationStart
 // --------------------
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s'});
-  var effect = div.getAnimations()[0].effect;
+
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 100s' });
+  const effect = div.getAnimations()[0].effect;
   assert_equals(effect.getComputedTiming().iterationStart, 0,
                 'Initial value of iterationStart');
 }, 'iterationStart of a new animation');
@@ -89,23 +95,24 @@ test(function(t) {
 // --------------------
 // iterations
 // --------------------
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s'});
-  var effect = div.getAnimations()[0].effect;
+
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 100s' });
+  const effect = div.getAnimations()[0].effect;
   assert_equals(effect.getComputedTiming().iterations, 1,
                 'Initial value of iterations');
 }, 'iterations of a new animation');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s 2016.5'});
-  var effect = div.getAnimations()[0].effect;
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 100s 2016.5' });
+  const effect = div.getAnimations()[0].effect;
   assert_equals(effect.getComputedTiming().iterations, 2016.5,
                 'Initial value of iterations');
 }, 'iterations of a finitely repeating animation');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s infinite'});
-  var effect = div.getAnimations()[0].effect;
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 100s infinite' });
+  const effect = div.getAnimations()[0].effect;
   assert_equals(effect.getComputedTiming().iterations, Infinity,
                 'Initial value of iterations');
 }, 'iterations of an infinitely repeating animation');
@@ -114,9 +121,12 @@ test(function(t) {
 // --------------------
 // duration
 // --------------------
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s -10s infinite'});
-  var effect = div.getAnimations()[0].effect;
+
+test(t => {
+  const div = addDiv(t, {
+    style: 'animation: moveAnimation 100s -10s infinite'
+  });
+  const effect = div.getAnimations()[0].effect;
   assert_equals(effect.getComputedTiming().duration, 100 * MS_PER_SEC,
                 'Initial value of duration');
 }, 'duration of a new animation');
@@ -125,13 +135,14 @@ test(function(t) {
 // --------------------
 // direction
 // --------------------
-test(function(t) {
-  var getEffectWithDir = function(dir) {
-    var div = addDiv(t, {style: 'animation: moveAnimation 100s ' + dir});
+
+test(t => {
+  const getEffectWithDir = dir => {
+    const div = addDiv(t, { style: 'animation: moveAnimation 100s ' + dir });
     return div.getAnimations()[0].effect;
   };
 
-  var effect = getEffectWithDir('');
+  let effect = getEffectWithDir('');
   assert_equals(effect.getComputedTiming().direction, 'normal',
                 'Initial value of normal direction');
   effect = getEffectWithDir('reverse');
@@ -149,9 +160,10 @@ test(function(t) {
 // --------------------
 // easing
 // --------------------
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s'});
-  var effect = div.getAnimations()[0].effect;
+
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 100s' });
+  const effect = div.getAnimations()[0].effect;
   assert_equals(effect.getComputedTiming().easing, 'linear',
                 'Initial value of easing');
 }, 'easing of a new animation');
@@ -161,40 +173,45 @@ test(function(t) {
 // endTime
 // = max(start delay + active duration + end delay, 0)
 // --------------------
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s'});
-  var effect = div.getAnimations()[0].effect;
+
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 100s' });
+  const effect = div.getAnimations()[0].effect;
   assert_equals(effect.getComputedTiming().endTime, 100 * MS_PER_SEC,
                 'Initial value of endTime');
 }, 'endTime of an new animation');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s -5s'});
-  var effect = div.getAnimations()[0].effect;
-  var answer = (100 - 5) * MS_PER_SEC;
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 100s -5s' });
+  const effect = div.getAnimations()[0].effect;
+  const answer = (100 - 5) * MS_PER_SEC;
   assert_equals(effect.getComputedTiming().endTime, answer,
                 'Initial value of endTime');
 }, 'endTime of an animation with a negative delay');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 10s -100s infinite'});
-  var effect = div.getAnimations()[0].effect;
+test(t => {
+  const div = addDiv(t, {
+    style: 'animation: moveAnimation 10s -100s infinite'
+  });
+  const effect = div.getAnimations()[0].effect;
   assert_equals(effect.getComputedTiming().endTime, Infinity,
                 'Initial value of endTime');
 }, 'endTime of an infinitely repeating animation');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 0s 100s infinite'});
-  var effect = div.getAnimations()[0].effect;
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 0s 100s infinite' });
+  const effect = div.getAnimations()[0].effect;
   assert_equals(effect.getComputedTiming().endTime, 100 * MS_PER_SEC,
                 'Initial value of endTime');
 }, 'endTime of an infinitely repeating zero-duration animation');
 
-test(function(t) {
+test(t => {
   // Fill forwards so div.getAnimations()[0] won't return an
   // undefined value.
-  var div = addDiv(t, {style: 'animation: moveAnimation 10s -100s forwards'});
-  var effect = div.getAnimations()[0].effect;
+  const div = addDiv(t, {
+    style: 'animation: moveAnimation 10s -100s forwards'
+  });
+  const effect = div.getAnimations()[0].effect;
   assert_equals(effect.getComputedTiming().endTime, 0,
                 'Initial value of endTime');
 }, 'endTime of an animation that finishes before its startTime');
@@ -204,33 +221,34 @@ test(function(t) {
 // activeDuration
 // = iteration duration * iteration count
 // --------------------
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s 5'});
-  var effect = div.getAnimations()[0].effect;
-  var answer = 100 * MS_PER_SEC * 5;
+
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 100s 5' });
+  const effect = div.getAnimations()[0].effect;
+  const answer = 100 * MS_PER_SEC * 5;
   assert_equals(effect.getComputedTiming().activeDuration, answer,
                 'Initial value of activeDuration');
 }, 'activeDuration of a new animation');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s infinite'});
-  var effect = div.getAnimations()[0].effect;
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 100s infinite' });
+  const effect = div.getAnimations()[0].effect;
   assert_equals(effect.getComputedTiming().activeDuration, Infinity,
                 'Initial value of activeDuration');
 }, 'activeDuration of an infinitely repeating animation');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 0s 1s infinite'});
-  var effect = div.getAnimations()[0].effect;
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 0s 1s infinite' });
+  const effect = div.getAnimations()[0].effect;
   // If either the iteration duration or iteration count are zero,
   // the active duration is zero.
   assert_equals(effect.getComputedTiming().activeDuration, 0,
                 'Initial value of activeDuration');
 }, 'activeDuration of an infinitely repeating zero-duration animation');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s 1s 0'});
-  var effect = div.getAnimations()[0].effect;
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 100s 1s 0' });
+  const effect = div.getAnimations()[0].effect;
   // If either the iteration duration or iteration count are zero,
   // the active duration is zero.
   assert_equals(effect.getComputedTiming().activeDuration, 0,
@@ -241,40 +259,42 @@ test(function(t) {
 // --------------------
 // localTime
 // --------------------
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s'});
-  var effect = div.getAnimations()[0].effect;
+
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 100s' });
+  const effect = div.getAnimations()[0].effect;
   assert_equals(effect.getComputedTiming().localTime, 0,
                 'Initial value of localTime');
 }, 'localTime of a new animation');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s'});
-  var anim = div.getAnimations()[0];
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 100s' });
+  const anim = div.getAnimations()[0];
   anim.currentTime = 5 * MS_PER_SEC;
   assert_equals(anim.effect.getComputedTiming().localTime, anim.currentTime,
                 'current localTime after setting currentTime');
 }, 'localTime of an animation is always equal to currentTime');
 
-promise_test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s'});
+promise_test(async t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 100s' });
 
-  var anim = div.getAnimations()[0];
+  const anim = div.getAnimations()[0];
   anim.playbackRate = 2; // 2 times faster
 
-  return anim.ready.then(function() {
-    assert_equals(anim.effect.getComputedTiming().localTime, anim.currentTime,
-                  'localTime is equal to currentTime');
-    return waitForFrame();
-  }).then(function() {
-    assert_equals(anim.effect.getComputedTiming().localTime, anim.currentTime,
-                  'localTime is equal to currentTime');
-  });
+  await anim.ready;
+
+  assert_equals(anim.effect.getComputedTiming().localTime, anim.currentTime,
+                'localTime is equal to currentTime');
+
+  await waitForFrame();
+
+  assert_equals(anim.effect.getComputedTiming().localTime, anim.currentTime,
+                'localTime is equal to currentTime');
 }, 'localTime reflects playbackRate immediately');
 
-test(function(t) {
-  var div = addDiv(t);
-  var effect = new KeyframeEffect(div, {left: ["0px", "100px"]});
+test(t => {
+  const div = addDiv(t);
+  const effect = new KeyframeEffect(div, {left: ["0px", "100px"]});
 
   assert_equals(effect.getComputedTiming().localTime, null,
                 'localTime for orphaned effect');
@@ -283,29 +303,38 @@ test(function(t) {
 
 // --------------------
 // progress
-// Note: Default timing function is linear.
+//
+// Note: Even though CSS animations have a default animation-timing-function of
+// "ease", this only applies between keyframes (often referred to as the
+// keyframe-level easing). The progress value returned by getComputedTiming(),
+// however, only reflects effect-level easing and this defaults to "linear",
+// even for CSS animations.
 // --------------------
-test(function(t) {
-  [{fill: '',          progress: [ null, null ]},
-   {fill: 'none',      progress: [ null, null ]},
-   {fill: 'forwards',  progress: [ null, 1.0 ]},
-   {fill: 'backwards', progress: [ 0.0, null ]},
-   {fill: 'both',      progress: [ 0.0, 1.0 ]}]
-  .forEach(function(test) {
-    var div =
-      addDiv(t, {style: 'animation: moveAnimation 100s 10s ' + test.fill});
-    var anim = div.getAnimations()[0];
+
+test(t => {
+  const tests = [
+    { fill: '', progress: [null, null] },
+    { fill: 'none', progress: [null, null] },
+    { fill: 'forwards', progress: [null, 1.0] },
+    { fill: 'backwards', progress: [0.0, null] },
+    { fill: 'both', progress: [0.0, 1.0] },
+  ];
+  for (const test of tests) {
+    const div = addDiv(t, {
+      style: 'animation: moveAnimation 100s 10s ' + test.fill
+    });
+    const anim = div.getAnimations()[0];
     assert_true(anim.effect.getComputedTiming().progress === test.progress[0],
-                'initial progress with "' + test.fill + '" fill');
+                `Initial progress with "${test.fill}" fill`);
     anim.finish();
     assert_true(anim.effect.getComputedTiming().progress === test.progress[1],
-                'finished progress with "' + test.fill + '" fill');
-  });
+                `Initial progress with "${test.fill}" fill`);
+  }
 }, 'progress of an animation with different fill modes');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 10s 10 both'});
-  var anim = div.getAnimations()[0];
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 10s 10 both' });
+  const anim = div.getAnimations()[0];
 
   assert_equals(anim.effect.getComputedTiming().progress, 0.0,
                 'Initial value of progress');
@@ -323,15 +352,14 @@ test(function(t) {
                 'Value of progress');
 }, 'progress of an integral repeating animation with normal direction');
 
-test(function(t) {
-  var div = addDiv(t);
+test(t => {
   // Note: FillMode here is "both" because
   // 1. Since this a zero-duration animation, it will already have finished
   //    so it won't be returned by getAnimations() unless it fills forwards.
   // 2. Fill backwards, so the progress before phase wouldn't be
   //    unresolved (null value).
-  var div = addDiv(t, {style: 'animation: moveAnimation 0s infinite both'});
-  var anim = div.getAnimations()[0];
+  const div = addDiv(t, { style: 'animation: moveAnimation 0s infinite both' });
+  const anim = div.getAnimations()[0];
 
   assert_equals(anim.effect.getComputedTiming().progress, 1.0,
                 'Initial value of progress in after phase');
@@ -342,10 +370,10 @@ test(function(t) {
                 'Value of progress before phase');
 }, 'progress of an infinitely repeating zero-duration animation');
 
-test(function(t) {
+test(t => {
   // Default iterations = 1
-  var div = addDiv(t, {style: 'animation: moveAnimation 0s both'});
-  var anim = div.getAnimations()[0];
+  const div = addDiv(t, { style: 'animation: moveAnimation 0s both' });
+  const anim = div.getAnimations()[0];
 
   assert_equals(anim.effect.getComputedTiming().progress, 1.0,
                 'Initial value of progress in after phase');
@@ -356,9 +384,9 @@ test(function(t) {
                 'Value of progress before phase');
 }, 'progress of a finitely repeating zero-duration animation');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 0s 5s 10.25 both'});
-  var anim = div.getAnimations()[0];
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 0s 5s 10.25 both' });
+  const anim = div.getAnimations()[0];
 
   assert_equals(anim.effect.getComputedTiming().progress, 0.0,
                 'Initial value of progress (before phase)');
@@ -370,9 +398,11 @@ test(function(t) {
                 'Value of progress in after phase');
 }, 'progress of a non-integral repeating zero-duration animation');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 0s 5s 10.25 both reverse'});
-  var anim = div.getAnimations()[0];
+test(t => {
+  const div = addDiv(t, {
+    style: 'animation: moveAnimation 0s 5s 10.25 both reverse',
+  });
+  const anim = div.getAnimations()[0];
 
   assert_equals(anim.effect.getComputedTiming().progress, 1.0,
                 'Initial value of progress (before phase)');
@@ -384,9 +414,11 @@ test(function(t) {
 }, 'Progress of a non-integral repeating zero-duration animation ' +
    'with reversing direction');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 10s 10.25 both alternate'});
-  var anim = div.getAnimations()[0];
+test(t => {
+  const div = addDiv(t, {
+    style: 'animation: moveAnimation 10s 10.25 both alternate',
+  });
+  const anim = div.getAnimations()[0];
 
   assert_equals(anim.effect.getComputedTiming().progress, 0.0,
                 'Initial value of progress');
@@ -405,9 +437,11 @@ test(function(t) {
 }, 'progress of a non-integral repeating animation ' +
    'with alternate direction');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 10s 10.25 both alternate-reverse'});
-  var anim = div.getAnimations()[0];
+test(t => {
+  const div = addDiv(t, {
+    style: 'animation: moveAnimation 10s 10.25 both alternate-reverse',
+  });
+  const anim = div.getAnimations()[0];
 
   assert_equals(anim.effect.getComputedTiming().progress, 1.0,
                 'Initial value of progress');
@@ -426,9 +460,11 @@ test(function(t) {
 }, 'progress of a non-integral repeating animation ' +
    'with alternate-reversing direction');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 0s 10.25 both alternate'});
-  var anim = div.getAnimations()[0];
+test(t => {
+  const div = addDiv(t, {
+    style: 'animation: moveAnimation 0s 10.25 both alternate',
+  });
+  const anim = div.getAnimations()[0];
 
   assert_equals(anim.effect.getComputedTiming().progress, 0.25,
                 'Initial value of progress');
@@ -444,9 +480,11 @@ test(function(t) {
 }, 'progress of a non-integral repeating zero-duration animation ' +
    'with alternate direction');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 0s 10.25 both alternate-reverse'});
-  var anim = div.getAnimations()[0];
+test(t => {
+  const div = addDiv(t, {
+    style: 'animation: moveAnimation 0s 10.25 both alternate-reverse',
+  });
+  const anim = div.getAnimations()[0];
 
   assert_equals(anim.effect.getComputedTiming().progress, 0.75,
                 'Initial value of progress');
@@ -466,29 +504,30 @@ test(function(t) {
 // --------------------
 // currentIteration
 // --------------------
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s 2s'});
-  var effect = div.getAnimations()[0].effect;
+
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 100s 2s' });
+  const effect = div.getAnimations()[0].effect;
   assert_equals(effect.getComputedTiming().currentIteration, null,
                 'Initial value of currentIteration before phase');
 }, 'currentIteration of a new animation with no backwards fill is unresolved ' +
    'in before phase');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s'});
-  var anim = div.getAnimations()[0];
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 100s' });
+  const anim = div.getAnimations()[0];
   assert_equals(anim.effect.getComputedTiming().currentIteration, 0,
                 'Initial value of currentIteration');
 }, 'currentIteration of a new animation is zero');
 
-test(function(t) {
+test(t => {
   // Note: FillMode here is "both" because
   // 1. Since this a zero-duration animation, it will already have finished
   //    so it won't be returned by getAnimations() unless it fills forwards.
   // 2. Fill backwards, so the currentIteration (before phase) wouldn't be
   //    unresolved (null value).
-  var div = addDiv(t, {style: 'animation: moveAnimation 0s infinite both'});
-  var anim = div.getAnimations()[0];
+  const div = addDiv(t, { style: 'animation: moveAnimation 0s infinite both' });
+  const anim = div.getAnimations()[0];
 
   assert_equals(anim.effect.getComputedTiming().currentIteration, Infinity,
                 'Initial value of currentIteration in after phase');
@@ -499,9 +538,9 @@ test(function(t) {
                 'Value of currentIteration count during before phase');
 }, 'currentIteration of an infinitely repeating zero-duration animation');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 0s 10.5 both'});
-  var anim = div.getAnimations()[0];
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 0s 10.5 both' });
+  const anim = div.getAnimations()[0];
 
   // Note: currentIteration = ceil(iteration start + iteration count) - 1
   assert_equals(anim.effect.getComputedTiming().currentIteration, 10,
@@ -513,9 +552,11 @@ test(function(t) {
                 'Value of currentIteration count during before phase');
 }, 'currentIteration of a finitely repeating zero-duration animation');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s 5.5 forwards'});
-  var anim = div.getAnimations()[0];
+test(t => {
+  const div = addDiv(t, {
+    style: 'animation: moveAnimation 100s 5.5 forwards'
+  });
+  const anim = div.getAnimations()[0];
 
   assert_equals(anim.effect.getComputedTiming().currentIteration, 0,
                 'Initial value of currentIteration');
@@ -530,9 +571,9 @@ test(function(t) {
                 'Value of currentIteration in after phase');
 }, 'currentIteration of an animation with a non-integral iteration count');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s 2 forwards'});
-  var anim = div.getAnimations()[0];
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 100s 2 forwards' });
+  const anim = div.getAnimations()[0];
 
   assert_equals(anim.effect.getComputedTiming().currentIteration, 0,
                 'Initial value of currentIteration');
@@ -542,9 +583,9 @@ test(function(t) {
                 'Value of currentIteration in after phase');
 }, 'currentIteration of an animation with an integral iteration count');
 
-test(function(t) {
-  var div = addDiv(t, {style: 'animation: moveAnimation 100s forwards'});
-  var anim = div.getAnimations()[0];
+test(t => {
+  const div = addDiv(t, { style: 'animation: moveAnimation 100s forwards' });
+  const anim = div.getAnimations()[0];
   assert_equals(anim.effect.getComputedTiming().currentIteration, 0,
                 'Initial value of currentIteration');
   // Finish
@@ -553,9 +594,9 @@ test(function(t) {
                 'Value of currentIteration in after phase');
 }, 'currentIteration of an animation with a default iteration count');
 
-test(function(t) {
-  var div = addDiv(t);
-  var effect = new KeyframeEffect(div, {left: ["0px", "100px"]});
+test(t => {
+  const div = addDiv(t);
+  const effect = new KeyframeEffect(div, {left: ["0px", "100px"]});
 
   assert_equals(effect.getComputedTiming().currentIteration, null,
                 'currentIteration for orphaned effect');
@@ -1,34 +1,36 @@
 <!doctype html>
 <meta charset=utf-8>
-<script src="../../../resources/testharness.js"></script>
-<script src="../../../resources/testharnessreport.js"></script>
-<script src="../resources/testcommon.js"></script>
+<title>CSSAnimation.animationName</title>
+<link rel="help"
+      href="https://drafts.csswg.org/css-animations-2/#dom-cssanimation-animationname">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="support/testcommon.js"></script>
 <style>
 @keyframes xyz {
   to { left: 100px }
 }
 </style>
-<body>
 <div id="log"></div>
 <script>
 'use strict';
 
-test(function(t) {
-  var div = addDiv(t);
+test(t => {
+  const div = addDiv(t);
   div.style.animation = 'xyz 100s';
   assert_equals(div.getAnimations()[0].animationName, 'xyz',
                 'Animation name matches keyframes rule name');
 }, 'Animation name makes keyframe rule');
 
-test(function(t) {
-  var div = addDiv(t);
+test(t => {
+  const div = addDiv(t);
   div.style.animation = 'x\\yz 100s';
   assert_equals(div.getAnimations()[0].animationName, 'xyz',
                 'Escaped animation name matches keyframes rule name');
 }, 'Escaped animation name');
 
-test(function(t) {
-  var div = addDiv(t);
+test(t => {
+  const div = addDiv(t);
   div.style.animation = 'x\\79 z 100s';
   assert_equals(div.getAnimations()[0].animationName, 'xyz',
                 'Hex-escaped animation name matches keyframes rule'
@@ -36,4 +38,3 @@ test(function(t) {
 }, 'Animation name with hex-escape');
 
 </script>
-</body>
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-canceling.tentative-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-canceling.tentative-expected.txt
new file mode 100644 (file)
index 0000000..668876e
--- /dev/null
@@ -0,0 +1,11 @@
+
+PASS Animated style is cleared after canceling a running CSS animation 
+PASS Animated style is cleared after canceling a filling CSS animation 
+PASS After canceling an animation, it can still be seeked 
+PASS After canceling an animation, it can still be re-used 
+PASS After canceling an animation, updating animation properties doesn't make it live again 
+PASS After canceling an animation, updating animation-play-state doesn't make it live again 
+PASS Setting animation-name to 'none' cancels the animation 
+PASS Setting display:none on an element cancel its animations 
+PASS Setting display:none on an ancestor element cancels animations on descendants 
+
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-canceling.tentative.html b/LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-canceling.tentative.html
new file mode 100644 (file)
index 0000000..77fb133
--- /dev/null
@@ -0,0 +1,196 @@
+<!doctype html>
+<meta charset=utf-8>
+<title>Canceling a CSS animation</title>
+<!--  TODO: Add a more specific link for this once it is specified.  -->
+<link rel="help" href="https://drafts.csswg.org/css-animations-2/">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="support/testcommon.js"></script>
+<style>
+@keyframes translateAnim {
+  to { transform: translate(100px) }
+}
+@keyframes marginLeftAnim {
+  to { margin-left: 100px }
+}
+@keyframes marginLeftAnim100To200 {
+  from { margin-left: 100px }
+  to { margin-left: 200px }
+}
+</style>
+<div id="log"></div>
+<script>
+'use strict';
+
+promise_test(async t => {
+  const div = addDiv(t, { style: 'animation: translateAnim 100s' });
+  const animation = div.getAnimations()[0];
+
+  await animation.ready;
+
+  assert_not_equals(getComputedStyle(div).transform, 'none',
+                    'transform style is animated before canceling');
+  animation.cancel();
+  assert_equals(getComputedStyle(div).transform, 'none',
+                'transform style is no longer animated after canceling');
+}, 'Animated style is cleared after canceling a running CSS animation');
+
+promise_test(async t => {
+  const div = addDiv(t, { style: 'animation: translateAnim 100s forwards' });
+  const animation = div.getAnimations()[0];
+  animation.finish();
+
+  await animation.ready;
+
+  assert_not_equals(getComputedStyle(div).transform, 'none',
+                    'transform style is filling before canceling');
+  animation.cancel();
+  assert_equals(getComputedStyle(div).transform, 'none',
+                'fill style is cleared after canceling');
+}, 'Animated style is cleared after canceling a filling CSS animation');
+
+test(t => {
+  const div = addDiv(t, { style: 'animation: marginLeftAnim 100s linear' });
+  const animation = div.getAnimations()[0];
+  animation.cancel();
+
+  assert_equals(getComputedStyle(div).marginLeft, '0px',
+                'margin-left style is not animated after canceling');
+
+  animation.currentTime = 50 * 1000;
+  assert_equals(getComputedStyle(div).marginLeft, '50px',
+                'margin-left style is updated when canceled animation is'
+                + ' seeked');
+}, 'After canceling an animation, it can still be seeked');
+
+promise_test(async t => {
+  const div =
+    addDiv(t, { style: 'animation: marginLeftAnim100To200 100s linear' });
+  const animation = div.getAnimations()[0];
+
+  await animation.ready;
+
+  animation.cancel();
+  assert_equals(getComputedStyle(div).marginLeft, '0px',
+                'margin-left style is not animated after canceling');
+  animation.play();
+  assert_equals(getComputedStyle(div).marginLeft, '100px',
+                'margin-left style is animated after re-starting animation');
+
+  await animation.ready;
+
+  assert_equals(animation.playState, 'running',
+                'Animation succeeds in running after being re-started');
+}, 'After canceling an animation, it can still be re-used');
+
+test(t => {
+  const div =
+    addDiv(t, { style: 'animation: marginLeftAnim100To200 100s linear' });
+  const animation = div.getAnimations()[0];
+  animation.cancel();
+  assert_equals(getComputedStyle(div).marginLeft, '0px',
+                'margin-left style is not animated after canceling');
+
+  // Trigger a change to some animation properties and check that this
+  // doesn't cause the animation to become live again
+  div.style.animationDuration = '200s';
+  assert_equals(getComputedStyle(div).marginLeft, '0px',
+                'margin-left style is still not animated after updating'
+                + ' animation-duration');
+  assert_equals(animation.playState, 'idle',
+                'Animation is still idle after updating animation-duration');
+}, 'After canceling an animation, updating animation properties doesn\'t make'
+   + ' it live again');
+
+test(t => {
+  const div =
+    addDiv(t, { style: 'animation: marginLeftAnim100To200 100s linear' });
+  const animation = div.getAnimations()[0];
+  animation.cancel();
+  assert_equals(getComputedStyle(div).marginLeft, '0px',
+                'margin-left style is not animated after canceling');
+
+  // Make some changes to animation-play-state and check that the
+  // animation doesn't become live again. This is because it should be
+  // possible to cancel an animation from script such that all future
+  // changes to style are ignored.
+
+  // Redundant change
+  div.style.animationPlayState = 'running';
+  assert_equals(animation.playState, 'idle',
+                'Animation is still idle after a redundant change to'
+                + ' animation-play-state');
+
+  // Pause
+  div.style.animationPlayState = 'paused';
+  assert_equals(animation.playState, 'idle',
+                'Animation is still idle after setting'
+                + ' animation-play-state: paused');
+
+  // Play
+  div.style.animationPlayState = 'running';
+  assert_equals(animation.playState, 'idle',
+                'Animation is still idle after re-setting'
+                + ' animation-play-state: running');
+
+}, 'After canceling an animation, updating animation-play-state doesn\'t'
+   + ' make it live again');
+
+promise_test(async t => {
+  const div = addDiv(t, { style: 'animation: translateAnim 10s both' });
+  div.style.marginLeft = '0px';
+
+  const animation = div.getAnimations()[0];
+
+  await animation.ready;
+
+  assert_equals(animation.playState, 'running');
+
+  div.style.animationName = 'none';
+  flushComputedStyle(div);
+
+  await waitForFrame();
+
+  assert_equals(animation.playState, 'idle');
+  assert_equals(getComputedStyle(div).marginLeft, '0px');
+}, 'Setting animation-name to \'none\' cancels the animation');
+
+promise_test(async t => {
+  const div = addDiv(t, { style: 'animation: translateAnim 10s both' });
+  const animation = div.getAnimations()[0];
+
+  await animation.ready;
+
+  assert_equals(animation.playState, 'running');
+
+  div.style.display = 'none';
+
+  await waitForFrame();
+
+  assert_equals(animation.playState, 'idle');
+  assert_equals(getComputedStyle(div).marginLeft, '0px');
+}, 'Setting display:none on an element cancel its animations');
+
+promise_test(async t => {
+  const parentDiv = addDiv(t);
+  const childDiv  = document.createElement('div');
+  parentDiv.appendChild(childDiv);
+
+  childDiv.setAttribute('style', 'animation: translateAnim 10s both');
+  flushComputedStyle(childDiv);
+
+  const animation = childDiv.getAnimations()[0];
+
+  await animation.ready;
+
+  assert_equals(animation.playState, 'running');
+
+  parentDiv.style.display = 'none';
+  await waitForFrame();
+
+  assert_equals(animation.playState, 'idle');
+  assert_equals(getComputedStyle(childDiv).marginLeft, '0px');
+}, 'Setting display:none on an ancestor element cancels animations on ' +
+   'descendants');
+
+</script>
@@ -3,6 +3,6 @@ PASS Setting a null effect on a running animation fires an animationend event
 PASS Replacing an animation's effect with an effect that targets a different property should update both properties 
 PASS Replacing an animation's effect with a shorter one that should have already finished, the animation finishes immediately 
 PASS A play-pending animation's effect whose effect is replaced still exits the pending state 
-PASS The event is dispatched at the original element even after setting an effect with a different target element 
+PASS CSS animation events are dispatched at the original element even after setting an effect with a different target element 
 PASS After replacing a finished animation's effect with a longer one it fires an animationstart event 
 
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-effect.tentative.html b/LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-effect.tentative.html
new file mode 100644 (file)
index 0000000..4f345b6
--- /dev/null
@@ -0,0 +1,131 @@
+<!doctype html>
+<meta charset=utf-8>
+<title>CSSAnimation.effect</title>
+<meta name="timeout" content="long">
+<!--  TODO: Add a more specific link for this once it is specified.  -->
+<link rel="help" href="https://drafts.csswg.org/css-animations-2/#cssanimation">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="support/testcommon.js"></script>
+<style>
+@keyframes anim {
+  from {
+    margin-left: 0px;
+  }
+  to {
+    margin-left: 100px;
+  }
+}
+</style>
+<div id="log"></div>
+<script>
+'use strict';
+
+promise_test(async t => {
+  const div = addDiv(t);
+  div.style.animation = 'anim 100s';
+
+  const watcher = new EventWatcher(t, div, [ 'animationend',
+                                             'animationcancel' ]);
+  const animation = div.getAnimations()[0];
+  await animation.ready;
+
+  animation.currentTime = 50 * MS_PER_SEC;
+  animation.effect = null;
+  assert_equals(animation.playState, 'finished');
+  assert_equals(getComputedStyle(div).marginLeft, '0px');
+  await watcher.wait_for('animationend');
+}, 'Setting a null effect on a running animation fires an animationend event');
+
+promise_test(async t => {
+  const div = addDiv(t);
+  div.style.animation = 'anim 100s';
+
+  const animation = div.getAnimations()[0];
+  await animation.ready;
+
+  animation.currentTime = 50 * MS_PER_SEC;
+  animation.effect = new KeyframeEffect(div,
+                                        { left: [ '0px' , '100px'] },
+                                        100 * MS_PER_SEC);
+  assert_equals(getComputedStyle(div).marginLeft, '0px');
+  assert_equals(getComputedStyle(div).left, '50px');
+}, 'Replacing an animation\'s effect with an effect that targets a different ' +
+   'property should update both properties');
+
+promise_test(async t => {
+  const div = addDiv(t);
+  div.style.animation = 'anim 100s';
+
+  const animation = div.getAnimations()[0];
+  await animation.ready;
+
+  animation.currentTime = 50 * MS_PER_SEC;
+  animation.effect = new KeyframeEffect(div,
+                                        { left: [ '0px' , '100px'] },
+                                        20 * MS_PER_SEC);
+  assert_equals(animation.playState, 'finished');
+}, 'Replacing an animation\'s effect with a shorter one that should have ' +
+   'already finished, the animation finishes immediately');
+
+promise_test(async t => {
+  const div = addDiv(t);
+  div.style.animation = 'anim 100s';
+
+  const animation = div.getAnimations()[0];
+  assert_true(animation.pending);
+
+  animation.effect = new KeyframeEffect(div,
+                                        { left: [ '0px' , '100px'] },
+                                        100 * MS_PER_SEC);
+  assert_true(animation.pending);
+
+  await animation.ready;
+
+  assert_false(animation.pending);
+}, 'A play-pending animation\'s effect whose effect is replaced still exits ' +
+   'the pending state');
+
+promise_test(async t => {
+  const div1 = addDiv(t);
+  const div2 = addDiv(t);
+
+  const watcher1 = new EventWatcher(t, div1, 'animationstart');
+  // Watch |div2| as well to ensure it does *not* get events.
+  const watcher2 = new EventWatcher(t, div2, 'animationstart');
+
+  div1.style.animation = 'anim 100s';
+
+  const animation = div1.getAnimations()[0];
+  animation.effect = new KeyframeEffect(div2,
+                                        { left: [ '0px', '100px' ] },
+                                        100 * MS_PER_SEC);
+
+  await watcher1.wait_for('animationstart');
+
+  assert_equals(animation.effect.target, div2);
+
+  // Then wait a couple of frames and check that no event was dispatched.
+  await waitForAnimationFrames(2);
+}, 'CSS animation events are dispatched at the original element even after'
+   + ' setting an effect with a different target element');
+
+promise_test(async t => {
+  const div = addDiv(t);
+  const watcher = new EventWatcher(t, div, [ 'animationstart',
+                                             'animationend',
+                                             'animationcancel' ]);
+  div.style.animation = 'anim 100s';
+  const animation = div.getAnimations()[0];
+  animation.finish();
+
+  await watcher.wait_for([ 'animationstart', 'animationend' ]);
+  // Set a longer effect
+  animation.effect = new KeyframeEffect(div,
+                                        { left: [ '0px', '100px' ] },
+                                        200 * MS_PER_SEC);
+  await watcher.wait_for('animationstart');
+}, 'After replacing a finished animation\'s effect with a longer one ' +
+   'it fires an animationstart event');
+
+</script>
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-finished.tentative-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-finished.tentative-expected.txt
new file mode 100644 (file)
index 0000000..43b8b3a
--- /dev/null
@@ -0,0 +1,5 @@
+
+PASS finished promise is rejected when an animation is canceled by resetting the animation property 
+PASS finished promise is rejected when an animation is canceled by changing the animation property 
+PASS finished promise is not reset when animationPlayState is set to running 
+
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-finished.tentative.html b/LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-finished.tentative.html
new file mode 100644 (file)
index 0000000..8969abd
--- /dev/null
@@ -0,0 +1,85 @@
+<!doctype html>
+<meta charset=utf-8>
+<title>CSSAnimation.finished</title>
+<!--  TODO: Add a more specific link for this once it is specified.  -->
+<link rel="help" href="https://drafts.csswg.org/css-animations-2/#cssanimation">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="support/testcommon.js"></script>
+<style>
+@keyframes abc {
+  to { transform: translate(10px) }
+}
+@keyframes def {}
+</style>
+<div id="log"></div>
+<script>
+'use strict';
+
+const ANIM_PROP_VAL = 'abc 100s';
+const ANIM_DURATION = 100 * MS_PER_SEC;
+
+promise_test(async t => {
+  const div = addDiv(t);
+
+  // Set up pending animation
+  div.style.animation = ANIM_PROP_VAL;
+  const animation = div.getAnimations()[0];
+  const originalFinishedPromise = animation.finished;
+
+  // Cancel the animation and flush styles
+  div.style.animation = '';
+  getComputedStyle(div).animation;
+
+  await promise_rejects(t, 'AbortError', originalFinishedPromise,
+                        'finished promise is rejected with AbortError');
+
+  assert_not_equals(animation.finished, originalFinishedPromise,
+                    'Finished promise should change after the original is ' +
+                    'rejected');
+}, 'finished promise is rejected when an animation is canceled by resetting ' +
+   'the animation property');
+
+promise_test(async t => {
+  const div = addDiv(t);
+  // As before, but this time instead of removing all animations, simply update
+  // the list of animations. At least for Firefox, updating is a different
+  // code path.
+
+  // Set up pending animation
+  div.style.animation = ANIM_PROP_VAL;
+  const animation = div.getAnimations()[0];
+  const originalFinishedPromise = animation.finished;
+
+  // Update the animation and flush styles
+  div.style.animation = 'def 100s';
+  getComputedStyle(div).animation;
+
+  await promise_rejects(t, 'AbortError', originalFinishedPromise,
+                        'finished promise is rejected with AbortError');
+
+  assert_not_equals(animation.finished, originalFinishedPromise,
+                    'Finished promise should change after the original is ' +
+                    'rejected');
+}, 'finished promise is rejected when an animation is canceled by changing ' +
+   'the animation property');
+
+promise_test(async t => {
+  const div = addDiv(t);
+  div.style.animation = ANIM_PROP_VAL;
+  const animation = div.getAnimations()[0];
+  const originalFinishedPromise = animation.finished;
+  animation.currentTime = ANIM_DURATION;
+
+  await animation.finished;
+
+  div.style.animationPlayState = 'running';
+  await waitForAnimationFrames(2);
+
+  assert_equals(animation.finished, originalFinishedPromise,
+                'The finished promise should NOT be reset');
+  assert_equals(animation.currentTime, ANIM_DURATION,
+                'Sanity check: the current time should not change');
+}, 'finished promise is not reset when animationPlayState is set to running');
+
+</script>
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-getCurrentTime.tentative-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-getCurrentTime.tentative-expected.txt
new file mode 100644 (file)
index 0000000..26181d8
--- /dev/null
@@ -0,0 +1,4 @@
+
+PASS currentTime can be used to seek a CSS animation 
+PASS Setting currentTime to null on a CSS animation throws 
+
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-getCurrentTime.tentative.html b/LayoutTests/imported/w3c/web-platform-tests/css/css-animations/CSSAnimation-getCurrentTime.tentative.html
new file mode 100644 (file)
index 0000000..056a544
--- /dev/null
@@ -0,0 +1,68 @@
+<!doctype html>
+<meta charset=utf-8>
+<title>CSSAnimation.currentTime</title>
+<!--  TODO: Add a more specific link for this once it is specified.  -->
+<link rel="help" href="https://drafts.csswg.org/css-animations-2/#cssanimation">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="support/testcommon.js"></script>
+<style>
+
+.animated-div {
+  margin-left: 10px;
+  /* Make it easier to calculate expected values: */
+  animation-timing-function: linear ! important;
+}
+
+@keyframes anim {
+  from { margin-left: 100px; }
+  to { margin-left: 200px; }
+}
+
+</style>
+<div id="log"></div>
+<script type="text/javascript">
+
+'use strict';
+
+promise_test(async t => {
+  const div = addDiv(t, { class: 'animated-div' });
+  div.style.animation = 'anim 100s';
+  const animation = div.getAnimations()[0];
+
+  assert_equals(
+    animation.currentTime,
+    0,
+    'Animation.currentTime should be zero when an animation ' +
+      'is initially created'
+  );
+
+  await animation.ready;
+
+  animation.currentTime = 50 * MS_PER_SEC;
+
+  assert_time_equals_literal(
+    animation.currentTime,
+    50 * MS_PER_SEC,
+    'Check setting of currentTime actually works'
+  );
+  assert_equals(getComputedStyle(div).marginLeft, '150px');
+}, 'currentTime can be used to seek a CSS animation');
+
+promise_test(async t => {
+  const div = addDiv(t, { class: 'animated-div' });
+  div.style.animation = 'anim 100s';
+
+  const animation = div.getAnimations()[0];
+  await animation.ready;
+
+  assert_throws(
+    new TypeError(),
+    () => {
+      animation.currentTime = null;
+    },
+    'Expect TypeError exception on trying to set Animation.currentTime to null'
+  );
+}, 'Setting currentTime to null on a CSS animation throws');
+
+</script>