Update web-platform-tests to revision 3f3849c5d05f9350fad0b06d3bb3ae30d7e18d14

tests/wpt/metadata/FileAPI/url/url-with-fetch.any.js.ini

@@ -14,6 +14,9 @@
   [Revoke blob URL after creating Request, will fetch]
     expected: FAIL
 
+  [Revoke blob URL after calling fetch, fetch should succeed]
+    expected: FAIL
+
 
 [url-with-fetch.any.html]
   [Untitled]
@@ -34,6 +37,3 @@
   [Revoke blob URL after creating Request, will fetch]
     expected: FAIL
 
-  [Revoke blob URL after calling fetch, fetch should succeed]
-    expected: FAIL
-

tests/wpt/metadata/css/css-text/white-space/break-spaces-tab-001.html.ini

@@ -0,0 +1,2 @@
+[break-spaces-tab-001.html]
+  expected: FAIL

tests/wpt/metadata/css/css-text/white-space/break-spaces-tab-002.html.ini

@@ -0,0 +1,2 @@
+[break-spaces-tab-002.html]
+  expected: FAIL

tests/wpt/metadata/css/css-text/white-space/break-spaces-tab-003.html.ini

@@ -0,0 +1,2 @@
+[break-spaces-tab-003.html]
+  expected: FAIL

tests/wpt/metadata/css/css-text/white-space/break-spaces-tab-004.html.ini

@@ -0,0 +1,2 @@
+[break-spaces-tab-004.html]
+  expected: FAIL

tests/wpt/metadata/css/css-text/white-space/break-spaces-tab-005.html.ini

@@ -0,0 +1,2 @@
+[break-spaces-tab-005.html]
+  expected: FAIL

tests/wpt/metadata/css/css-text/white-space/break-spaces-tab-006.html.ini

@@ -0,0 +1,2 @@
+[break-spaces-tab-006.html]
+  expected: FAIL

tests/wpt/metadata/css/css-text/white-space/pre-wrap-tab-003.html.ini

@@ -0,0 +1,2 @@
+[pre-wrap-tab-003.html]
+  expected: FAIL

tests/wpt/metadata/css/css-text/white-space/pre-wrap-tab-004.html.ini

@@ -0,0 +1,2 @@
+[pre-wrap-tab-004.html]
+  expected: FAIL

tests/wpt/metadata/css/css-text/white-space/pre-wrap-tab-005.html.ini

@@ -0,0 +1,2 @@
+[pre-wrap-tab-005.html]
+  expected: FAIL

tests/wpt/metadata/css/css-text/white-space/pre-wrap-tab-006.html.ini

@@ -0,0 +1,2 @@
+[pre-wrap-tab-006.html]
+  expected: FAIL

tests/wpt/metadata/css/css-transforms/parsing/perspective-origin-computed.html.ini

@@ -0,0 +1,64 @@
+[perspective-origin-computed.html]
+  [Property perspective-origin value '40px top' computes to '40px 0px']
+    expected: FAIL
+
+  [Property perspective-origin value 'right 30% top -60px' computes to '140px -60px']
+    expected: FAIL
+
+  [Property perspective-origin value '10%' computes to '20px 150px']
+    expected: FAIL
+
+  [Property perspective-origin value '30px center' computes to '30px 150px']
+    expected: FAIL
+
+  [Property perspective-origin value 'center bottom' computes to '100px 300px']
+    expected: FAIL
+
+  [Property perspective-origin value 'left 10px' computes to '0px 10px']
+    expected: FAIL
+
+  [Property perspective-origin value '20% 30px' computes to '40px 30px']
+    expected: FAIL
+
+  [Property perspective-origin value 'top' computes to '100px 0px']
+    expected: FAIL
+
+  [Property perspective-origin value 'center' computes to '100px 150px']
+    expected: FAIL
+
+  [Property perspective-origin value 'center 50px' computes to '100px 50px']
+    expected: FAIL
+
+  [Property perspective-origin value '10% center' computes to '20px 150px']
+    expected: FAIL
+
+  [Property perspective-origin value 'left' computes to '0px 150px']
+    expected: FAIL
+
+  [Property perspective-origin value 'bottom 10% right 20%' computes to '160px 270px']
+    expected: FAIL
+
+  [Property perspective-origin value 'center left' computes to '0px 150px']
+    expected: FAIL
+
+  [Property perspective-origin value 'right 20px bottom 30px' computes to '180px 270px']
+    expected: FAIL
+
+  [Property perspective-origin value 'right calc(10px - 0.5em) top calc(10px - 0.5em)' computes to '210px -10px']
+    expected: FAIL
+
+  [Property perspective-origin value 'left bottom' computes to '0px 300px']
+    expected: FAIL
+
+  [Property perspective-origin value 'bottom right' computes to '200px 300px']
+    expected: FAIL
+
+  [Property perspective-origin value 'right 40%' computes to '200px 120px']
+    expected: FAIL
+
+  [Property perspective-origin value 'left center' computes to '0px 150px']
+    expected: FAIL
+
+  [Property perspective-origin value 'center center' computes to '100px 150px']
+    expected: FAIL
+

tests/wpt/metadata/css/css-transforms/parsing/transform-origin-computed.html.ini

@@ -0,0 +1,67 @@
+[transform-origin-computed.html]
+  [Property transform-origin value 'center bottom' computes to '100px 300px']
+    expected: FAIL
+
+  [Property transform-origin value 'center top' computes to '100px 0px']
+    expected: FAIL
+
+  [Property transform-origin value 'left 10px' computes to '0px 10px']
+    expected: FAIL
+
+  [Property transform-origin value 'right 40%' computes to '200px 120px']
+    expected: FAIL
+
+  [Property transform-origin value '10% center' computes to '20px 150px']
+    expected: FAIL
+
+  [Property transform-origin value '40px top' computes to '40px 0px']
+    expected: FAIL
+
+  [Property transform-origin value 'left bottom' computes to '0px 300px']
+    expected: FAIL
+
+  [Property transform-origin value '-1px bottom 5px' computes to '-1px 300px 5px']
+    expected: FAIL
+
+  [Property transform-origin value '10%' computes to '20px 150px']
+    expected: FAIL
+
+  [Property transform-origin value 'top' computes to '100px 0px']
+    expected: FAIL
+
+  [Property transform-origin value 'bottom right' computes to '200px 300px']
+    expected: FAIL
+
+  [Property transform-origin value 'right bottom 7px' computes to '200px 300px 7px']
+    expected: FAIL
+
+  [Property transform-origin value '20% 30px' computes to '40px 30px']
+    expected: FAIL
+
+  [Property transform-origin value 'calc(-100% + 10px - 0.5em) calc(10px - 0.5em) calc(10px - 0.5em)' computes to '-210px -10px -10px']
+    expected: FAIL
+
+  [Property transform-origin value 'center center' computes to '100px 150px']
+    expected: FAIL
+
+  [Property transform-origin value 'center 50px' computes to '100px 50px']
+    expected: FAIL
+
+  [Property transform-origin value 'left center' computes to '0px 150px']
+    expected: FAIL
+
+  [Property transform-origin value 'center left' computes to '0px 150px']
+    expected: FAIL
+
+  [Property transform-origin value 'center' computes to '100px 150px']
+    expected: FAIL
+
+  [Property transform-origin value '30px center' computes to '30px 150px']
+    expected: FAIL
+
+  [Property transform-origin value 'left center 6px' computes to '0px 150px 6px']
+    expected: FAIL
+
+  [Property transform-origin value 'left' computes to '0px 150px']
+    expected: FAIL
+

tests/wpt/metadata/css/css-transitions/properties-value-001.html.ini

@@ -1079,6 +1079,3 @@
   [text-indent percentage(%) / values]
     expected: FAIL
 
-  [padding-bottom length(ex) / values]
-    expected: FAIL
-

tests/wpt/metadata/css/cssom-view/scrollLeftTop.html.ini

@@ -0,0 +1,19 @@
+[scrollLeftTop.html]
+  [writing-mode:vertical-lr; direction:ltr]
+    expected: FAIL
+
+  [writing-mode:vertical-rl; direction:rtl]
+    expected: FAIL
+
+  [writing-mode:vertical-lr; direction:rtl]
+    expected: FAIL
+
+  [writing-mode:vertical-rl; direction:ltr]
+    expected: FAIL
+
+  [writing-mode:horizontal-tb; direction:ltr]
+    expected: FAIL
+
+  [writing-mode:horizontal-tb; direction:rtl]
+    expected: FAIL
+

tests/wpt/metadata/css/cssom/interfaces.html.ini

@@ -1296,3 +1296,6 @@
   [CSSStyleSheet interface: calling addRule(DOMString, DOMString, unsigned long) on sheet with too few arguments must throw TypeError]
     expected: FAIL
 
+  [SVGStyleElement interface: attribute sheet]
+    expected: FAIL
+

tests/wpt/metadata/fetch/content-type/response.window.js.ini

@@ -315,12 +315,18 @@
   [<iframe>: combined response Content-Type: text/html */*]
     expected: FAIL
 
-  [<iframe>: separate response Content-Type: text/plain */*]
-    expected: FAIL
-
   [<iframe>: combined response Content-Type: text/html;x=" text/plain]
     expected: FAIL
 
-  [<iframe>: separate response Content-Type: text/plain */*;charset=gbk]
+  [<iframe>: combined response Content-Type: text/html;" text/plain]
+    expected: FAIL
+
+  [<iframe>: separate response Content-Type: text/html */*]
+    expected: FAIL
+
+  [<iframe>: combined response Content-Type: text/html */*;charset=gbk]
+    expected: FAIL
+
+  [<iframe>: separate response Content-Type: text/html;" \\" text/plain]
     expected: FAIL
 

tests/wpt/metadata/fetch/content-type/script.window.js.ini

@@ -59,3 +59,6 @@
   [separate text/javascript;charset=windows-1252 error text/javascript]
     expected: FAIL
 
+  [separate text/javascript error]
+    expected: FAIL
+

tests/wpt/metadata/fetch/nosniff/parsing-nosniff.window.js.ini

@@ -11,6 +11,6 @@
   [X-Content-Type-Options%3A%20nosniff%0C]
     expected: FAIL
 
-  [Content-Type-Options%3A%20nosniff]
+  [X-Content-Type-Options%3A%20'NosniFF']
     expected: FAIL
 

tests/wpt/metadata/html/browsers/history/the-history-interface/traverse_the_history_1.html.ini

@@ -1,4 +0,0 @@
-[traverse_the_history_1.html]
-  [Multiple history traversals from the same task]
-    expected: FAIL
-

tests/wpt/metadata/html/browsers/history/the-history-interface/traverse_the_history_2.html.ini

@@ -1,4 +1,4 @@
-[traverse_the_history_4.html]
+[traverse_the_history_2.html]
   [Multiple history traversals, last would be aborted]
     expected: FAIL
 

tests/wpt/metadata/html/browsers/history/the-history-interface/traverse_the_history_5.html.ini

@@ -0,0 +1,4 @@
+[traverse_the_history_5.html]
+  [Multiple history traversals, last would be aborted]
+    expected: FAIL
+

tests/wpt/metadata/html/browsers/the-window-object/apis-for-creating-and-navigating-browsing-contexts-by-name/creating_browsing_context_test_01.html.ini

@@ -0,0 +1,5 @@
+[creating_browsing_context_test_01.html]
+  expected: TIMEOUT
+  [first argument: absolute url]
+    expected: TIMEOUT
+

tests/wpt/metadata/html/dom/interfaces.https.html.ini

@@ -10556,3 +10556,93 @@
   [ElementInternals interface: attribute validity]
     expected: FAIL
 
+  [SVGSVGElement interface: attribute onstorage]
+    expected: FAIL
+
+  [SVGAElement interface: attribute hash]
+    expected: FAIL
+
+  [SVGSVGElement interface: attribute onbeforeprint]
+    expected: FAIL
+
+  [SVGAElement interface: attribute protocol]
+    expected: FAIL
+
+  [SVGSVGElement interface: attribute onoffline]
+    expected: FAIL
+
+  [SVGAElement interface: stringifier]
+    expected: FAIL
+
+  [SVGSVGElement interface: attribute onpageshow]
+    expected: FAIL
+
+  [SVGAElement interface: attribute search]
+    expected: FAIL
+
+  [SVGSVGElement interface: attribute onunload]
+    expected: FAIL
+
+  [SVGAElement interface: attribute port]
+    expected: FAIL
+
+  [SVGSVGElement interface: attribute onbeforeunload]
+    expected: FAIL
+
+  [SVGSVGElement interface: attribute onmessageerror]
+    expected: FAIL
+
+  [SVGSVGElement interface: attribute onmessage]
+    expected: FAIL
+
+  [SVGAElement interface: attribute hostname]
+    expected: FAIL
+
+  [SVGAElement interface: attribute pathname]
+    expected: FAIL
+
+  [SVGAElement interface: attribute host]
+    expected: FAIL
+
+  [SVGSVGElement interface: attribute onlanguagechange]
+    expected: FAIL
+
+  [SVGSVGElement interface: attribute onunhandledrejection]
+    expected: FAIL
+
+  [SVGSVGElement interface: attribute onrejectionhandled]
+    expected: FAIL
+
+  [SVGSVGElement interface: attribute onhashchange]
+    expected: FAIL
+
+  [SVGAElement interface: attribute origin]
+    expected: FAIL
+
+  [SVGSVGElement interface: attribute onpopstate]
+    expected: FAIL
+
+  [SVGSVGElement interface: attribute onpagehide]
+    expected: FAIL
+
+  [WebSocket interface: new WebSocket("wss://nonexistent.web-platform.test") must inherit property "extensions" with the proper type]
+    expected: FAIL
+
+  [SVGSVGElement interface: attribute onafterprint]
+    expected: FAIL
+
+  [SVGSVGElement interface: attribute ononline]
+    expected: FAIL
+
+  [SVGAElement interface: attribute href]
+    expected: FAIL
+
+  [SVGAElement interface: attribute password]
+    expected: FAIL
+
+  [SVGAElement interface: attribute username]
+    expected: FAIL
+
+  [SVGElement interface: attribute onformdata]
+    expected: FAIL
+

tests/wpt/metadata/html/semantics/forms/form-submission-0/form-submission-algorithm.html.ini

@@ -1,7 +1,11 @@
 [form-submission-algorithm.html]
+  expected: TIMEOUT
   [If form's firing submission events is true, then return; 'submit' event]
     expected: FAIL
 
   [If form's firing submission events is true, then return; 'invalid' event]
     expected: FAIL
 
+  [Cannot navigate (after constructing the entry list)]
+    expected: TIMEOUT
+

tests/wpt/metadata/html/syntax/parsing/DOMContentLoaded-defer.html.ini

@@ -0,0 +1,4 @@
+[DOMContentLoaded-defer.html]
+  [The end: DOMContentLoaded and defer scripts]
+    expected: FAIL
+

tests/wpt/metadata/html/webappapis/scripting/processing-model-2/unhandled-promise-rejections/promise-rejection-events.html.ini

@@ -1,4 +1,5 @@
 [promise-rejection-events.html]
+  expected: TIMEOUT
   [delayed handling: delaying handling rejected promise created from createImageBitmap will cause both events to fire]
     expected: FAIL
 
@@ -8,3 +9,6 @@
   [no unhandledrejection/rejectionhandled: rejection handler attached synchronously to a promise created from createImageBitmap]
     expected: FAIL
 
+  [rejectionhandled is dispatched from a queued task, and not immediately]
+    expected: TIMEOUT
+

tests/wpt/metadata/resource-timing/resource_TAO_zero.htm.ini

@@ -20,6 +20,3 @@
   [domainLookupStart should be 0 in cross-origin request.]
     expected: FAIL
 
-  [responseEnd should be greater than 0 in cross-origin request.]
-    expected: FAIL
-

tests/wpt/metadata/webaudio/the-audio-api/the-analysernode-interface/realtimeanalyser-fft-scaling.html.ini

@@ -1,5 +1,4 @@
 [realtimeanalyser-fft-scaling.html]
-  expected: TIMEOUT
   [X 2048-point FFT peak position is not equal to 64. Got 0.]
     expected: FAIL
 

tests/wpt/metadata/webaudio/the-audio-api/the-audiobuffersourcenode-interface/sub-sample-buffer-stitching.html.ini

@@ -122,3 +122,9 @@
   [X SNR (21.35658911509222 dB) is not greater than or equal to 65.737. Got 21.35658911509222.]
     expected: FAIL
 
+  [X Stitched sine-wave buffers at sample rate 43800 does not equal [0,0.06264832615852356,0.12505052983760834,0.18696144223213196,0.24813786149024963,0.308339387178421,0.36732959747314453,0.4248766601085663,0.480754554271698,0.5347436666488647,0.5866320133209229,0.6362156271934509,0.6832997798919678,0.7276994585990906,0.7692402601242065,0.8077589869499207...\] with an element-wise tolerance of {"absoluteThreshold":0.0038986,"relativeThreshold":0}.\n\tIndex\tActual\t\t\tExpected\t\tAbsError\t\tRelError\t\tTest threshold\n\t[30\]\t9.4836157560348511e-1\t9.5236867666244507e-1\t4.0071010589599609e-3\t4.2075103446311962e-3\t3.8985999999999999e-3\n\t[31\]\t9.2646563053131104e-1\t9.3139332532882690e-1\t4.9276947975158691e-3\t5.2906700783754857e-3\t3.8985999999999999e-3\n\t[32\]\t9.0087991952896118e-1\t9.0675884485244751e-1\t5.8789253234863281e-3\t6.4834496590358351e-3\t3.8985999999999999e-3\n\t[33\]\t8.7170630693435669e-1\t8.7856203317642212e-1\t6.8557262420654297e-3\t7.8033490899654511e-3\t3.8985999999999999e-3\n\t[34\]\t8.3906102180480957e-1\t8.4691369533538818e-1\t7.8526735305786133e-3\t9.2721059699818163e-3\t3.8985999999999999e-3\n\t...and 31037 more errors.\n\tMax AbsError of 9.8276454366209975e-1 at index of 39267.\n\t[39267\]\t1.5592860336255399e-9\t-9.8276454210281372e-1\t9.8276454366209975e-1\t1.0000000015866324e+0\t3.8985999999999999e-3\n\tMax RelError of 3.3137802965303198e+0 at index of 1253.\n\t[1253\]\t-4.3022233992815018e-2\t-9.9732093513011932e-3\t3.3049024641513824e-2\t3.3137802965303198e+0\t3.8985999999999999e-3\n]
+    expected: FAIL
+
+  [X SNR (21.440582478520547 dB) is not greater than or equal to 65.737. Got 21.440582478520547.]
+    expected: FAIL
+

tests/wpt/metadata/webdriver/tests/set_window_rect/set.py.ini

@@ -41,3 +41,6 @@
   [test_height_width_larger_than_max]
     expected: FAIL
 
+  [test_negative_x_y]
+    expected: FAIL
+

tests/wpt/metadata/webxr/xrSession_prevent_multiple_exclusive.https.html.ini

@@ -1,4 +1,5 @@
 [xrSession_prevent_multiple_exclusive.https.html]
+  expected: TIMEOUT
   [Test prevention of multiple simultaneous immersive sessions]
-    expected: FAIL
+    expected: TIMEOUT
 

tests/wpt/web-platform-tests/animation-worklet/common.js

@@ -18,13 +18,20 @@ function registerConstantLocalTimeAnimator(localTime) {
   `);
 }
 
-
 function runInAnimationWorklet(code) {
   return CSS.animationWorklet.addModule(
     URL.createObjectURL(new Blob([code], {type: 'text/javascript'}))
   );
 }
 
+function approxEquals(actual, expected){
+  // precision in ms
+  const epsilon = 0.005;
+  const lowerBound = (expected - epsilon) < actual;
+  const upperBound = (expected + epsilon) > actual;
+  return lowerBound && upperBound;
+}
+
 function waitForAsyncAnimationFrames(count) {
   // In Chrome, waiting for N+1 main thread frames guarantees that compositor has produced
   // at least N frames.

tests/wpt/web-platform-tests/animation-worklet/worklet-animation-get-computed-timing-progress-on-worklet-thread.https.html

@@ -0,0 +1,87 @@
+<html>
+<title>Animation Worklet should update calculated timing whenever localTime changes</title>
+<link rel="help" href="https://drafts.css-houdini.org/css-animationworklet/">
+
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/web-animations/testcommon.js"></script>
+<script src="common.js"></script>
+
+<div id="box"></div>
+
+<script id="get_computed_timing_animator" type="text/worklet">
+  registerAnimator('get_computed_timing', class {
+    constructor(options, state) {
+      this.step = state ? state.step : 0;
+    }
+    state() {
+      return {
+        step: 0
+      }
+    }
+    animate(currentTime, effect){
+      if (this.step === 0){
+        // check calculated timing values before ever setting effect.localTime
+        effect.localTime = (effect.getComputedTiming().currentIteration * 100) + (effect.getComputedTiming().progress * 100);
+        this.step = 1;
+      }
+      else if (this.step === 1){
+        // set effect.localTime, this should be the first time calculated timing values are computed
+        effect.localTime = 420; // 20% of the way through the last iteration
+
+        // using the calculated timing of effect, set effect.localTime.
+        effect.localTime = (effect.getComputedTiming().currentIteration * 100) + (effect.getComputedTiming().progress * 100);
+        this.step = 2;
+      }
+      else if (this.step === 2){
+        // set effect.localTime to null
+        effect.localTime = null;
+        effect.localTime = (effect.getComputedTiming().currentIteration * 100) + (effect.getComputedTiming().progress * 100);
+        this.step = 3;
+      }
+      else if (this.step === 3){
+        // Check to make sure we can go from null to a valid localTime and that calculated timing values are computed
+        effect.localTime = 350; // 50% of the way through second iteration
+        effect.localTime = (effect.getComputedTiming().currentIteration * 100) + (effect.getComputedTiming().progress * 100);
+        this.step = 4;
+      }
+    }
+  });
+</script>
+
+<script>
+  promise_test(async t => {
+    await runInAnimationWorklet(document.getElementById('get_computed_timing_animator').textContent);
+
+    const box = document.getElementById("box");
+    const effect = new KeyframeEffect(
+      box,
+      [
+        { opacity: 0 },
+        { opacity: 1 }
+      ], {
+        delay: 200,
+        duration: 100,
+        iterations: 3
+      }
+    );
+
+    const animation = new WorkletAnimation('get_computed_timing', effect);
+    animation.play();
+
+    // check calculated timing values before ever setting effect.localTime
+    await waitForAnimationFrameWithCondition(() => {return approxEquals(effect.getComputedTiming().localTime, 0)});
+
+    // Check to make sure initial values can be set for computed timing
+    await waitForAnimationFrameWithCondition(() => {return approxEquals(effect.getComputedTiming().localTime, 220)});
+
+    // Make sure setting effect.localTime to null causes calculated timing values to be computed
+    await waitForAnimationFrameWithCondition(() => {return approxEquals(effect.getComputedTiming().localTime, 0)});
+
+    // Make sure we can go from null to a valid localTime and that calculated timing values are computed
+    await waitForAnimationFrameWithCondition(() => {return approxEquals(effect.getComputedTiming().localTime, 150)});
+
+    // Passes if it doesn't timeout
+    animation.cancel();
+  }, "WorkletAnimation effect should recompute its calculated timing if its local time changes");
+</script>

tests/wpt/web-platform-tests/content-security-policy/securitypolicyviolation/securitypolicyviolation-block-cross-origin-image-from-script.sub.html

@@ -15,8 +15,8 @@
         assert_equals(e.effectiveDirective, "img-src");
         assert_equals(e.originalPolicy, "img-src \'none\'");
         assert_equals(e.disposition, "enforce");
-        assert_equals(e.sourceFile, "");
+        assert_equals(new URL(e.sourceFile).pathname, "/content-security-policy/support/inject-image.sub.js");
-        assert_equals(e.lineNumber, 0);
+        assert_equals(e.lineNumber, 2);
         assert_equals(e.columnNumber, 0);
         assert_equals(e.statusCode, 200);
       }));

tests/wpt/web-platform-tests/content-security-policy/securitypolicyviolation/securitypolicyviolation-block-cross-origin-image.sub.html

@@ -15,9 +15,9 @@
         assert_equals(e.effectiveDirective, "img-src");
         assert_equals(e.originalPolicy, "img-src \'none\'");
         assert_equals(e.disposition, "enforce");
-        assert_equals(e.sourceFile, "");
+        assert_equals(new URL(e.sourceFile).pathname, "/content-security-policy/securitypolicyviolation/securitypolicyviolation-block-cross-origin-image.sub.html");
-        assert_equals(e.lineNumber, 0);
+        assert_equals(e.lineNumber, 25);
-        assert_equals(e.columnNumber, 0);
+        assert_equals(e.columnNumber, 4);
         assert_equals(e.statusCode, 200);
       }));
     

tests/wpt/web-platform-tests/content-security-policy/securitypolicyviolation/securitypolicyviolation-block-image-from-script.sub.html

@@ -15,8 +15,8 @@
         assert_equals(e.effectiveDirective, "img-src");
         assert_equals(e.originalPolicy, "img-src \'none\'");
         assert_equals(e.disposition, "enforce");
-        assert_equals(e.sourceFile, "");
+        assert_equals(new URL(e.sourceFile).pathname, "/content-security-policy/support/inject-image.sub.js");
-        assert_equals(e.lineNumber, 0);
+        assert_equals(e.lineNumber, 2);
         assert_equals(e.columnNumber, 0);
         assert_equals(e.statusCode, 200);
       }));

tests/wpt/web-platform-tests/content-security-policy/securitypolicyviolation/securitypolicyviolation-block-image.sub.html

@@ -15,9 +15,9 @@
         assert_equals(e.effectiveDirective, "img-src");
         assert_equals(e.originalPolicy, "img-src \'none\'");
         assert_equals(e.disposition, "enforce");
-        assert_equals(e.sourceFile, "");
+        assert_equals(new URL(e.sourceFile).pathname, "/content-security-policy/securitypolicyviolation/securitypolicyviolation-block-image.sub.html");
-        assert_equals(e.lineNumber, 0);
+        assert_equals(e.lineNumber, 25);
-        assert_equals(e.columnNumber, 0);
+        assert_equals(e.columnNumber, 4);
         assert_equals(e.statusCode, 200);
       }));
     

tests/wpt/web-platform-tests/cookie-store/cookieListItem_attributes.tentative.https.window.js

@@ -1,15 +1,5 @@
 'use strict';
 
-// Workaround because add_cleanup doesn't support async functions yet.
-// See https://github.com/web-platform-tests/wpt/issues/6075
-async function async_cleanup(cleanup_function) {
-  try {
-    await cleanup_function();
-  } catch (e) {
-    // Errors in cleanup functions shouldn't result in test failures.
-  }
-}
-
 const kCurrentHostname = (new URL(self.location.href)).hostname;
 
 const kOneDay = 24 * 60 * 60 * 1000;
@@ -23,6 +13,9 @@ promise_test(async testCase => {
   await cookieStore.delete('cookie-name');
 
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
@@ -33,14 +26,15 @@ promise_test(async testCase => {
   assert_equals(cookie.secure, true);
   assert_equals(cookie.sameSite, 'strict');
   assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'CookieListItem - cookieStore.set defaults with positional name and value');
 
 promise_test(async testCase => {
   await cookieStore.delete('cookie-name');
 
   await cookieStore.set({ name: 'cookie-name', value: 'cookie-value' });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
@@ -50,8 +44,6 @@ promise_test(async testCase => {
   assert_equals(cookie.secure, true);
   assert_equals(cookie.sameSite, 'strict');
   assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'CookieListItem - cookieStore.set defaults with name and value in options');
 
 promise_test(async testCase => {
@@ -59,6 +51,9 @@ promise_test(async testCase => {
 
   await cookieStore.set('cookie-name', 'cookie-value',
                         { expires: kTenYearsFromNow });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
@@ -68,8 +63,6 @@ promise_test(async testCase => {
   assert_equals(cookie.secure, true);
   assert_equals(cookie.sameSite, 'strict');
   assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'CookieListItem - cookieStore.set with expires set to a timestamp 10 ' +
    'years in the future');
 
@@ -78,6 +71,9 @@ promise_test(async testCase => {
 
   await cookieStore.set({ name: 'cookie-name', value: 'cookie-value',
                           expires: kTenYearsFromNow });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
@@ -87,8 +83,6 @@ promise_test(async testCase => {
   assert_equals(cookie.secure, true);
   assert_equals(cookie.sameSite, 'strict');
   assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'CookieListItem - cookieStore.set with name and value in options and ' +
    'expires set to a future timestamp');
 
@@ -97,6 +91,9 @@ promise_test(async testCase => {
 
   await cookieStore.set('cookie-name', 'cookie-value',
                         { expires: new Date(kTenYearsFromNow) });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
@@ -104,8 +101,6 @@ promise_test(async testCase => {
   assert_equals(cookie.path, '/');
   assert_approx_equals(cookie.expires, kTenYearsFromNow, kOneDay);
   assert_equals(cookie.secure, true);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'CookieListItem - cookieStore.set with expires set to a Date 10 ' +
    'years in the future');
 
@@ -114,6 +109,9 @@ promise_test(async testCase => {
 
   await cookieStore.set({ name: 'cookie-name', value: 'cookie-value',
                           expires: new Date(kTenYearsFromNow) });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
@@ -123,8 +121,6 @@ promise_test(async testCase => {
   assert_equals(cookie.secure, true);
   assert_equals(cookie.sameSite, 'strict');
   assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'CookieListItem - cookieStore.set with name and value in options and ' +
    'expires set to a future Date');
 
@@ -133,6 +129,9 @@ promise_test(async testCase => {
 
   await cookieStore.set('cookie-name', 'cookie-value',
                         { domain: kCurrentHostname });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete({ name: 'cookie-name', domain: kCurrentHostname });
+  });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
@@ -142,10 +141,6 @@ promise_test(async testCase => {
   assert_equals(cookie.secure, true);
   assert_equals(cookie.sameSite, 'strict');
   assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
-
-  await async_cleanup(async () => {
-    await cookieStore.delete({ name: 'cookie-name', domain: kCurrentHostname });
-  });
 }, 'CookieListItem - cookieStore.set with domain set to the current hostname');
 
 promise_test(async testCase => {
@@ -157,6 +152,9 @@ promise_test(async testCase => {
 
   await cookieStore.set('cookie-name', 'cookie-value',
                         { path: currentDirectory });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
+  });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
@@ -166,16 +164,15 @@ promise_test(async testCase => {
   assert_equals(cookie.secure, true);
   assert_equals(cookie.sameSite, 'strict');
   assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
-
-  await async_cleanup(async () => {
-    await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
-  });
 }, 'CookieListItem - cookieStore.set with path set to the current directory');
 
 promise_test(async testCase => {
   await cookieStore.delete('cookie-name');
 
   await cookieStore.set('cookie-name', 'cookie-value', { secure: false });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
@@ -185,8 +182,6 @@ promise_test(async testCase => {
   assert_equals(cookie.secure, false);
   assert_equals(cookie.sameSite, 'strict');
   assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'CookieListItem - cookieStore.set with secure set to false');
 
 ['strict', 'lax', 'unrestricted'].forEach(sameSiteValue => {
@@ -195,6 +190,9 @@ promise_test(async testCase => {
 
     await cookieStore.set({
         name: 'cookie-name', value: 'cookie-value', sameSite: sameSiteValue });
+    testCase.add_cleanup(async () => {
+      await cookieStore.delete('cookie-name');
+    });
     const cookie = await cookieStore.get('cookie-name');
     assert_equals(cookie.name, 'cookie-name');
     assert_equals(cookie.value, 'cookie-value');
@@ -204,8 +202,6 @@ promise_test(async testCase => {
     assert_equals(cookie.secure, true);
     assert_equals(cookie.sameSite, sameSiteValue);
     assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
-
-    await async_cleanup(() => cookieStore.delete('cookie-name'));
   }, `CookieListItem - cookieStore.set with sameSite set to ${sameSiteValue}`);
 
   promise_test(async testCase => {
@@ -213,6 +209,9 @@ promise_test(async testCase => {
 
     await cookieStore.set('cookie-name', 'cookie-value',
                           { sameSite: sameSiteValue });
+    testCase.add_cleanup(async () => {
+      await cookieStore.delete('cookie-name');
+    });
     const cookie = await cookieStore.get('cookie-name');
     assert_equals(cookie.name, 'cookie-name');
     assert_equals(cookie.value, 'cookie-value');
@@ -222,8 +221,6 @@ promise_test(async testCase => {
     assert_equals(cookie.secure, true);
     assert_equals(cookie.sameSite, sameSiteValue);
     assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
-
-    await async_cleanup(() => cookieStore.delete('cookie-name'));
   }, 'CookieListItem - cookieStore.set with positional name and value and ' +
      `sameSite set to ${sameSiteValue}`);
-});
+});

tests/wpt/web-platform-tests/cookie-store/cookieStore_delete_arguments.tentative.https.window.js

@@ -1,15 +1,5 @@
 'use strict';
 
-// Workaround because add_cleanup doesn't support async functions yet.
-// See https://github.com/web-platform-tests/wpt/issues/6075
-async function async_cleanup(cleanup_function) {
-  try {
-    await cleanup_function();
-  } catch (e) {
-    // Errors in cleanup functions shouldn't result in test failures.
-  }
-}
-
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
 
@@ -20,22 +10,24 @@ promise_test(async testCase => {
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   await cookieStore.delete({ name: 'cookie-name' });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie, null);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.delete with name in options');
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   await cookieStore.delete('cookie-name', { name: 'wrong-cookie-name' });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie, null);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.delete with name in both positional arguments and options');
 
 promise_test(async testCase => {
@@ -43,14 +35,13 @@ promise_test(async testCase => {
   const currentDomain = currentUrl.hostname;
   await cookieStore.set(
       'cookie-name', 'cookie-value', { domain: currentDomain });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
+  });
 
   await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie, null);
-
-  await async_cleanup(async () => {
-    await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
-  });
 }, 'cookieStore.delete with domain set to the current hostname');
 
 promise_test(async testCase => {
@@ -79,14 +70,13 @@ promise_test(async testCase => {
   const currentDomain = currentUrl.hostname;
   await cookieStore.set(
       'cookie-name', 'cookie-value', { domain: currentDomain });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
+  });
 
   await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie, null);
-
-  await async_cleanup(async () => {
-    await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
-  });
 }, 'cookieStore.delete with name in options and domain set to the current ' +
    'hostname');
 
@@ -119,14 +109,13 @@ promise_test(async testCase => {
       currentPath.substr(0, currentPath.lastIndexOf('/') + 1);
   await cookieStore.set(
       'cookie-name', 'cookie-value', { path: currentDirectory });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
+  });
 
   await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie, null);
-
-  async_cleanup(async () => {
-    await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
-  });
 }, 'cookieStore.delete with path set to the current directory');
 
 promise_test(async testCase => {
@@ -137,19 +126,21 @@ promise_test(async testCase => {
   const subDirectory = currentDirectory + "subdir/";
   await cookieStore.set(
       'cookie-name', 'cookie-value', { path: currentDirectory });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
+  });
 
   await cookieStore.delete({ name: 'cookie-name', path: subDirectory });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
-
-  await async_cleanup(async () => {
-    await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
-  });
 }, 'cookieStore.delete with path set to subdirectory of the current directory');
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const cookie_attributes = await cookieStore.get('cookie-name');
   assert_equals(cookie_attributes.name, 'cookie-name');
@@ -158,6 +149,4 @@ promise_test(async testCase => {
   await cookieStore.delete(cookie_attributes);
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie, null);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.delete with get result');

tests/wpt/web-platform-tests/cookie-store/cookieStore_event_basic.tentative.https.window.js

@@ -1,21 +1,14 @@
 'use strict';
 
-// Workaround because add_cleanup doesn't support async functions yet.
-// See https://github.com/web-platform-tests/wpt/issues/6075
-async function async_cleanup(cleanup_function) {
-  try {
-    await cleanup_function();
-  } catch (e) {
-    // Errors in cleanup functions shouldn't result in test failures.
-  }
-}
-
 promise_test(async testCase => {
   const eventPromise = new Promise((resolve) => {
     cookieStore.onchange = resolve;
   });
 
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const event = await eventPromise;
   assert_true(event instanceof CookieChangeEvent);
@@ -24,6 +17,4 @@ promise_test(async testCase => {
   assert_equals(event.changed[0].name, 'cookie-name');
   assert_equals(event.changed[0].value, 'cookie-value');
   assert_equals(event.deleted.length, 0);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore fires change event for cookie set by cookieStore.set()');

tests/wpt/web-platform-tests/cookie-store/cookieStore_event_delete.tenative.https.window.js

@@ -1,17 +1,10 @@
 'use strict';
 
-// Workaround because add_cleanup doesn't support async functions yet.
-// See https://github.com/web-platform-tests/wpt/issues/6075
-async function async_cleanup(cleanup_function) {
-  try {
-    await cleanup_function();
-  } catch (e) {
-    // Errors in cleanup functions shouldn't result in test failures.
-  }
-}
-
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const eventPromise = new Promise((resolve) => {
     cookieStore.onchange = resolve;
@@ -26,6 +19,4 @@ promise_test(async testCase => {
       event.deleted[0].value, undefined,
       'Cookie change events for deletions should not have cookie values');
   assert_equals(event.changed.length, 0);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore fires change event for cookie deleted by cookieStore.delete()');

tests/wpt/web-platform-tests/cookie-store/cookieStore_event_overwrite.tentative.https.window.js

@@ -1,17 +1,10 @@
 'use strict';
 
-// Workaround because add_cleanup doesn't support async functions yet.
-// See https://github.com/web-platform-tests/wpt/issues/6075
-async function async_cleanup(cleanup_function) {
-  try {
-    await cleanup_function();
-  } catch (e) {
-    // Errors in cleanup functions shouldn't result in test failures.
-  }
-}
-
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const eventPromise = new Promise((resolve) => {
     cookieStore.onchange = resolve;
@@ -26,6 +19,4 @@ promise_test(async testCase => {
   assert_equals(event.changed[0].name, 'cookie-name');
   assert_equals(event.changed[0].value, 'new-cookie-value');
   assert_equals(event.deleted.length, 0);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore fires change event for cookie overwritten by cookieStore.set()');

tests/wpt/web-platform-tests/cookie-store/cookieStore_getAll_arguments.tentative.https.window.js

@@ -1,18 +1,14 @@
 'use strict';
 
-// Workaround because add_cleanup doesn't support async functions yet.
-// See https://github.com/web-platform-tests/wpt/issues/6075
-async function async_cleanup(cleanup_function) {
-  try {
-    await cleanup_function();
-  } catch (e) {
-    // Errors in cleanup functions shouldn't result in test failures.
-  }
-}
-
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   await cookieStore.set('cookie-name-2', 'cookie-value-2');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name-2');
+  });
 
   const cookies = await cookieStore.getAll();
   cookies.sort((a, b) => a.name.localeCompare(b.name));
@@ -21,53 +17,62 @@ promise_test(async testCase => {
   assert_equals(cookies[0].value, 'cookie-value');
   assert_equals(cookies[1].name, 'cookie-name-2');
   assert_equals(cookies[1].value, 'cookie-value-2');
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-  await async_cleanup(() => cookieStore.delete('cookie-name-2'));
 }, 'cookieStore.getAll with no arguments');
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   await cookieStore.set('cookie-name-2', 'cookie-value-2');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name-2');
+  });
 
   const cookies = await cookieStore.getAll('cookie-name');
   assert_equals(cookies.length, 1);
   assert_equals(cookies[0].name, 'cookie-name');
   assert_equals(cookies[0].value, 'cookie-value');
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-  await async_cleanup(() => cookieStore.delete('cookie-name-2'));
 }, 'cookieStore.getAll with positional name');
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   await cookieStore.set('cookie-name-2', 'cookie-value-2');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name-2');
+  });
 
   const cookies = await cookieStore.getAll({ name: 'cookie-name' });
   assert_equals(cookies.length, 1);
   assert_equals(cookies[0].name, 'cookie-name');
   assert_equals(cookies[0].value, 'cookie-value');
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-  await async_cleanup(() => cookieStore.delete('cookie-name-2'));
 }, 'cookieStore.getAll with name in options');
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   await cookieStore.set('cookie-name-2', 'cookie-value-2');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name-2');
+  });
 
   const cookies = await cookieStore.getAll('cookie-name',
                                            { name: 'wrong-cookie-name' });
   assert_equals(cookies.length, 1);
   assert_equals(cookies[0].name, 'cookie-name');
   assert_equals(cookies[0].value, 'cookie-value');
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-  await async_cleanup(() => cookieStore.delete('cookie-name-2'));
 }, 'cookieStore.getAll with name in both positional arguments and options');
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const cookies = await cookieStore.getAll({ name: 'cookie-name',
                                              matchType: 'equals' });
@@ -78,53 +83,59 @@ promise_test(async testCase => {
   const no_cookies = await cookieStore.getAll(
       'cookie-na', { matchType: 'equals' });
   assert_equals(no_cookies.length, 0);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.getAll with matchType explicitly set to equals');
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   await cookieStore.set('cookie-name-2', 'cookie-value-2');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name-2');
+  });
 
   const cookies = await cookieStore.getAll({ name: 'cookie-name-',
                                              matchType: 'starts-with' });
   assert_equals(cookies.length, 1);
   assert_equals(cookies[0].name, 'cookie-name-2');
   assert_equals(cookies[0].value, 'cookie-value-2');
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-  await async_cleanup(() => cookieStore.delete('cookie-name-2'));
 }, 'cookieStore.getAll with matchType set to starts-with');
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   await cookieStore.set('cookie-name-2', 'cookie-value-2');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name-2');
+  });
 
   await promise_rejects(testCase, new TypeError(), cookieStore.getAll(
       { name: 'cookie-name', matchType: 'invalid' }));
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-  await async_cleanup(() => cookieStore.delete('cookie-name-2'));
 }, 'cookieStore.getAll with invalid matchType');
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const cookies = await cookieStore.getAll({ matchType: 'equals' });
   assert_equals(cookies.length, 1);
   assert_equals(cookies[0].name, 'cookie-name');
   assert_equals(cookies[0].value, 'cookie-value');
-
-  async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.getAll with matchType set to equals and missing name');
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const cookies = await cookieStore.getAll({ matchType: 'starts-with' });
   assert_equals(cookies.length, 1);
   assert_equals(cookies[0].name, 'cookie-name');
   assert_equals(cookies[0].value, 'cookie-value');
-
-  async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.getAll with matchType set to starts-with and missing name');

tests/wpt/web-platform-tests/cookie-store/cookieStore_getAll_multiple.tentative.https.window.js

@@ -1,19 +1,18 @@
 'use strict';
 
-// Workaround because add_cleanup doesn't support async functions yet.
-// See https://github.com/web-platform-tests/wpt/issues/6075
-async function async_cleanup(cleanup_function) {
-  try {
-    await cleanup_function();
-  } catch (e) {
-    // Errors in cleanup functions shouldn't result in test failures.
-  }
-}
-
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   await cookieStore.set('cookie-name-2', 'cookie-value-2');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name-2');
+  });
   await cookieStore.set('cookie-name-3', 'cookie-value-3');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name-3');
+  });
 
   const cookies = await cookieStore.getAll();
   cookies.sort((a, b) => a.name.localeCompare(b.name));
@@ -24,8 +23,4 @@ promise_test(async testCase => {
   assert_equals(cookies[1].value, 'cookie-value-2');
   assert_equals(cookies[2].name, 'cookie-name-3');
   assert_equals(cookies[2].value, 'cookie-value-3');
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-  await async_cleanup(() => cookieStore.delete('cookie-name-2'));
-  await async_cleanup(() => cookieStore.delete('cookie-name-3'));
 }, 'cookieStore.getAll returns multiple cookies written by cookieStore.set');

tests/wpt/web-platform-tests/cookie-store/cookieStore_getAll_set_basic.tentative.https.window.js

@@ -1,22 +1,13 @@
 'use strict';
 
-// Workaround because add_cleanup doesn't support async functions yet.
-// See https://github.com/web-platform-tests/wpt/issues/6075
-async function async_cleanup(cleanup_function) {
-  try {
-    await cleanup_function();
-  } catch (e) {
-    // Errors in cleanup functions shouldn't result in test failures.
-  }
-}
-
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   const cookies = await cookieStore.getAll('cookie-name');
 
   assert_equals(cookies.length, 1);
   assert_equals(cookies[0].name, 'cookie-name');
   assert_equals(cookies[0].value, 'cookie-value');
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.getAll returns the cookie written by cookieStore.set');

tests/wpt/web-platform-tests/cookie-store/cookieStore_get_arguments.tentative.https.window.js

@@ -1,56 +1,53 @@
 'use strict';
 
-// Workaround because add_cleanup doesn't support async functions yet.
-// See https://github.com/web-platform-tests/wpt/issues/6075
-async function async_cleanup(cleanup_function) {
-  try {
-    await cleanup_function();
-  } catch (e) {
-    // Errors in cleanup functions shouldn't result in test failures.
-  }
-}
-
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const cookie = await cookieStore.get();
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.get with no arguments');
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.get with positional name');
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const cookie = await cookieStore.get({ name: 'cookie-name' });
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.get with name in options');
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const cookie = await cookieStore.get('cookie-name',
                                        { name: 'wrong-cookie-name' });
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.get with name in both positional arguments and options');
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const cookie = await cookieStore.get(
       'cookie-name', { matchType: 'equals' });
@@ -60,46 +57,48 @@ promise_test(async testCase => {
   const no_cookie = await cookieStore.get({ name: 'cookie-na',
                                             matchType: 'equals' });
   assert_equals(no_cookie, null);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.get with matchType explicitly set to equals');
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const cookie = await cookieStore.get({ name: 'cookie-na',
                                          matchType: 'starts-with' });
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
-
-  async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.get with matchType set to starts-with');
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   await promise_rejects(testCase, new TypeError(), cookieStore.get(
       { name: 'cookie-name', matchType: 'invalid' }));
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.get with invalid matchType');
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const cookie = await cookieStore.get({ matchType: 'equals' });
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
-
-  async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.get with matchType set to equals and missing name');
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const cookie = await cookieStore.get({ matchType: 'starts-with' });
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
-
-  async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.get with matchType set to starts-with and missing name');

tests/wpt/web-platform-tests/cookie-store/cookieStore_get_delete_basic.tentative.https.window.js

@@ -1,20 +1,11 @@
 'use strict';
 
-// Workaround because add_cleanup doesn't support async functions yet.
-// See https://github.com/web-platform-tests/wpt/issues/6075
-async function async_cleanup(cleanup_function) {
-  try {
-    await cleanup_function();
-  } catch (e) {
-    // Errors in cleanup functions shouldn't result in test failures.
-  }
-}
-
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+     await cookieStore.delete('cookie-name');
+  });
   await cookieStore.delete('cookie-name');
   const cookie = await cookieStore.get();
   assert_equals(cookie, null);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.get returns null for a cookie deleted by cookieStore.delete');

tests/wpt/web-platform-tests/cookie-store/cookieStore_get_set_across_frames.tentative.https.html

@@ -19,7 +19,9 @@ promise_test(async t => {
       'Precondition not met: cookie store should be empty');
 
   await cookieStore.set('cookie-name', 'cookie-value');
-  t.add_cleanup(() => cookieStore.delete('cookie-name'));
+  t.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const frameCookie = await frameCookieStore.get('cookie-name');
   assert_equals(frameCookie.value, 'cookie-value');
@@ -34,7 +36,9 @@ promise_test(async t => {
       'Precondition not met: cookie store should be empty');
 
   await frameCookieStore.set('cookie-name', 'cookie-value');
-  t.add_cleanup(() => frameCookieStore.delete('cookie-name'));
+  t.add_cleanup(async () => {
+    await frameCookieStore.delete('cookie-name');
+  });
 
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.value, 'cookie-value');

tests/wpt/web-platform-tests/cookie-store/cookieStore_get_set_across_origins.tentative.sub.https.html

@@ -24,10 +24,9 @@ promise_test(async t => {
     name: 'cookie-name',
     value: 'cookie-value',
   }, kCorsBase);
-  t.add_cleanup(() => cookieStore.delete({
+  t.add_cleanup(async () => {
-    name: 'cookie-name',
+    await cookieStore.delete({ name: 'cookie-name', domain: '{{host}}' });
-    domain: '{{host}}',
+  });
-  }));
   await waitForMessage();
 
   const cookies = await cookieStore.getAll();
@@ -53,10 +52,9 @@ promise_test(async t => {
     opname: 'get-cookie',
     name: 'cookie-name',
   }, kCorsBase);
-  t.add_cleanup(() => cookieStore.delete({
+  t.add_cleanup(async () => {
-    name: 'cookie-name',
+    await cookieStore.delete({ name: 'cookie-name', domain: '{{host}}' });
-    domain: '{{host}}',
+  });
-  }));
 
   const message = await waitForMessage();
 

tests/wpt/web-platform-tests/cookie-store/cookieStore_get_set_basic.tentative.https.window.js

@@ -1,21 +1,12 @@
 'use strict';
 
-// Workaround because add_cleanup doesn't support async functions yet.
-// See https://github.com/web-platform-tests/wpt/issues/6075
-async function async_cleanup(cleanup_function) {
-  try {
-    await cleanup_function();
-  } catch (e) {
-    // Errors in cleanup functions shouldn't result in test failures.
-  }
-}
-
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   const cookie = await cookieStore.get('cookie-name');
 
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.get returns the cookie written by cookieStore.set');

tests/wpt/web-platform-tests/cookie-store/cookieStore_set_arguments.tentative.https.window.js

@@ -1,47 +1,40 @@
 'use strict';
 
-// Workaround because add_cleanup doesn't support async functions yet.
-// See https://github.com/web-platform-tests/wpt/issues/6075
-async function async_cleanup(cleanup_function) {
-  try {
-    await cleanup_function();
-  } catch (e) {
-    // Errors in cleanup functions shouldn't result in test failures.
-  }
-}
-
 promise_test(async testCase => {
   await cookieStore.delete('cookie-name');
 
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.set with positional name and value');
 
 promise_test(async testCase => {
   await cookieStore.delete('cookie-name');
 
   await cookieStore.set({ name: 'cookie-name', value: 'cookie-value' });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.set with name and value in options');
 
 promise_test(async testCase => {
   await cookieStore.delete('cookie-name');
 
   cookieStore.set('cookie-name', 'cookie-value', { name: 'wrong-cookie-name' });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.set with name in both positional arguments and options');
 
 promise_test(async testCase => {
@@ -49,11 +42,12 @@ promise_test(async testCase => {
 
   cookieStore.set('cookie-name', 'cookie-value',
                   { value: 'wrong-cookie-value' });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.set with value in both positional arguments and options');
 
 promise_test(async testCase => {
@@ -63,11 +57,12 @@ promise_test(async testCase => {
 
   await cookieStore.set(
       'cookie-name', 'cookie-value', { expires: tenYearsFromNow });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.set with expires set to a future timestamp');
 
 promise_test(async testCase => {
@@ -77,10 +72,11 @@ promise_test(async testCase => {
 
   await cookieStore.set(
       'cookie-name', 'cookie-value', { expires: tenYearsAgo });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie, null);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.set with expires set to a past timestamp');
 
 promise_test(async testCase => {
@@ -90,11 +86,12 @@ promise_test(async testCase => {
 
   await cookieStore.set(
       'cookie-name', 'cookie-value', { expires: new Date(tenYearsFromNow) });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.set with expires set to a future Date');
 
 promise_test(async testCase => {
@@ -104,10 +101,11 @@ promise_test(async testCase => {
 
   await cookieStore.set(
       'cookie-name', 'cookie-value', { expires: new Date(tenYearsAgo) });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie, null);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.set with expires set to a past Date');
 
 promise_test(async testCase => {
@@ -117,11 +115,12 @@ promise_test(async testCase => {
 
   await cookieStore.set(
       { name: 'cookie-name', value: 'cookie-value', expires: tenYearsFromNow });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.set with name and value in options and expires in the future');
 
 promise_test(async testCase => {
@@ -131,10 +130,11 @@ promise_test(async testCase => {
 
   await cookieStore.set(
       { name: 'cookie-name', value: 'cookie-value', expires: tenYearsAgo });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie, null);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.set with name and value in options and expires in the past');
 
 promise_test(async testCase => {
@@ -144,13 +144,12 @@ promise_test(async testCase => {
 
   await cookieStore.set(
       'cookie-name', 'cookie-value', { domain: currentDomain });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
+  });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
-
-  await async_cleanup(async () => {
-    await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
-  });
 }, 'cookieStore.set with domain set to the current hostname');
 
 promise_test(async testCase => {
@@ -184,8 +183,14 @@ promise_test(async testCase => {
   await cookieStore.delete('cookie-name');
 
   await cookieStore.set('cookie-name', 'cookie-value1');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   await cookieStore.set('cookie-name', 'cookie-value2',
                         { domain: currentDomain });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
+  });
 
   const cookies = await cookieStore.getAll('cookie-name');
   assert_equals(cookies.length, 2);
@@ -196,11 +201,6 @@ promise_test(async testCase => {
   const values = cookies.map((cookie) => cookie.value);
   values.sort();
   assert_array_equals(values, ['cookie-value1', 'cookie-value2']);
-
-  await async_cleanup(async () => {
-    await cookieStore.delete('cookie-name');
-    await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
-  });
 }, 'cookieStore.set default domain is null and differs from current hostname');
 
 promise_test(async testCase => {
@@ -212,13 +212,12 @@ promise_test(async testCase => {
 
   await cookieStore.set(
       'cookie-name', 'cookie-value', { path: currentDirectory });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
+  });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
-
-  await async_cleanup(async () => {
-    await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
-  });
 }, 'cookieStore.set with path set to the current directory');
 
 promise_test(async testCase => {
@@ -232,33 +231,36 @@ promise_test(async testCase => {
 
   await cookieStore.set(
       'cookie-name', 'cookie-value', { path: subDirectory });
-  const cookie = await cookieStore.get('cookie-name');
+  testCase.add_cleanup(async () => {
-  assert_equals(cookie, null);
-
-  await async_cleanup(async () => {
     await cookieStore.delete({ name: 'cookie-name', path: subDirectory });
   });
+  const cookie = await cookieStore.get('cookie-name');
+  assert_equals(cookie, null);
 }, 'cookieStore.set with path set to a subdirectory of the current directory');
 
 promise_test(async testCase => {
   await cookieStore.delete('cookie-name');
 
   await cookieStore.set('cookie-name', 'cookie-old-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
   await cookieStore.set('cookie-name', 'cookie-new-value', { path: '/' });
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete({ name: 'cookie-name',  path: '/' });
+  });
 
   const cookies = await cookieStore.getAll('cookie-name');
   assert_equals(cookies.length, 1);
   assert_equals(cookies[0].name, 'cookie-name');
   assert_equals(cookies[0].value, 'cookie-new-value');
-
-  await async_cleanup(async () => {
-    await cookieStore.delete('cookie-name');
-    await cookieStore.delete({ name: 'cookie-name',  path: '/' });
-  });
 }, 'cookieStore.set default path is /');
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'old-cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const cookie_attributes = await cookieStore.get('cookie-name');
   assert_equals(cookie_attributes.name, 'cookie-name');
@@ -269,6 +271,4 @@ promise_test(async testCase => {
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'new-cookie-value');
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.set with get result');

tests/wpt/web-platform-tests/cookie-store/serviceworker_cookieStore_cross_origin.tentative.https.sub.html

@@ -27,9 +27,7 @@ promise_test(async t => {
     name: 'cookie-name',
     value: 'cookie-value',
   }, kCorsBase);
-  t.add_cleanup(() => {
+  t.add_cleanup(async () => { await cookieStore.delete('cookie-name'); });
-    cookieStore.delete('cookie-name');
-  });
 
   await waitForMessage();
 

tests/wpt/web-platform-tests/cookie-store/serviceworker_cookieStore_subscriptions.js

@@ -24,16 +24,6 @@ self.addEventListener('install', (event) => {
   })());
 });
 
-// Workaround because add_cleanup doesn't support async functions yet.
-// See https://github.com/web-platform-tests/wpt/issues/6075
-async function async_cleanup(cleanup_function) {
-  try {
-    await cleanup_function();
-  } catch (e) {
-    // Errors in cleanup functions shouldn't result in test failures.
-  }
-}
-
 // Resolves when the service worker receives the 'activate' event.
 const kServiceWorkerActivatedPromise = new Promise(resolve => {
   self.addEventListener('activate', event => { resolve(); });
@@ -96,8 +86,13 @@ promise_test(async testCase => {
   await kServiceWorkerActivatedPromise;
 
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
+  testCase.add_cleanup(() => { g_cookie_changes = []; });
 
   await g_cookie_change_received_promise;
+  testCase.add_cleanup(() => RearmCookieChangeReceivedPromise());
 
   assert_equals(g_cookie_changes.length, 1);
   const event = g_cookie_changes[0]
@@ -108,12 +103,6 @@ promise_test(async testCase => {
   assert_equals(event.deleted.length, 0);
   assert_true(event instanceof ExtendableCookieChangeEvent);
   assert_true(event instanceof ExtendableEvent);
-
-  await async_cleanup(async () => {
-    await cookieStore.delete('cookie-name');
-    g_cookie_changes = [];
-    RearmCookieChangeReceivedPromise();
-  });
 }, 'cookiechange dispatched with cookie change that matches subscription');
 
 done();

tests/wpt/web-platform-tests/cookie-store/serviceworker_cookieStore_subscriptions_basic.js

@@ -17,16 +17,6 @@ self.addEventListener('install', (event) => {
   })());
 });
 
-// Workaround because add_cleanup doesn't support async functions yet.
-// See https://github.com/web-platform-tests/wpt/issues/6075
-async function async_cleanup(cleanup_function) {
-  try {
-    await cleanup_function();
-  } catch (e) {
-    // Errors in cleanup functions shouldn't result in test failures.
-  }
-}
-
 // Resolves when the service worker receives the 'activate' event.
 const kServiceWorkerActivatedPromise = new Promise(resolve => {
   self.addEventListener('activate', event => { resolve(); });
@@ -53,6 +43,9 @@ promise_test(async testCase => {
   });
 
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const event = await cookie_change_received_promise;
   assert_equals(event.type, 'cookiechange');
@@ -62,8 +55,6 @@ promise_test(async testCase => {
   assert_equals(event.deleted.length, 0);
   assert_true(event instanceof ExtendableCookieChangeEvent);
   assert_true(event instanceof ExtendableEvent);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookiechange dispatched with cookie change that matches subscription ' +
    'to event handler registered with addEventListener');
 

tests/wpt/web-platform-tests/cookie-store/serviceworker_cookieStore_subscriptions_empty.js

@@ -16,16 +16,6 @@ self.addEventListener('install', (event) => {
   })());
 });
 
-// Workaround because add_cleanup doesn't support async functions yet.
-// See https://github.com/w3c/web-platform-tests/issues/6075
-async function async_cleanup(cleanup_function) {
-  try {
-    await cleanup_function();
-  } catch (e) {
-    // Errors in cleanup functions shouldn't result in test failures.
-  }
-}
-
 // Resolves when the service worker receives the 'activate' event.
 const kServiceWorkerActivatedPromise = new Promise(resolve => {
   self.addEventListener('activate', event => { resolve(); });

tests/wpt/web-platform-tests/cookie-store/serviceworker_cookieStore_subscriptions_eventhandler_attribute.js

@@ -17,16 +17,6 @@ self.addEventListener('install', (event) => {
   })());
 });
 
-// Workaround because add_cleanup doesn't support async functions yet.
-// See https://github.com/web-platform-tests/wpt/issues/6075
-async function async_cleanup(cleanup_function) {
-  try {
-    await cleanup_function();
-  } catch (e) {
-    // Errors in cleanup functions shouldn't result in test failures.
-  }
-}
-
 // Resolves when the service worker receives the 'activate' event.
 const kServiceWorkerActivatedPromise = new Promise(resolve => {
   self.addEventListener('activate', event => { resolve(); });
@@ -40,6 +30,9 @@ promise_test(async testCase => {
   });
 
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const event = await cookie_change_received_promise;
   assert_equals(event.type, 'cookiechange');
@@ -49,8 +42,6 @@ promise_test(async testCase => {
   assert_equals(event.deleted.length, 0);
   assert_true(event instanceof ExtendableCookieChangeEvent);
   assert_true(event instanceof ExtendableEvent);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookiechange dispatched with cookie change that matches subscription ' +
    'to event handler registered with oncookiechange');
 

tests/wpt/web-platform-tests/cookie-store/serviceworker_cookieStore_subscriptions_mismatch.js

@@ -17,16 +17,6 @@ self.addEventListener('install', (event) => {
   })());
 });
 
-// Workaround because add_cleanup doesn't support async functions yet.
-// See https://github.com/w3c/web-platform-tests/issues/6075
-async function async_cleanup(cleanup_function) {
-  try {
-    await cleanup_function();
-  } catch (e) {
-    // Errors in cleanup functions shouldn't result in test failures.
-  }
-}
-
 // Resolves when the service worker receives the 'activate' event.
 const kServiceWorkerActivatedPromise = new Promise(resolve => {
   self.addEventListener('activate', event => { resolve(); });
@@ -42,18 +32,19 @@ promise_test(async testCase => {
   });
 
   await cookieStore.set('another-cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('another-cookie-name');
+  });
   await cookieStore.set('cookie-name', 'cookie-value');
+  testCase.add_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+  });
 
   const event = await cookie_change_received_promise;
   assert_equals(event.type, 'cookiechange');
   assert_equals(event.changed.length, 1);
   assert_equals(event.changed[0].name, 'cookie-name');
   assert_equals(event.changed[0].value, 'cookie-value');
-
-  await async_cleanup(async () => {
-    await cookieStore.delete('another-cookie-name');
-    await cookieStore.delete('cookie-name');
-  });
 }, 'cookiechange not dispatched for change that does not match subscription');
 
 done();

tests/wpt/web-platform-tests/css/css-box/parsing/margin-computed.html

@@ -0,0 +1,37 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>CSS basic box model: getComputedStyle().margin</title>
+<link rel="help" href="https://drafts.csswg.org/css-box-3/#propdef-margin">
+<meta name="assert" content="margin computed value has absolute lengths.">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/css/support/computed-testcommon.js"></script>
+<style>
+  #parent {
+    width: 200px;
+  }
+  #target {
+    width: 0px;
+    font-size: 40px;
+  }
+</style>
+</head>
+<body>
+<div id="parent">
+  <div id="target"></div>
+</div>
+<script>
+test_computed_value("margin", "10px");
+test_computed_value("margin", "10px 20px 30px 40px");
+test_computed_value("margin", "calc(0.5em + 10px)", "30px");
+test_computed_value("margin", "30%", "60px");
+
+test_computed_value("margin-top", "10px");
+test_computed_value("margin-right", "20px");
+test_computed_value("margin-bottom", "30px");
+test_computed_value("margin-left", "40px");
+</script>
+</body>
+</html>

tests/wpt/web-platform-tests/css/css-logical/parsing/block-size-computed.html

@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>CSS Logical Properties and Values: getComputedStyle().blockSize</title>
+<link rel="help" href="https://drafts.csswg.org/css-logical-1/#dimension-properties">
+<meta name="assert" content="block-size computed value is an absolute length.">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/css/support/computed-testcommon.js"></script>
+<style>
+  #parent {
+    height: 300px;
+  }
+  #target {
+    width: 0px;
+    height: 0px;
+    font-size: 40px;
+  }
+  #child {
+    height: 80px;
+  }
+</style>
+</head>
+<body>
+<div id="parent">
+  <div id="target">
+    <div id="child">
+    </div>
+  </div>
+</div>
+<script>
+test_computed_value("block-size", "auto", "80px"); // child height
+
+test_computed_value("block-size", "10px");
+test_computed_value("block-size", "20%", "60px");
+test_computed_value("block-size", "calc(0.5em + 10px)", "30px");
+test_computed_value("block-size", "calc(-0.5em + 10px)", "0px");
+
+test_computed_value("block-size", "min-content", "80px"); // child height
+test_computed_value("block-size", "max-content", "80px");
+</script>
+</body>
+</html>

tests/wpt/web-platform-tests/css/css-logical/parsing/inline-size-computed.html

@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>CSS Logical Properties and Values: getComputedStyle().inlineSize</title>
+<link rel="help" href="https://drafts.csswg.org/css-logical-1/#dimension-properties">
+<meta name="assert" content="inline-size computed value is an absolute length.">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/css/support/computed-testcommon.js"></script>
+<style>
+  #parent {
+    width: 200px;
+  }
+  #target {
+    width: 0px;
+    height: 0px;
+    font-size: 40px;
+  }
+  #child {
+    width: 60px;
+  }
+</style>
+</head>
+<body>
+<div id="parent">
+  <div id="target">
+    <div id="child">
+    </div>
+  </div>
+</div>
+<script>
+test_computed_value("inline-size", "auto", "200px"); // parent width
+
+test_computed_value("inline-size", "10px");
+test_computed_value("inline-size", "20%", "40px");
+test_computed_value("inline-size", "calc(0.5em + 10px)", "30px");
+test_computed_value("inline-size", "calc(-0.5em + 10px)", "0px");
+
+test_computed_value("inline-size", "min-content", "60px"); // child width
+test_computed_value("inline-size", "max-content", "60px");
+</script>
+</body>
+</html>

tests/wpt/web-platform-tests/css/css-paint-api/background-image-alpha.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="background-image-alpha-ref.html">
 <style>
 .container {

tests/wpt/web-platform-tests/css/css-paint-api/background-image-multiple.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="background-image-multiple-ref.html">
 <style>
     #output {

tests/wpt/web-platform-tests/css/css-paint-api/background-image-tiled.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="background-image-tiled-ref.html">
 <style>
     div {

tests/wpt/web-platform-tests/css/css-paint-api/geometry-background-image-001.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="geometry-background-image-001-ref.html">
 <style>
 html, body { margin: 0; padding: 0; }

tests/wpt/web-platform-tests/css/css-paint-api/geometry-background-image-002.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="geometry-background-image-002-ref.html">
 <style>
 html, body { margin: 0; padding: 0; }

tests/wpt/web-platform-tests/css/css-paint-api/geometry-background-image-tiled-001.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="geometry-background-image-tiled-001-ref.html">
 <style>
 html, body { margin: 0; padding: 0; }

tests/wpt/web-platform-tests/css/css-paint-api/geometry-background-image-tiled-002.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="geometry-background-image-tiled-002-ref.html">
 <style>
 html, body { margin: 0; padding: 0; }

tests/wpt/web-platform-tests/css/css-paint-api/geometry-background-image-tiled-003.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="geometry-background-image-tiled-003-ref.html">
 <style>
 html, body { margin: 0; padding: 0; }

tests/wpt/web-platform-tests/css/css-paint-api/geometry-border-image-001.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="geometry-border-image-001-ref.html">
 <style>
 html, body { margin: 0; padding: 0; }

tests/wpt/web-platform-tests/css/css-paint-api/geometry-border-image-002.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="geometry-border-image-002-ref.html">
 <style>
 html, body { margin: 0; padding: 0; }

tests/wpt/web-platform-tests/css/css-paint-api/geometry-border-image-003.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="geometry-border-image-003-ref.html">
 <style>
 html, body { margin: 0; padding: 0; }

tests/wpt/web-platform-tests/css/css-paint-api/geometry-border-image-004.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="geometry-border-image-004-ref.html">
 <style>
 html, body { margin: 0; padding: 0; }

tests/wpt/web-platform-tests/css/css-paint-api/geometry-with-float-size.https.html

@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html class=reftest-wait>
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="geometry-with-float-size-ref.html">
-<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/#dom-css-paintworklet">
 <style>
 .container {
   width: 100.5px;

tests/wpt/web-platform-tests/css/css-paint-api/hidpi/canvas-transform.https.html

@@ -1,6 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
-<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/#dom-css-paintworklet">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="canvas-transform-ref.html">
 <style>
 .container {

tests/wpt/web-platform-tests/css/css-paint-api/hidpi/device-pixel-ratio.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="device-pixel-ratio-ref.html">
 <style>
 html, body { margin: 0; padding: 0; }

tests/wpt/web-platform-tests/css/css-paint-api/idlharness.html

@@ -1,6 +1,6 @@
 <!doctype html>
 <title>CSS Painting API IDL tests</title>
-<link rel="help" href="https://drafts.css-houdini.org/css-paint-api-1/">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/WebIDLParser.js"></script>

tests/wpt/web-platform-tests/css/css-paint-api/invalid-image-constructor-error.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="invalid-image-constructor-error-ref.html">
 <style>
     #output {

tests/wpt/web-platform-tests/css/css-paint-api/invalid-image-paint-error.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="invalid-image-paint-error-ref.html">
 <style>
     #output {

tests/wpt/web-platform-tests/css/css-paint-api/invalid-image-pending-script.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="invalid-image-pending-script-ref.html">
 <style>
     #output {

tests/wpt/web-platform-tests/css/css-paint-api/overdraw.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class=reftest-wait>
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="overdraw-ref.html">
 <style>
     #output {

tests/wpt/web-platform-tests/css/css-paint-api/paint-arguments.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="paint-arguments-ref.html">
 <style>
 .container {

tests/wpt/web-platform-tests/css/css-paint-api/paint-function-arguments.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="paint-function-arguments-ref.html">
 <style>
 .container {

tests/wpt/web-platform-tests/css/css-paint-api/paint2d-composite.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="paint2d-composite-ref.html">
 <style>
     div {

tests/wpt/web-platform-tests/css/css-paint-api/paint2d-filter.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="paint2d-filter-ref.html">
 <style>
     div {

tests/wpt/web-platform-tests/css/css-paint-api/paint2d-gradient.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="paint2d-gradient-ref.html">
 <style>
     #output {

tests/wpt/web-platform-tests/css/css-paint-api/paint2d-image.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="paint2d-image-ref.html">
 <style>
 #output {

tests/wpt/web-platform-tests/css/css-paint-api/paint2d-paths.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="paint2d-paths-ref.html">
 <style>
     #output {

tests/wpt/web-platform-tests/css/css-paint-api/paint2d-rects.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="paint2d-rects-ref.html">
 <style>
     #output {

tests/wpt/web-platform-tests/css/css-paint-api/paint2d-shadows.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="paint2d-shadows-ref.html">
 <style>
     #output {

tests/wpt/web-platform-tests/css/css-paint-api/paint2d-transform.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="paint2d-transform-ref.html">
 <style>
     #output {

tests/wpt/web-platform-tests/css/css-paint-api/parse-input-arguments-001.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="parse-input-arguments-ref.html">
 <style>
 .container {

tests/wpt/web-platform-tests/css/css-paint-api/parse-input-arguments-002.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="parse-input-arguments-ref.html">
 <style>
 .container {

tests/wpt/web-platform-tests/css/css-paint-api/parse-input-arguments-003.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="parse-input-arguments-ref.html">
 <style>
 .container {

tests/wpt/web-platform-tests/css/css-paint-api/parse-input-arguments-004.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="parse-input-arguments-ref.html">
 <style>
 .container {

tests/wpt/web-platform-tests/css/css-paint-api/parse-input-arguments-005.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="parse-input-arguments-ref.html">
 <style>
 .container {

tests/wpt/web-platform-tests/css/css-paint-api/parse-input-arguments-006.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="parse-input-arguments-ref.html">
 <style>
 .container {

tests/wpt/web-platform-tests/css/css-paint-api/parse-input-arguments-007.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="parse-input-arguments-ref.html">
 <style>
 .container {

tests/wpt/web-platform-tests/css/css-paint-api/parse-input-arguments-008.https.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html class="reftest-wait">
+<link rel="help" href="https://drafts.css-houdini.org/css-paint-api/">
 <link rel="match" href="parse-input-arguments-ref.html">
 <style>
 .container {