lib: implement AbortSignal.any()

PR-URL: #47821
Backport-PR-URL: #48800Fixes: #47811
Refs: whatwg/dom#1152
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Moshe Atlow <moshe@atlow.co.il>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>

Author: atlowChemi

doc/api/globals.md

@@ -121,6 +121,18 @@ added:
 
 Returns a new `AbortSignal` which will be aborted in `delay` milliseconds.
 
+#### Static method: `AbortSignal.any(signals)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+*`signals` {AbortSignal\[]} The `AbortSignal`s of which to compose a new `AbortSignal`.
+
+Returns a new `AbortSignal` which will be aborted if any of the provided
+signals are aborted. Its [`abortSignal.reason`][] will be set to whichever
+one of the `signals` caused it to be aborted.
+
 #### Event: `'abort'`
 
 <!-- YAML
@@ -906,6 +918,7 @@ A browser-compatible implementation of [`WritableStreamDefaultWriter`][].
 [`WritableStream`]: webstreams.md#class-writablestream
 [`__dirname`]: modules.md#__dirname
 [`__filename`]: modules.md#__filename
+[`abortSignal.reason`]: #abortsignalreason
 [`buffer.atob()`]: buffer.md#bufferatobdata
 [`buffer.btoa()`]: buffer.md#bufferbtoadata
 [`clearImmediate`]: timers.md#clearimmediateimmediate

lib/internal/abort_controller.js

@@ -42,6 +42,7 @@ const {
 
 const{
  validateAbortSignal,
+ validateAbortSignalArray,
  validateObject,
  validateUint32,
 }=require('internal/validators');
@@ -54,6 +55,7 @@ const {
  clearTimeout,
  setTimeout,
 }=require('timers');
+constassert=require('internal/assert');
 
 const{
 messaging_deserialize_symbol: kDeserialize,
@@ -80,13 +82,16 @@ function lazyMakeTransferable(obj) {
 }
 
 constclearTimeoutRegistry=newSafeFinalizationRegistry(clearTimeout);
-consttimeOutSignals=newSafeSet();
+constgcPersistentSignals=newSafeSet();
 
 constkAborted=Symbol('kAborted');
 constkReason=Symbol('kReason');
 constkCloneData=Symbol('kCloneData');
 constkTimeout=Symbol('kTimeout');
 constkMakeTransferable=Symbol('kMakeTransferable');
+constkComposite=Symbol('kComposite');
+constkSourceSignals=Symbol('kSourceSignals');
+constkDependantSignals=Symbol('kDependantSignals');
 
 functioncustomInspect(self,obj,depth,options){
 if(depth<0)
@@ -116,7 +121,7 @@ function setWeakAbortSignalTimeout(weakRef, delay) {
 consttimeout=setTimeout(()=>{
 constsignal=weakRef.deref();
 if(signal!==undefined){
-timeOutSignals.delete(signal);
+gcPersistentSignals.delete(signal);
 abortSignal(
 signal,
 newDOMException(
@@ -185,25 +190,68 @@ class AbortSignal extends EventTarget {
 returnsignal;
 }
 
+/**
+ * @param {AbortSignal[]} signals
+ * @returns {AbortSignal}
+ */
+staticany(signals){
+validateAbortSignalArray(signals,'signals');
+constresultSignal=createAbortSignal({composite: true});
+constresultSignalWeakRef=newWeakRef(resultSignal);
+resultSignal[kSourceSignals]=newSafeSet();
+for(leti=0;i<signals.length;i++){
+constsignal=signals[i];
+if(signal.aborted){
+abortSignal(resultSignal,signal.reason);
+returnresultSignal;
+}
+signal[kDependantSignals]??=newSafeSet();
+if(!signal[kComposite]){
+resultSignal[kSourceSignals].add(newWeakRef(signal));
+signal[kDependantSignals].add(resultSignalWeakRef);
+}elseif(!signal[kSourceSignals]){
+continue;
+}else{
+for(constsourceSignalofsignal[kSourceSignals]){
+constsourceSignalRef=sourceSignal.deref();
+if(!sourceSignalRef){
+continue;
+}
+assert(!sourceSignalRef.aborted);
+assert(!sourceSignalRef[kComposite]);
+
+if(resultSignal[kSourceSignals].has(sourceSignal)){
+continue;
+}
+resultSignal[kSourceSignals].add(sourceSignal);
+sourceSignalRef[kDependantSignals].add(resultSignalWeakRef);
+}
+}
+}
+returnresultSignal;
+}
+
 [kNewListener](size,type,listener,once,capture,passive,weak){
 super[kNewListener](size,type,listener,once,capture,passive,weak);
-if(this[kTimeout]&&
-type==='abort'&&
-!this.aborted&&
-!weak&&
-size===1){
-// If this is a timeout signal, and we're adding a non-weak abort
+constisTimeoutOrNonEmptyCompositeSignal=this[kTimeout]||(this[kComposite]&&this[kSourceSignals]?.size);
+if(isTimeoutOrNonEmptyCompositeSignal&&
+type==='abort'&&
+!this.aborted&&
+!weak&&
+size===1){
+// If this is a timeout signal, or a non-empty composite signal, and we're adding a non-weak abort
 // listener, then we don't want it to be gc'd while the listener
 // is attached and the timer still hasn't fired. So, we retain a
 // strong ref that is held for as long as the listener is registered.
-timeOutSignals.add(this);
+gcPersistentSignals.add(this);
 }
 }
 
 [kRemoveListener](size,type,listener,capture){
 super[kRemoveListener](size,type,listener,capture);
-if(this[kTimeout]&&type==='abort'&&size===0){
-timeOutSignals.delete(this);
+constisTimeoutOrNonEmptyCompositeSignal=this[kTimeout]||(this[kComposite]&&this[kSourceSignals]?.size);
+if(isTimeoutOrNonEmptyCompositeSignal&&type==='abort'&&size===0){
+gcPersistentSignals.delete(this);
 }
 }
 
@@ -287,7 +335,8 @@ defineEventHandler(AbortSignal.prototype, 'abort');
  * @param {{
  * aborted? : boolean,
  * reason? : any,
- * transferable? : boolean
+ * transferable? : boolean,
+ * composite? : boolean,
  * }} [init]
  * @returns {AbortSignal}
  */
@@ -296,11 +345,13 @@ function createAbortSignal(init = kEmptyObject) {
  aborted =false,
  reason =undefined,
  transferable =false,
+ composite =false,
 }=init;
 constsignal=newEventTarget();
 ObjectSetPrototypeOf(signal,AbortSignal.prototype);
 signal[kAborted]=aborted;
 signal[kReason]=reason;
+signal[kComposite]=composite;
 returntransferable ? lazyMakeTransferable(signal) : signal;
 }
 
@@ -312,6 +363,10 @@ function abortSignal(signal, reason) {
 [kTrustEvent]: true,
 });
 signal.dispatchEvent(event);
+signal[kDependantSignals]?.forEach((s)=>{
+constsignalRef=s.deref();
+if(signalRef)abortSignal(signalRef,reason);
+});
 }
 
 // TODO(joyeecheung): use private fields and we'll get invalid access

lib/internal/validators.js

@@ -324,6 +324,26 @@ function validateBooleanArray(value, name) {
 }
 }
 
+/**
+ * @callback validateAbortSignalArray
+ * @param {*} value
+ * @param {string} name
+ * @returns {asserts value is AbortSignal[]}
+ */
+
+/** @type {validateAbortSignalArray} */
+functionvalidateAbortSignalArray(value,name){
+validateArray(value,name);
+for(leti=0;i<value.length;i++){
+constsignal=value[i];
+constindexedName=`${name}[${i}]`;
+if(signal==null){
+thrownewERR_INVALID_ARG_TYPE(indexedName,'AbortSignal',signal);
+}
+validateAbortSignal(signal,indexedName);
+}
+}
+
 /**
  * @param {*} signal
  * @param {string} [name='signal']
@@ -528,6 +548,7 @@ module.exports = {
  validateArray,
  validateStringArray,
  validateBooleanArray,
+ validateAbortSignalArray,
  validateBoolean,
  validateBuffer,
  validateDictionary,

test/common/wpt.js

@@ -614,7 +614,7 @@ class WPTRunner {
 
 process.on('exit',()=>{
 for(constspecofthis.inProgress){
-this.fail(spec,{name: 'Unknown'},kIncomplete);
+this.fail(spec,{name: 'Incomplete'},kIncomplete);
 }
 inspect.defaultOptions.depth=Infinity;
 // Sorts the rules to have consistent output
@@ -738,11 +738,11 @@ class WPTRunner {
  * @param {object} harnessStatus - The status object returned by WPT harness.
  */
 completionCallback(filename,harnessStatus){
+conststatus=this.getTestStatus(harnessStatus.status);
+
 // Treat it like a test case failure
-if(harnessStatus.status===2){
-consttitle=this.getTestTitle(filename);
-console.log(`---- ${title} ----`);
-this.resultCallback(filename,{status: 2,name: 'Unknown'});
+if(status===kTimeout){
+this.fail(filename,{name: 'WPT testharness timeout'},kTimeout);
 }
 this.inProgress.delete(filename);
 // Always force termination of the worker. Some tests allocate resources

test/common/wpt/worker.js

@@ -41,8 +41,17 @@ add_result_callback((result) => {
 });
 });
 
+// Keep the event loop alive
+consttimeout=setTimeout(()=>{
+parentPort.postMessage({
+type: 'completion',
+status: {status: 2},
+});
+},2**31-1);// Max timeout is 2^31-1, when overflown the timeout is set to 1.
+
 // eslint-disable-next-line no-undef
 add_completion_callback((_,status)=>{
+clearTimeout(timeout);
 parentPort.postMessage({
 type: 'completion',
  status,

test/fixtures/wpt/README.md

@@ -12,7 +12,7 @@ Last update:
 
 - common: https://github.com/web-platform-tests/wpt/tree/03c5072aff/common
 - console: https://github.com/web-platform-tests/wpt/tree/767ae35464/console
-- dom/abort: https://github.com/web-platform-tests/wpt/tree/8fadb38120/dom/abort
+- dom/abort: https://github.com/web-platform-tests/wpt/tree/d1f1ecbd52/dom/abort
 - dom/events: https://github.com/web-platform-tests/wpt/tree/ab8999891c/dom/events
 - encoding: https://github.com/web-platform-tests/wpt/tree/0c1b9d1622/encoding
 - fetch/data-urls/resources: https://github.com/web-platform-tests/wpt/tree/7c79d998ff/fetch/data-urls/resources

test/fixtures/wpt/dom/abort/abort-signal-any.any.js

@@ -0,0 +1,4 @@
+// META: script=./resources/abort-signal-any-tests.js
+
+abortSignalAnySignalOnlyTests(AbortSignal);
+abortSignalAnyTests(AbortSignal,AbortController);