+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/mathml/relations/css-styling/padding-border-margin/border-002.html b/tests/wpt/web-platform-tests/mathml/relations/css-styling/padding-border-margin/border-002.html
index 38d89aa186e..2556f680ca5 100644
--- a/tests/wpt/web-platform-tests/mathml/relations/css-styling/padding-border-margin/border-002.html
+++ b/tests/wpt/web-platform-tests/mathml/relations/css-styling/padding-border-margin/border-002.html
@@ -35,28 +35,30 @@
continue;
}
+ var default_border = tag === "merror" ? 1 : 0;
+
test(function() {
assert_true(MathMLFeatureDetection[`has_${tag}`](), `${tag} is supported`);
var s = compareSpaceWithAndWithoutStyle(tag, style);
- assert_approx_equals(s.left_delta, 30, epsilon, "left border");
- assert_approx_equals(s.right_delta, 40, epsilon, "right border");
- assert_approx_equals(s.top_delta, 50, epsilon, "top border");
- assert_approx_equals(s.bottom_delta, 60, epsilon, "bottom border");
- assert_approx_equals(s.element_width_delta, 30 + 40, epsilon, "element width");
- assert_approx_equals(s.element_height_delta, 50 + 60, epsilon, "element height");
- assert_approx_equals(s.preferred_width_delta, 30 + 40, epsilon, "element preferred width");
+ assert_approx_equals(s.left_delta + default_border, 30, epsilon, "left border");
+ assert_approx_equals(s.right_delta + default_border, 40, epsilon, "right border");
+ assert_approx_equals(s.top_delta + default_border, 50, epsilon, "top border");
+ assert_approx_equals(s.bottom_delta + default_border, 60, epsilon, "bottom border");
+ assert_approx_equals(s.element_width_delta + 2 * default_border, 30 + 40, epsilon, "element width");
+ assert_approx_equals(s.element_height_delta + 2 * default_border, 50 + 60, epsilon, "element height");
+ assert_approx_equals(s.preferred_width_delta + 2 * default_border, 30 + 40, epsilon, "element preferred width");
}, `Border properties on ${tag}`);
test(function() {
assert_true(MathMLFeatureDetection[`has_${tag}`](), `${tag} is supported`);
var s = compareSpaceWithAndWithoutStyle(tag, style, null, "rtl");
- assert_approx_equals(s.left_delta, 30, epsilon, "left border");
- assert_approx_equals(s.right_delta, 40, epsilon, "right border");
- assert_approx_equals(s.top_delta, 50, epsilon, "top border");
- assert_approx_equals(s.bottom_delta, 60, epsilon, "bottom border");
- assert_approx_equals(s.element_width_delta, 30 + 40, epsilon, "element width");
- assert_approx_equals(s.element_height_delta, 50 + 60, epsilon, "element height");
- assert_approx_equals(s.preferred_width_delta, 30 + 40, epsilon, "element preferred width");
+ assert_approx_equals(s.left_delta + default_border, 30, epsilon, "left border");
+ assert_approx_equals(s.right_delta + default_border, 40, epsilon, "right border");
+ assert_approx_equals(s.top_delta + default_border, 50, epsilon, "top border");
+ assert_approx_equals(s.bottom_delta + default_border, 60, epsilon, "bottom border");
+ assert_approx_equals(s.element_width_delta + 2 * default_border, 30 + 40, epsilon, "element width");
+ assert_approx_equals(s.element_height_delta + 2 * default_border, 50 + 60, epsilon, "element height");
+ assert_approx_equals(s.preferred_width_delta + 2 * default_border, 30 + 40, epsilon, "element preferred width");
}, `Border properties on ${tag} (rtl)`);
}
diff --git a/tests/wpt/web-platform-tests/resources/chromium/web-bluetooth-test.js b/tests/wpt/web-platform-tests/resources/chromium/web-bluetooth-test.js
index ee8f082b874..fb6965c9f38 100644
--- a/tests/wpt/web-platform-tests/resources/chromium/web-bluetooth-test.js
+++ b/tests/wpt/web-platform-tests/resources/chromium/web-bluetooth-test.js
@@ -13,6 +13,23 @@ function toMojoCentralState(state) {
}
}
+// Converts bluetooth.mojom.WriteType to a string. If |writeType| is
+// invalid, this method will throw.
+function writeTypeToString(writeType) {
+ switch (writeType) {
+ case bluetooth.mojom.WriteType.kNone:
+ return 'none';
+ case bluetooth.mojom.WriteType.kWriteDefaultDeprecated:
+ return 'default-deprecated';
+ case bluetooth.mojom.WriteType.kWriteWithResponse:
+ return 'with-response';
+ case bluetooth.mojom.WriteType.kWriteWithoutResponse:
+ return 'without-response';
+ default:
+ throw `Unknown bluetooth.mojom.WriteType: ${writeType}`;
+ }
+}
+
// Canonicalizes UUIDs and converts them to Mojo UUIDs.
function canonicalizeAndConvertToMojoUUID(uuids) {
let canonicalUUIDs = uuids.map(val => ({uuid: BluetoothUUID.getService(val)}));
@@ -448,16 +465,19 @@ class FakeRemoteGATTCharacteristic {
return isNotifying;
}
- // Gets the last successfully written value to the characteristic.
- // Returns null if no value has yet been written to the characteristic.
+ // Gets the last successfully written value to the characteristic and its
+ // write type. Write type is one of 'none', 'default-deprecated',
+ // 'with-response', 'without-response'. Returns {lastValue: null,
+ // lastWriteType: 'none'} if no value has yet been written to the
+ // characteristic.
async getLastWrittenValue() {
- let {success, value} =
- await this.fake_central_ptr_.getLastWrittenCharacteristicValue(
- ...this.ids_);
+ let {success, value, writeType} =
+ await this.fake_central_ptr_.getLastWrittenCharacteristicValue(
+ ...this.ids_);
if (!success) throw 'getLastWrittenCharacteristicValue failed';
- return value;
+ return {lastValue: value, lastWriteType: writeTypeToString(writeType)};
}
// Removes the fake GATT Characteristic from its fake service.
diff --git a/tests/wpt/web-platform-tests/scroll-animations/cancel-animation.html b/tests/wpt/web-platform-tests/scroll-animations/cancel-animation.html
new file mode 100644
index 00000000000..16858f4f2b2
--- /dev/null
+++ b/tests/wpt/web-platform-tests/scroll-animations/cancel-animation.html
@@ -0,0 +1,214 @@
+
+
+<Canceling an animation
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/scroll-animations/finish-animation.html b/tests/wpt/web-platform-tests/scroll-animations/finish-animation.html
index 6729d2fe7f3..ab80458b033 100644
--- a/tests/wpt/web-platform-tests/scroll-animations/finish-animation.html
+++ b/tests/wpt/web-platform-tests/scroll-animations/finish-animation.html
@@ -339,5 +339,155 @@
}, 'Finishing running animation attached to inactive timeline pauses the ' +
'animation.');
+ promise_test(async t => {
+ const animation = createScrollLinkedAnimation(t);
+ // Wait for new animation frame which allows the timeline to compute new
+ // current time.
+ await waitForNextFrame();
+ animation.pause();
+ await animation.ready;
+
+ animation.finish();
+
+ assert_equals(animation.playState, 'finished',
+ 'The play state of a paused animation should become ' +
+ '"finished"');
+ assert_times_equal(animation.startTime,
+ animation.timeline.currentTime - 1000,
+ 'The start time of a paused animation should be set');
+ }, 'Finishing a paused animation resolves the start time');
+
+ promise_test(async t => {
+ const animation = createScrollLinkedAnimation(t);
+ // Wait for new animation frame which allows the timeline to compute new
+ // current time.
+ await waitForNextFrame();
+ animation.play();
+ // Update playbackRate so we can test that the calculated startTime
+ // respects it
+ animation.playbackRate = 2;
+ animation.pause();
+ // While animation is still pause-pending call finish()
+ animation.finish();
+
+ assert_false(animation.pending);
+ assert_equals(animation.playState, 'finished',
+ 'The play state of a pause-pending animation should become ' +
+ '"finished"');
+ assert_times_equal(animation.startTime,
+ animation.timeline.currentTime - 1000 / 2,
+ 'The start time of a pause-pending animation should ' +
+ 'be set');
+ }, 'Finishing a pause-pending animation resolves the pending task'
+ + ' immediately and update the start time');
+
+ promise_test(async t => {
+ const animation = createScrollLinkedAnimation(t);
+ // Wait for new animation frame which allows the timeline to compute new
+ // current time.
+ await waitForNextFrame();
+ animation.play();
+ animation.playbackRate = -2;
+ animation.pause();
+ animation.finish();
+
+ assert_false(animation.pending);
+ assert_equals(animation.playState, 'finished',
+ 'The play state of a pause-pending animation should become ' +
+ '"finished"');
+ assert_times_equal(animation.startTime, animation.timeline.currentTime,
+ 'The start time of a pause-pending animation should be ' +
+ 'set');
+ }, 'Finishing a pause-pending animation with negative playback rate'
+ + ' resolves the pending task immediately');
+
+ promise_test(async t => {
+ const animation = createScrollLinkedAnimation(t);
+ // Wait for new animation frame which allows the timeline to compute new
+ // current time.
+ await waitForNextFrame();
+ animation.play();
+ await animation.ready;
+
+ animation.pause();
+ animation.play();
+ // We are now in the unusual situation of being play-pending whilst having
+ // a resolved start time. Check that finish() still triggers a transition
+ // to the finished state immediately.
+ animation.finish();
+
+ assert_equals(animation.playState, 'finished',
+ 'After aborting a pause then finishing an animation its play ' +
+ 'state should become "finished" immediately');
+ }, 'Finishing an animation during an aborted pause makes it finished'
+ + ' immediately');
+
+ promise_test(async t => {
+ const animation = createScrollLinkedAnimation(t);
+ // Wait for new animation frame which allows the timeline to compute new
+ // current time.
+ await waitForNextFrame();
+ animation.play();
+ await animation.ready;
+
+ animation.updatePlaybackRate(2);
+ assert_true(animation.pending);
+
+ animation.finish();
+ assert_false(animation.pending);
+ assert_equals(animation.playbackRate, 2);
+ assert_times_equal(animation.currentTime, 1000);
+ }, 'A pending playback rate should be applied immediately when an animation'
+ + ' is finished');
+
+ promise_test(async t => {
+ const animation = createScrollLinkedAnimation(t);
+ // Wait for new animation frame which allows the timeline to compute new
+ // current time.
+ await waitForNextFrame();
+ animation.play();
+ await animation.ready;
+
+ animation.updatePlaybackRate(0);
+
+ assert_throws_dom('InvalidStateError', () => {
+ animation.finish();
+ });
+ }, 'An exception should be thrown if the effective playback rate is zero');
+
+ promise_test(async t => {
+ const animation = createScrollLinkedAnimation(t);
+ animation.effect.updateTiming({ iterations: Infinity });
+ // Wait for new animation frame which allows the timeline to compute new
+ // current time.
+ await waitForNextFrame();
+ animation.play();
+ animation.currentTime = 500;
+ animation.playbackRate = -1;
+ await animation.ready;
+
+ animation.updatePlaybackRate(1);
+
+ assert_throws_dom('InvalidStateError', () => {
+ animation.finish();
+ });
+ }, 'An exception should be thrown when finishing if the effective playback rate'
+ + ' is positive and the target effect end is infinity');
+
+ promise_test(async t => {
+ const animation = createScrollLinkedAnimation(t);
+ animation.effect.updateTiming({ iterations: Infinity });
+ // Wait for new animation frame which allows the timeline to compute new
+ // current time.
+ await waitForNextFrame();
+ animation.play();
+ await animation.ready;
+
+ animation.updatePlaybackRate(-1);
+
+ animation.finish();
+ // Should not have thrown
+ }, 'An exception is NOT thrown when finishing if the effective playback rate'
+ + ' is negative and the target effect end is infinity');
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/scroll-animations/pause-animation.html b/tests/wpt/web-platform-tests/scroll-animations/pause-animation.html
new file mode 100644
index 00000000000..07c72aad07c
--- /dev/null
+++ b/tests/wpt/web-platform-tests/scroll-animations/pause-animation.html
@@ -0,0 +1,209 @@
+
+
+Pausing an animation
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/scroll-animations/play-animation.html b/tests/wpt/web-platform-tests/scroll-animations/play-animation.html
new file mode 100644
index 00000000000..fc1182d80a0
--- /dev/null
+++ b/tests/wpt/web-platform-tests/scroll-animations/play-animation.html
@@ -0,0 +1,234 @@
+
+
+Playing an animation
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/scroll-animations/reverse-animation.html b/tests/wpt/web-platform-tests/scroll-animations/reverse-animation.html
new file mode 100644
index 00000000000..95c772e30a8
--- /dev/null
+++ b/tests/wpt/web-platform-tests/scroll-animations/reverse-animation.html
@@ -0,0 +1,330 @@
+
+
+Reversing an animation
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/scroll-animations/scroll-animation-inactive-timeline.html b/tests/wpt/web-platform-tests/scroll-animations/scroll-animation-inactive-timeline.html
index 2d36648925c..70b732eddd6 100644
--- a/tests/wpt/web-platform-tests/scroll-animations/scroll-animation-inactive-timeline.html
+++ b/tests/wpt/web-platform-tests/scroll-animations/scroll-animation-inactive-timeline.html
@@ -12,6 +12,7 @@
width: 100px;
will-change: transform;
}
+
.contents {
height: 1000px;
width: 100%;
@@ -29,6 +30,8 @@ promise_test(async t => {
// Wait for new animation frame which allows the timeline to compute new
// current time.
await waitForNextFrame();
+ assert_equals(animation.timeline.currentTime, null,
+ 'Sanity check the timeline is inactive.');
// Play the animation when the timeline is inactive.
animation.play();
assert_equals(animation.currentTime, null,
@@ -50,6 +53,8 @@ promise_test(async t => {
// Wait for new animation frame which allows the timeline to compute new
// current time.
await waitForNextFrame();
+ assert_equals(animation.timeline.currentTime, null,
+ 'Sanity check the timeline is inactive.');
// Play the animation when the timeline is inactive.
animation.play();
@@ -70,9 +75,12 @@ promise_test(async t => {
const target = animation.effect.target;
// Make the scroll timeline inactive.
scroller.style.overflow = 'visible';
+ scroller.scrollTop;
// Wait for new animation frame which allows the timeline to compute new
// current time.
await waitForNextFrame();
+ assert_equals(animation.timeline.currentTime, null,
+ 'Sanity check the timeline is inactive.');
// Set start time when the timeline is inactive.
animation.startTime = 0;
assert_equals(animation.currentTime, null,
@@ -115,6 +123,8 @@ promise_test(async t => {
scroller.style.overflow = 'visible';
scroller.scrollTop;
await waitForNextFrame();
+ assert_equals(animation.timeline.currentTime, null,
+ 'Sanity check the timeline is inactive.');
assert_equals(animation.playState, 'running',
'State is \'running\' when the timeline is inactive.');
assert_equals(animation.currentTime, null,
@@ -146,32 +156,4 @@ promise_test(async t => {
'Animation has an effect when the timeline is active.');
}, 'Animation current time is correct when the timeline becomes newly ' +
'inactive and then active again.');
-
-promise_test(async t => {
- const animation = createScrollLinkedAnimation(t);
- const scroller = animation.timeline.scrollSource;
- scroller.scrollTop;
-
- // Wait for new animation frame which allows the timeline to compute new
- // current time.
- await waitForNextFrame();
- animation.play();
- await animation.ready;
-
- // Make the scroll timeline inactive.
- scroller.style.overflow = 'visible';
- scroller.scrollTop;
- await waitForNextFrame();
-
- const eventWatcher = new EventWatcher(t, animation, 'cancel');
- animation.cancel();
- const cancelEvent = await eventWatcher.wait_for('cancel');
-
- assert_equals(cancelEvent.currentTime, null,
- 'event.currentTime should be unresolved when the timeline is inactive.');
- assert_equals(cancelEvent.timelineTime, null,
- 'event.timelineTime should be unresolved when the timeline is inactive');
-}, 'oncancel event is fired when the timeline is inactive.');
-
-
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/scroll-animations/scroll-timeline-phases.tentative.html b/tests/wpt/web-platform-tests/scroll-animations/scroll-timeline-phases.tentative.html
index 46fe06a0bdd..c58ba1dc066 100644
--- a/tests/wpt/web-platform-tests/scroll-animations/scroll-timeline-phases.tentative.html
+++ b/tests/wpt/web-platform-tests/scroll-animations/scroll-timeline-phases.tentative.html
@@ -193,18 +193,21 @@
promise_test(async t => {
const timeline = createScrollTimeline(t);
const scroller = timeline.scrollSource;
- // Timeline should be inactive since layout hasn't updated yet
+ // Setting the scroller to display none should make the timeline inactive
+ scroller.style.display = "none";
+ scroller.scrollTop;
+ await waitForNextFrame();
assert_equals(timeline.phase, "inactive");
- // Accessing scroller.scrollHeight forces the scroller to update
- scroller.scrollHeight;
- // Wait for new animation frame which allows the timeline to compute new
- // current time.
+ // Setting the scroller to display "block" should make the timeline active
+ scroller.style.display = "block";
+ scroller.scrollTop;
await waitForNextFrame();
assert_equals(timeline.phase, "active");
// Setting the scroller to display none should make the timeline inactive
- scroller.style.display = "none"
+ scroller.style.display = "none";
+ scroller.scrollTop;
await waitForNextFrame();
assert_equals(timeline.phase, "inactive");
diff --git a/tests/wpt/web-platform-tests/scroll-animations/setting-start-time.html b/tests/wpt/web-platform-tests/scroll-animations/setting-start-time.html
index 9346214b057..2b208e7e06a 100644
--- a/tests/wpt/web-platform-tests/scroll-animations/setting-start-time.html
+++ b/tests/wpt/web-platform-tests/scroll-animations/setting-start-time.html
@@ -13,6 +13,7 @@
width: 100px;
will-change: transform;
}
+
.contents {
height: 1000px;
width: 100%;
@@ -28,7 +29,7 @@ promise_test(async t => {
const scroller = animation.timeline.scrollSource;
const maxScroll = scroller.scrollHeight - scroller.clientHeight;
scroller.scrollTop = 0.2 * maxScroll;
- // Wait for new animation frame which allows the timeline to compute new
+ // Wait for new animation frame which allows the timeline to compute new
// current time.
await waitForNextFrame();
@@ -60,7 +61,7 @@ promise_test(async t => {
const scroller = animation.timeline.scrollSource;
// Make the scroll timeline inactive.
scroller.style.overflow = 'visible';
- // Wait for new animation frame which allows the timeline to compute new
+ // Wait for new animation frame which allows the timeline to compute new
// current time.
await waitForNextFrame();
assert_equals(animation.timeline.currentTime, null,
@@ -95,7 +96,7 @@ promise_test(async t => {
const maxScroll = scroller.scrollHeight - scroller.clientHeight;
scroller.scrollTop = 0.2 * maxScroll;
- // Wait for new animation frame which allows the timeline to compute new
+ // Wait for new animation frame which allows the timeline to compute new
// current time.
await waitForNextFrame();
@@ -124,7 +125,7 @@ promise_test(async t => {
const scroller = animation.timeline.scrollSource;
// Make the scroll timeline inactive.
scroller.style.overflow = 'visible';
- // Wait for new animation frame which allows the timeline to compute new
+ // Wait for new animation frame which allows the timeline to compute new
// current time.
await waitForNextFrame();
assert_equals(animation.timeline.currentTime, null,
@@ -156,7 +157,7 @@ promise_test(async t => {
promise_test(async t => {
const animation = createScrollLinkedAnimation(t);
- // Wait for new animation frame which allows the timeline to compute new
+ // Wait for new animation frame which allows the timeline to compute new
// current time.
await waitForNextFrame();
@@ -190,7 +191,7 @@ promise_test(async t => {
const scroller = animation.timeline.scrollSource;
// Make the scroll timeline inactive.
scroller.style.overflow = 'visible';
- // Wait for new animation frame which allows the timeline to compute new
+ // Wait for new animation frame which allows the timeline to compute new
// current time.
await waitForNextFrame();
assert_equals(animation.timeline.currentTime, null,
@@ -225,7 +226,7 @@ promise_test(async t => {
promise_test(async t => {
const animation = createScrollLinkedAnimation(t);
- // Wait for new animation frame which allows the timeline to compute new
+ // Wait for new animation frame which allows the timeline to compute new
// current time.
await waitForNextFrame();
@@ -249,7 +250,7 @@ promise_test(async t => {
const scroller = animation.timeline.scrollSource;
// Make the scroll timeline inactive.
scroller.style.overflow = 'visible';
- // Wait for new animation frame which allows the timeline to compute new
+ // Wait for new animation frame which allows the timeline to compute new
// current time.
await waitForNextFrame();
assert_equals(animation.timeline.currentTime, null,
@@ -272,7 +273,7 @@ promise_test(async t => {
promise_test(async t => {
const animation = createScrollLinkedAnimation(t);
- // Wait for new animation frame which allows the timeline to compute new
+ // Wait for new animation frame which allows the timeline to compute new
// current time.
await waitForNextFrame();
@@ -301,7 +302,7 @@ promise_test(async t => {
promise_test(async t => {
const animation = createScrollLinkedAnimation(t);
- // Wait for new animation frame which allows the timeline to compute new
+ // Wait for new animation frame which allows the timeline to compute new
// current time.
await waitForNextFrame();
animation.play();
@@ -319,7 +320,7 @@ promise_test(async t => {
promise_test(async t => {
const animation = createScrollLinkedAnimation(t);
- // Wait for new animation frame which allows the timeline to compute new
+ // Wait for new animation frame which allows the timeline to compute new
// current time.
await waitForNextFrame();
animation.play();
@@ -336,5 +337,85 @@ promise_test(async t => {
assert_times_equal(animation.currentTime, -2000);
}, 'Setting the start time on a reverse running animation updates the play '
+ 'state');
+ promise_test(async t => {
+ const animation = createScrollLinkedAnimation(t);
+ // Wait for new animation frame which allows the timeline to compute new
+ // current time.
+ await waitForNextFrame();
+ let readyPromiseCallbackCalled = false;
+ animation.ready.then(() => { readyPromiseCallbackCalled = true; } );
+ animation.pause();
+
+ // Sanity check
+ assert_true(animation.pending && animation.playState === 'paused',
+ 'Animation is in pause-pending state');
+
+ // Setting the start time should resolve the 'ready' promise although
+ // the resolution callbacks when be run in a separate microtask.
+ animation.startTime = null;
+ assert_false(readyPromiseCallbackCalled,
+ 'Ready promise callback is not called synchronously');
+
+ await Promise.resolve();
+ assert_true(readyPromiseCallbackCalled,
+ 'Ready promise callback called after setting startTime');
+}, 'Setting the start time resolves a pending pause task');
+
+promise_test(async t => {
+ const anim = createScrollLinkedAnimation(t);
+ // Wait for new animation frame which allows the timeline to compute new
+ // current time.
+ await waitForNextFrame();
+ anim.play();
+
+ // We should be play-pending now
+ assert_true(anim.pending);
+ assert_equals(anim.playState, 'running');
+
+ // Apply a pending playback rate
+ anim.updatePlaybackRate(2);
+ assert_equals(anim.playbackRate, 1);
+ assert_true(anim.pending);
+
+ // Setting the start time should apply the pending playback rate
+ anim.startTime = anim.timeline.currentTime - 25 * MS_PER_SEC;
+ assert_equals(anim.playbackRate, 2);
+ assert_false(anim.pending);
+
+ // Sanity check that the start time is preserved and current time is
+ // calculated using the new playback rate
+ assert_times_equal(anim.startTime,
+ anim.timeline.currentTime - 25 * MS_PER_SEC);
+ assert_time_equals_literal(anim.currentTime, 50 * MS_PER_SEC);
+}, 'Setting the start time of a play-pending animation applies a pending playback rate');
+
+promise_test(async t => {
+ const anim = createScrollLinkedAnimation(t);
+ // Wait for new animation frame which allows the timeline to compute new
+ // current time.
+ await waitForNextFrame();
+ anim.play();
+ await anim.ready;
+
+ // We should be running now
+ assert_false(anim.pending);
+ assert_equals(anim.playState, 'running');
+
+ // Apply a pending playback rate
+ anim.updatePlaybackRate(2);
+ assert_equals(anim.playbackRate, 1);
+ assert_true(anim.pending);
+
+ // Setting the start time should apply the pending playback rate
+ anim.startTime = anim.timeline.currentTime - 250;
+ assert_equals(anim.playbackRate, 2);
+ assert_false(anim.pending);
+
+ // Sanity check that the start time is preserved and current time is
+ // calculated using the new playback rate
+ assert_times_equal(anim.startTime,
+ anim.timeline.currentTime - 250);
+ assert_time_equals_literal(parseInt(anim.currentTime.toPrecision(5), 10), 500);
+}, 'Setting the start time of a playing animation applies a pending playback rate');
diff --git a/tests/wpt/web-platform-tests/scroll-animations/testcommon.js b/tests/wpt/web-platform-tests/scroll-animations/testcommon.js
index 733b5f9f643..96bafdb396b 100644
--- a/tests/wpt/web-platform-tests/scroll-animations/testcommon.js
+++ b/tests/wpt/web-platform-tests/scroll-animations/testcommon.js
@@ -2,6 +2,8 @@ function createScroller(test) {
var scroller = createDiv(test);
scroller.innerHTML = "";
scroller.classList.add('scroller');
+ // Trigger layout run.
+ scroller.scrollTop;
return scroller;
}
diff --git a/tests/wpt/web-platform-tests/scroll-animations/update-playback-rate.html b/tests/wpt/web-platform-tests/scroll-animations/update-playback-rate.html
new file mode 100644
index 00000000000..82cf69999f6
--- /dev/null
+++ b/tests/wpt/web-platform-tests/scroll-animations/update-playback-rate.html
@@ -0,0 +1,181 @@
+
+
+Seamlessly updating the playback rate of an animation
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/scroll-animations/updating-the-finished-state.html b/tests/wpt/web-platform-tests/scroll-animations/updating-the-finished-state.html
new file mode 100644
index 00000000000..2e758dbe689
--- /dev/null
+++ b/tests/wpt/web-platform-tests/scroll-animations/updating-the-finished-state.html
@@ -0,0 +1,674 @@
+
+
+Updating the finished state
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/service-workers/service-worker/resources/mime-sniffing-worker.js b/tests/wpt/web-platform-tests/service-workers/service-worker/resources/mime-sniffing-worker.js
index 046628055e1..5c34a7a49e8 100644
--- a/tests/wpt/web-platform-tests/service-workers/service-worker/resources/mime-sniffing-worker.js
+++ b/tests/wpt/web-platform-tests/service-workers/service-worker/resources/mime-sniffing-worker.js
@@ -1,5 +1,9 @@
self.addEventListener('fetch', function(event) {
- var res = new Response('\n
test
');
- res.headers.delete('content-type');
+ // Use an empty content-type value to force mime-sniffing. Note, this
+ // must be passed to the constructor since the mime-type of the Response
+ // is fixed and cannot be later changed.
+ var res = new Response('\n
test
', {
+ headers: { 'content-type': '' }
+ });
event.respondWith(res);
});
diff --git a/tests/wpt/web-platform-tests/xhr/resources/inspect-headers.py b/tests/wpt/web-platform-tests/xhr/resources/inspect-headers.py
index e71f671ced3..68cece452c9 100644
--- a/tests/wpt/web-platform-tests/xhr/resources/inspect-headers.py
+++ b/tests/wpt/web-platform-tests/xhr/resources/inspect-headers.py
@@ -1,33 +1,50 @@
+from six import PY3
+
def get_response(raw_headers, filter_value, filter_name):
- result = ""
- for line in raw_headers.headers:
- if line[-2:] != '\r\n':
- return "Syntax error: missing CRLF: " + line
+ result = b""
+ # Type of raw_headers is in Python 2 and in
+ # Python 3. doesn't have 'headers" attribute or equivalent
+ # [https://bugs.python.org/issue4773].
+ # In Python 2, variable raw_headers.headers returns a completely uninterpreted list of lines
+ # contained in the header. In Python 3, raw_headers.as_string() returns entire formatted
+ # message as a string. Here is to construct an equivalent "headers" variable to support tests
+ # in Python 3.
+ if PY3:
+ header_list = [
+ (s + u'\r\n').encode("iso-8859-1") for s in raw_headers.as_string().splitlines() if s
+ ]
+ else:
+ header_list = raw_headers.headers
+ for line in header_list:
+ if line[-2:] != b'\r\n':
+ return b"Syntax error: missing CRLF: " + line
line = line[:-2]
- if ': ' not in line:
- return "Syntax error: no colon and space found: " + line
- name, value = line.split(': ', 1)
+ if b': ' not in line:
+ return b"Syntax error: no colon and space found: " + line
+ name, value = line.split(b': ', 1)
if filter_value:
if value == filter_value:
- result += name + ","
+ result += name + b","
elif name.lower() == filter_name:
- result += name + ": " + value + "\n"
+ result += name + b": " + value + b"\n"
return result
def main(request, response):
headers = []
if "cors" in request.GET:
- headers.append(("Access-Control-Allow-Origin", "*"))
- headers.append(("Access-Control-Allow-Credentials", "true"))
- headers.append(("Access-Control-Allow-Methods", "GET, POST, PUT, FOO"))
- headers.append(("Access-Control-Allow-Headers", "x-test, x-foo"))
- headers.append(("Access-Control-Expose-Headers", "x-request-method, x-request-content-type, x-request-query, x-request-content-length"))
- headers.append(("content-type", "text/plain"))
+ headers.append((b"Access-Control-Allow-Origin", b"*"))
+ headers.append((b"Access-Control-Allow-Credentials", b"true"))
+ headers.append((b"Access-Control-Allow-Methods", b"GET, POST, PUT, FOO"))
+ headers.append((b"Access-Control-Allow-Headers", b"x-test, x-foo"))
+ headers.append((
+ b"Access-Control-Expose-Headers",
+ b"x-request-method, x-request-content-type, x-request-query, x-request-content-length"))
+ headers.append((b"content-type", b"text/plain"))
- filter_value = request.GET.first("filter_value", "")
- filter_name = request.GET.first("filter_name", "").lower()
+ filter_value = request.GET.first(b"filter_value", b"")
+ filter_name = request.GET.first(b"filter_name", b"").lower()
result = get_response(request.raw_headers, filter_value, filter_name)
return headers, result