feat(ext/web): add `AbortSignal.reason` (#12697)

1 files changed, 44 insertions, 19 deletions

diff --git a/ext/web/03_abort_signal.js b/ext/web/03_abort_signal.js
index 98f14f47a..6b278ba07 100644
--- a/ext/web/03_abort_signal.js
+++ b/ext/web/03_abort_signal.js
@@ -8,7 +8,6 @@
   const webidl = window.__bootstrap.webidl;
   const { setIsTrusted, defineEventHandler } = window.__bootstrap.event;
   const {
-    Boolean,
     Set,
     SetPrototypeAdd,
     SetPrototypeDelete,
@@ -16,33 +15,42 @@
     TypeError,
   } = window.__bootstrap.primordials;
 
-  const add = Symbol("add");
-  const signalAbort = Symbol("signalAbort");
-  const remove = Symbol("remove");
-  const aborted = Symbol("aborted");
-  const abortAlgos = Symbol("abortAlgos");
+  const add = Symbol("[[add]]");
+  const signalAbort = Symbol("[[signalAbort]]");
+  const remove = Symbol("[[remove]]");
+  const abortReason = Symbol("[[abortReason]]");
+  const abortAlgos = Symbol("[[abortAlgos]]");
+  const signal = Symbol("[[signal]]");
 
   const illegalConstructorKey = Symbol("illegalConstructorKey");
 
   class AbortSignal extends EventTarget {
-    static abort() {
+    static abort(reason = undefined) {
+      if (reason !== undefined) {
+        reason = webidl.converters.any(reason);
+      }
       const signal = new AbortSignal(illegalConstructorKey);
-      signal[signalAbort]();
+      signal[signalAbort](reason);
       return signal;
     }
 
     [add](algorithm) {
+      if (this.aborted) {
+        return;
+      }
       if (this[abortAlgos] === null) {
         this[abortAlgos] = new Set();
       }
       SetPrototypeAdd(this[abortAlgos], algorithm);
     }
 
-    [signalAbort]() {
-      if (this[aborted]) {
+    [signalAbort](
+      reason = new DOMException("The signal has been aborted", "AbortError"),
+    ) {
+      if (this.aborted) {
         return;
       }
-      this[aborted] = true;
+      this[abortReason] = reason;
       if (this[abortAlgos] !== null) {
         for (const algorithm of this[abortAlgos]) {
           algorithm();
@@ -63,13 +71,19 @@
         throw new TypeError("Illegal constructor.");
       }
       super();
-      this[aborted] = false;
+      this[abortReason] = undefined;
       this[abortAlgos] = null;
       this[webidl.brand] = webidl.brand;
     }
 
     get aborted() {
-      return Boolean(this[aborted]);
+      webidl.assertBranded(this, AbortSignal);
+      return this[abortReason] !== undefined;
+    }
+
+    get reason() {
+      webidl.assertBranded(this, AbortSignal);
+      return this[abortReason];
     }
   }
   defineEventHandler(AbortSignal.prototype, "abort");
@@ -77,14 +91,20 @@
   webidl.configurePrototype(AbortSignal);
 
   class AbortController {
-    #signal = new AbortSignal(illegalConstructorKey);
+    [signal] = new AbortSignal(illegalConstructorKey);
+
+    constructor() {
+      this[webidl.brand] = webidl.brand;
+    }
 
     get signal() {
-      return this.#signal;
+      webidl.assertBranded(this, AbortController);
+      return this[signal];
     }
 
-    abort() {
-      this.#signal[signalAbort]();
+    abort(reason) {
+      webidl.assertBranded(this, AbortController);
+      this[signal][signalAbort](reason);
     }
   }
 
@@ -100,10 +120,15 @@
   }
 
   function follow(followingSignal, parentSignal) {
+    if (followingSignal.aborted) {
+      return;
+    }
     if (parentSignal.aborted) {
-      followingSignal[signalAbort]();
+      followingSignal[signalAbort](parentSignal.reason);
     } else {
-      parentSignal[add](() => followingSignal[signalAbort]());
+      parentSignal[add](() =>
+        followingSignal[signalAbort](parentSignal.reason)
+      );
     }
   }