From 1cff8fdbb4056d2690b2832e68475230fe07c4e0 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Fri, 22 May 2020 18:11:14 -0700
Subject: [PATCH 01/40] lib: initial experimental AbortController
 implementation

AbortController impl based very closely on:
 https://github.com/mysticatea/abort-controller

Marked experimental.
Not currently used by any of the existing promise apis.

Signed-off-by: James M Snell <jasnell@gmail.com>

PR-URL: https://github.com/nodejs/node/pull/33527
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 .eslintrc.js                            |  1 +
 doc/api/cli.md                          |  8 +++
 doc/api/globals.md                      | 96 +++++++++++++++++++++++++
 doc/node.1                              |  3 +
 lib/internal/abort_controller.js        | 83 +++++++++++++++++++++
 lib/internal/bootstrap/pre_execution.js | 27 +++++++
 lib/internal/main/worker_thread.js      |  2 +
 node.gyp                                |  1 +
 src/node_options.cc                     |  4 ++
 src/node_options.h                      |  1 +
 test/parallel/test-abortcontroller.js   | 22 ++++++
 tools/doc/type-parser.js                |  4 ++
 12 files changed, 252 insertions(+)
 create mode 100644 lib/internal/abort_controller.js
 create mode 100644 test/parallel/test-abortcontroller.js

diff --git a/.eslintrc.js b/.eslintrc.js
index 2ad6cc199cedf7..8464945125b678 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -282,6 +282,7 @@ module.exports = {
     'node-core/no-duplicate-requires': 'error',
   },
   globals: {
+    AbortController: 'readable',
     Atomics: 'readable',
     BigInt: 'readable',
     BigInt64Array: 'readable',
diff --git a/doc/api/cli.md b/doc/api/cli.md
index 3c39689c620f32..3befa5ae6ddfe6 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -197,6 +197,13 @@ Enable experimental Source Map v3 support for stack traces.
 Currently, overriding `Error.prepareStackTrace` is ignored when the
 `--enable-source-maps` flag is set.
 
+### `--experimental-abortcontroller`
+<!-- YAML
+added: REPLACEME
+-->
+
+Enable experimental `AbortController` and `AbortSignal` support.
+
 ### `--experimental-import-meta-resolve`
 <!-- YAML
 added:
@@ -1222,6 +1229,7 @@ Node.js options that are allowed are:
 * `--disable-proto`
 * `--enable-fips`
 * `--enable-source-maps`
+* `--experimental-abortcontroller`
 * `--experimental-import-meta-resolve`
 * `--experimental-json-modules`
 * `--experimental-loader`
diff --git a/doc/api/globals.md b/doc/api/globals.md
index 1da43051ba8255..da86cada230092 100644
--- a/doc/api/globals.md
+++ b/doc/api/globals.md
@@ -17,6 +17,101 @@ The objects listed here are specific to Node.js. There are [built-in objects][]
 that are part of the JavaScript language itself, which are also globally
 accessible.
 
+## Class: `AbortController`
+<!--YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+<!-- type=global -->
+
+A utility class used to signal cancelation in selected `Promise`-based APIs.
+The API is based on the Web API [`AbortController`][].
+
+To use, launch Node.js using the `--experimental-abortcontroller` flag.
+
+```js
+const ac = new AbortController();
+
+ac.signal.addEventListener('abort', () => console.log('Aborted!'),
+                           { once: true });
+
+ac.abort();
+
+console.log(ac.signal.aborted);  // Prints True
+```
+
+### `abortController.abort()`
+<!-- YAML
+added: REPLACEME
+-->
+
+Triggers the abort signal, causing the `abortController.signal` to emit
+the `'abort'` event.
+
+### `abortController.signal`
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {AbortSignal}
+
+### Class: `AbortSignal extends EventTarget`
+<!-- YAML
+added: REPLACEME
+-->
+
+The `AbortSignal` is used to notify observers when the
+`abortController.abort()` method is called.
+
+#### Event: `'abort'`
+<!-- YAML
+added: REPLACEME
+-->
+
+The `'abort'` event is emitted when the `abortController.abort()` method
+is called. The callback is invoked with a single object argument with a
+single `type` propety set to `'abort'`:
+
+```js
+const ac = new AbortController();
+
+// Use either the onabort property...
+ac.signal.onabort = () => console.log('aborted!');
+
+// Or the EventTarget API...
+ac.signal.addEventListener('abort', (event) => {
+  console.log(event.type);  // Prints 'abort'
+}, { once: true });
+
+ac.abort();
+```
+
+The `AbortController` with which the `AbortSignal` is associated will only
+ever trigger the `'abort'` event once. Any event listeners attached to the
+`AbortSignal` *should* use the `{ once: true }` option (or, if using the
+`EventEmitter` APIs to attach a listener, use the `once()` method) to ensure
+that the event listener is removed as soon as the `'abort'` event is handled.
+Failure to do so may result in memory leaks.
+
+#### `abortSignal.aborted`
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {boolean} True after the `AbortController` has been aborted.
+
+#### `abortSignal.onabort`
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {Function}
+
+An optional callback function that may be set by user code to be notified
+when the `abortController.abort()` function has been called.
+
 ## Class: `Buffer`
 <!-- YAML
 added: v0.1.103
@@ -226,6 +321,7 @@ The object that acts as the namespace for all W3C
 [WebAssembly][webassembly-org] related functionality. See the
 [Mozilla Developer Network][webassembly-mdn] for usage and compatibility.
 
+[`AbortController`]: https://developer.mozilla.org/en-US/docs/Web/API/AbortController
 [`TextDecoder`]: util.md#util_class_util_textdecoder
 [`TextEncoder`]: util.md#util_class_util_textencoder
 [`URLSearchParams`]: url.md#url_class_urlsearchparams
diff --git a/doc/node.1 b/doc/node.1
index f52014dbdcb9dc..835fdf179e2df9 100644
--- a/doc/node.1
+++ b/doc/node.1
@@ -136,6 +136,9 @@ Enable FIPS-compliant crypto at startup.
 Requires Node.js to be built with
 .Sy ./configure --openssl-fips .
 .
+.It Fl -experimental-abortcontroller
+Enable experimental AbortController and AbortSignal support.
+.
 .It Fl -enable-source-maps
 Enable experimental Source Map V3 support for stack traces.
 .
diff --git a/lib/internal/abort_controller.js b/lib/internal/abort_controller.js
new file mode 100644
index 00000000000000..b4ba6dd4f87603
--- /dev/null
+++ b/lib/internal/abort_controller.js
@@ -0,0 +1,83 @@
+'use strict';
+
+// Modeled very closely on the AbortController implementation
+// in https://github.com/mysticatea/abort-controller (MIT license)
+
+const {
+  Object,
+  Symbol,
+} = primordials;
+
+const {
+  EventTarget,
+  Event
+} = require('internal/event_target');
+const {
+  customInspectSymbol,
+  emitExperimentalWarning
+} = require('internal/util');
+const { inspect } = require('internal/util/inspect');
+
+const kAborted = Symbol('kAborted');
+
+function customInspect(self, obj, depth, options) {
+  if (depth < 0)
+    return self;
+
+  const opts = Object.assign({}, options, {
+    depth: options.depth === null ? null : options.depth - 1
+  });
+
+  return `${self.constructor.name} ${inspect(obj, opts)}`;
+}
+
+class AbortSignal extends EventTarget {
+  get aborted() { return !!this[kAborted]; }
+
+  [customInspectSymbol](depth, options) {
+    return customInspect(this, {
+      aborted: this.aborted
+    }, depth, options);
+  }
+}
+
+Object.defineProperties(AbortSignal.prototype, {
+  aborted: { enumerable: true }
+});
+
+function abortSignal(signal) {
+  if (signal[kAborted]) return;
+  signal[kAborted] = true;
+  const event = new Event('abort');
+  if (typeof signal.onabort === 'function') {
+    signal.onabort(event);
+  }
+  signal.dispatchEvent(event);
+}
+
+class AbortController {
+  #signal = new AbortSignal();
+
+  constructor() {
+    emitExperimentalWarning('AbortController');
+  }
+
+  get signal() { return this.#signal; }
+  abort() { abortSignal(this.#signal); }
+
+  [customInspectSymbol](depth, options) {
+    return customInspect(this, {
+      signal: this.signal
+    }, depth, options);
+  }
+}
+
+Object.defineProperties(AbortController.prototype, {
+  signal: { enumerable: true },
+  abort: { enumerable: true }
+});
+
+module.exports = {
+  AbortController,
+  AbortSignal,
+};
diff --git a/lib/internal/bootstrap/pre_execution.js b/lib/internal/bootstrap/pre_execution.js
index 3a6a25f05c3b6f..3156a12836711b 100644
--- a/lib/internal/bootstrap/pre_execution.js
+++ b/lib/internal/bootstrap/pre_execution.js
@@ -3,6 +3,7 @@
 const {
   NumberParseInt,
   ObjectDefineProperty,
+  ObjectDefineProperties,
   SafeMap,
   SafeWeakMap,
   StringPrototypeStartsWith,
@@ -58,6 +59,7 @@ function prepareMainThreadExecution(expandArgv1 = false) {
   // (including preload modules).
   initializeClusterIPC();
 
+  initializeAbortController();
   initializeDeprecations();
   initializeWASI();
   initializeCJSLoader();
@@ -312,6 +314,30 @@ function initializeDeprecations() {
   });
 }
 
+function initializeAbortController() {
+  const abortController = getOptionValue('--experimental-abortcontroller');
+  if (abortController) {
+    const {
+      AbortController,
+      AbortSignal
+    } = require('internal/abort_controller');
+    ObjectDefineProperties(global, {
+      AbortController: {
+        writable: true,
+        enumerable: false,
+        configurable: true,
+        value: AbortController
+      },
+      AbortSignal: {
+        writable: true,
+        enumerable: false,
+        configurable: true,
+        value: AbortSignal
+      }
+    });
+  }
+}
+
 function setupChildProcessIpcChannel() {
   if (process.env.NODE_CHANNEL_FD) {
     const assert = require('internal/assert');
@@ -448,6 +474,7 @@ module.exports = {
   setupWarningHandler,
   setupDebugEnv,
   prepareMainThreadExecution,
+  initializeAbortController,
   initializeDeprecations,
   initializeESMLoader,
   initializeFrozenIntrinsics,
diff --git a/lib/internal/main/worker_thread.js b/lib/internal/main/worker_thread.js
index c2a4b67e6e0669..d4d641e79c4902 100644
--- a/lib/internal/main/worker_thread.js
+++ b/lib/internal/main/worker_thread.js
@@ -13,6 +13,7 @@ const {
   setupInspectorHooks,
   setupWarningHandler,
   setupDebugEnv,
+  initializeAbortController,
   initializeDeprecations,
   initializeWASI,
   initializeCJSLoader,
@@ -112,6 +113,7 @@ port.on('message', (message) => {
     if (manifestSrc) {
       require('internal/process/policy').setup(manifestSrc, manifestURL);
     }
+    initializeAbortController();
     initializeDeprecations();
     initializeWASI();
     initializeCJSLoader();
diff --git a/node.gyp b/node.gyp
index f18a0d58a84c79..fbc26fed51cf5d 100644
--- a/node.gyp
+++ b/node.gyp
@@ -95,6 +95,7 @@
       'lib/wasi.js',
       'lib/worker_threads.js',
       'lib/zlib.js',
+      'lib/internal/abort_controller.js',
       'lib/internal/assert.js',
       'lib/internal/assert/assertion_error.js',
       'lib/internal/assert/calltracker.js',
diff --git a/src/node_options.cc b/src/node_options.cc
index e7dc220f5c3fca..d5edbf58bb8caf 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -281,6 +281,10 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "experimental Source Map V3 support",
             &EnvironmentOptions::enable_source_maps,
             kAllowedInEnvironment);
+  AddOption("--experimental-abortcontroller",
+            "experimental AbortController support",
+            &EnvironmentOptions::experimental_abortcontroller,
+            kAllowedInEnvironment);
   AddOption("--experimental-json-modules",
             "experimental JSON interop support for the ES Module loader",
             &EnvironmentOptions::experimental_json_modules,
diff --git a/src/node_options.h b/src/node_options.h
index bd63fcb0485c77..0a5aef792d051f 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -102,6 +102,7 @@ class EnvironmentOptions : public Options {
   bool abort_on_uncaught_exception = false;
   std::vector<std::string> conditions;
   bool enable_source_maps = false;
+  bool experimental_abortcontroller = false;
   bool experimental_json_modules = false;
   bool experimental_modules = false;
   std::string experimental_specifier_resolution;
diff --git a/test/parallel/test-abortcontroller.js b/test/parallel/test-abortcontroller.js
new file mode 100644
index 00000000000000..c1e28e16146785
--- /dev/null
+++ b/test/parallel/test-abortcontroller.js
@@ -0,0 +1,22 @@
+// Flags: --no-warnings --experimental-abortcontroller
+'use strict';
+
+const common = require('../common');
+
+const { ok, strictEqual } = require('assert');
+
+{
+  const ac = new AbortController();
+  ok(ac.signal);
+  ac.signal.onabort = common.mustCall((event) => {
+    ok(event);
+    strictEqual(event.type, 'abort');
+  });
+  ac.signal.addEventListener('abort', common.mustCall((event) => {
+    ok(event);
+    strictEqual(event.type, 'abort');
+  }), { once: true });
+  ac.abort();
+  ac.abort();
+  ok(ac.signal.aborted);
+}
diff --git a/tools/doc/type-parser.js b/tools/doc/type-parser.js
index b057fd2a96ca86..0ca1998b282c5c 100644
--- a/tools/doc/type-parser.js
+++ b/tools/doc/type-parser.js
@@ -26,6 +26,10 @@ const customTypesMap = {
 
   'this': `${jsDocPrefix}Reference/Operators/this`,
 
+  'AbortController': 'globals.html#globals_class_abortcontroller',
+  'AbortSignal':
+    'globals.html#globals_class_abortsignal_extends_eventtarget',
+
   'ArrayBufferView':
     'https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView',
 

From c86e131cea473639141f0668c94a7aee137507ee Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Wed, 10 Jun 2020 14:14:23 -0700
Subject: [PATCH 02/40] timers: allow promisified timeouts/immediates to be
 canceled

Using the new experimental AbortController...

Signed-off-by: James M Snell <jasnell@gmail.com>

PR-URL: https://github.com/nodejs/node/pull/33833
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Gus Caplan <me@gus.host>
---
 doc/api/timers.md                        | 44 ++++++++++++-
 lib/timers.js                            | 79 ++++++++++++++++++++++--
 test/parallel/test-timers-promisified.js | 54 ++++++++++++++++
 3 files changed, 171 insertions(+), 6 deletions(-)

diff --git a/doc/api/timers.md b/doc/api/timers.md
index 21226257dd7c6f..ac63d1e63ef7b3 100644
--- a/doc/api/timers.md
+++ b/doc/api/timers.md
@@ -248,8 +248,47 @@ The [`setImmediate()`][], [`setInterval()`][], and [`setTimeout()`][] methods
 each return objects that represent the scheduled timers. These can be used to
 cancel the timer and prevent it from triggering.
 
-It is not possible to cancel timers that were created using the promisified
-variants of [`setImmediate()`][], [`setTimeout()`][].
+For the promisified variants of [`setImmediate()`][] and [`setTimeout()`][],
+an [`AbortController`][] may be used to cancel the timer. When canceled, the
+returned Promises will be rejected with an `'AbortError'`.
+
+For `setImmediate()`:
+
+```js
+const util = require('util');
+const setImmediatePromise = util.promisify(setImmediate);
+
+const ac = new AbortController();
+const signal = ac.signal;
+
+setImmediatePromise('foobar', { signal })
+  .then(console.log)
+  .catch((err) => {
+    if (err.message === 'AbortError')
+      console.log('The immediate was aborted');
+  });
+
+ac.abort();
+```
+
+For `setTimeout()`:
+
+```js
+const util = require('util');
+const setTimeoutPromise = util.promisify(setTimeout);
+
+const ac = new AbortController();
+const signal = ac.signal;
+
+setTimeoutPromise(1000, 'foobar', { signal })
+  .then(console.log)
+  .catch((err) => {
+    if (err.message === 'AbortError')
+      console.log('The timeout was aborted');
+  });
+
+ac.abort();
+```
 
 ### `clearImmediate(immediate)`
 <!-- YAML
@@ -280,6 +319,7 @@ added: v0.0.1
 Cancels a `Timeout` object created by [`setTimeout()`][].
 
 [Event Loop]: https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#setimmediate-vs-settimeout
+[`AbortController`]: globals.md#globals_class_abortcontroller
 [`TypeError`]: errors.md#errors_class_typeerror
 [`clearImmediate()`]: timers.md#timers_clearimmediate_immediate
 [`clearInterval()`]: timers.md#timers_clearinterval_timeout
diff --git a/lib/timers.js b/lib/timers.js
index de50e56a11909a..3dbdeb433e4430 100644
--- a/lib/timers.js
+++ b/lib/timers.js
@@ -28,6 +28,12 @@ const {
   SymbolToPrimitive
 } = primordials;
 
+const {
+  codes: { ERR_INVALID_ARG_TYPE }
+} = require('internal/errors');
+
+let DOMException;
+
 const {
   immediateInfo,
   toggleImmediateRef
@@ -129,6 +135,11 @@ function enroll(item, msecs) {
  * DOM-style timers
  */
 
+function lazyDOMException(message) {
+  if (DOMException === undefined)
+    DOMException = internalBinding('messaging').DOMException;
+  return new DOMException(message);
+}
 
 function setTimeout(callback, after, arg1, arg2, arg3) {
   validateCallback(callback);
@@ -160,11 +171,40 @@ function setTimeout(callback, after, arg1, arg2, arg3) {
   return timeout;
 }
 
-setTimeout[customPromisify] = function(after, value) {
+setTimeout[customPromisify] = function(after, value, options = {}) {
   const args = value !== undefined ? [value] : value;
-  return new Promise((resolve) => {
+  if (options == null || typeof options !== 'object') {
+    return Promise.reject(
+      new ERR_INVALID_ARG_TYPE(
+        'options',
+        'Object',
+        options));
+  }
+  const { signal } = options;
+  if (signal !== undefined &&
+      (signal === null ||
+       typeof signal !== 'object' ||
+       !('aborted' in signal))) {
+    return Promise.reject(
+      new ERR_INVALID_ARG_TYPE(
+        'options.signal',
+        'AbortSignal',
+        signal));
+  }
+  // TODO(@jasnell): If a decision is made that this cannot be backported
+  // to 12.x, then this can be converted to use optional chaining to
+  // simplify the check.
+  if (signal && signal.aborted)
+    return Promise.reject(lazyDOMException('AbortError'));
+  return new Promise((resolve, reject) => {
     const timeout = new Timeout(resolve, after, args, false, true);
     insert(timeout, timeout._idleTimeout);
+    if (signal) {
+      signal.addEventListener('abort', () => {
+        clearTimeout(timeout);
+        reject(lazyDOMException('AbortError'));
+      }, { once: true });
+    }
   });
 };
 
@@ -300,8 +340,39 @@ function setImmediate(callback, arg1, arg2, arg3) {
   return new Immediate(callback, args);
 }
 
-setImmediate[customPromisify] = function(value) {
-  return new Promise((resolve) => new Immediate(resolve, [value]));
+setImmediate[customPromisify] = function(value, options = {}) {
+  if (options == null || typeof options !== 'object') {
+    return Promise.reject(
+      new ERR_INVALID_ARG_TYPE(
+        'options',
+        'Object',
+        options));
+  }
+  const { signal } = options;
+  if (signal !== undefined &&
+    (signal === null ||
+     typeof signal !== 'object' ||
+     !('aborted' in signal))) {
+    return Promise.reject(
+      new ERR_INVALID_ARG_TYPE(
+        'options.signal',
+        'AbortSignal',
+        signal));
+  }
+  // TODO(@jasnell): If a decision is made that this cannot be backported
+  // to 12.x, then this can be converted to use optional chaining to
+  // simplify the check.
+  if (signal && signal.aborted)
+    return Promise.reject(lazyDOMException('AbortError'));
+  return new Promise((resolve, reject) => {
+    const immediate = new Immediate(resolve, [value]);
+    if (signal) {
+      signal.addEventListener('abort', () => {
+        clearImmediate(immediate);
+        reject(lazyDOMException('AbortError'));
+      }, { once: true });
+    }
+  });
 };
 
 function clearImmediate(immediate) {
diff --git a/test/parallel/test-timers-promisified.js b/test/parallel/test-timers-promisified.js
index 85e7093cfa185f..6fbf6157603f2c 100644
--- a/test/parallel/test-timers-promisified.js
+++ b/test/parallel/test-timers-promisified.js
@@ -1,3 +1,4 @@
+// Flags: --no-warnings --experimental-abortcontroller
 'use strict';
 const common = require('../common');
 const assert = require('assert');
@@ -36,3 +37,56 @@ const setImmediate = promisify(timers.setImmediate);
     assert.strictEqual(value, 'foobar');
   }));
 }
+
+{
+  const ac = new AbortController();
+  const signal = ac.signal;
+  assert.rejects(setTimeout(10, undefined, { signal }), /AbortError/);
+  ac.abort();
+}
+
+{
+  const ac = new AbortController();
+  const signal = ac.signal;
+  ac.abort(); // Abort in advance
+  assert.rejects(setTimeout(10, undefined, { signal }), /AbortError/);
+}
+
+{
+  const ac = new AbortController();
+  const signal = ac.signal;
+  assert.rejects(setImmediate(10, { signal }), /AbortError/);
+  ac.abort();
+}
+
+{
+  const ac = new AbortController();
+  const signal = ac.signal;
+  ac.abort(); // Abort in advance
+  assert.rejects(setImmediate(10, { signal }), /AbortError/);
+}
+
+{
+  Promise.all(
+    [1, '', false, Infinity].map((i) => assert.rejects(setImmediate(10, i)), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    })).then(common.mustCall());
+
+  Promise.all(
+    [1, '', false, Infinity, null, {}].map(
+      (signal) => assert.rejects(setImmediate(10, { signal })), {
+        code: 'ERR_INVALID_ARG_TYPE'
+      })).then(common.mustCall());
+
+  Promise.all(
+    [1, '', false, Infinity].map(
+      (i) => assert.rejects(setTimeout(10, null, i)), {
+        code: 'ERR_INVALID_ARG_TYPE'
+      })).then(common.mustCall());
+
+  Promise.all(
+    [1, '', false, Infinity, null, {}].map(
+      (signal) => assert.rejects(setTimeout(10, null, { signal })), {
+        code: 'ERR_INVALID_ARG_TYPE'
+      })).then(common.mustCall());
+}

From 290ce9f463b0569b37655660a8f97a6a9fcd9001 Mon Sep 17 00:00:00 2001
From: Denys Otrishko <shishugi@gmail.com>
Date: Thu, 18 Jun 2020 22:58:42 +0300
Subject: [PATCH 03/40] timers: fix multipleResolves in promisified
 timeouts/immediates

After successful timer finish the abort event callback would still
reject (already resolved promise) upon calling abortController.abort().

Signed-off-by: Denys Otrishko <shishugi@gmail.com>

PR-URL: https://github.com/nodejs/node/pull/33949
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 lib/timers.js                            | 12 ++++++++----
 test/parallel/test-timers-promisified.js | 19 +++++++++++++++++++
 2 files changed, 27 insertions(+), 4 deletions(-)

diff --git a/lib/timers.js b/lib/timers.js
index 3dbdeb433e4430..60e8bc5c0d073d 100644
--- a/lib/timers.js
+++ b/lib/timers.js
@@ -201,8 +201,10 @@ setTimeout[customPromisify] = function(after, value, options = {}) {
     insert(timeout, timeout._idleTimeout);
     if (signal) {
       signal.addEventListener('abort', () => {
-        clearTimeout(timeout);
-        reject(lazyDOMException('AbortError'));
+        if (!timeout._destroyed) {
+          clearTimeout(timeout);
+          reject(lazyDOMException('AbortError'));
+        }
       }, { once: true });
     }
   });
@@ -368,8 +370,10 @@ setImmediate[customPromisify] = function(value, options = {}) {
     const immediate = new Immediate(resolve, [value]);
     if (signal) {
       signal.addEventListener('abort', () => {
-        clearImmediate(immediate);
-        reject(lazyDOMException('AbortError'));
+        if (!immediate._destroyed) {
+          clearImmediate(immediate);
+          reject(lazyDOMException('AbortError'));
+        }
       }, { once: true });
     }
   });
diff --git a/test/parallel/test-timers-promisified.js b/test/parallel/test-timers-promisified.js
index 6fbf6157603f2c..286a7fd8965d36 100644
--- a/test/parallel/test-timers-promisified.js
+++ b/test/parallel/test-timers-promisified.js
@@ -10,6 +10,8 @@ const { promisify } = require('util');
 const setTimeout = promisify(timers.setTimeout);
 const setImmediate = promisify(timers.setImmediate);
 
+process.on('multipleResolves', common.mustNotCall());
+
 {
   const promise = setTimeout(1);
   promise.then(common.mustCall((value) => {
@@ -66,6 +68,23 @@ const setImmediate = promisify(timers.setImmediate);
   assert.rejects(setImmediate(10, { signal }), /AbortError/);
 }
 
+{
+  // Check that aborting after resolve will not reject.
+  const ac = new AbortController();
+  const signal = ac.signal;
+  setTimeout(10, undefined, { signal }).then(() => {
+    ac.abort();
+  });
+}
+{
+  // Check that aborting after resolve will not reject.
+  const ac = new AbortController();
+  const signal = ac.signal;
+  setImmediate(10, { signal }).then(() => {
+    ac.abort();
+  });
+}
+
 {
   Promise.all(
     [1, '', false, Infinity].map((i) => assert.rejects(setImmediate(10, i)), {

From d0971710f548c096b87125b268b7f2830275d211 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Thu, 18 Jun 2020 13:22:17 -0700
Subject: [PATCH 04/40] timers: move promisified timers implementations

Move the promisified timers implementations into a new internal.
submodule.

Also adds `ref` option to the promisified versions.

Signed-off-by: James M Snell <jasnell@gmail.com>

PR-URL: https://github.com/nodejs/node/pull/33950
Reviewed-By: Denys Otrishko <shishugi@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
---
 lib/internal/timers.js                   |  44 ++++++-
 lib/internal/timers/promises.js          | 124 +++++++++++++++++++
 lib/timers.js                            | 147 +++--------------------
 node.gyp                                 |   1 +
 test/parallel/test-timers-promisified.js |   6 +
 5 files changed, 194 insertions(+), 128 deletions(-)
 create mode 100644 lib/internal/timers/promises.js

diff --git a/lib/internal/timers.js b/lib/internal/timers.js
index 045994a23d0210..d39bab9d074895 100644
--- a/lib/internal/timers.js
+++ b/lib/internal/timers.js
@@ -84,7 +84,8 @@ const {
   scheduleTimer,
   toggleTimerRef,
   getLibuvNow,
-  immediateInfo
+  immediateInfo,
+  toggleImmediateRef
 } = internalBinding('timers');
 
 const {
@@ -593,12 +594,53 @@ function getTimerCallbacks(runNextTicks) {
   };
 }
 
+class Immediate {
+  constructor(callback, args) {
+    this._idleNext = null;
+    this._idlePrev = null;
+    this._onImmediate = callback;
+    this._argv = args;
+    this._destroyed = false;
+    this[kRefed] = false;
+
+    initAsyncResource(this, 'Immediate');
+
+    this.ref();
+    immediateInfo[kCount]++;
+
+    immediateQueue.append(this);
+  }
+
+  ref() {
+    if (this[kRefed] === false) {
+      this[kRefed] = true;
+      if (immediateInfo[kRefCount]++ === 0)
+        toggleImmediateRef(true);
+    }
+    return this;
+  }
+
+  unref() {
+    if (this[kRefed] === true) {
+      this[kRefed] = false;
+      if (--immediateInfo[kRefCount] === 0)
+        toggleImmediateRef(false);
+    }
+    return this;
+  }
+
+  hasRef() {
+    return !!this[kRefed];
+  }
+}
+
 module.exports = {
   TIMEOUT_MAX,
   kTimeout: Symbol('timeout'), // For hiding Timeouts on other internals.
   async_id_symbol,
   trigger_async_id_symbol,
   Timeout,
+  Immediate,
   kRefed,
   kHasPrimitive,
   initAsyncResource,
diff --git a/lib/internal/timers/promises.js b/lib/internal/timers/promises.js
new file mode 100644
index 00000000000000..78197fe86f6e22
--- /dev/null
+++ b/lib/internal/timers/promises.js
@@ -0,0 +1,124 @@
+'use strict';
+
+const {
+  Promise,
+  PromiseReject,
+} = primordials;
+
+const {
+  Timeout,
+  Immediate,
+  insert
+} = require('internal/timers');
+
+const {
+  hideStackFrames,
+  codes: { ERR_INVALID_ARG_TYPE }
+} = require('internal/errors');
+
+let DOMException;
+
+const lazyDOMException = hideStackFrames((message) => {
+  if (DOMException === undefined)
+    DOMException = internalBinding('messaging').DOMException;
+  return new DOMException(message);
+});
+
+function setTimeout(after, value, options = {}) {
+  const args = value !== undefined ? [value] : value;
+  if (options == null || typeof options !== 'object') {
+    return PromiseReject(
+      new ERR_INVALID_ARG_TYPE(
+        'options',
+        'Object',
+        options));
+  }
+  const { signal, ref = true } = options;
+  if (signal !== undefined &&
+      (signal === null ||
+       typeof signal !== 'object' ||
+       !('aborted' in signal))) {
+    return PromiseReject(
+      new ERR_INVALID_ARG_TYPE(
+        'options.signal',
+        'AbortSignal',
+        signal));
+  }
+  if (typeof ref !== 'boolean') {
+    return PromiseReject(
+      new ERR_INVALID_ARG_TYPE(
+        'options.ref',
+        'boolean',
+        ref));
+  }
+  // TODO(@jasnell): If a decision is made that this cannot be backported
+  // to 12.x, then this can be converted to use optional chaining to
+  // simplify the check.
+  if (signal && signal.aborted)
+    return PromiseReject(lazyDOMException('AbortError'));
+  return new Promise((resolve, reject) => {
+    const timeout = new Timeout(resolve, after, args, false, true);
+    if (!ref) timeout.unref();
+    insert(timeout, timeout._idleTimeout);
+    if (signal) {
+      signal.addEventListener('abort', () => {
+        if (!timeout._destroyed) {
+          // eslint-disable-next-line no-undef
+          clearTimeout(timeout);
+          reject(lazyDOMException('AbortError'));
+        }
+      }, { once: true });
+    }
+  });
+}
+
+function setImmediate(value, options = {}) {
+  if (options == null || typeof options !== 'object') {
+    return PromiseReject(
+      new ERR_INVALID_ARG_TYPE(
+        'options',
+        'Object',
+        options));
+  }
+  const { signal, ref = true } = options;
+  if (signal !== undefined &&
+    (signal === null ||
+     typeof signal !== 'object' ||
+     !('aborted' in signal))) {
+    return PromiseReject(
+      new ERR_INVALID_ARG_TYPE(
+        'options.signal',
+        'AbortSignal',
+        signal));
+  }
+  if (typeof ref !== 'boolean') {
+    return PromiseReject(
+      new ERR_INVALID_ARG_TYPE(
+        'options.ref',
+        'boolean',
+        ref));
+  }
+  // TODO(@jasnell): If a decision is made that this cannot be backported
+  // to 12.x, then this can be converted to use optional chaining to
+  // simplify the check.
+  if (signal && signal.aborted)
+    return PromiseReject(lazyDOMException('AbortError'));
+  return new Promise((resolve, reject) => {
+    const immediate = new Immediate(resolve, [value]);
+    if (!ref) immediate.unref();
+    if (signal) {
+      signal.addEventListener('abort', () => {
+        if (!immediate._destroyed) {
+          // eslint-disable-next-line no-undef
+          clearImmediate(immediate);
+          reject(lazyDOMException('AbortError'));
+        }
+      }, { once: true });
+    }
+  });
+}
+
+module.exports = {
+  setTimeout,
+  setImmediate,
+};
diff --git a/lib/timers.js b/lib/timers.js
index 60e8bc5c0d073d..27f0f11f095f62 100644
--- a/lib/timers.js
+++ b/lib/timers.js
@@ -24,16 +24,10 @@
 const {
   ObjectCreate,
   MathTrunc,
-  Promise,
-  SymbolToPrimitive
+  Object,
+  SymbolToPrimitive,
 } = primordials;
 
-const {
-  codes: { ERR_INVALID_ARG_TYPE }
-} = require('internal/errors');
-
-let DOMException;
-
 const {
   immediateInfo,
   toggleImmediateRef
@@ -42,6 +36,7 @@ const L = require('internal/linkedlist');
 const {
   async_id_symbol,
   Timeout,
+  Immediate,
   decRefCount,
   immediateInfoFields: {
     kCount,
@@ -49,7 +44,6 @@ const {
   },
   kRefed,
   kHasPrimitive,
-  initAsyncResource,
   getTimerDuration,
   timerListMap,
   timerListQueue,
@@ -67,6 +61,8 @@ let debug = require('internal/util/debuglog').debuglog('timer', (fn) => {
 });
 const { validateCallback } = require('internal/validators');
 
+let timersPromises;
+
 const {
   destroyHooksExist,
   // The needed emit*() functions.
@@ -135,12 +131,6 @@ function enroll(item, msecs) {
  * DOM-style timers
  */
 
-function lazyDOMException(message) {
-  if (DOMException === undefined)
-    DOMException = internalBinding('messaging').DOMException;
-  return new DOMException(message);
-}
-
 function setTimeout(callback, after, arg1, arg2, arg3) {
   validateCallback(callback);
 
@@ -171,44 +161,14 @@ function setTimeout(callback, after, arg1, arg2, arg3) {
   return timeout;
 }
 
-setTimeout[customPromisify] = function(after, value, options = {}) {
-  const args = value !== undefined ? [value] : value;
-  if (options == null || typeof options !== 'object') {
-    return Promise.reject(
-      new ERR_INVALID_ARG_TYPE(
-        'options',
-        'Object',
-        options));
+Object.defineProperty(setTimeout, customPromisify, {
+  enumerable: true,
+  get() {
+    if (!timersPromises)
+      timersPromises = require('internal/timers/promises');
+    return timersPromises.setTimeout;
   }
-  const { signal } = options;
-  if (signal !== undefined &&
-      (signal === null ||
-       typeof signal !== 'object' ||
-       !('aborted' in signal))) {
-    return Promise.reject(
-      new ERR_INVALID_ARG_TYPE(
-        'options.signal',
-        'AbortSignal',
-        signal));
-  }
-  // TODO(@jasnell): If a decision is made that this cannot be backported
-  // to 12.x, then this can be converted to use optional chaining to
-  // simplify the check.
-  if (signal && signal.aborted)
-    return Promise.reject(lazyDOMException('AbortError'));
-  return new Promise((resolve, reject) => {
-    const timeout = new Timeout(resolve, after, args, false, true);
-    insert(timeout, timeout._idleTimeout);
-    if (signal) {
-      signal.addEventListener('abort', () => {
-        if (!timeout._destroyed) {
-          clearTimeout(timeout);
-          reject(lazyDOMException('AbortError'));
-        }
-      }, { once: true });
-    }
-  });
-};
+});
 
 function clearTimeout(timer) {
   if (timer && timer._onTimeout) {
@@ -276,46 +236,6 @@ Timeout.prototype[SymbolToPrimitive] = function() {
   return id;
 };
 
-const Immediate = class Immediate {
-  constructor(callback, args) {
-    this._idleNext = null;
-    this._idlePrev = null;
-    this._onImmediate = callback;
-    this._argv = args;
-    this._destroyed = false;
-    this[kRefed] = false;
-
-    initAsyncResource(this, 'Immediate');
-
-    this.ref();
-    immediateInfo[kCount]++;
-
-    immediateQueue.append(this);
-  }
-
-  ref() {
-    if (this[kRefed] === false) {
-      this[kRefed] = true;
-      if (immediateInfo[kRefCount]++ === 0)
-        toggleImmediateRef(true);
-    }
-    return this;
-  }
-
-  unref() {
-    if (this[kRefed] === true) {
-      this[kRefed] = false;
-      if (--immediateInfo[kRefCount] === 0)
-        toggleImmediateRef(false);
-    }
-    return this;
-  }
-
-  hasRef() {
-    return !!this[kRefed];
-  }
-};
-
 function setImmediate(callback, arg1, arg2, arg3) {
   validateCallback(callback);
 
@@ -342,42 +262,15 @@ function setImmediate(callback, arg1, arg2, arg3) {
   return new Immediate(callback, args);
 }
 
-setImmediate[customPromisify] = function(value, options = {}) {
-  if (options == null || typeof options !== 'object') {
-    return Promise.reject(
-      new ERR_INVALID_ARG_TYPE(
-        'options',
-        'Object',
-        options));
+Object.defineProperty(setImmediate, customPromisify, {
+  enumerable: true,
+  get() {
+    if (!timersPromises)
+      timersPromises = require('internal/timers/promises');
+    return timersPromises.setImmediate;
   }
-  const { signal } = options;
-  if (signal !== undefined &&
-    (signal === null ||
-     typeof signal !== 'object' ||
-     !('aborted' in signal))) {
-    return Promise.reject(
-      new ERR_INVALID_ARG_TYPE(
-        'options.signal',
-        'AbortSignal',
-        signal));
-  }
-  // TODO(@jasnell): If a decision is made that this cannot be backported
-  // to 12.x, then this can be converted to use optional chaining to
-  // simplify the check.
-  if (signal && signal.aborted)
-    return Promise.reject(lazyDOMException('AbortError'));
-  return new Promise((resolve, reject) => {
-    const immediate = new Immediate(resolve, [value]);
-    if (signal) {
-      signal.addEventListener('abort', () => {
-        if (!immediate._destroyed) {
-          clearImmediate(immediate);
-          reject(lazyDOMException('AbortError'));
-        }
-      }, { once: true });
-    }
-  });
-};
+});
+
 
 function clearImmediate(immediate) {
   if (!immediate || immediate._destroyed)
diff --git a/node.gyp b/node.gyp
index fbc26fed51cf5d..ab2480c4657540 100644
--- a/node.gyp
+++ b/node.gyp
@@ -199,6 +199,7 @@
       'lib/internal/source_map/source_map.js',
       'lib/internal/source_map/source_map_cache.js',
       'lib/internal/test/binding.js',
+      'lib/internal/timers/promises.js',
       'lib/internal/timers.js',
       'lib/internal/tls.js',
       'lib/internal/trace_events_async_hooks.js',
diff --git a/test/parallel/test-timers-promisified.js b/test/parallel/test-timers-promisified.js
index 286a7fd8965d36..1b1e98d628543a 100644
--- a/test/parallel/test-timers-promisified.js
+++ b/test/parallel/test-timers-promisified.js
@@ -108,4 +108,10 @@ process.on('multipleResolves', common.mustNotCall());
       (signal) => assert.rejects(setTimeout(10, null, { signal })), {
         code: 'ERR_INVALID_ARG_TYPE'
       })).then(common.mustCall());
+
+  Promise.all(
+    [1, '', Infinity, null, {}].map(
+      (ref) => assert.rejects(setTimeout(10, null, { ref })), {
+        code: 'ERR_INVALID_ARG_TYPE'
+      })).then(common.mustCall());
 }

From 26b76264baa00e5c729d5c0297adafd8b66bb518 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Thu, 13 Aug 2020 21:00:55 +0200
Subject: [PATCH 05/40] timers: use AbortController with correct name/message

On the web, `AbortError` is the error name, not the error
message. Change the code to match that.

PR-URL: https://github.com/nodejs/node/pull/34763
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 lib/internal/timers/promises.js | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/lib/internal/timers/promises.js b/lib/internal/timers/promises.js
index 78197fe86f6e22..ef1e6437d4f6ca 100644
--- a/lib/internal/timers/promises.js
+++ b/lib/internal/timers/promises.js
@@ -18,10 +18,10 @@ const {
 
 let DOMException;
 
-const lazyDOMException = hideStackFrames((message) => {
+const lazyDOMException = hideStackFrames((message, name) => {
   if (DOMException === undefined)
     DOMException = internalBinding('messaging').DOMException;
-  return new DOMException(message);
+  return new DOMException(message, name);
 });
 
 function setTimeout(after, value, options = {}) {
@@ -54,8 +54,10 @@ function setTimeout(after, value, options = {}) {
   // TODO(@jasnell): If a decision is made that this cannot be backported
   // to 12.x, then this can be converted to use optional chaining to
   // simplify the check.
-  if (signal && signal.aborted)
-    return PromiseReject(lazyDOMException('AbortError'));
+  if (signal && signal.aborted) {
+    return PromiseReject(
+      lazyDOMException('The operation was aborted', 'AbortError'));
+  }
   return new Promise((resolve, reject) => {
     const timeout = new Timeout(resolve, after, args, false, true);
     if (!ref) timeout.unref();
@@ -65,7 +67,7 @@ function setTimeout(after, value, options = {}) {
         if (!timeout._destroyed) {
           // eslint-disable-next-line no-undef
           clearTimeout(timeout);
-          reject(lazyDOMException('AbortError'));
+          reject(lazyDOMException('The operation was aborted', 'AbortError'));
         }
       }, { once: true });
     }
@@ -101,8 +103,10 @@ function setImmediate(value, options = {}) {
   // TODO(@jasnell): If a decision is made that this cannot be backported
   // to 12.x, then this can be converted to use optional chaining to
   // simplify the check.
-  if (signal && signal.aborted)
-    return PromiseReject(lazyDOMException('AbortError'));
+  if (signal && signal.aborted) {
+    return PromiseReject(
+      lazyDOMException('The operation was aborted', 'AbortError'));
+  }
   return new Promise((resolve, reject) => {
     const immediate = new Immediate(resolve, [value]);
     if (!ref) immediate.unref();
@@ -111,7 +115,7 @@ function setImmediate(value, options = {}) {
         if (!immediate._destroyed) {
           // eslint-disable-next-line no-undef
           clearImmediate(immediate);
-          reject(lazyDOMException('AbortError'));
+          reject(lazyDOMException('The operation was aborted', 'AbortError'));
         }
       }, { once: true });
     }

From 268686a3de8322960a709ca34100d1361beedfb1 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Mon, 24 Aug 2020 13:11:23 -0700
Subject: [PATCH 06/40] events: allow use of AbortController with once

Allows an AbortSignal to be passed in to events.once() to cancel
waiting on an event.

Signed-off-by: James M Snell <jasnell@gmail.com>

PR-URL: https://github.com/nodejs/node/pull/34911
Reviewed-By: Denys Otrishko <shishugi@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 doc/api/events.md                 | 30 ++++++++++-
 lib/events.js                     | 53 +++++++++++++++++-
 lib/internal/validators.js        | 10 ++++
 test/parallel/test-events-once.js | 90 ++++++++++++++++++++++++++++++-
 4 files changed, 179 insertions(+), 4 deletions(-)

diff --git a/doc/api/events.md b/doc/api/events.md
index 55ede34dc38c64..09e435cd2963c3 100644
--- a/doc/api/events.md
+++ b/doc/api/events.md
@@ -829,7 +829,7 @@ class MyClass extends EventEmitter {
 }
 ```
 
-## `events.once(emitter, name)`
+## `events.once(emitter, name[, options])`
 <!-- YAML
 added:
  - v11.13.0
@@ -838,6 +838,9 @@ added:
 
 * `emitter` {EventEmitter}
 * `name` {string}
+* `options` {Object}
+  * `signal` {AbortSignal} An {AbortSignal} that may be used to cancel waiting
+    for the event.
 * Returns: {Promise}
 
 Creates a `Promise` that is fulfilled when the `EventEmitter` emits the given
@@ -896,6 +899,31 @@ ee.emit('error', new Error('boom'));
 // Prints: ok boom
 ```
 
+An {AbortSignal} may be used to cancel waiting for the event early:
+
+```js
+const { EventEmitter, once } = require('events');
+
+const ee = new EventEmitter();
+const ac = new AbortController();
+
+async function foo(emitter, event, signal) {
+  try {
+    await once(emitter, event, { signal });
+    console.log('event emitted!');
+  } catch (error) {
+    if (error.name === 'AbortError') {
+      console.error('Waiting for the event was canceled!');
+    } else {
+      console.error('There was an error', error.message);
+    }
+  }
+}
+
+foo(ee, 'foo', ac.signal);
+ac.abort(); // Abort waiting for the event
+```
+
 ### Awaiting multiple events emitted on `process.nextTick()`
 
 There is an edge case worth noting when using the `events.once()` function
diff --git a/lib/events.js b/lib/events.js
index 48da5e0ed1b72d..d08b79aba17959 100644
--- a/lib/events.js
+++ b/lib/events.js
@@ -46,6 +46,7 @@ const kRejection = SymbolFor('nodejs.rejection');
 let spliceOne;
 
 const {
+  hideStackFrames,
   kEnhanceStackBeforeInspector,
   codes
 } = require('internal/errors');
@@ -59,9 +60,20 @@ const {
   inspect
 } = require('internal/util/inspect');
 
+const {
+  validateAbortSignal
+} = require('internal/validators');
+
 const kCapture = Symbol('kCapture');
 const kErrorMonitor = Symbol('events.errorMonitor');
 
+let DOMException;
+const lazyDOMException = hideStackFrames((message, name) => {
+  if (DOMException === undefined)
+    DOMException = internalBinding('messaging').DOMException;
+  return new DOMException(message, name);
+});
+
 function EventEmitter(opts) {
   EventEmitter.init.call(this, opts);
 }
@@ -622,22 +634,61 @@ function unwrapListeners(arr) {
   return ret;
 }
 
-function once(emitter, name) {
+async function once(emitter, name, options = {}) {
+  const signal = options ? options.signal : undefined;
+  validateAbortSignal(signal, 'options.signal');
+  if (signal && signal.aborted)
+    throw lazyDOMException('The operation was aborted', 'AbortError');
   return new Promise((resolve, reject) => {
     const errorListener = (err) => {
       emitter.removeListener(name, resolver);
+      if (signal != null) {
+        eventTargetAgnosticRemoveListener(
+          signal,
+          'abort',
+          abortListener,
+          { once: true });
+      }
       reject(err);
     };
     const resolver = (...args) => {
       if (typeof emitter.removeListener === 'function') {
         emitter.removeListener('error', errorListener);
       }
+      if (signal != null) {
+        eventTargetAgnosticRemoveListener(
+          signal,
+          'abort',
+          abortListener,
+          { once: true });
+      }
       resolve(args);
     };
     eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
     if (name !== 'error') {
       addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
     }
+    function abortListener() {
+      if (typeof emitter.removeListener === 'function') {
+        emitter.removeListener(name, resolver);
+        emitter.removeListener('error', errorListener);
+      } else {
+        eventTargetAgnosticRemoveListener(
+          emitter,
+          name,
+          resolver,
+          { once: true });
+        eventTargetAgnosticRemoveListener(
+          emitter,
+          'error',
+          errorListener,
+          { once: true });
+      }
+      reject(lazyDOMException('The operation was aborted', 'AbortError'));
+    }
+    if (signal != null) {
+      signal.addEventListener('abort', abortListener, { once: true });
+    }
   });
 }
 
diff --git a/lib/internal/validators.js b/lib/internal/validators.js
index c1655fb1a843fe..ac54c96bb2dec0 100644
--- a/lib/internal/validators.js
+++ b/lib/internal/validators.js
@@ -218,6 +218,15 @@ const validateCallback = hideStackFrames((callback) => {
     throw new ERR_INVALID_CALLBACK(callback);
 });
 
+const validateAbortSignal = hideStackFrames((signal, name) => {
+  if (signal !== undefined &&
+      (signal === null ||
+       typeof signal !== 'object' ||
+       !('aborted' in signal))) {
+    throw new ERR_INVALID_ARG_TYPE(name, 'AbortSignal', signal);
+  }
+});
+
 module.exports = {
   isInt32,
   isUint32,
@@ -236,4 +245,5 @@ module.exports = {
   validateString,
   validateUint32,
   validateCallback,
+  validateAbortSignal,
 };
diff --git a/test/parallel/test-events-once.js b/test/parallel/test-events-once.js
index 658a9964be73e1..867987da9ef386 100644
--- a/test/parallel/test-events-once.js
+++ b/test/parallel/test-events-once.js
@@ -1,9 +1,14 @@
 'use strict';
-// Flags: --expose-internals
+// Flags: --expose-internals --no-warnings --experimental-abortcontroller
 
 const common = require('../common');
 const { once, EventEmitter } = require('events');
-const { strictEqual, deepStrictEqual, fail } = require('assert');
+const {
+  strictEqual,
+  deepStrictEqual,
+  fail,
+  rejects,
+} = require('assert');
 const { EventTarget, Event } = require('internal/event_target');
 
 async function onceAnEvent() {
@@ -114,6 +119,81 @@ async function prioritizesEventEmitter() {
   process.nextTick(() => ee.emit('foo'));
   await once(ee, 'foo');
 }
+
+async function abortSignalBefore() {
+  const ee = new EventEmitter();
+  const ac = new AbortController();
+  ee.on('error', common.mustNotCall());
+  ac.abort();
+
+  await Promise.all([1, {}, 'hi', null, false].map((signal) => {
+    return rejects(once(ee, 'foo', { signal }), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+  }));
+
+  return rejects(once(ee, 'foo', { signal: ac.signal }), {
+    name: 'AbortError'
+  });
+}
+
+async function abortSignalAfter() {
+  const ee = new EventEmitter();
+  const ac = new AbortController();
+  ee.on('error', common.mustNotCall());
+  const r = rejects(once(ee, 'foo', { signal: ac.signal }), {
+    name: 'AbortError'
+  });
+  process.nextTick(() => ac.abort());
+  return r;
+}
+
+async function abortSignalAfterEvent() {
+  const ee = new EventEmitter();
+  const ac = new AbortController();
+  process.nextTick(() => {
+    ee.emit('foo');
+    ac.abort();
+  });
+  await once(ee, 'foo', { signal: ac.signal });
+}
+
+async function eventTargetAbortSignalBefore() {
+  const et = new EventTarget();
+  const ac = new AbortController();
+  ac.abort();
+
+  await Promise.all([1, {}, 'hi', null, false].map((signal) => {
+    return rejects(once(et, 'foo', { signal }), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+  }));
+
+  return rejects(once(et, 'foo', { signal: ac.signal }), {
+    name: 'AbortError'
+  });
+}
+
+async function eventTargetAbortSignalAfter() {
+  const et = new EventTarget();
+  const ac = new AbortController();
+  const r = rejects(once(et, 'foo', { signal: ac.signal }), {
+    name: 'AbortError'
+  });
+  process.nextTick(() => ac.abort());
+  return r;
+}
+
+async function eventTargetAbortSignalAfterEvent() {
+  const et = new EventTarget();
+  const ac = new AbortController();
+  process.nextTick(() => {
+    et.dispatchEvent(new Event('foo'));
+    ac.abort();
+  });
+  await once(et, 'foo', { signal: ac.signal });
+}
+
 Promise.all([
   onceAnEvent(),
   onceAnEventWithTwoArgs(),
@@ -123,4 +203,10 @@ Promise.all([
   onceWithEventTarget(),
   onceWithEventTargetError(),
   prioritizesEventEmitter(),
+  abortSignalBefore(),
+  abortSignalAfter(),
+  abortSignalAfterEvent(),
+  eventTargetAbortSignalBefore(),
+  eventTargetAbortSignalAfter(),
+  eventTargetAbortSignalAfterEvent(),
 ]).then(common.mustCall());

From 51031f328d872c7e62735e4762cf3e2c0e8d10ba Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Mon, 24 Aug 2020 13:48:15 -0700
Subject: [PATCH 07/40] events: allow use of AbortController with on

Signed-off-by: James M Snell <jasnell@gmail.com>

PR-URL: https://github.com/nodejs/node/pull/34912
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Denys Otrishko <shishugi@gmail.com>
---
 doc/api/events.md                             |  32 ++++-
 lib/events.js                                 |  28 +++-
 test/parallel/test-event-on-async-iterator.js | 121 +++++++++++++++++-
 3 files changed, 177 insertions(+), 4 deletions(-)

diff --git a/doc/api/events.md b/doc/api/events.md
index 09e435cd2963c3..e33413873c7126 100644
--- a/doc/api/events.md
+++ b/doc/api/events.md
@@ -1004,7 +1004,7 @@ Value: `Symbol.for('nodejs.rejection')`
 
 See how to write a custom [rejection handler][rejection].
 
-## `events.on(emitter, eventName)`
+## `events.on(emitter, eventName[, options])`
 <!-- YAML
 added:
  - v13.6.0
@@ -1013,6 +1013,9 @@ added:
 
 * `emitter` {EventEmitter}
 * `eventName` {string|symbol} The name of the event being listened for
+* `options` {Object}
+  * `signal` {AbortSignal} An {AbortSignal} that can be used to cancel awaiting
+    events.
 * Returns: {AsyncIterator} that iterates `eventName` events emitted by the `emitter`
 
 ```js
@@ -1042,6 +1045,33 @@ if the `EventEmitter` emits `'error'`. It removes all listeners when
 exiting the loop. The `value` returned by each iteration is an array
 composed of the emitted event arguments.
 
+An {AbortSignal} may be used to cancel waiting on events:
+
+```js
+const { on, EventEmitter } = require('events');
+const ac = new AbortController();
+
+(async () => {
+  const ee = new EventEmitter();
+
+  // Emit later on
+  process.nextTick(() => {
+    ee.emit('foo', 'bar');
+    ee.emit('foo', 42);
+  });
+
+  for await (const event of on(ee, 'foo', { signal: ac.signal })) {
+    // The execution of this inner block is synchronous and it
+    // processes one event at a time (even with await). Do not use
+    // if concurrent execution is required.
+    console.log(event); // prints ['bar'] [42]
+  }
+  // Unreachable here
+})();
+
+process.nextTick(() => ac.abort());
+```
+
 ## `EventTarget` and `Event` API
 <!-- YAML
 added: v14.5.0
diff --git a/lib/events.js b/lib/events.js
index d08b79aba17959..f4c116b8baf3b7 100644
--- a/lib/events.js
+++ b/lib/events.js
@@ -731,7 +731,13 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
   }
 }
 
-function on(emitter, event) {
+function on(emitter, event, options) {
+  const { signal } = { ...options };
+  validateAbortSignal(signal, 'options.signal');
+  if (signal && signal.aborted) {
+    throw lazyDOMException('The operation was aborted', 'AbortError');
+  }
+
   const unconsumedEvents = [];
   const unconsumedPromises = [];
   let error = null;
@@ -769,6 +775,15 @@ function on(emitter, event) {
     return() {
       eventTargetAgnosticRemoveListener(emitter, event, eventHandler);
       eventTargetAgnosticRemoveListener(emitter, 'error', errorHandler);
+
+      if (signal) {
+        eventTargetAgnosticRemoveListener(
+          signal,
+          'abort',
+          abortListener,
+          { once: true });
+      }
+
       finished = true;
 
       for (const promise of unconsumedPromises) {
@@ -798,9 +813,20 @@ function on(emitter, event) {
     addErrorHandlerIfEventEmitter(emitter, errorHandler);
   }
 
+  if (signal) {
+    eventTargetAgnosticAddListener(
+      signal,
+      'abort',
+      abortListener,
+      { once: true });
+  }
 
   return iterator;
 
+  function abortListener() {
+    errorHandler(lazyDOMException('The operation was aborted', 'AbortError'));
+  }
+
   function eventHandler(...args) {
     const promise = unconsumedPromises.shift();
     if (promise) {
diff --git a/test/parallel/test-event-on-async-iterator.js b/test/parallel/test-event-on-async-iterator.js
index 5c02360250538c..a6dc4b9c81c04f 100644
--- a/test/parallel/test-event-on-async-iterator.js
+++ b/test/parallel/test-event-on-async-iterator.js
@@ -1,4 +1,4 @@
-// Flags: --expose-internals
+// Flags: --expose-internals --no-warnings --experimental-abortcontroller
 'use strict';
 
 const common = require('../common');
@@ -248,6 +248,117 @@ async function nodeEventTarget() {
   clearInterval(interval);
 }
 
+async function abortableOnBefore() {
+  const ee = new EventEmitter();
+  const ac = new AbortController();
+  ac.abort();
+  [1, {}, null, false, 'hi'].forEach((signal) => {
+    assert.throws(() => on(ee, 'foo', { signal }), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+  });
+  assert.throws(() => on(ee, 'foo', { signal: ac.signal }), {
+    name: 'AbortError'
+  });
+}
+
+async function eventTargetAbortableOnBefore() {
+  const et = new EventTarget();
+  const ac = new AbortController();
+  ac.abort();
+  [1, {}, null, false, 'hi'].forEach((signal) => {
+    assert.throws(() => on(et, 'foo', { signal }), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+  });
+  assert.throws(() => on(et, 'foo', { signal: ac.signal }), {
+    name: 'AbortError'
+  });
+}
+
+async function abortableOnAfter() {
+  const ee = new EventEmitter();
+  const ac = new AbortController();
+
+  const i = setInterval(() => ee.emit('foo', 'foo'), 10);
+
+  async function foo() {
+    for await (const f of on(ee, 'foo', { signal: ac.signal })) {
+      assert.strictEqual(f, 'foo');
+    }
+  }
+
+  foo().catch(common.mustCall((error) => {
+    assert.strictEqual(error.name, 'AbortError');
+  })).finally(() => {
+    clearInterval(i);
+  });
+
+  process.nextTick(() => ac.abort());
+}
+
+async function eventTargetAbortableOnAfter() {
+  const et = new EventTarget();
+  const ac = new AbortController();
+
+  const i = setInterval(() => et.dispatchEvent(new Event('foo')), 10);
+
+  async function foo() {
+    for await (const f of on(et, 'foo', { signal: ac.signal })) {
+      assert(f);
+    }
+  }
+
+  foo().catch(common.mustCall((error) => {
+    assert.strictEqual(error.name, 'AbortError');
+  })).finally(() => {
+    clearInterval(i);
+  });
+
+  process.nextTick(() => ac.abort());
+}
+
+async function eventTargetAbortableOnAfter2() {
+  const et = new EventTarget();
+  const ac = new AbortController();
+
+  const i = setInterval(() => et.dispatchEvent(new Event('foo')), 10);
+
+  async function foo() {
+    for await (const f of on(et, 'foo', { signal: ac.signal })) {
+      assert(f);
+      // Cancel after a single event has been triggered.
+      ac.abort();
+    }
+  }
+
+  foo().catch(common.mustCall((error) => {
+    assert.strictEqual(error.name, 'AbortError');
+  })).finally(() => {
+    clearInterval(i);
+  });
+}
+
+async function abortableOnAfterDone() {
+  const ee = new EventEmitter();
+  const ac = new AbortController();
+
+  const i = setInterval(() => ee.emit('foo', 'foo'), 1);
+  let count = 0;
+
+  async function foo() {
+    for await (const f of on(ee, 'foo', { signal: ac.signal })) {
+      assert.strictEqual(f[0], 'foo');
+      if (++count === 5)
+        break;
+    }
+    ac.abort();  // No error will occur
+  }
+
+  foo().finally(() => {
+    clearInterval(i);
+  });
+}
 
 async function run() {
   const funcs = [
@@ -260,7 +371,13 @@ async function run() {
     iterableThrow,
     eventTarget,
     errorListenerCount,
-    nodeEventTarget
+    nodeEventTarget,
+    abortableOnBefore,
+    abortableOnAfter,
+    eventTargetAbortableOnBefore,
+    eventTargetAbortableOnAfter,
+    eventTargetAbortableOnAfter2,
+    abortableOnAfterDone
   ];
 
   for (const fn of funcs) {

From affb52d76fc3db69079d96225d7e72d0f475aa67 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Mon, 31 Aug 2020 19:36:20 -0700
Subject: [PATCH 08/40] doc: revise AbortSignal text and example using
 events.once()
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add a line to the example code to clarify what happens if an event is
emitted after listening is canceled. Make minor revisions to surrounding
text.

PR-URL: https://github.com/nodejs/node/pull/35005
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 doc/api/events.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/doc/api/events.md b/doc/api/events.md
index e33413873c7126..6acef2f9653418 100644
--- a/doc/api/events.md
+++ b/doc/api/events.md
@@ -839,8 +839,7 @@ added:
 * `emitter` {EventEmitter}
 * `name` {string}
 * `options` {Object}
-  * `signal` {AbortSignal} An {AbortSignal} that may be used to cancel waiting
-    for the event.
+  * `signal` {AbortSignal} Can be used to cancel waiting for the event.
 * Returns: {Promise}
 
 Creates a `Promise` that is fulfilled when the `EventEmitter` emits the given
@@ -899,7 +898,7 @@ ee.emit('error', new Error('boom'));
 // Prints: ok boom
 ```
 
-An {AbortSignal} may be used to cancel waiting for the event early:
+An {AbortSignal} can be used to cancel waiting for the event:
 
 ```js
 const { EventEmitter, once } = require('events');
@@ -922,6 +921,7 @@ async function foo(emitter, event, signal) {
 
 foo(ee, 'foo', ac.signal);
 ac.abort(); // Abort waiting for the event
+ee.emit('foo'); // Prints: Waiting for the event was canceled!
 ```
 
 ### Awaiting multiple events emitted on `process.nextTick()`

From 561d832638eb673e0120b4c5e3e2826477311e7f Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Wed, 2 Sep 2020 20:55:43 -0700
Subject: [PATCH 09/40] doc: make AbortSignal text consistent in events.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Further minor modifications to AbortSignal text in events.md for
consistency.

PR-URL: https://github.com/nodejs/node/pull/35005
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 doc/api/events.md | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/doc/api/events.md b/doc/api/events.md
index 6acef2f9653418..73007f3f7ab8d1 100644
--- a/doc/api/events.md
+++ b/doc/api/events.md
@@ -1014,8 +1014,7 @@ added:
 * `emitter` {EventEmitter}
 * `eventName` {string|symbol} The name of the event being listened for
 * `options` {Object}
-  * `signal` {AbortSignal} An {AbortSignal} that can be used to cancel awaiting
-    events.
+  * `signal` {AbortSignal} Can be used to cancel awaiting events.
 * Returns: {AsyncIterator} that iterates `eventName` events emitted by the `emitter`
 
 ```js
@@ -1045,7 +1044,7 @@ if the `EventEmitter` emits `'error'`. It removes all listeners when
 exiting the loop. The `value` returned by each iteration is an array
 composed of the emitted event arguments.
 
-An {AbortSignal} may be used to cancel waiting on events:
+An {AbortSignal} can be used to cancel waiting on events:
 
 ```js
 const { on, EventEmitter } = require('events');

From b38918291faacfb285e7d27a6661064d17f0698f Mon Sep 17 00:00:00 2001
From: Benjamin Gruenbaum <benjamingr@gmail.com>
Date: Mon, 26 Oct 2020 13:56:48 +0200
Subject: [PATCH 10/40] events: make abort_controller event trusted

The AbortController abort event is trusted, currently we fire all
events with isTrusted: false. Allow dispatching events
internally with `isTrusted: true` and add a test for it.

Co-Authored-By: ExE Boss <3889017+ExE-Boss@users.noreply.github.com>
Fixes: https://github.com/nodejs/node/issues/35748

PR-URL: https://github.com/nodejs/node/pull/35811
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 doc/api/events.md                       |  5 ++--
 lib/internal/abort_controller.js        |  7 +++--
 lib/internal/event_target.js            | 15 ++++++++++-
 lib/internal/per_context/primordials.js |  4 +++
 test/parallel/test-abortcontroller.js   | 34 ++++++++++++++++++++++++-
 5 files changed, 59 insertions(+), 6 deletions(-)

diff --git a/doc/api/events.md b/doc/api/events.md
index 73007f3f7ab8d1..8a2fc8dbaab50e 100644
--- a/doc/api/events.md
+++ b/doc/api/events.md
@@ -1272,9 +1272,10 @@ This is not used in Node.js and is provided purely for completeness.
 added: v14.5.0
 -->
 
-* Type: {boolean} Always returns `false`.
+* Type: {boolean} True for Node.js internal events, false otherwise.
 
-This is not used in Node.js and is provided purely for completeness.
+Currently only `AbortSignal`s' `"abort"` event is fired with `isTrusted`
+set to `true`.
 
 #### `event.preventDefault()`
 <!-- YAML
diff --git a/lib/internal/abort_controller.js b/lib/internal/abort_controller.js
index b4ba6dd4f87603..63fc31dac4dbd3 100644
--- a/lib/internal/abort_controller.js
+++ b/lib/internal/abort_controller.js
@@ -10,7 +10,8 @@ const {
 
 const {
   EventTarget,
-  Event
+  Event,
+  kTrustEvent
 } = require('internal/event_target');
 const {
   customInspectSymbol,
@@ -48,7 +49,9 @@ Object.defineProperties(AbortSignal.prototype, {
 function abortSignal(signal) {
   if (signal[kAborted]) return;
   signal[kAborted] = true;
-  const event = new Event('abort');
+  const event = new Event('abort', {
+    [kTrustEvent]: true
+  });
   if (typeof signal.onabort === 'function') {
     signal.onabort(event);
   }
diff --git a/lib/internal/event_target.js b/lib/internal/event_target.js
index 58ae809302461e..7345219e5a845a 100644
--- a/lib/internal/event_target.js
+++ b/lib/internal/event_target.js
@@ -8,10 +8,12 @@ const {
   NumberIsInteger,
   Object,
   ObjectDefineProperty,
+  ObjectGetOwnPropertyDescriptor,
   String,
   Symbol,
   SymbolFor,
   SymbolToStringTag,
+  SafeWeakSet,
 } = primordials;
 
 const {
@@ -40,6 +42,7 @@ const kRemoveListener = Symbol('kRemoveListener');
 const kIsNodeStyleListener = Symbol('kIsNodeStyleListener');
 const kMaxListeners = Symbol('kMaxListeners');
 const kMaxListenersWarned = Symbol('kMaxListenersWarned');
+const kTrustEvent = Symbol('kTrustEvent');
 
 // Lazy load perf_hooks to avoid the additional overhead on startup
 let perf_hooks;
@@ -60,7 +63,12 @@ const kBubbles = Symbol('bubbles');
 const kComposed = Symbol('composed');
 const kPropagationStopped = Symbol('propagationStopped');
 
-const isTrusted = () => false;
+const isTrustedSet = new SafeWeakSet();
+const isTrusted = ObjectGetOwnPropertyDescriptor({
+  get isTrusted() {
+    return isTrustedSet.has(this);
+  }
+}, 'isTrusted').get;
 
 class Event {
   constructor(type, options) {
@@ -76,6 +84,10 @@ class Event {
     this[kDefaultPrevented] = false;
     this[kTimestamp] = lazyNow();
     this[kPropagationStopped] = false;
+    if (options != null && options[kTrustEvent]) {
+      isTrustedSet.add(this);
+    }
+
     // isTrusted is special (LegacyUnforgeable)
     ObjectDefineProperty(this, 'isTrusted', {
       get: isTrusted,
@@ -572,5 +584,6 @@ module.exports = {
   initNodeEventTarget,
   kCreateEvent,
   kNewListener,
+  kTrustEvent,
   kRemoveListener,
 };
diff --git a/lib/internal/per_context/primordials.js b/lib/internal/per_context/primordials.js
index 8b1b8841c25379..75dfd8fdcba4dc 100644
--- a/lib/internal/per_context/primordials.js
+++ b/lib/internal/per_context/primordials.js
@@ -101,6 +101,10 @@ primordials.SafeSet = makeSafe(
   Set,
   class SafeSet extends Set {}
 );
+primordials.SafeWeakSet = makeSafe(
+  WeakSet,
+  class SafeWeakSet extends WeakSet {}
+);
 primordials.SafePromise = makeSafe(
   Promise,
   class SafePromise extends Promise {}
diff --git a/test/parallel/test-abortcontroller.js b/test/parallel/test-abortcontroller.js
index c1e28e16146785..aba647a1eccc02 100644
--- a/test/parallel/test-abortcontroller.js
+++ b/test/parallel/test-abortcontroller.js
@@ -1,11 +1,13 @@
-// Flags: --no-warnings --experimental-abortcontroller
+// Flags: --no-warnings --expose-internals --experimental-abortcontroller
 'use strict';
 
 const common = require('../common');
 
 const { ok, strictEqual } = require('assert');
+const { Event } = require('internal/event_target');
 
 {
+  // Tests that abort is fired with the correct event type on AbortControllers
   const ac = new AbortController();
   ok(ac.signal);
   ac.signal.onabort = common.mustCall((event) => {
@@ -20,3 +22,33 @@ const { ok, strictEqual } = require('assert');
   ac.abort();
   ok(ac.signal.aborted);
 }
+
+{
+  // Tests that abort events are trusted
+  const ac = new AbortController();
+  ac.signal.addEventListener('abort', common.mustCall((event) => {
+    ok(event.isTrusted);
+  }));
+  ac.abort();
+}
+
+{
+  // Tests that abort events have the same `isTrusted` reference
+  const first = new AbortController();
+  const second = new AbortController();
+  let ev1, ev2;
+  const ev3 = new Event('abort');
+  first.signal.addEventListener('abort', common.mustCall((event) => {
+    ev1 = event;
+  }));
+  second.signal.addEventListener('abort', common.mustCall((event) => {
+    ev2 = event;
+  }));
+  first.abort();
+  second.abort();
+  const firstTrusted = Reflect.getOwnPropertyDescriptor(ev1, 'isTrusted').get;
+  const secondTrusted = Reflect.getOwnPropertyDescriptor(ev2, 'isTrusted').get;
+  const untrusted = Reflect.getOwnPropertyDescriptor(ev3, 'isTrusted').get;
+  strictEqual(firstTrusted, secondTrusted);
+  strictEqual(untrusted, firstTrusted);
+}

From f76ab5a8ea56a6ba5cd973e9f07dac7ed7df9e6c Mon Sep 17 00:00:00 2001
From: Daijiro Wachi <daijiro.wachi@gmail.com>
Date: Sat, 31 Oct 2020 07:38:26 +0900
Subject: [PATCH 11/40] lib: let abort_controller target be EventTarget
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The AbortController abort event should have EventTarget as a target
property of the argument event.

PR-URL: https://github.com/nodejs/node/pull/35869
Refs: https://github.com/web-platform-tests/wpt/blob/master/dom/abort/event.any.js
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
---
 lib/internal/abort_controller.js | 16 +++++++++-------
 lib/internal/event_target.js     |  5 ++---
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/lib/internal/abort_controller.js b/lib/internal/abort_controller.js
index 63fc31dac4dbd3..8507935d198bc7 100644
--- a/lib/internal/abort_controller.js
+++ b/lib/internal/abort_controller.js
@@ -9,6 +9,7 @@ const {
 } = primordials;
 
 const {
+  defineEventHandler,
   EventTarget,
   Event,
   kTrustEvent
@@ -52,21 +53,22 @@ function abortSignal(signal) {
   const event = new Event('abort', {
     [kTrustEvent]: true
   });
-  if (typeof signal.onabort === 'function') {
-    signal.onabort(event);
-  }
   signal.dispatchEvent(event);
 }
 
+// TODO(joyeecheung): V8 snapshot does not support instance member
+// initializers for now:
+// https://bugs.chromium.org/p/v8/issues/detail?id=10704
+const kSignal = Symbol('signal');
 class AbortController {
-  #signal = new AbortSignal();
-
   constructor() {
+    this[kSignal] = new AbortSignal();
     emitExperimentalWarning('AbortController');
+    defineEventHandler(this[kSignal], 'abort');
   }
 
-  get signal() { return this.#signal; }
-  abort() { abortSignal(this.#signal); }
+  get signal() { return this[kSignal]; }
+  abort() { abortSignal(this[kSignal]); }
 
   [customInspectSymbol](depth, options) {
     return customInspect(this, {
diff --git a/lib/internal/event_target.js b/lib/internal/event_target.js
index 7345219e5a845a..a684c270ceba11 100644
--- a/lib/internal/event_target.js
+++ b/lib/internal/event_target.js
@@ -333,14 +333,13 @@ class EventTarget {
       }
       return event;
     };
+    if (event !== undefined)
+      event[kTarget] = this;
 
     const root = this[kEvents].get(type);
     if (root === undefined || root.next === undefined)
       return true;
 
-    if (event !== undefined)
-      event[kTarget] = this;
-
     let handler = root.next;
     let next;
 

From 76cdf87f8008593b20fa2473040f27f004f29183 Mon Sep 17 00:00:00 2001
From: Daijiro Wachi <daijiro.wachi@gmail.com>
Date: Sat, 31 Oct 2020 07:38:52 +0900
Subject: [PATCH 12/40] test: integrate abort_controller tests from wpt
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Refs: https://github.com/web-platform-tests/wpt/pull/9361

PR-URL: https://github.com/nodejs/node/pull/35869
Refs: https://github.com/web-platform-tests/wpt/blob/master/dom/abort/event.any.js
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
---
 test/fixtures/wpt/README.md              |  1 +
 test/fixtures/wpt/dom/abort/event.any.js | 67 ++++++++++++++++++++++++
 test/fixtures/wpt/versions.json          |  6 ++-
 test/parallel/test-eventtarget.js        |  6 +++
 test/wpt/status/dom/abort.json           |  1 +
 test/wpt/test-abort.js                   |  9 ++++
 6 files changed, 89 insertions(+), 1 deletion(-)
 create mode 100644 test/fixtures/wpt/dom/abort/event.any.js
 create mode 100644 test/wpt/status/dom/abort.json
 create mode 100644 test/wpt/test-abort.js

diff --git a/test/fixtures/wpt/README.md b/test/fixtures/wpt/README.md
index a728d94361ca9c..6d2fc11710d3b6 100644
--- a/test/fixtures/wpt/README.md
+++ b/test/fixtures/wpt/README.md
@@ -18,6 +18,7 @@ Last update:
 - html/webappapis/microtask-queuing: https://github.com/web-platform-tests/wpt/tree/0c3bed38df/html/webappapis/microtask-queuing
 - html/webappapis/timers: https://github.com/web-platform-tests/wpt/tree/ddfe9c089b/html/webappapis/timers
 - hr-time: https://github.com/web-platform-tests/wpt/tree/a5d1774ecf/hr-time
+- dom/abort: https://github.com/web-platform-tests/wpt/tree/7caa3de747/dom/abort
 
 [Web Platform Tests]: https://github.com/web-platform-tests/wpt
 [`git node wpt`]: https://github.com/nodejs/node-core-utils/blob/master/docs/git-node.md#git-node-wpt
diff --git a/test/fixtures/wpt/dom/abort/event.any.js b/test/fixtures/wpt/dom/abort/event.any.js
new file mode 100644
index 00000000000000..a67e6f400fcf1d
--- /dev/null
+++ b/test/fixtures/wpt/dom/abort/event.any.js
@@ -0,0 +1,67 @@
+test(t => {
+  const c = new AbortController(),
+        s = c.signal;
+  let state = "begin";
+
+  assert_false(s.aborted);
+
+  s.addEventListener("abort",
+    t.step_func(e => {
+      assert_equals(state, "begin");
+      state = "aborted";
+    })
+  );
+  c.abort();
+
+  assert_equals(state, "aborted");
+  assert_true(s.aborted);
+
+  c.abort();
+}, "AbortController abort() should fire event synchronously");
+
+test(t => {
+  const controller = new AbortController();
+  const signal = controller.signal;
+  assert_equals(controller.signal, signal,
+                "value of controller.signal should not have changed");
+  controller.abort();
+  assert_equals(controller.signal, signal,
+                "value of controller.signal should still not have changed");
+}, "controller.signal should always return the same object");
+
+test(t => {
+  const controller = new AbortController();
+  const signal = controller.signal;
+  let eventCount = 0;
+  signal.onabort = () => {
+    ++eventCount;
+  };
+  controller.abort();
+  assert_true(signal.aborted);
+  assert_equals(eventCount, 1, "event handler should have been called once");
+  controller.abort();
+  assert_true(signal.aborted);
+  assert_equals(eventCount, 1,
+                "event handler should not have been called again");
+}, "controller.abort() should do nothing the second time it is called");
+
+test(t => {
+  const controller = new AbortController();
+  controller.abort();
+  controller.signal.onabort =
+      t.unreached_func("event handler should not be called");
+}, "event handler should not be called if added after controller.abort()");
+
+test(t => {
+  const controller = new AbortController();
+  const signal = controller.signal;
+  signal.onabort = t.step_func(e => {
+    assert_equals(e.type, "abort", "event type should be abort");
+    assert_equals(e.target, signal, "event target should be signal");
+    assert_false(e.bubbles, "event should not bubble");
+    assert_true(e.isTrusted, "event should be trusted");
+  });
+  controller.abort();
+}, "the abort event should have the right properties");
+
+done();
diff --git a/test/fixtures/wpt/versions.json b/test/fixtures/wpt/versions.json
index b6c9a36fa641c9..0bbc27a9ff1d1f 100644
--- a/test/fixtures/wpt/versions.json
+++ b/test/fixtures/wpt/versions.json
@@ -30,5 +30,9 @@
   "hr-time": {
     "commit": "a5d1774ecf41751d1c9357c27c709ee33bf3e279",
     "path": "hr-time"
+  },
+  "dom/abort": {
+    "commit": "7caa3de7471cf19b78ee9efa313c7341a462b5e3",
+    "path": "dom/abort"
   }
-}
\ No newline at end of file
+}
diff --git a/test/parallel/test-eventtarget.js b/test/parallel/test-eventtarget.js
index 9487c22e26d1af..786cbc65f3371b 100644
--- a/test/parallel/test-eventtarget.js
+++ b/test/parallel/test-eventtarget.js
@@ -479,3 +479,9 @@ let asyncTest = Promise.resolve();
     throws(() => eventTarget.addEventListener('foo', Symbol()), TypeError);
   });
 }
+{
+  const eventTarget = new EventTarget();
+  const event = new Event('foo');
+  eventTarget.dispatchEvent(event);
+  strictEqual(event.target, eventTarget);
+}
diff --git a/test/wpt/status/dom/abort.json b/test/wpt/status/dom/abort.json
new file mode 100644
index 00000000000000..0967ef424bce67
--- /dev/null
+++ b/test/wpt/status/dom/abort.json
@@ -0,0 +1 @@
+{}
diff --git a/test/wpt/test-abort.js b/test/wpt/test-abort.js
new file mode 100644
index 00000000000000..36946d721e9dc9
--- /dev/null
+++ b/test/wpt/test-abort.js
@@ -0,0 +1,9 @@
+'use strict';
+require('../common');
+const { WPTRunner } = require('../common/wpt');
+
+const runner = new WPTRunner('dom/abort');
+
+runner.setFlags(['--experimental-abortcontroller']);
+
+runner.runJsTests();

From dc3d8527feb030a3e5adac3cde8b6e31c5d506cb Mon Sep 17 00:00:00 2001
From: Benjamin Gruenbaum <benjamingr@gmail.com>
Date: Sun, 1 Nov 2020 18:22:20 +0200
Subject: [PATCH 13/40] fs: add support for AbortSignal in readFile
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/35911
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
---
 doc/api/fs.md                              | 42 ++++++++++++++++++
 lib/fs.js                                  |  3 ++
 lib/internal/fs/promises.js                | 25 ++++++++++-
 lib/internal/fs/read_file_context.js       | 16 +++++++
 lib/internal/fs/utils.js                   |  5 +++
 test/parallel/test-fs-promises-readfile.js | 50 ++++++++++++++++------
 test/parallel/test-fs-readfile.js          | 19 ++++++++
 7 files changed, 146 insertions(+), 14 deletions(-)

diff --git a/doc/api/fs.md b/doc/api/fs.md
index e9cba0cceedbf5..d6d95dd149f9f8 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -3026,6 +3026,10 @@ If `options.withFileTypes` is set to `true`, the result will contain
 <!-- YAML
 added: v0.1.29
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/35911
+    description: The options argument may include an AbortSignal to abort an
+                 ongoing readFile request.
   - version: v10.0.0
     pr-url: https://github.com/nodejs/node/pull/12562
     description: The `callback` parameter is no longer optional. Not passing
@@ -3051,6 +3055,7 @@ changes:
 * `options` {Object|string}
   * `encoding` {string|null} **Default:** `null`
   * `flag` {string} See [support of file system `flags`][]. **Default:** `'r'`.
+  * `signal` {AbortSignal} allows aborting an in-progress readFile
 * `callback` {Function}
   * `err` {Error}
   * `data` {string|Buffer}
@@ -3092,9 +3097,25 @@ fs.readFile('<directory>', (err, data) => {
 });
 ```
 
+It is possible to abort an ongoing request using an `AbortSignal`. If a
+request is aborted the callback is called with an `AbortError`:
+
+```js
+const controller = new AbortController();
+const signal = controller.signal;
+fs.readFile(fileInfo[0].name, { signal }, (err, buf) => {
+  // ...
+});
+// When you want to abort the request
+controller.abort();
+```
+
 The `fs.readFile()` function buffers the entire file. To minimize memory costs,
 when possible prefer streaming via `fs.createReadStream()`.
 
+Aborting an ongoing request does not abort individual operating
+system requests but rather the internal buffering `fs.readFile` performs.
+
 ### File descriptors
 
 1. Any specified file descriptor has to support reading.
@@ -4748,6 +4769,7 @@ added: v10.0.0
 
 * `options` {Object|string}
   * `encoding` {string|null} **Default:** `null`
+  * `signal` {AbortSignal} allows aborting an in-progress readFile
 * Returns: {Promise}
 
 Asynchronously reads the entire contents of a file.
@@ -5411,12 +5433,18 @@ print('./').catch(console.error);
 ### `fsPromises.readFile(path[, options])`
 <!-- YAML
 added: v10.0.0
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/35911
+    description: The options argument may include an AbortSignal to abort an
+                 ongoing readFile request.
 -->
 
 * `path` {string|Buffer|URL|FileHandle} filename or `FileHandle`
 * `options` {Object|string}
   * `encoding` {string|null} **Default:** `null`
   * `flag` {string} See [support of file system `flags`][]. **Default:** `'r'`.
+  * `signal` {AbortSignal} allows aborting an in-progress readFile
 * Returns: {Promise}
 
 Asynchronously reads the entire contents of a file.
@@ -5432,6 +5460,20 @@ platform-specific. On macOS, Linux, and Windows, the promise will be rejected
 with an error. On FreeBSD, a representation of the directory's contents will be
 returned.
 
+It is possible to abort an ongoing `readFile` using an `AbortSignal`. If a
+request is aborted the promise returned is rejected with an `AbortError`:
+
+```js
+const controller = new AbortController();
+const signal = controller.signal;
+readFile(fileName, { signal }).then((file) => { /* ... */ });
+// Abort the request
+controller.abort();
+```
+
+Aborting an ongoing request does not abort individual operating
+system requests but rather the internal buffering `fs.readFile` performs.
+
 Any specified `FileHandle` has to support reading.
 
 ### `fsPromises.readlink(path[, options])`
diff --git a/lib/fs.js b/lib/fs.js
index 5746fbe1349c74..3aa7a901a562a2 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -316,6 +316,9 @@ function readFile(path, options, callback) {
   const context = new ReadFileContext(callback, options.encoding);
   context.isUserFd = isFd(path); // File descriptor ownership
 
+  if (options.signal) {
+    context.signal = options.signal;
+  }
   if (context.isUserFd) {
     process.nextTick(function tick(context) {
       readFileAfterOpen.call({ context }, null, path);
diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js
index 1f81a6f47b1d59..d4e83947feb193 100644
--- a/lib/internal/fs/promises.js
+++ b/lib/internal/fs/promises.js
@@ -30,12 +30,14 @@ const {
 } = internalBinding('constants').fs;
 const binding = internalBinding('fs');
 const { Buffer } = require('buffer');
+
+const { codes, hideStackFrames } = require('internal/errors');
 const {
   ERR_FS_FILE_TOO_LARGE,
   ERR_INVALID_ARG_TYPE,
   ERR_INVALID_ARG_VALUE,
-  ERR_METHOD_NOT_IMPLEMENTED
-} = require('internal/errors').codes;
+  ERR_METHOD_NOT_IMPLEMENTED,
+} = codes;
 const { isArrayBufferView } = require('internal/util/types');
 const { rimrafPromises } = require('internal/fs/rimraf');
 const {
@@ -83,6 +85,13 @@ const {
 const getDirectoryEntriesPromise = promisify(getDirents);
 const validateRmOptionsPromise = promisify(validateRmOptions);
 
+let DOMException;
+const lazyDOMException = hideStackFrames((message, name) => {
+  if (DOMException === undefined)
+    DOMException = internalBinding('messaging').DOMException;
+  return new DOMException(message, name);
+});
+
 class FileHandle extends JSTransferable {
   constructor(filehandle) {
     super();
@@ -260,8 +269,17 @@ async function writeFileHandle(filehandle, data) {
 }
 
 async function readFileHandle(filehandle, options) {
+  const signal = options && options.signal;
+
+  if (signal && signal.aborted) {
+    throw lazyDOMException('The operation was aborted', 'AbortError');
+  }
   const statFields = await binding.fstat(filehandle.fd, false, kUsePromises);
 
+  if (signal && signal.aborted) {
+    throw lazyDOMException('The operation was aborted', 'AbortError');
+  }
+
   let size;
   if ((statFields[1/* mode */] & S_IFMT) === S_IFREG) {
     size = statFields[8/* size */];
@@ -278,6 +296,9 @@ async function readFileHandle(filehandle, options) {
     MathMin(size, kReadFileMaxChunkSize);
   let endOfFile = false;
   do {
+    if (signal && signal.aborted) {
+      throw lazyDOMException('The operation was aborted', 'AbortError');
+    }
     const buf = Buffer.alloc(chunkSize);
     const { bytesRead, buffer } =
       await read(filehandle, buf, 0, chunkSize, -1);
diff --git a/lib/internal/fs/read_file_context.js b/lib/internal/fs/read_file_context.js
index 5091a34231665b..faca0e0c331e39 100644
--- a/lib/internal/fs/read_file_context.js
+++ b/lib/internal/fs/read_file_context.js
@@ -8,6 +8,16 @@ const { Buffer } = require('buffer');
 
 const { FSReqCallback, close, read } = internalBinding('fs');
 
+const { hideStackFrames } = require('internal/errors');
+
+
+let DOMException;
+const lazyDOMException = hideStackFrames((message, name) => {
+  if (DOMException === undefined)
+    DOMException = internalBinding('messaging').DOMException;
+  return new DOMException(message, name);
+});
+
 // Use 64kb in case the file type is not a regular file and thus do not know the
 // actual file size. Increasing the value further results in more frequent over
 // allocation for small files and consumes CPU time and memory that should be
@@ -74,6 +84,7 @@ class ReadFileContext {
     this.pos = 0;
     this.encoding = encoding;
     this.err = null;
+    this.signal = undefined;
   }
 
   read() {
@@ -81,6 +92,11 @@ class ReadFileContext {
     let offset;
     let length;
 
+    if (this.signal && this.signal.aborted) {
+      return this.close(
+        lazyDOMException('The operation was aborted', 'AbortError')
+      );
+    }
     if (this.size === 0) {
       buffer = Buffer.allocUnsafeSlow(kReadFileUnknownBufferLength);
       offset = 0;
diff --git a/lib/internal/fs/utils.js b/lib/internal/fs/utils.js
index e3255cdb2f2562..3ff3d9c561675c 100644
--- a/lib/internal/fs/utils.js
+++ b/lib/internal/fs/utils.js
@@ -37,6 +37,7 @@ const {
 const { once } = require('internal/util');
 const { toPathIfFileURL } = require('internal/url');
 const {
+  validateAbortSignal,
   validateBoolean,
   validateInt32,
   validateUint32
@@ -297,6 +298,10 @@ function getOptions(options, defaultOptions) {
 
   if (options.encoding !== 'buffer')
     assertEncoding(options.encoding);
+
+  if (options.signal !== undefined) {
+    validateAbortSignal(options.signal, 'options.signal');
+  }
   return options;
 }
 
diff --git a/test/parallel/test-fs-promises-readfile.js b/test/parallel/test-fs-promises-readfile.js
index ff25be75b84ff0..10632ba62e770b 100644
--- a/test/parallel/test-fs-promises-readfile.js
+++ b/test/parallel/test-fs-promises-readfile.js
@@ -1,3 +1,4 @@
+// Flags: --experimental-abortcontroller
 'use strict';
 
 const common = require('../common');
@@ -10,18 +11,21 @@ tmpdir.refresh();
 
 const fn = path.join(tmpdir.path, 'large-file');
 
-async function validateReadFile() {
-  // Creating large buffer with random content
-  const buffer = Buffer.from(
-    Array.apply(null, { length: 16834 * 2 })
-      .map(Math.random)
-      .map((number) => (number * (1 << 8)))
-  );
+// Creating large buffer with random content
+const largeBuffer = Buffer.from(
+  Array.apply(null, { length: 16834 * 2 })
+    .map(Math.random)
+    .map((number) => (number * (1 << 8)))
+);
 
+async function createLargeFile() {
   // Writing buffer to a file then try to read it
-  await writeFile(fn, buffer);
+  await writeFile(fn, largeBuffer);
+}
+
+async function validateReadFile() {
   const readBuffer = await readFile(fn);
-  assert.strictEqual(readBuffer.equals(buffer), true);
+  assert.strictEqual(readBuffer.equals(largeBuffer), true);
 }
 
 async function validateReadFileProc() {
@@ -39,6 +43,28 @@ async function validateReadFileProc() {
   assert.ok(hostname.length > 0);
 }
 
-validateReadFile()
-  .then(() => validateReadFileProc())
-  .then(common.mustCall());
+function validateReadFileAbortLogicBefore() {
+  const controller = new AbortController();
+  const signal = controller.signal;
+  controller.abort();
+  assert.rejects(readFile(fn, { signal }), {
+    name: 'AbortError'
+  });
+}
+
+function validateReadFileAbortLogicDuring() {
+  const controller = new AbortController();
+  const signal = controller.signal;
+  process.nextTick(() => controller.abort());
+  assert.rejects(readFile(fn, { signal }), {
+    name: 'AbortError'
+  });
+}
+
+(async () => {
+  await createLargeFile();
+  await validateReadFile();
+  await validateReadFileProc();
+  await validateReadFileAbortLogicBefore();
+  await validateReadFileAbortLogicDuring();
+})().then(common.mustCall());
diff --git a/test/parallel/test-fs-readfile.js b/test/parallel/test-fs-readfile.js
index 648bf692d1dcc8..b5cfabc547ad82 100644
--- a/test/parallel/test-fs-readfile.js
+++ b/test/parallel/test-fs-readfile.js
@@ -1,3 +1,4 @@
+// Flags: --experimental-abortcontroller
 'use strict';
 const common = require('../common');
 
@@ -57,3 +58,21 @@ for (const e of fileInfo) {
     assert.deepStrictEqual(buf, e.contents);
   }));
 }
+{
+  // Test cancellation, before
+  const controller = new AbortController();
+  const signal = controller.signal;
+  controller.abort();
+  fs.readFile(fileInfo[0].name, { signal }, common.mustCall((err, buf) => {
+    assert.strictEqual(err.name, 'AbortError');
+  }));
+}
+{
+  // Test cancellation, during read
+  const controller = new AbortController();
+  const signal = controller.signal;
+  fs.readFile(fileInfo[0].name, { signal }, common.mustCall((err, buf) => {
+    assert.strictEqual(err.name, 'AbortError');
+  }));
+  process.nextTick(() => controller.abort());
+}

From ceef7e3d5173c24d22d4d3a5d61741f91f84faa3 Mon Sep 17 00:00:00 2001
From: Benjamin Gruenbaum <benjamingr@gmail.com>
Date: Fri, 6 Nov 2020 13:44:40 +0200
Subject: [PATCH 14/40] fs: support abortsignal in writeFile

PR-URL: https://github.com/nodejs/node/pull/35993
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 doc/api/fs.md                               | 61 ++++++++++++++++++++-
 lib/fs.js                                   | 26 +++++++--
 lib/internal/fs/promises.js                 | 10 +++-
 test/parallel/test-fs-promises-writefile.js | 12 ++++
 test/parallel/test-fs-write-file.js         | 30 ++++++++++
 5 files changed, 132 insertions(+), 7 deletions(-)

diff --git a/doc/api/fs.md b/doc/api/fs.md
index d6d95dd149f9f8..35a0fd462bc652 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -4375,6 +4375,10 @@ details.
 <!-- YAML
 added: v0.1.29
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/35993
+    description: The options argument may include an AbortSignal to abort an
+                 ongoing writeFile request.
   - version: v14.12.0
     pr-url: https://github.com/nodejs/node/pull/34993
     description: The `data` parameter will stringify an object with an
@@ -4409,6 +4413,7 @@ changes:
   * `encoding` {string|null} **Default:** `'utf8'`
   * `mode` {integer} **Default:** `0o666`
   * `flag` {string} See [support of file system `flags`][]. **Default:** `'w'`.
+  * `signal` {AbortSignal} allows aborting an in-progress writeFile
 * `callback` {Function}
   * `err` {Error}
 
@@ -4440,6 +4445,28 @@ It is unsafe to use `fs.writeFile()` multiple times on the same file without
 waiting for the callback. For this scenario, [`fs.createWriteStream()`][] is
 recommended.
 
+Similarly to `fs.readFile` - `fs.writeFile` is a convenience method that
+performs multiple `write` calls internally to write the buffer passed to it.
+For performance sensitive code consider using [`fs.createWriteStream()`][].
+
+It is possible to use an {AbortSignal} to cancel an `fs.writeFile()`.
+Cancelation is "best effort", and some amount of data is likely still
+to be written.
+
+```js
+const controller = new AbortController();
+const { signal } = controller;
+const data = new Uint8Array(Buffer.from('Hello Node.js'));
+fs.writeFile('message.txt', data, { signal }, (err) => {
+  // When a request is aborted - the callback is called with an AbortError
+});
+// When the request should be aborted
+controller.abort();
+```
+
+Aborting an ongoing request does not abort individual operating
+system requests but rather the internal buffering `fs.writeFile` performs.
+
 ### Using `fs.writeFile()` with file descriptors
 
 When `file` is a file descriptor, the behavior is almost identical to directly
@@ -5684,6 +5711,10 @@ The `atime` and `mtime` arguments follow these rules:
 <!-- YAML
 added: v10.0.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/35993
+    description: The options argument may include an AbortSignal to abort an
+                 ongoing writeFile request.
   - version: v14.12.0
     pr-url: https://github.com/nodejs/node/pull/34993
     description: The `data` parameter will stringify an object with an
@@ -5700,6 +5731,7 @@ changes:
   * `encoding` {string|null} **Default:** `'utf8'`
   * `mode` {integer} **Default:** `0o666`
   * `flag` {string} See [support of file system `flags`][]. **Default:** `'w'`.
+  * `signal` {AbortSignal} allows aborting an in-progress writeFile
 * Returns: {Promise}
 
 Asynchronously writes data to a file, replacing the file if it already exists.
@@ -5713,7 +5745,34 @@ If `options` is a string, then it specifies the encoding.
 Any specified `FileHandle` has to support writing.
 
 It is unsafe to use `fsPromises.writeFile()` multiple times on the same file
-without waiting for the `Promise` to be resolved (or rejected).
+without waiting for the `Promise` to be fulfilled (or rejected).
+
+Similarly to `fsPromises.readFile` - `fsPromises.writeFile` is a convenience
+method that performs multiple `write` calls internally to write the buffer
+passed to it. For performance sensitive code consider using
+[`fs.createWriteStream()`][].
+
+It is possible to use an {AbortSignal} to cancel an `fsPromises.writeFile()`.
+Cancelation is "best effort", and some amount of data is likely still
+to be written.
+
+```js
+const controller = new AbortController();
+const { signal } = controller;
+const data = new Uint8Array(Buffer.from('Hello Node.js'));
+(async () => {
+  try {
+    await fs.writeFile('message.txt', data, { signal });
+  } catch (err) {
+  // When a request is aborted - err is an AbortError
+  }
+})();
+// When the request should be aborted
+controller.abort();
+```
+
+Aborting an ongoing request does not abort individual operating
+system requests but rather the internal buffering `fs.writeFile` performs.
 
 ## FS constants
 
diff --git a/lib/fs.js b/lib/fs.js
index 3aa7a901a562a2..49dbe2cb621e71 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -71,6 +71,7 @@ const {
     ERR_INVALID_CALLBACK,
     ERR_FEATURE_UNAVAILABLE_ON_PLATFORM
   },
+  hideStackFrames,
   uvErrmapGet,
   uvException
 } = require('internal/errors');
@@ -134,6 +135,13 @@ let ReadStream;
 let WriteStream;
 let rimraf;
 let rimrafSync;
+let DOMException;
+
+const lazyDOMException = hideStackFrames((message, name) => {
+  if (DOMException === undefined)
+    DOMException = internalBinding('messaging').DOMException;
+  return new DOMException(message, name);
+});
 
 // These have to be separate because of how graceful-fs happens to do it's
 // monkeypatching.
@@ -1425,7 +1433,11 @@ function lutimesSync(path, atime, mtime) {
   handleErrorFromBinding(ctx);
 }
 
-function writeAll(fd, isUserFd, buffer, offset, length, callback) {
+function writeAll(fd, isUserFd, buffer, offset, length, signal, callback) {
+  if (signal?.aborted) {
+    callback(lazyDOMException('The operation was aborted', 'AbortError'));
+    return;
+  }
   // write(fd, buffer, offset, length, position, callback)
   fs.write(fd, buffer, offset, length, null, (writeErr, written) => {
     if (writeErr) {
@@ -1445,7 +1457,7 @@ function writeAll(fd, isUserFd, buffer, offset, length, callback) {
     } else {
       offset += written;
       length -= written;
-      writeAll(fd, isUserFd, buffer, offset, length, callback);
+      writeAll(fd, isUserFd, buffer, offset, length, signal, callback);
     }
   });
 }
@@ -1462,16 +1474,22 @@ function writeFile(path, data, options, callback) {
 
   if (isFd(path)) {
     const isUserFd = true;
-    writeAll(path, isUserFd, data, 0, data.byteLength, callback);
+    const signal = options.signal;
+    writeAll(path, isUserFd, data, 0, data.byteLength, signal, callback);
     return;
   }
 
+  if (options.signal?.aborted) {
+    callback(lazyDOMException('The operation was aborted', 'AbortError'));
+    return;
+  }
   fs.open(path, flag, options.mode, (openErr, fd) => {
     if (openErr) {
       callback(openErr);
     } else {
       const isUserFd = false;
-      writeAll(fd, isUserFd, data, 0, data.byteLength, callback);
+      const signal = options.signal;
+      writeAll(fd, isUserFd, data, 0, data.byteLength, signal, callback);
     }
   });
 }
diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js
index d4e83947feb193..a6b50054774f4e 100644
--- a/lib/internal/fs/promises.js
+++ b/lib/internal/fs/promises.js
@@ -250,12 +250,15 @@ async function fsCall(fn, handle, ...args) {
   }
 }
 
-async function writeFileHandle(filehandle, data) {
+async function writeFileHandle(filehandle, data, signal) {
   // `data` could be any kind of typed array.
   data = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
   let remaining = data.length;
   if (remaining === 0) return;
   do {
+    if (signal?.aborted) {
+      throw new lazyDOMException('The operation was aborted', 'AbortError');
+    }
     const { bytesWritten } =
       await write(filehandle, data, 0,
                   MathMin(kWriteFileMaxChunkSize, data.length));
@@ -644,9 +647,12 @@ async function writeFile(path, data, options) {
   }
 
   if (path instanceof FileHandle)
-    return writeFileHandle(path, data);
+    return writeFileHandle(path, data, options.signal);
 
   const fd = await open(path, flag, options.mode);
+  if (options.signal?.aborted) {
+    throw new lazyDOMException('The operation was aborted', 'AbortError');
+  }
   return PromisePrototypeFinally(writeFileHandle(fd, data), fd.close);
 }
 
diff --git a/test/parallel/test-fs-promises-writefile.js b/test/parallel/test-fs-promises-writefile.js
index 858e90bc6291de..de58395774ba0d 100644
--- a/test/parallel/test-fs-promises-writefile.js
+++ b/test/parallel/test-fs-promises-writefile.js
@@ -1,3 +1,4 @@
+// Flags: --experimental-abortcontroller
 'use strict';
 
 const common = require('../common');
@@ -11,6 +12,7 @@ const tmpDir = tmpdir.path;
 tmpdir.refresh();
 
 const dest = path.resolve(tmpDir, 'tmp.txt');
+const otherDest = path.resolve(tmpDir, 'tmp-2.txt');
 const buffer = Buffer.from('abc'.repeat(1000));
 const buffer2 = Buffer.from('xyz'.repeat(1000));
 
@@ -20,6 +22,15 @@ async function doWrite() {
   assert.deepStrictEqual(data, buffer);
 }
 
+async function doWriteWithCancel() {
+  const controller = new AbortController();
+  const { signal } = controller;
+  process.nextTick(() => controller.abort());
+  assert.rejects(fsPromises.writeFile(otherDest, buffer, { signal }), {
+    name: 'AbortError'
+  });
+}
+
 async function doAppend() {
   await fsPromises.appendFile(dest, buffer2);
   const data = fs.readFileSync(dest);
@@ -41,6 +52,7 @@ async function doReadWithEncoding() {
 }
 
 doWrite()
+  .then(doWriteWithCancel)
   .then(doAppend)
   .then(doRead)
   .then(doReadWithEncoding)
diff --git a/test/parallel/test-fs-write-file.js b/test/parallel/test-fs-write-file.js
index e80861756ab2d8..3484782a8d4071 100644
--- a/test/parallel/test-fs-write-file.js
+++ b/test/parallel/test-fs-write-file.js
@@ -19,6 +19,7 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+// Flags: --experimental-abortcontroller
 'use strict';
 const common = require('../common');
 const assert = require('assert');
@@ -66,3 +67,32 @@ fs.open(filename4, 'w+', common.mustSucceed((fd) => {
     }));
   }));
 }));
+
+
+{
+  // Test that writeFile is cancellable with an AbortSignal.
+  // Before the operation has started
+  const controller = new AbortController();
+  const signal = controller.signal;
+  const filename3 = join(tmpdir.path, 'test3.txt');
+
+  fs.writeFile(filename3, s, { signal }, common.mustCall((err) => {
+    assert.strictEqual(err.name, 'AbortError');
+  }));
+
+  controller.abort();
+}
+
+{
+  // Test that writeFile is cancellable with an AbortSignal.
+  // After the operation has started
+  const controller = new AbortController();
+  const signal = controller.signal;
+  const filename4 = join(tmpdir.path, 'test4.txt');
+
+  fs.writeFile(filename4, s, { signal }, common.mustCall((err) => {
+    assert.strictEqual(err.name, 'AbortError');
+  }));
+
+  process.nextTick(() => controller.abort());
+}

From 01d2b67ccfdadf9b1f6abdae56e99eb8cd8838a6 Mon Sep 17 00:00:00 2001
From: Benjamin Gruenbaum <benjamingr@gmail.com>
Date: Mon, 26 Oct 2020 11:11:13 +0200
Subject: [PATCH 15/40] events: add a few tests

PR-URL: https://github.com/nodejs/node/pull/35806
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
---
 lib/internal/event_target.js      |  4 ++--
 test/parallel/test-eventtarget.js | 32 +++++++++++++++++++++++++++++++
 2 files changed, 34 insertions(+), 2 deletions(-)

diff --git a/lib/internal/event_target.js b/lib/internal/event_target.js
index a684c270ceba11..99988a3dcd6fc5 100644
--- a/lib/internal/event_target.js
+++ b/lib/internal/event_target.js
@@ -71,10 +71,10 @@ const isTrusted = ObjectGetOwnPropertyDescriptor({
 }, 'isTrusted').get;
 
 class Event {
-  constructor(type, options) {
+  constructor(type, options = null) {
     if (arguments.length === 0)
       throw new ERR_MISSING_ARGS('type');
-    if (options != null)
+    if (options !== null)
       validateObject(options, 'options');
     const { cancelable, bubbles, composed } = { ...options };
     this[kCancelable] = !!cancelable;
diff --git a/test/parallel/test-eventtarget.js b/test/parallel/test-eventtarget.js
index 786cbc65f3371b..accacb8a328c03 100644
--- a/test/parallel/test-eventtarget.js
+++ b/test/parallel/test-eventtarget.js
@@ -414,6 +414,7 @@ let asyncTest = Promise.resolve();
 }
 
 {
+  // Event Statics
   strictEqual(Event.NONE, 0);
   strictEqual(Event.CAPTURING_PHASE, 1);
   strictEqual(Event.AT_TARGET, 2);
@@ -424,6 +425,8 @@ let asyncTest = Promise.resolve();
     strictEqual(e.eventPhase, Event.AT_TARGET);
   }), { once: true });
   target.dispatchEvent(new Event('foo'));
+  // Event is a function
+  strictEqual(Event.length, 1);
 }
 
 {
@@ -485,3 +488,32 @@ let asyncTest = Promise.resolve();
   eventTarget.dispatchEvent(event);
   strictEqual(event.target, eventTarget);
 }
+{
+  // Event target exported keys
+  const eventTarget = new EventTarget();
+  deepStrictEqual(Object.keys(eventTarget), []);
+  deepStrictEqual(Object.getOwnPropertyNames(eventTarget), []);
+  const parentKeys = Object.keys(Object.getPrototypeOf(eventTarget)).sort();
+  const keys = ['addEventListener', 'dispatchEvent', 'removeEventListener'];
+  deepStrictEqual(parentKeys, keys);
+}
+{
+  // Subclassing
+  class SubTarget extends EventTarget {}
+  const target = new SubTarget();
+  target.addEventListener('foo', common.mustCall());
+  target.dispatchEvent(new Event('foo'));
+}
+{
+  // Test event order
+  const target = new EventTarget();
+  let state = 0;
+  target.addEventListener('foo', common.mustCall(() => {
+    strictEqual(state, 0);
+    state++;
+  }));
+  target.addEventListener('foo', common.mustCall(() => {
+    strictEqual(state, 1);
+  }));
+  target.dispatchEvent(new Event('foo'));
+}

From 1ca549d99443bc7f353a02704398fcdd4fb7be0a Mon Sep 17 00:00:00 2001
From: Benjamin Gruenbaum <benjamingr@gmail.com>
Date: Wed, 28 Oct 2020 16:23:44 +0200
Subject: [PATCH 16/40] events: support emit on nodeeventtarget

PR-URL: https://github.com/nodejs/node/pull/35851
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Yongsheng Zhang <zyszys98@gmail.com>
Reviewed-By: Ricky Zhou <0x19951125@gmail.com>
---
 lib/internal/event_target.js              | 20 ++++++++++++++++++++
 lib/internal/worker/io.js                 |  5 +++++
 test/parallel/test-nodeeventtarget.js     | 22 ++++++++++++++++++++++
 test/parallel/test-worker-message-port.js | 13 ++++++++++++-
 4 files changed, 59 insertions(+), 1 deletion(-)

diff --git a/lib/internal/event_target.js b/lib/internal/event_target.js
index 99988a3dcd6fc5..a82d9e7a4e6cf9 100644
--- a/lib/internal/event_target.js
+++ b/lib/internal/event_target.js
@@ -171,6 +171,14 @@ Object.defineProperty(Event.prototype, SymbolToStringTag, {
   value: 'Event',
 });
 
+class NodeCustomEvent extends Event {
+  constructor(type, options) {
+    super(type, options);
+    if (options && options.detail) {
+      this.detail = options.detail;
+    }
+  }
+}
 // The listeners for an EventTarget are maintained as a linked list.
 // Unfortunately, the way EventTarget is defined, listeners are accounted
 // using the tuple [handler,capture], and even if we don't actually make
@@ -376,6 +384,9 @@ class EventTarget {
       event[kTarget] = undefined;
   }
 
+  [kCreateEvent](nodeValue, type) {
+    return new NodeCustomEvent(type, { detail: nodeValue });
+  }
   [customInspectSymbol](depth, options) {
     const name = this.constructor.name;
     if (depth < 0)
@@ -473,6 +484,14 @@ class NodeEventTarget extends EventTarget {
     this.addEventListener(type, listener, { [kIsNodeStyleListener]: true });
     return this;
   }
+  emit(type, arg) {
+    if (typeof type !== 'string') {
+      throw new ERR_INVALID_ARG_TYPE('type', 'string', type);
+    }
+    const hadListeners = this.listenerCount(type) > 0;
+    this[kHybridDispatch](arg, type);
+    return hadListeners;
+  }
 
   once(type, listener) {
     this.addEventListener(type, listener,
@@ -501,6 +520,7 @@ Object.defineProperties(NodeEventTarget.prototype, {
   on: { enumerable: true },
   addListener: { enumerable: true },
   once: { enumerable: true },
+  emit: { enumerable: true },
   removeAllListeners: { enumerable: true },
 });
 
diff --git a/lib/internal/worker/io.js b/lib/internal/worker/io.js
index 5b5118a1d70b21..319283852ce2ea 100644
--- a/lib/internal/worker/io.js
+++ b/lib/internal/worker/io.js
@@ -30,6 +30,7 @@ const {
 const { Readable, Writable } = require('stream');
 const {
   Event,
+  EventTarget,
   NodeEventTarget,
   defineEventHandler,
   initNodeEventTarget,
@@ -79,11 +80,15 @@ class MessageEvent extends Event {
   }
 }
 
+const originalCreateEvent = EventTarget.prototype[kCreateEvent];
 ObjectDefineProperty(
   MessagePort.prototype,
   kCreateEvent,
   {
     value: function(data, type) {
+      if (type !== 'message' && type !== 'messageerror') {
+        return originalCreateEvent.call(this, data, type);
+      }
       return new MessageEvent(data, this, type);
     },
     configurable: false,
diff --git a/test/parallel/test-nodeeventtarget.js b/test/parallel/test-nodeeventtarget.js
index 0f9218f540860d..276bd9feb4da7c 100644
--- a/test/parallel/test-nodeeventtarget.js
+++ b/test/parallel/test-nodeeventtarget.js
@@ -11,6 +11,7 @@ const {
   deepStrictEqual,
   ok,
   strictEqual,
+  throws,
 } = require('assert');
 
 const { on } = require('events');
@@ -145,6 +146,27 @@ const { on } = require('events');
   target.on('foo', () => {});
   target.on('foo', () => {});
 }
+{
+  // Test NodeEventTarget emit
+  const emitter = new NodeEventTarget();
+  emitter.addEventListener('foo', common.mustCall((e) => {
+    strictEqual(e.type, 'foo');
+    strictEqual(e.detail, 'bar');
+    ok(e instanceof Event);
+  }), { once: true });
+  emitter.once('foo', common.mustCall((e, droppedAdditionalArgument) => {
+    strictEqual(e, 'bar');
+    strictEqual(droppedAdditionalArgument, undefined);
+  }));
+  emitter.emit('foo', 'bar', 'baz');
+}
+{
+  // Test NodeEventTarget emit unsupported usage
+  const emitter = new NodeEventTarget();
+  throws(() => {
+    emitter.emit();
+  }, /ERR_INVALID_ARG_TYPE/);
+}
 
 (async () => {
   // test NodeEventTarget async-iterability
diff --git a/test/parallel/test-worker-message-port.js b/test/parallel/test-worker-message-port.js
index 4f4863c45ed516..6f4e09d029d168 100644
--- a/test/parallel/test-worker-message-port.js
+++ b/test/parallel/test-worker-message-port.js
@@ -16,7 +16,18 @@ const { MessageChannel, MessagePort } = require('worker_threads');
     port2.close(common.mustCall());
   }));
 }
-
+{
+  // Test emitting non-message events on a port
+  const { port2 } = new MessageChannel();
+  port2.addEventListener('foo', common.mustCall((received) => {
+    assert.strictEqual(received.type, 'foo');
+    assert.strictEqual(received.detail, 'bar');
+  }));
+  port2.on('foo', common.mustCall((received) => {
+    assert.strictEqual(received, 'bar');
+  }));
+  port2.emit('foo', 'bar');
+}
 {
   const { port1, port2 } = new MessageChannel();
 

From 307bebc75c3bcedbc86b5731162dbf4439d9f2c6 Mon Sep 17 00:00:00 2001
From: Benjamin Gruenbaum <benjamingr@gmail.com>
Date: Mon, 2 Nov 2020 22:40:00 +0200
Subject: [PATCH 17/40] events: define event handler as enumerable

PR-URL: https://github.com/nodejs/node/pull/35931
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Daijiro Wachi <daijiro.wachi@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 lib/internal/event_target.js      | 4 +++-
 test/parallel/test-eventtarget.js | 7 +++++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/lib/internal/event_target.js b/lib/internal/event_target.js
index a82d9e7a4e6cf9..5f84ffbccf449d 100644
--- a/lib/internal/event_target.js
+++ b/lib/internal/event_target.js
@@ -591,7 +591,9 @@ function defineEventHandler(emitter, name) {
         emitter.addEventListener(name, value);
       }
       eventHandlerValue = value;
-    }
+    },
+    configurable: true,
+    enumerable: true
   });
 }
 module.exports = {
diff --git a/test/parallel/test-eventtarget.js b/test/parallel/test-eventtarget.js
index accacb8a328c03..96d755a8f32fe2 100644
--- a/test/parallel/test-eventtarget.js
+++ b/test/parallel/test-eventtarget.js
@@ -517,3 +517,10 @@ let asyncTest = Promise.resolve();
   }));
   target.dispatchEvent(new Event('foo'));
 }
+{
+  const target = new EventTarget();
+  defineEventHandler(target, 'foo');
+  const descriptor = Object.getOwnPropertyDescriptor(target, 'onfoo');
+  strictEqual(descriptor.configurable, true);
+  strictEqual(descriptor.enumerable, true);
+}

From 902503c3e39d578ca6b891edd2a286c8fd821328 Mon Sep 17 00:00:00 2001
From: Benjamin Gruenbaum <benjamingr@gmail.com>
Date: Mon, 2 Nov 2020 22:53:59 +0200
Subject: [PATCH 18/40] events: support event handlers on prototypes

PR-URL: https://github.com/nodejs/node/pull/35931
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Daijiro Wachi <daijiro.wachi@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 lib/internal/event_target.js              | 21 ++++++++++++++-------
 lib/internal/worker/io.js                 |  5 +++--
 test/parallel/test-worker-message-port.js |  6 ++----
 3 files changed, 19 insertions(+), 13 deletions(-)

diff --git a/lib/internal/event_target.js b/lib/internal/event_target.js
index 5f84ffbccf449d..30ee46909e6274 100644
--- a/lib/internal/event_target.js
+++ b/lib/internal/event_target.js
@@ -13,6 +13,7 @@ const {
   Symbol,
   SymbolFor,
   SymbolToStringTag,
+  SafeWeakMap,
   SafeWeakSet,
 } = primordials;
 
@@ -576,21 +577,27 @@ function emitUnhandledRejectionOrErr(that, err, event) {
   process.emit('error', err, event);
 }
 
+// A map of emitter -> map of name -> handler
+const eventHandlerValueMap = new SafeWeakMap();
+
 function defineEventHandler(emitter, name) {
   // 8.1.5.1 Event handlers - basically `on[eventName]` attributes
-  let eventHandlerValue;
-  Object.defineProperty(emitter, `on${name}`, {
+  ObjectDefineProperty(emitter, `on${name}`, {
     get() {
-      return eventHandlerValue;
+      return eventHandlerValueMap.get(this)?.get(name);
     },
     set(value) {
-      if (eventHandlerValue) {
-        emitter.removeEventListener(name, eventHandlerValue);
+      const oldValue = eventHandlerValueMap.get(this)?.get(name);
+      if (oldValue) {
+        this.removeEventListener(name, oldValue);
       }
       if (typeof value === 'function') {
-        emitter.addEventListener(name, value);
+        this.addEventListener(name, value);
+      }
+      if (!eventHandlerValueMap.has(this)) {
+        eventHandlerValueMap.set(this, new Map());
       }
-      eventHandlerValue = value;
+      eventHandlerValueMap.get(this).set(name, value);
     },
     configurable: true,
     enumerable: true
diff --git a/lib/internal/worker/io.js b/lib/internal/worker/io.js
index 319283852ce2ea..b2fed9f06ff35c 100644
--- a/lib/internal/worker/io.js
+++ b/lib/internal/worker/io.js
@@ -99,13 +99,14 @@ ObjectDefineProperty(
 // This is called from inside the `MessagePort` constructor.
 function oninit() {
   initNodeEventTarget(this);
-  // TODO(addaleax): This should be on MessagePort.prototype, but
-  // defineEventHandler() does not support that.
   defineEventHandler(this, 'message');
   defineEventHandler(this, 'messageerror');
   setupPortReferencing(this, this, 'message');
 }
 
+defineEventHandler(MessagePort.prototype, 'message');
+defineEventHandler(MessagePort.prototype, 'messageerror');
+
 ObjectDefineProperty(MessagePort.prototype, onInitSymbol, {
   enumerable: true,
   writable: false,
diff --git a/test/parallel/test-worker-message-port.js b/test/parallel/test-worker-message-port.js
index 6f4e09d029d168..51618e4fab1850 100644
--- a/test/parallel/test-worker-message-port.js
+++ b/test/parallel/test-worker-message-port.js
@@ -165,9 +165,7 @@ const { MessageChannel, MessagePort } = require('worker_threads');
   assert.deepStrictEqual(
     Object.getOwnPropertyNames(MessagePort.prototype).sort(),
     [
-      // TODO(addaleax): This should include onmessage (and eventually
-      // onmessageerror).
-      'close', 'constructor', 'postMessage', 'ref', 'start',
-      'unref'
+      'close', 'constructor', 'onmessage', 'onmessageerror', 'postMessage',
+      'ref', 'start', 'unref'
     ]);
 }

From 6bbd82f9e897c5d5ee6b0d005cd1c7c56bc15ae1 Mon Sep 17 00:00:00 2001
From: Benjamin Gruenbaum <benjamingr@gmail.com>
Date: Mon, 2 Nov 2020 22:59:54 +0200
Subject: [PATCH 19/40] events: define abort on prototype

PR-URL: https://github.com/nodejs/node/pull/35931
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Daijiro Wachi <daijiro.wachi@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 lib/internal/abort_controller.js |  3 ++-
 lib/internal/event_target.js     | 19 ++++++++-----------
 lib/internal/worker/io.js        |  2 --
 3 files changed, 10 insertions(+), 14 deletions(-)

diff --git a/lib/internal/abort_controller.js b/lib/internal/abort_controller.js
index 8507935d198bc7..9762280426e544 100644
--- a/lib/internal/abort_controller.js
+++ b/lib/internal/abort_controller.js
@@ -47,6 +47,8 @@ Object.defineProperties(AbortSignal.prototype, {
   aborted: { enumerable: true }
 });
 
+defineEventHandler(AbortSignal.prototype, 'abort');
+
 function abortSignal(signal) {
   if (signal[kAborted]) return;
   signal[kAborted] = true;
@@ -64,7 +66,6 @@ class AbortController {
   constructor() {
     this[kSignal] = new AbortSignal();
     emitExperimentalWarning('AbortController');
-    defineEventHandler(this[kSignal], 'abort');
   }
 
   get signal() { return this[kSignal]; }
diff --git a/lib/internal/event_target.js b/lib/internal/event_target.js
index 30ee46909e6274..fef80c65d97ba3 100644
--- a/lib/internal/event_target.js
+++ b/lib/internal/event_target.js
@@ -4,16 +4,15 @@ const {
   ArrayFrom,
   Boolean,
   Error,
-  Map,
   NumberIsInteger,
   Object,
   ObjectDefineProperty,
   ObjectGetOwnPropertyDescriptor,
+  SafeMap,
   String,
   Symbol,
   SymbolFor,
   SymbolToStringTag,
-  SafeWeakMap,
   SafeWeakSet,
 } = primordials;
 
@@ -35,6 +34,7 @@ const kIsEventTarget = SymbolFor('nodejs.event_target');
 const kEvents = Symbol('kEvents');
 const kStop = Symbol('kStop');
 const kTarget = Symbol('kTarget');
+const kHandlers = Symbol('khandlers');
 
 const kHybridDispatch = Symbol.for('nodejs.internal.kHybridDispatch');
 const kCreateEvent = Symbol('kCreateEvent');
@@ -218,7 +218,7 @@ class Listener {
 }
 
 function initEventTarget(self) {
-  self[kEvents] = new Map();
+  self[kEvents] = new SafeMap();
 }
 
 class EventTarget {
@@ -577,27 +577,24 @@ function emitUnhandledRejectionOrErr(that, err, event) {
   process.emit('error', err, event);
 }
 
-// A map of emitter -> map of name -> handler
-const eventHandlerValueMap = new SafeWeakMap();
-
 function defineEventHandler(emitter, name) {
   // 8.1.5.1 Event handlers - basically `on[eventName]` attributes
   ObjectDefineProperty(emitter, `on${name}`, {
     get() {
-      return eventHandlerValueMap.get(this)?.get(name);
+      return this[kHandlers]?.get(name);
     },
     set(value) {
-      const oldValue = eventHandlerValueMap.get(this)?.get(name);
+      const oldValue = this[kHandlers]?.get(name);
       if (oldValue) {
         this.removeEventListener(name, oldValue);
       }
       if (typeof value === 'function') {
         this.addEventListener(name, value);
       }
-      if (!eventHandlerValueMap.has(this)) {
-        eventHandlerValueMap.set(this, new Map());
+      if (!this[kHandlers]) {
+        this[kHandlers] = new SafeMap();
       }
-      eventHandlerValueMap.get(this).set(name, value);
+      this[kHandlers].set(name, value);
     },
     configurable: true,
     enumerable: true
diff --git a/lib/internal/worker/io.js b/lib/internal/worker/io.js
index b2fed9f06ff35c..406c8e77fd3375 100644
--- a/lib/internal/worker/io.js
+++ b/lib/internal/worker/io.js
@@ -99,8 +99,6 @@ ObjectDefineProperty(
 // This is called from inside the `MessagePort` constructor.
 function oninit() {
   initNodeEventTarget(this);
-  defineEventHandler(this, 'message');
-  defineEventHandler(this, 'messageerror');
   setupPortReferencing(this, this, 'message');
 }
 

From 7d255e60875ca5acca8295ee88d7b055a5dae526 Mon Sep 17 00:00:00 2001
From: Benjamin Gruenbaum <benjamingr@gmail.com>
Date: Fri, 6 Nov 2020 11:01:59 +0200
Subject: [PATCH 20/40] events: fire handlers in correct oder

PR-URL: https://github.com/nodejs/node/pull/35931
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Daijiro Wachi <daijiro.wachi@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 lib/internal/event_target.js      | 42 ++++++++++++++++++++++++-------
 test/parallel/test-eventtarget.js | 12 +++++++++
 2 files changed, 45 insertions(+), 9 deletions(-)

diff --git a/lib/internal/event_target.js b/lib/internal/event_target.js
index fef80c65d97ba3..3d28205737d601 100644
--- a/lib/internal/event_target.js
+++ b/lib/internal/event_target.js
@@ -8,6 +8,7 @@ const {
   Object,
   ObjectDefineProperty,
   ObjectGetOwnPropertyDescriptor,
+  ReflectApply,
   SafeMap,
   String,
   Symbol,
@@ -577,24 +578,47 @@ function emitUnhandledRejectionOrErr(that, err, event) {
   process.emit('error', err, event);
 }
 
+function makeEventHandler(handler) {
+  // Event handlers are dispatched in the order they were first set
+  // See https://github.com/nodejs/node/pull/35949#issuecomment-722496598
+  function eventHandler(...args) {
+    if (typeof eventHandler.handler !== 'function') {
+      return;
+    }
+    return ReflectApply(eventHandler.handler, this, args);
+  }
+  eventHandler.handler = handler;
+  return eventHandler;
+}
+
 function defineEventHandler(emitter, name) {
   // 8.1.5.1 Event handlers - basically `on[eventName]` attributes
   ObjectDefineProperty(emitter, `on${name}`, {
     get() {
-      return this[kHandlers]?.get(name);
+      return this[kHandlers]?.get(name)?.handler;
     },
     set(value) {
-      const oldValue = this[kHandlers]?.get(name);
-      if (oldValue) {
-        this.removeEventListener(name, oldValue);
-      }
-      if (typeof value === 'function') {
-        this.addEventListener(name, value);
-      }
       if (!this[kHandlers]) {
         this[kHandlers] = new SafeMap();
       }
-      this[kHandlers].set(name, value);
+      let wrappedHandler = this[kHandlers]?.get(name);
+      if (wrappedHandler) {
+        if (typeof wrappedHandler.handler === 'function') {
+          this[kEvents].get(name).size--;
+          const size = this[kEvents].get(name).size;
+          this[kRemoveListener](size, name, wrappedHandler.handler, false);
+        }
+        wrappedHandler.handler = value;
+        if (typeof wrappedHandler.handler === 'function') {
+          this[kEvents].get(name).size++;
+          const size = this[kEvents].get(name).size;
+          this[kNewListener](size, name, value, false, false, false);
+        }
+      } else {
+        wrappedHandler = makeEventHandler(value);
+        this.addEventListener(name, wrappedHandler);
+      }
+      this[kHandlers].set(name, wrappedHandler);
     },
     configurable: true,
     enumerable: true
diff --git a/test/parallel/test-eventtarget.js b/test/parallel/test-eventtarget.js
index 96d755a8f32fe2..fa280027c61f29 100644
--- a/test/parallel/test-eventtarget.js
+++ b/test/parallel/test-eventtarget.js
@@ -524,3 +524,15 @@ let asyncTest = Promise.resolve();
   strictEqual(descriptor.configurable, true);
   strictEqual(descriptor.enumerable, true);
 }
+{
+  const target = new EventTarget();
+  defineEventHandler(target, 'foo');
+  const output = [];
+  target.addEventListener('foo', () => output.push(1));
+  target.onfoo = common.mustNotCall();
+  target.addEventListener('foo', () => output.push(3));
+  target.onfoo = () => output.push(2);
+  target.addEventListener('foo', () => output.push(4));
+  target.dispatchEvent(new Event('foo'));
+  deepStrictEqual(output, [1, 2, 3, 4]);
+}

From 01315864f10ad6b2faa85bfd07b15a70acf7be94 Mon Sep 17 00:00:00 2001
From: raisinten <raisinten@gmail.com>
Date: Thu, 12 Nov 2020 19:56:06 +0530
Subject: [PATCH 21/40] events: disabled manual construction AbortSignal

Fixes: https://github.com/nodejs/node/issues/36064

PR-URL: https://github.com/nodejs/node/pull/36094
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Zeyu Yang <himself65@outlook.com>
Reviewed-By: Andrey Pechkurov <apechkurov@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 lib/internal/abort_controller.js      | 16 +++++++++++++++-
 test/parallel/test-abortcontroller.js | 11 ++++++++++-
 2 files changed, 25 insertions(+), 2 deletions(-)

diff --git a/lib/internal/abort_controller.js b/lib/internal/abort_controller.js
index 9762280426e544..f047a878ffedd0 100644
--- a/lib/internal/abort_controller.js
+++ b/lib/internal/abort_controller.js
@@ -5,7 +5,9 @@
 
 const {
   Object,
+  ObjectSetPrototypeOf,
   Symbol,
+  TypeError,
 } = primordials;
 
 const {
@@ -34,6 +36,11 @@ function customInspect(self, obj, depth, options) {
 }
 
 class AbortSignal extends EventTarget {
+  constructor() {
+    // eslint-disable-next-line no-restricted-syntax
+    throw new TypeError('Illegal constructor');
+  }
+
   get aborted() { return !!this[kAborted]; }
 
   [customInspectSymbol](depth, options) {
@@ -49,6 +56,13 @@ Object.defineProperties(AbortSignal.prototype, {
 
 defineEventHandler(AbortSignal.prototype, 'abort');
 
+function createAbortSignal() {
+  const signal = new EventTarget();
+  ObjectSetPrototypeOf(signal, AbortSignal.prototype);
+  signal[kAborted] = false;
+  return signal;
+}
+
 function abortSignal(signal) {
   if (signal[kAborted]) return;
   signal[kAborted] = true;
@@ -64,7 +78,7 @@ function abortSignal(signal) {
 const kSignal = Symbol('signal');
 class AbortController {
   constructor() {
-    this[kSignal] = new AbortSignal();
+    this[kSignal] = createAbortSignal();
     emitExperimentalWarning('AbortController');
   }
 
diff --git a/test/parallel/test-abortcontroller.js b/test/parallel/test-abortcontroller.js
index aba647a1eccc02..3eba5fff051512 100644
--- a/test/parallel/test-abortcontroller.js
+++ b/test/parallel/test-abortcontroller.js
@@ -3,7 +3,7 @@
 
 const common = require('../common');
 
-const { ok, strictEqual } = require('assert');
+const { ok, strictEqual, throws } = require('assert');
 const { Event } = require('internal/event_target');
 
 {
@@ -52,3 +52,12 @@ const { Event } = require('internal/event_target');
   strictEqual(firstTrusted, secondTrusted);
   strictEqual(untrusted, firstTrusted);
 }
+
+{
+  // Tests that AbortSignal is impossible to construct manually
+  const ac = new AbortController();
+  throws(
+    () => new ac.signal.constructor(),
+    /^TypeError: Illegal constructor$/
+  );
+}

From 555a5a25b2bb9aa49e07ef42b5dc99142aaacd27 Mon Sep 17 00:00:00 2001
From: Benjamin Gruenbaum <benjamingr@gmail.com>
Date: Fri, 6 Nov 2020 12:05:08 +0200
Subject: [PATCH 22/40] events: getEventListeners static

PR-URL: https://github.com/nodejs/node/pull/35991
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 doc/api/events.md                             | 34 +++++++++++++++++
 lib/events.js                                 | 26 ++++++++++++-
 lib/internal/event_target.js                  |  2 +
 .../test-events-static-geteventlisteners.js   | 38 +++++++++++++++++++
 4 files changed, 99 insertions(+), 1 deletion(-)
 create mode 100644 test/parallel/test-events-static-geteventlisteners.js

diff --git a/doc/api/events.md b/doc/api/events.md
index 8a2fc8dbaab50e..014451f2179ed7 100644
--- a/doc/api/events.md
+++ b/doc/api/events.md
@@ -829,6 +829,40 @@ class MyClass extends EventEmitter {
 }
 ```
 
+## `events.getEventListeners(emitterOrTarget, eventName)`
+<!-- YAML
+added:
+ - REPLACEME
+-->
+* `emitterOrTarget` {EventEmitter|EventTarget}
+* `eventName` {string|symbol}
+* Returns: {Function[]}
+
+Returns a copy of the array of listeners for the event named `eventName`.
+
+For `EventEmitter`s this behaves exactly the same as calling `.listeners` on
+the emitter.
+
+For `EventTarget`s this is the only way to get the event listeners for the
+event target. This is useful for debugging and diagnostic purposes.
+
+```js
+const { getEventListeners, EventEmitter } = require('events');
+
+{
+  const ee = new EventEmitter();
+  const listener = () => console.log('Events are fun');
+  ee.on('foo', listener);
+  getEventListeners(ee, 'foo'); // [listener]
+}
+{
+  const et = new EventTarget();
+  const listener = () => console.log('Events are fun');
+  ee.addEventListener('foo', listener);
+  getEventListeners(ee, 'foo'); // [listener]
+}
+```
+
 ## `events.once(emitter, name[, options])`
 <!-- YAML
 added:
diff --git a/lib/events.js b/lib/events.js
index f4c116b8baf3b7..c532d7024e9095 100644
--- a/lib/events.js
+++ b/lib/events.js
@@ -22,6 +22,7 @@
 'use strict';
 
 const {
+  ArrayPrototypePush,
   Boolean,
   Error,
   ErrorCaptureStackTrace,
@@ -74,13 +75,14 @@ const lazyDOMException = hideStackFrames((message, name) => {
   return new DOMException(message, name);
 });
 
+
 function EventEmitter(opts) {
   EventEmitter.init.call(this, opts);
 }
 module.exports = EventEmitter;
 module.exports.once = once;
 module.exports.on = on;
-
+module.exports.getEventListeners = getEventListeners;
 // Backwards-compat with node 0.10.x
 EventEmitter.EventEmitter = EventEmitter;
 
@@ -634,6 +636,28 @@ function unwrapListeners(arr) {
   return ret;
 }
 
+function getEventListeners(emitterOrTarget, type) {
+  // First check if EventEmitter
+  if (typeof emitterOrTarget.listeners === 'function') {
+    return emitterOrTarget.listeners(type);
+  }
+  // Require event target lazily to avoid always loading it
+  const { isEventTarget, kEvents } = require('internal/event_target');
+  if (isEventTarget(emitterOrTarget)) {
+    const root = emitterOrTarget[kEvents].get(type);
+    const listeners = [];
+    let handler = root?.next;
+    while (handler?.listener !== undefined) {
+      ArrayPrototypePush(listeners, handler.listener);
+      handler = handler.next;
+    }
+    return listeners;
+  }
+  throw new ERR_INVALID_ARG_TYPE('emitter',
+                                 ['EventEmitter', 'EventTarget'],
+                                 emitterOrTarget);
+}
+
 async function once(emitter, name, options = {}) {
   const signal = options ? options.signal : undefined;
   validateAbortSignal(signal, 'options.signal');
diff --git a/lib/internal/event_target.js b/lib/internal/event_target.js
index 3d28205737d601..716a157f464557 100644
--- a/lib/internal/event_target.js
+++ b/lib/internal/event_target.js
@@ -635,4 +635,6 @@ module.exports = {
   kNewListener,
   kTrustEvent,
   kRemoveListener,
+  kEvents,
+  isEventTarget,
 };
diff --git a/test/parallel/test-events-static-geteventlisteners.js b/test/parallel/test-events-static-geteventlisteners.js
new file mode 100644
index 00000000000000..d5e8c457f5d57f
--- /dev/null
+++ b/test/parallel/test-events-static-geteventlisteners.js
@@ -0,0 +1,38 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+
+const {
+  deepStrictEqual,
+} = require('assert');
+
+const { getEventListeners, EventEmitter } = require('events');
+const { EventTarget } = require('internal/event_target');
+
+// Test getEventListeners on EventEmitter
+{
+  const fn1 = common.mustNotCall();
+  const fn2 = common.mustNotCall();
+  const emitter = new EventEmitter();
+  emitter.on('foo', fn1);
+  emitter.on('foo', fn2);
+  emitter.on('baz', fn1);
+  emitter.on('baz', fn1);
+  deepStrictEqual(getEventListeners(emitter, 'foo'), [fn1, fn2]);
+  deepStrictEqual(getEventListeners(emitter, 'bar'), []);
+  deepStrictEqual(getEventListeners(emitter, 'baz'), [fn1, fn1]);
+}
+// Test getEventListeners on EventTarget
+{
+  const fn1 = common.mustNotCall();
+  const fn2 = common.mustNotCall();
+  const target = new EventTarget();
+  target.addEventListener('foo', fn1);
+  target.addEventListener('foo', fn2);
+  target.addEventListener('baz', fn1);
+  target.addEventListener('baz', fn1);
+  deepStrictEqual(getEventListeners(target, 'foo'), [fn1, fn2]);
+  deepStrictEqual(getEventListeners(target, 'bar'), []);
+  deepStrictEqual(getEventListeners(target, 'baz'), [fn1]);
+}

From e8bd59c617f78e822e0a4ae57f62d5a2e7bc42f2 Mon Sep 17 00:00:00 2001
From: Benjamin Gruenbaum <benjamingr@gmail.com>
Date: Mon, 9 Nov 2020 12:51:14 +0200
Subject: [PATCH 23/40] http: add support for abortsignal to http.request

PR-URL: https://github.com/nodejs/node/pull/36048
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Denys Otrishko <shishugi@gmail.com>
Reviewed-By: Ricky Zhou <0x19951125@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 doc/api/http.md                               |  9 +++++++
 lib/.eslintrc.yaml                            |  2 +-
 lib/_http_client.js                           | 16 +++++++++--
 lib/internal/errors.js                        | 11 ++++++++
 .../test-http-client-abort-destroy.js         | 27 +++++++++++++++++--
 5 files changed, 60 insertions(+), 5 deletions(-)

diff --git a/doc/api/http.md b/doc/api/http.md
index a48ec63381c0c3..a17c7246c52c3e 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -2326,6 +2326,9 @@ This can be overridden for servers and client requests by passing the
 <!-- YAML
 added: v0.3.6
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/36048
+    description: It is possible to abort a request with an AbortSignal.
   - version:
      - v13.8.0
      - v12.15.0
@@ -2393,6 +2396,8 @@ changes:
      or `port` is specified, those specify a TCP Socket).
   * `timeout` {number}: A number specifying the socket timeout in milliseconds.
     This will set the timeout before the socket is connected.
+  * `signal` {AbortSignal}: An AbortSignal that may be used to abort an ongoing
+    request.
 * `callback` {Function}
 * Returns: {http.ClientRequest}
 
@@ -2580,6 +2585,10 @@ events will be emitted in the following order:
 Setting the `timeout` option or using the `setTimeout()` function will
 not abort the request or do anything besides add a `'timeout'` event.
 
+Passing an `AbortSignal` and then calling `abort` on the corresponding
+`AbortController` will behave the same way as calling `.destroy()` on the
+request itself.
+
 ## `http.validateHeaderName(name)`
 <!-- YAML
 added: v14.3.0
diff --git a/lib/.eslintrc.yaml b/lib/.eslintrc.yaml
index 20e01898695507..6bbdafab632fdd 100644
--- a/lib/.eslintrc.yaml
+++ b/lib/.eslintrc.yaml
@@ -95,7 +95,7 @@ rules:
     - selector: "ThrowStatement > CallExpression[callee.name=/Error$/]"
       message: "Use new keyword when throwing an Error."
     # Config specific to lib
-    - selector: "NewExpression[callee.name=/Error$/]:not([callee.name=/^(AssertionError|NghttpError)$/])"
+    - selector: "NewExpression[callee.name=/Error$/]:not([callee.name=/^(AssertionError|NghttpError|AbortError)$/])"
       message: "Use an error exported by the internal/errors module."
     - selector: "CallExpression[callee.object.name='Error'][callee.property.name='captureStackTrace']"
       message: "Please use `require('internal/errors').hideStackFrames()` instead."
diff --git a/lib/_http_client.js b/lib/_http_client.js
index 7b1232f33f0a9b..0ff5ab23727959 100644
--- a/lib/_http_client.js
+++ b/lib/_http_client.js
@@ -51,7 +51,7 @@ const { Buffer } = require('buffer');
 const { defaultTriggerAsyncIdScope } = require('internal/async_hooks');
 const { URL, urlToOptions, searchParamsSymbol } = require('internal/url');
 const { kOutHeaders, kNeedDrain } = require('internal/http');
-const { connResetException, codes } = require('internal/errors');
+const { AbortError, connResetException, codes } = require('internal/errors');
 const {
   ERR_HTTP_HEADERS_SENT,
   ERR_INVALID_ARG_TYPE,
@@ -59,7 +59,10 @@ const {
   ERR_INVALID_PROTOCOL,
   ERR_UNESCAPED_CHARACTERS
 } = codes;
-const { validateInteger } = require('internal/validators');
+const {
+  validateInteger,
+  validateAbortSignal,
+} = require('internal/validators');
 const { getTimerDuration } = require('internal/timers');
 const {
   DTRACE_HTTP_CLIENT_REQUEST,
@@ -169,6 +172,15 @@ function ClientRequest(input, options, cb) {
   if (options.timeout !== undefined)
     this.timeout = getTimerDuration(options.timeout, 'timeout');
 
+  const signal = options.signal;
+  if (signal) {
+    validateAbortSignal(signal, 'options.signal');
+    const listener = (e) => this.destroy(new AbortError());
+    signal.addEventListener('abort', listener);
+    this.once('close', () => {
+      signal.removeEventListener('abort', listener);
+    });
+  }
   let method = options.method;
   const methodIsString = (typeof method === 'string');
   if (method !== null && method !== undefined && !methodIsString) {
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index b0c8c0a130259e..0ee39432e38ae1 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -704,6 +704,16 @@ const fatalExceptionStackEnhancers = {
   }
 };
 
+// Node uses an AbortError that isn't exactly the same as the DOMException
+// to make usage of the error in userland and readable-stream easier.
+// It is a regular error with `.code` and `.name`.
+class AbortError extends Error {
+  constructor() {
+    super('The operation was aborted');
+    this.code = 'ABORT_ERR';
+    this.name = 'AbortError';
+  }
+}
 module.exports = {
   addCodeToName, // Exported for NghttpError
   codes,
@@ -718,6 +728,7 @@ module.exports = {
   uvException,
   uvExceptionWithHostPort,
   SystemError,
+  AbortError,
   // This is exported only to facilitate testing.
   E,
   kNoOverride,
diff --git a/test/parallel/test-http-client-abort-destroy.js b/test/parallel/test-http-client-abort-destroy.js
index 6db2ea5682e922..f46d10d367106e 100644
--- a/test/parallel/test-http-client-abort-destroy.js
+++ b/test/parallel/test-http-client-abort-destroy.js
@@ -1,3 +1,4 @@
+// Flags: --experimental-abortcontroller
 'use strict';
 const common = require('../common');
 const http = require('http');
@@ -52,8 +53,7 @@ const assert = require('assert');
 {
   // destroy
 
-  const server = http.createServer(common.mustNotCall((req, res) => {
-  }));
+  const server = http.createServer(common.mustNotCall());
 
   server.listen(0, common.mustCall(() => {
     const options = { port: server.address().port };
@@ -69,3 +69,26 @@ const assert = require('assert');
     assert.strictEqual(req.destroyed, true);
   }));
 }
+
+
+{
+  // Destroy with AbortSignal
+
+  const server = http.createServer(common.mustNotCall());
+  const controller = new AbortController();
+
+  server.listen(0, common.mustCall(() => {
+    const options = { port: server.address().port, signal: controller.signal };
+    const req = http.get(options, common.mustNotCall());
+    req.on('error', common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ABORT_ERR');
+      assert.strictEqual(err.name, 'AbortError');
+      server.close();
+    }));
+    assert.strictEqual(req.aborted, false);
+    assert.strictEqual(req.destroyed, false);
+    controller.abort();
+    assert.strictEqual(req.aborted, false);
+    assert.strictEqual(req.destroyed, true);
+  }));
+}

From 5ce6f9115bffa25514b16525341853dfc941306f Mon Sep 17 00:00:00 2001
From: Madara Uchiha <me@madara.ninja>
Date: Tue, 10 Nov 2020 19:06:41 +0200
Subject: [PATCH 24/40] http2: add support for AbortSignal to
 http2Session.request

- Add support
- Add test
- Docs once PR is up

PR-URL: https://github.com/nodejs/node/pull/36070
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
---
 doc/api/http2.md                           |  9 +++
 lib/internal/http2/core.js                 | 27 ++++++--
 test/parallel/test-http2-client-destroy.js | 76 +++++++++++++++++++++-
 3 files changed, 106 insertions(+), 6 deletions(-)

diff --git a/doc/api/http2.md b/doc/api/http2.md
index 3e4f66f8cd4c06..f033b50548a1e7 100644
--- a/doc/api/http2.md
+++ b/doc/api/http2.md
@@ -2,6 +2,9 @@
 <!-- YAML
 added: v8.4.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/36070
+    description: It is possible to abort a request with an AbortSignal.
   - version: v10.10.0
     pr-url: https://github.com/nodejs/node/pull/22466
     description: HTTP/2 is now Stable. Previously, it had been Experimental.
@@ -819,6 +822,8 @@ added: v8.4.0
     and `256` (inclusive).
   * `waitForTrailers` {boolean} When `true`, the `Http2Stream` will emit the
     `'wantTrailers'` event after the final `DATA` frame has been sent.
+  * `signal` {AbortSignal} An AbortSignal that may be used to abort an ongoing
+    request.
 
 * Returns: {ClientHttp2Stream}
 
@@ -855,6 +860,10 @@ close when the final `DATA` frame is transmitted. User code must call either
 `http2stream.sendTrailers()` or `http2stream.close()` to close the
 `Http2Stream`.
 
+When `options.signal` is set with an `AbortSignal` and then `abort` on the
+corresponding `AbortController` is called, the request will emit an `'error'`
+event with an `AbortError` error.
+
 The `:method` and `:path` pseudo-headers are not specified within `headers`,
 they respectively default to:
 
diff --git a/lib/internal/http2/core.js b/lib/internal/http2/core.js
index f8f88957de36be..3c11cf1adad2ca 100644
--- a/lib/internal/http2/core.js
+++ b/lib/internal/http2/core.js
@@ -94,12 +94,15 @@ const {
     ERR_OUT_OF_RANGE,
     ERR_SOCKET_CLOSED
   },
-  hideStackFrames
+  hideStackFrames,
+  AbortError
 } = require('internal/errors');
-const { validateNumber,
-        validateString,
-        validateUint32,
-        isUint32,
+const {
+  isUint32,
+  validateNumber,
+  validateString,
+  validateUint32,
+  validateAbortSignal,
 } = require('internal/validators');
 const fsPromisesInternal = require('internal/fs/promises');
 const { utcDate } = require('internal/http');
@@ -1666,6 +1669,20 @@ class ClientHttp2Session extends Http2Session {
     if (options.waitForTrailers)
       stream[kState].flags |= STREAM_FLAGS_HAS_TRAILERS;
 
+    const { signal } = options;
+    if (signal) {
+      validateAbortSignal(signal, 'options.signal');
+      const aborter = () => stream.destroy(new AbortError());
+      if (signal.aborted) {
+        aborter();
+      } else {
+        signal.addEventListener('abort', aborter);
+        stream.once('close', () => {
+          signal.removeEventListener('abort', aborter);
+        });
+      }
+    }
+
     const onConnect = requestOnConnect.bind(stream, headersList, options);
     if (this.connecting) {
       if (this[kPendingRequestCalls] !== null) {
diff --git a/test/parallel/test-http2-client-destroy.js b/test/parallel/test-http2-client-destroy.js
index 12da903c6535a0..0336c7910fa6a6 100644
--- a/test/parallel/test-http2-client-destroy.js
+++ b/test/parallel/test-http2-client-destroy.js
@@ -1,4 +1,4 @@
-// Flags: --expose-internals
+// Flags: --expose-internals --experimental-abortcontroller
 
 'use strict';
 
@@ -8,6 +8,7 @@ if (!common.hasCrypto)
 const assert = require('assert');
 const h2 = require('http2');
 const { kSocket } = require('internal/http2/util');
+const { kEvents } = require('internal/event_target');
 const Countdown = require('../common/countdown');
 
 {
@@ -165,3 +166,76 @@ const Countdown = require('../common/countdown');
     req.on('close', common.mustCall(() => server.close()));
   }));
 }
+
+// Destroy with AbortSignal
+{
+  const server = h2.createServer();
+  const controller = new AbortController();
+
+  server.on('stream', common.mustNotCall());
+  server.listen(0, common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+    client.on('close', common.mustCall());
+
+    const { signal } = controller;
+    assert.strictEqual(signal[kEvents].get('abort'), undefined);
+
+    client.on('error', common.mustCall(() => {
+      // After underlying stream dies, signal listener detached
+      assert.strictEqual(signal[kEvents].get('abort'), undefined);
+    }));
+
+    const req = client.request({}, { signal });
+
+    req.on('error', common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ABORT_ERR');
+      assert.strictEqual(err.name, 'AbortError');
+    }));
+    req.on('close', common.mustCall(() => server.close()));
+
+    assert.strictEqual(req.aborted, false);
+    assert.strictEqual(req.destroyed, false);
+    // Signal listener attached
+    assert.strictEqual(signal[kEvents].get('abort').size, 1);
+
+    controller.abort();
+
+    assert.strictEqual(req.aborted, false);
+    assert.strictEqual(req.destroyed, true);
+  }));
+}
+// Pass an already destroyed signal to abort immediately.
+{
+  const server = h2.createServer();
+  const controller = new AbortController();
+
+  server.on('stream', common.mustNotCall());
+  server.listen(0, common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+    client.on('close', common.mustCall());
+
+    const { signal } = controller;
+    controller.abort();
+
+    assert.strictEqual(signal[kEvents].get('abort'), undefined);
+
+    client.on('error', common.mustCall(() => {
+      // After underlying stream dies, signal listener detached
+      assert.strictEqual(signal[kEvents].get('abort'), undefined);
+    }));
+
+    const req = client.request({}, { signal });
+    // Signal already aborted, so no event listener attached.
+    assert.strictEqual(signal[kEvents].get('abort'), undefined);
+
+    assert.strictEqual(req.aborted, false);
+    // Destroyed on same tick as request made
+    assert.strictEqual(req.destroyed, true);
+
+    req.on('error', common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ABORT_ERR');
+      assert.strictEqual(err.name, 'AbortError');
+    }));
+    req.on('close', common.mustCall(() => server.close()));
+  }));
+}

From 8277ec1a345a1dd92acdf6d17941dc8ddcab83af Mon Sep 17 00:00:00 2001
From: Benjamin Gruenbaum <benjamingr@gmail.com>
Date: Sat, 28 Nov 2020 21:42:34 +0200
Subject: [PATCH 25/40] child_process: add AbortSignal support

PR-URL: https://github.com/nodejs/node/pull/36308
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 doc/api/child_process.md                     | 17 +++++++++++
 lib/child_process.js                         | 32 ++++++++++++++++++--
 test/parallel/test-child-process-execfile.js | 15 +++++++++
 3 files changed, 61 insertions(+), 3 deletions(-)

diff --git a/doc/api/child_process.md b/doc/api/child_process.md
index 6f6c81e253ff06..1b9fc0229ab389 100644
--- a/doc/api/child_process.md
+++ b/doc/api/child_process.md
@@ -250,6 +250,9 @@ lsExample();
 <!-- YAML
 added: v0.1.91
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/36308
+    description: AbortSignal support was added.
   - version: v8.8.0
     pr-url: https://github.com/nodejs/node/pull/15380
     description: The `windowsHide` option is supported now.
@@ -277,6 +280,7 @@ changes:
     `'/bin/sh'` on Unix, and `process.env.ComSpec` on Windows. A different
     shell can be specified as a string. See [Shell requirements][] and
     [Default Windows shell][]. **Default:** `false` (no shell).
+  * `signal` {AbortSignal} allows aborting the execFile using an AbortSignal
 * `callback` {Function} Called with the output when process terminates.
   * `error` {Error}
   * `stdout` {string|Buffer}
@@ -330,6 +334,19 @@ getVersion();
 function. Any input containing shell metacharacters may be used to trigger
 arbitrary command execution.**
 
+If the `signal` option is enabled, calling `.abort()` on the corresponding
+`AbortController` is similar to calling `.kill()` on the child process except
+the error passed to the callback will be an `AbortError`:
+
+```js
+const controller = new AbortController();
+const { signal } = controller;
+const child = execFile('node', ['--version'], { signal }, (error) => {
+  console.log(error); // an AbortError
+});
+signal.abort();
+```
+
 ### `child_process.fork(modulePath[, args][, options])`
 <!-- YAML
 added: v0.5.0
diff --git a/lib/child_process.js b/lib/child_process.js
index 9e1c37af8f169f..1b645e43c8151b 100644
--- a/lib/child_process.js
+++ b/lib/child_process.js
@@ -45,15 +45,24 @@ let debug = require('internal/util/debuglog').debuglog(
 );
 const { Buffer } = require('buffer');
 const { Pipe, constants: PipeConstants } = internalBinding('pipe_wrap');
+
+const {
+  AbortError,
+  codes: errorCodes,
+} = require('internal/errors');
 const {
   ERR_INVALID_ARG_VALUE,
   ERR_CHILD_PROCESS_IPC_REQUIRED,
   ERR_CHILD_PROCESS_STDIO_MAXBUFFER,
   ERR_INVALID_ARG_TYPE,
-  ERR_OUT_OF_RANGE
-} = require('internal/errors').codes;
+  ERR_OUT_OF_RANGE,
+} = errorCodes;
 const { clearTimeout, setTimeout } = require('timers');
-const { validateString, isInt32 } = require('internal/validators');
+const {
+  validateString,
+  isInt32,
+  validateAbortSignal,
+} = require('internal/validators');
 const child_process = require('internal/child_process');
 const {
   getValidStdio,
@@ -232,6 +241,9 @@ function execFile(file /* , args, options, callback */) {
   // Validate maxBuffer, if present.
   validateMaxBuffer(options.maxBuffer);
 
+  // Validate signal, if present
+  validateAbortSignal(options.signal, 'options.signal');
+
   options.killSignal = sanitizeKillSignal(options.killSignal);
 
   const child = spawn(file, args, {
@@ -349,6 +361,20 @@ function execFile(file /* , args, options, callback */) {
       timeoutId = null;
     }, options.timeout);
   }
+  if (options.signal) {
+    if (options.signal.aborted) {
+      process.nextTick(() => kill());
+    } else {
+      options.signal.addEventListener('abort', () => {
+        if (!ex) {
+          ex = new AbortError();
+        }
+        kill();
+      });
+      const remove = () => options.signal.removeEventListener('abort', kill);
+      child.once('close', remove);
+    }
+  }
 
   if (child.stdout) {
     if (encoding)
diff --git a/test/parallel/test-child-process-execfile.js b/test/parallel/test-child-process-execfile.js
index bc0495b3332384..389ad73c228762 100644
--- a/test/parallel/test-child-process-execfile.js
+++ b/test/parallel/test-child-process-execfile.js
@@ -1,3 +1,4 @@
+// Flags: --experimental-abortcontroller
 'use strict';
 
 const common = require('../common');
@@ -7,6 +8,7 @@ const { getSystemErrorName } = require('util');
 const fixtures = require('../common/fixtures');
 
 const fixture = fixtures.path('exit.js');
+const echoFixture = fixtures.path('echo.js');
 const execOpts = { encoding: 'utf8', shell: true };
 
 {
@@ -45,3 +47,16 @@ const execOpts = { encoding: 'utf8', shell: true };
   // Verify the shell option works properly
   execFile(process.execPath, [fixture, 0], execOpts, common.mustSucceed());
 }
+
+{
+  // Verify that the signal option works properly
+  const ac = new AbortController();
+  const { signal } = ac;
+
+  const callback = common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ABORT_ERR');
+    assert.strictEqual(err.name, 'AbortError');
+  });
+  execFile(process.execPath, [echoFixture, 0], { signal }, callback);
+  ac.abort();
+}

From 6c86e682fb665fc623ed52987e387cf8f908ab96 Mon Sep 17 00:00:00 2001
From: Moshe vilner <shootermv@gmail.com>
Date: Mon, 7 Dec 2020 16:01:25 +0200
Subject: [PATCH 26/40] test: increase execFile abort coverage

Verify that if something different than Abortcontroller.signal is passed
to child_process.execFile(), ERR_INVALID_ARG_TYPE is thrown.

PR-URL: https://github.com/nodejs/node/pull/36429
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 test/parallel/test-child-process-execfile.js | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/test/parallel/test-child-process-execfile.js b/test/parallel/test-child-process-execfile.js
index 389ad73c228762..6012072eb297d1 100644
--- a/test/parallel/test-child-process-execfile.js
+++ b/test/parallel/test-child-process-execfile.js
@@ -60,3 +60,14 @@ const execOpts = { encoding: 'utf8', shell: true };
   execFile(process.execPath, [echoFixture, 0], { signal }, callback);
   ac.abort();
 }
+
+{
+  // Verify that if something different than Abortcontroller.signal
+  // is passed, ERR_INVALID_ARG_TYPE is thrown
+  assert.throws(() => {
+    const callback = common.mustNotCall(() => {});
+
+    execFile(process.execPath, [echoFixture, 0], { signal: 'hello' }, callback);
+  }, { code: 'ERR_INVALID_ARG_TYPE', name: 'TypeError' });
+
+}

From 4f04104425b29f07d79913d69a8423d5d0857fc4 Mon Sep 17 00:00:00 2001
From: Benjamin Gruenbaum <benjamingr@gmail.com>
Date: Mon, 7 Dec 2020 12:54:50 +0200
Subject: [PATCH 27/40] child_process: clean event listener correctly

I was working on AbortSignal for spawn and noticed there is a leak in
the current code for AbortSignal support in child_process since it
removes the wrong listener. I used the new signal as argument feature
to make removing the listener easier and added a test.

PR-URL: https://github.com/nodejs/node/pull/36424
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 lib/child_process.js                         |  9 ++++-----
 test/parallel/test-child-process-execfile.js | 11 +++++++++++
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/lib/child_process.js b/lib/child_process.js
index 1b645e43c8151b..28290f65a0fb2d 100644
--- a/lib/child_process.js
+++ b/lib/child_process.js
@@ -365,14 +365,13 @@ function execFile(file /* , args, options, callback */) {
     if (options.signal.aborted) {
       process.nextTick(() => kill());
     } else {
+      const childController = new AbortController();
       options.signal.addEventListener('abort', () => {
-        if (!ex) {
+        if (!ex)
           ex = new AbortError();
-        }
         kill();
-      });
-      const remove = () => options.signal.removeEventListener('abort', kill);
-      child.once('close', remove);
+      }, { signal: childController.signal });
+      child.once('close', () => childController.abort());
     }
   }
 
diff --git a/test/parallel/test-child-process-execfile.js b/test/parallel/test-child-process-execfile.js
index 6012072eb297d1..ca430d17cfe1bb 100644
--- a/test/parallel/test-child-process-execfile.js
+++ b/test/parallel/test-child-process-execfile.js
@@ -4,6 +4,7 @@
 const common = require('../common');
 const assert = require('assert');
 const execFile = require('child_process').execFile;
+const { getEventListeners } = require('events');
 const { getSystemErrorName } = require('util');
 const fixtures = require('../common/fixtures');
 
@@ -69,5 +70,15 @@ const execOpts = { encoding: 'utf8', shell: true };
 
     execFile(process.execPath, [echoFixture, 0], { signal: 'hello' }, callback);
   }, { code: 'ERR_INVALID_ARG_TYPE', name: 'TypeError' });
+}
+{
+  // Verify that the process completing removes the abort listener
+  const ac = new AbortController();
+  const { signal } = ac;
 
+  const callback = common.mustCall((err) => {
+    assert.strictEqual(getEventListeners(ac.signal).length, 0);
+    assert.strictEqual(err, null);
+  });
+  execFile(process.execPath, [fixture, 0], { signal }, callback);
 }

From 44a304dd10c4b5cbc99d1d1fc708ce4ce5842913 Mon Sep 17 00:00:00 2001
From: Benjamin Gruenbaum <benjamingr@gmail.com>
Date: Mon, 7 Dec 2020 19:02:06 +0200
Subject: [PATCH 28/40] child_process: add signal support to spawn

PR-URL: https://github.com/nodejs/node/pull/36432
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 doc/api/child_process.md                      | 23 ++++++++++++++--
 lib/child_process.js                          | 26 ++++++++++++++++++-
 .../test-child-process-spawn-controller.js    | 22 ++++++++++++++++
 3 files changed, 68 insertions(+), 3 deletions(-)
 create mode 100644 test/parallel/test-child-process-spawn-controller.js

diff --git a/doc/api/child_process.md b/doc/api/child_process.md
index 1b9fc0229ab389..16e88401e4d7bb 100644
--- a/doc/api/child_process.md
+++ b/doc/api/child_process.md
@@ -280,7 +280,7 @@ changes:
     `'/bin/sh'` on Unix, and `process.env.ComSpec` on Windows. A different
     shell can be specified as a string. See [Shell requirements][] and
     [Default Windows shell][]. **Default:** `false` (no shell).
-  * `signal` {AbortSignal} allows aborting the execFile using an AbortSignal
+  * `signal` {AbortSignal} allows aborting the execFile using an AbortSignal.
 * `callback` {Function} Called with the output when process terminates.
   * `error` {Error}
   * `stdout` {string|Buffer}
@@ -344,7 +344,7 @@ const { signal } = controller;
 const child = execFile('node', ['--version'], { signal }, (error) => {
   console.log(error); // an AbortError
 });
-signal.abort();
+controller.abort();
 ```
 
 ### `child_process.fork(modulePath[, args][, options])`
@@ -424,6 +424,9 @@ The `shell` option available in [`child_process.spawn()`][] is not supported by
 <!-- YAML
 added: v0.1.90
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/36432
+    description: AbortSignal support was added.
   - version:
       - v13.2.0
       - v12.16.0
@@ -466,6 +469,8 @@ changes:
     when `shell` is specified and is CMD. **Default:** `false`.
   * `windowsHide` {boolean} Hide the subprocess console window that would
     normally be created on Windows systems. **Default:** `false`.
+  * `signal` {AbortSignal} allows aborting the execFile using an AbortSignal.
+
 * Returns: {ChildProcess}
 
 The `child_process.spawn()` method spawns a new process using the given
@@ -572,6 +577,20 @@ Node.js currently overwrites `argv[0]` with `process.execPath` on startup, so
 parameter passed to `spawn` from the parent, retrieve it with the
 `process.argv0` property instead.
 
+If the `signal` option is enabled, calling `.abort()` on the corresponding
+`AbortController` is similar to calling `.kill()` on the child process except
+the error passed to the callback will be an `AbortError`:
+
+```js
+const controller = new AbortController();
+const { signal } = controller;
+const grep = spawn('grep', ['ssh'], { signal });
+grep.on('error', (err) => {
+  // This will be called with err being an AbortError if the controller aborts
+});
+controller.abort(); // stops the process
+```
+
 #### `options.detached`
 <!-- YAML
 added: v0.7.10
diff --git a/lib/child_process.js b/lib/child_process.js
index 28290f65a0fb2d..3249c97a021cfd 100644
--- a/lib/child_process.js
+++ b/lib/child_process.js
@@ -709,6 +709,30 @@ function sanitizeKillSignal(killSignal) {
   }
 }
 
+// This level of indirection is here because the other child_process methods
+// call spawn internally but should use different cancellation logic.
+function spawnWithSignal(file, args, options) {
+  const child = spawn(file, args, options);
+
+  if (options && options.signal) {
+    // Validate signal, if present
+    validateAbortSignal(options.signal, 'options.signal');
+    function kill() {
+      if (child._handle) {
+        child._handle.kill('SIGTERM');
+        child.emit('error', new AbortError());
+      }
+    }
+    if (options.signal.aborted) {
+      process.nextTick(kill);
+    } else {
+      options.signal.addEventListener('abort', kill);
+      const remove = () => options.signal.removeEventListener('abort', kill);
+      child.once('close', remove);
+    }
+  }
+  return child;
+}
 module.exports = {
   _forkChild,
   ChildProcess,
@@ -717,6 +741,6 @@ module.exports = {
   execFileSync,
   execSync,
   fork,
-  spawn,
+  spawn: spawnWithSignal,
   spawnSync
 };
diff --git a/test/parallel/test-child-process-spawn-controller.js b/test/parallel/test-child-process-spawn-controller.js
new file mode 100644
index 00000000000000..2ac3a0ddd514a7
--- /dev/null
+++ b/test/parallel/test-child-process-spawn-controller.js
@@ -0,0 +1,22 @@
+// Flags: --experimental-abortcontroller
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+
+// Verify that passing an AbortSignal works
+const controller = new AbortController();
+const { signal } = controller;
+
+const echo = cp.spawn('echo', ['fun'], {
+  encoding: 'utf8',
+  shell: true,
+  signal
+});
+
+echo.on('error', common.mustCall((e) => {
+  assert.strictEqual(e.name, 'AbortError');
+}));
+
+controller.abort();

From b9732d4cb0e4c514b4d1ae7dc58b8ccd46fb88ea Mon Sep 17 00:00:00 2001
From: Benjamin Gruenbaum <benjamingr@gmail.com>
Date: Tue, 22 Dec 2020 15:27:14 +0200
Subject: [PATCH 29/40] child_process: support AbortSignal in fork

PR-URL: https://github.com/nodejs/node/pull/36603
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 doc/api/child_process.md                      | 11 ++++--
 lib/child_process.js                          |  4 +--
 .../child-process-stay-alive-forever.js       |  3 ++
 .../test-child-process-fork-abort-signal.js   | 34 +++++++++++++++++++
 4 files changed, 48 insertions(+), 4 deletions(-)
 create mode 100644 test/fixtures/child-process-stay-alive-forever.js
 create mode 100644 test/parallel/test-child-process-fork-abort-signal.js

diff --git a/doc/api/child_process.md b/doc/api/child_process.md
index 16e88401e4d7bb..13c342b07e765f 100644
--- a/doc/api/child_process.md
+++ b/doc/api/child_process.md
@@ -351,6 +351,9 @@ controller.abort();
 <!-- YAML
 added: v0.5.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/36603
+    description: AbortSignal support was added.
   - version:
       - v13.2.0
       - v12.16.0
@@ -375,9 +378,11 @@ changes:
   * `execPath` {string} Executable used to create the child process.
   * `execArgv` {string[]} List of string arguments passed to the executable.
     **Default:** `process.execArgv`.
+  * `gid` {number} Sets the group identity of the process (see setgid(2)).
   * `serialization` {string} Specify the kind of serialization used for sending
     messages between processes. Possible values are `'json'` and `'advanced'`.
     See [Advanced serialization][] for more details. **Default:** `'json'`.
+  * `signal` {AbortSignal} Allows closing the subprocess using an AbortSignal.
   * `silent` {boolean} If `true`, stdin, stdout, and stderr of the child will be
     piped to the parent, otherwise they will be inherited from the parent, see
     the `'pipe'` and `'inherit'` options for [`child_process.spawn()`][]'s
@@ -386,10 +391,9 @@ changes:
     When this option is provided, it overrides `silent`. If the array variant
     is used, it must contain exactly one item with value `'ipc'` or an error
     will be thrown. For instance `[0, 1, 2, 'ipc']`.
+  * `uid` {number} Sets the user identity of the process (see setuid(2)).
   * `windowsVerbatimArguments` {boolean} No quoting or escaping of arguments is
     done on Windows. Ignored on Unix. **Default:** `false`.
-  * `uid` {number} Sets the user identity of the process (see setuid(2)).
-  * `gid` {number} Sets the group identity of the process (see setgid(2)).
 * Returns: {ChildProcess}
 
 The `child_process.fork()` method is a special case of
@@ -420,6 +424,9 @@ current process.
 The `shell` option available in [`child_process.spawn()`][] is not supported by
 `child_process.fork()` and will be ignored if set.
 
+The `signal` option works exactly the same way it does in
+[`child_process.spawn()`][].
+
 ### `child_process.spawn(command[, args][, options])`
 <!-- YAML
 added: v0.1.90
diff --git a/lib/child_process.js b/lib/child_process.js
index 3249c97a021cfd..fae9c930ebb0bf 100644
--- a/lib/child_process.js
+++ b/lib/child_process.js
@@ -127,7 +127,7 @@ function fork(modulePath /* , args, options */) {
   options.execPath = options.execPath || process.execPath;
   options.shell = false;
 
-  return spawn(options.execPath, args, options);
+  return spawnWithSignal(options.execPath, args, options);
 }
 
 function _forkChild(fd, serializationMode) {
@@ -719,7 +719,7 @@ function spawnWithSignal(file, args, options) {
     validateAbortSignal(options.signal, 'options.signal');
     function kill() {
       if (child._handle) {
-        child._handle.kill('SIGTERM');
+        child.kill('SIGTERM');
         child.emit('error', new AbortError());
       }
     }
diff --git a/test/fixtures/child-process-stay-alive-forever.js b/test/fixtures/child-process-stay-alive-forever.js
new file mode 100644
index 00000000000000..fda313eba074c1
--- /dev/null
+++ b/test/fixtures/child-process-stay-alive-forever.js
@@ -0,0 +1,3 @@
+setInterval(() => {
+    // Starting an interval to stay alive.
+}, 1000);
diff --git a/test/parallel/test-child-process-fork-abort-signal.js b/test/parallel/test-child-process-fork-abort-signal.js
new file mode 100644
index 00000000000000..809821738d1b9d
--- /dev/null
+++ b/test/parallel/test-child-process-fork-abort-signal.js
@@ -0,0 +1,34 @@
+// Flags: --experimental-abortcontroller
+'use strict';
+
+const { mustCall } = require('../common');
+const { strictEqual } = require('assert');
+const fixtures = require('../common/fixtures');
+const { fork } = require('child_process');
+
+{
+  // Test aborting a forked child_process after calling fork
+  const ac = new AbortController();
+  const { signal } = ac;
+  const cp = fork(fixtures.path('child-process-stay-alive-forever.js'), {
+    signal
+  });
+  cp.on('exit', mustCall());
+  cp.on('error', mustCall((err) => {
+    strictEqual(err.name, 'AbortError');
+  }));
+  process.nextTick(() => ac.abort());
+}
+{
+  // Test passing an already aborted signal to a forked child_process
+  const ac = new AbortController();
+  const { signal } = ac;
+  ac.abort();
+  const cp = fork(fixtures.path('child-process-stay-alive-forever.js'), {
+    signal
+  });
+  cp.on('exit', mustCall());
+  cp.on('error', mustCall((err) => {
+    strictEqual(err.name, 'AbortError');
+  }));
+}

From 130b797b382de7f9105701a5440420d5d8a7ab64 Mon Sep 17 00:00:00 2001
From: ZiJian Liu <Lxxyxzj@gmail.com>
Date: Tue, 22 Dec 2020 23:23:23 +0800
Subject: [PATCH 30/40] timers: refactor to use validateAbortSignal
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/36604
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Juan José Arboleda <soyjuanarbol@gmail.com>
Reviewed-By: Richard Lau <rlau@redhat.com>
---
 lib/internal/timers/promises.js | 28 ++++++++++------------------
 1 file changed, 10 insertions(+), 18 deletions(-)

diff --git a/lib/internal/timers/promises.js b/lib/internal/timers/promises.js
index ef1e6437d4f6ca..94c8f40a19db5e 100644
--- a/lib/internal/timers/promises.js
+++ b/lib/internal/timers/promises.js
@@ -16,6 +16,8 @@ const {
   codes: { ERR_INVALID_ARG_TYPE }
 } = require('internal/errors');
 
+const { validateAbortSignal } = require('internal/validators');
+
 let DOMException;
 
 const lazyDOMException = hideStackFrames((message, name) => {
@@ -34,15 +36,10 @@ function setTimeout(after, value, options = {}) {
         options));
   }
   const { signal, ref = true } = options;
-  if (signal !== undefined &&
-      (signal === null ||
-       typeof signal !== 'object' ||
-       !('aborted' in signal))) {
-    return PromiseReject(
-      new ERR_INVALID_ARG_TYPE(
-        'options.signal',
-        'AbortSignal',
-        signal));
+  try {
+    validateAbortSignal(signal, 'options.signal');
+  } catch (err) {
+    return PromiseReject(err);
   }
   if (typeof ref !== 'boolean') {
     return PromiseReject(
@@ -83,15 +80,10 @@ function setImmediate(value, options = {}) {
         options));
   }
   const { signal, ref = true } = options;
-  if (signal !== undefined &&
-    (signal === null ||
-     typeof signal !== 'object' ||
-     !('aborted' in signal))) {
-    return PromiseReject(
-      new ERR_INVALID_ARG_TYPE(
-        'options.signal',
-        'AbortSignal',
-        signal));
+  try {
+    validateAbortSignal(signal, 'options.signal');
+  } catch (err) {
+    return PromiseReject(err);
   }
   if (typeof ref !== 'boolean') {
     return PromiseReject(

From 1b04e635df421c35666206ea8407d2ce74380cf4 Mon Sep 17 00:00:00 2001
From: Nitzan Uziely <nitzan@testim.io>
Date: Fri, 22 Jan 2021 23:01:43 +0200
Subject: [PATCH 31/40] dgram: support AbortSignal in createSocket

PR-URL: https://github.com/nodejs/node/pull/37026
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 doc/api/dgram.md                         | 18 +++++++++++++
 lib/dgram.js                             | 15 +++++++++++
 test/parallel/test-dgram-close-signal.js | 34 ++++++++++++++++++++++++
 3 files changed, 67 insertions(+)
 create mode 100644 test/parallel/test-dgram-close-signal.js

diff --git a/doc/api/dgram.md b/doc/api/dgram.md
index 209c76ccdb0601..484ef07a65b714 100644
--- a/doc/api/dgram.md
+++ b/doc/api/dgram.md
@@ -733,6 +733,9 @@ chained.
 <!-- YAML
 added: v0.11.13
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/37026
+    description: AbortSignal support was added.
   - version: v11.4.0
     pr-url: https://github.com/nodejs/node/pull/23798
     description: The `ipv6Only` option is supported.
@@ -757,6 +760,7 @@ changes:
   * `recvBufferSize` {number} Sets the `SO_RCVBUF` socket value.
   * `sendBufferSize` {number} Sets the `SO_SNDBUF` socket value.
   * `lookup` {Function} Custom lookup function. **Default:** [`dns.lookup()`][].
+  * `signal` {AbortSignal} An AbortSignal that may be used to close a socket.
 * `callback` {Function} Attached as a listener for `'message'` events. Optional.
 * Returns: {dgram.Socket}
 
@@ -768,6 +772,20 @@ method will bind the socket to the "all interfaces" address on a random port
 and port can be retrieved using [`socket.address().address`][] and
 [`socket.address().port`][].
 
+If the `signal` option is enabled, calling `.abort()` on the corresponding
+`AbortController` is similar to calling `.close()` on the socket:
+
+```js
+const controller = new AbortController();
+const { signal } = controller;
+const server = dgram.createSocket({ type: 'udp4', signal });
+server.on('message', (msg, rinfo) => {
+  console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
+});
+// Later, when you want to close the server.
+controller.abort();
+```
+
 ### `dgram.createSocket(type[, callback])`
 <!-- YAML
 added: v0.1.99
diff --git a/lib/dgram.js b/lib/dgram.js
index 1c1b4781617695..4db4388c4f9fff 100644
--- a/lib/dgram.js
+++ b/lib/dgram.js
@@ -48,6 +48,7 @@ const {
 } = errors.codes;
 const {
   isInt32,
+  validateAbortSignal,
   validateString,
   validateNumber,
   validatePort,
@@ -121,6 +122,20 @@ function Socket(type, listener) {
     recvBufferSize,
     sendBufferSize
   };
+
+  if (options?.signal !== undefined) {
+    const { signal } = options;
+    validateAbortSignal(signal, 'options.signal');
+    const onAborted = () => {
+      this.close();
+    };
+    if (signal.aborted) {
+      onAborted();
+    } else {
+      signal.addEventListener('abort', onAborted);
+      this.once('close', () => signal.removeEventListener('abort', onAborted));
+    }
+  }
 }
 ObjectSetPrototypeOf(Socket.prototype, EventEmitter.prototype);
 ObjectSetPrototypeOf(Socket, EventEmitter);
diff --git a/test/parallel/test-dgram-close-signal.js b/test/parallel/test-dgram-close-signal.js
new file mode 100644
index 00000000000000..680d795a22e22d
--- /dev/null
+++ b/test/parallel/test-dgram-close-signal.js
@@ -0,0 +1,34 @@
+// Flags: --experimental-abortcontroller
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const dgram = require('dgram');
+
+{
+  // Test bad signal.
+  assert.throws(
+    () => dgram.createSocket({ type: 'udp4', signal: {} }),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    });
+}
+
+{
+  // Test close.
+  const controller = new AbortController();
+  const { signal } = controller;
+  const server = dgram.createSocket({ type: 'udp4', signal });
+  server.on('close', common.mustCall());
+  controller.abort();
+}
+
+{
+  // Test close with pre-aborted signal.
+  const controller = new AbortController();
+  controller.abort();
+  const { signal } = controller;
+  const server = dgram.createSocket({ type: 'udp4', signal });
+  server.on('close', common.mustCall());
+}

From ef6af8ccd853aa0cf61db5e961c41bc3e1b17ace Mon Sep 17 00:00:00 2001
From: Benjamin Gruenbaum <benjamingr@gmail.com>
Date: Tue, 2 Feb 2021 19:30:43 +0200
Subject: [PATCH 32/40] fs: add AbortSignal support to watch

PR-URL: https://github.com/nodejs/node/pull/37190
Refs: https://github.com/nodejs/node/pull/37179
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Darshan Sen <raisinten@gmail.com>
---
 doc/api/fs.md                               |  7 +++++
 lib/fs.js                                   | 11 +++++++
 test/parallel/test-fs-watch-abort-signal.js | 32 +++++++++++++++++++++
 3 files changed, 50 insertions(+)
 create mode 100644 test/parallel/test-fs-watch-abort-signal.js

diff --git a/doc/api/fs.md b/doc/api/fs.md
index 35a0fd462bc652..edb6656fad2c41 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -4060,6 +4060,9 @@ this API: [`fs.utimes()`][].
 <!-- YAML
 added: v0.5.10
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/37190
+    description: Added support for closing the watcher with an AbortSignal.
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `filename` parameter can be a WHATWG `URL` object using
@@ -4079,6 +4082,7 @@ changes:
     `false`.
   * `encoding` {string} Specifies the character encoding to be used for the
      filename passed to the listener. **Default:** `'utf8'`.
+  * `signal` {AbortSignal} allows closing the watcher with an AbortSignal.
 * `listener` {Function|undefined} **Default:** `undefined`
   * `eventType` {string}
   * `filename` {string|Buffer}
@@ -4101,6 +4105,9 @@ The listener callback is attached to the `'change'` event fired by
 [`fs.FSWatcher`][], but it is not the same thing as the `'change'` value of
 `eventType`.
 
+If a `signal` is passed, aborting the corresponding AbortController will close
+the returned [`fs.FSWatcher`][].
+
 ### Caveats
 
 <!--type=misc-->
diff --git a/lib/fs.js b/lib/fs.js
index 49dbe2cb621e71..8d27c5b2d9279c 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -1571,6 +1571,17 @@ function watch(filename, options, listener) {
   if (listener) {
     watcher.addListener('change', listener);
   }
+  if (options.signal) {
+    if (options.signal.aborted) {
+      process.nextTick(() => watcher.close());
+    } else {
+      const listener = () => watcher.close();
+      options.signal.addEventListener('abort', listener);
+      watcher.once('close', () => {
+        options.signal.removeEventListener('abort', listener);
+      });
+    }
+  }
 
   return watcher;
 }
diff --git a/test/parallel/test-fs-watch-abort-signal.js b/test/parallel/test-fs-watch-abort-signal.js
new file mode 100644
index 00000000000000..e5589bc1140f8b
--- /dev/null
+++ b/test/parallel/test-fs-watch-abort-signal.js
@@ -0,0 +1,32 @@
+// Flags: --expose-internals --experimental-abortcontroller
+'use strict';
+
+// Verify that AbortSignal integration works for fs.watch
+
+const common = require('../common');
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+const fs = require('fs');
+const fixtures = require('../common/fixtures');
+
+
+{
+  // Signal aborted after creating the watcher
+  const file = fixtures.path('empty.js');
+  const ac = new AbortController();
+  const { signal } = ac;
+  const watcher = fs.watch(file, { signal });
+  watcher.once('close', common.mustCall());
+  setImmediate(() => ac.abort());
+}
+{
+  // Signal aborted before creating the watcher
+  const file = fixtures.path('empty.js');
+  const ac = new AbortController();
+  const { signal } = ac;
+  ac.abort();
+  const watcher = fs.watch(file, { signal });
+  watcher.once('close', common.mustCall());
+}

From 88b3463ebc5af7e0c935af631073efa6a178ee5d Mon Sep 17 00:00:00 2001
From: Nitzan Uziely <nitzan@testim.io>
Date: Tue, 16 Feb 2021 15:18:51 +0200
Subject: [PATCH 33/40] fs: fix pre-aborted writeFile AbortSignal file leak

Fix an issue in writeFile where a file is opened, and not closed
if the abort signal is aborted after the file was opened
but before writing began.

PR-URL: https://github.com/nodejs/node/pull/37393
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
---
 lib/internal/fs/promises.js | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js
index a6b50054774f4e..ccac60477ff83c 100644
--- a/lib/internal/fs/promises.js
+++ b/lib/internal/fs/promises.js
@@ -63,6 +63,7 @@ const {
 const { opendir } = require('internal/fs/dir');
 const {
   parseFileMode,
+  validateAbortSignal,
   validateBuffer,
   validateInteger,
   validateUint32
@@ -646,14 +647,17 @@ async function writeFile(path, data, options) {
     data = Buffer.from(data, options.encoding || 'utf8');
   }
 
+  validateAbortSignal(options.signal);
   if (path instanceof FileHandle)
     return writeFileHandle(path, data, options.signal);
 
-  const fd = await open(path, flag, options.mode);
   if (options.signal?.aborted) {
     throw new lazyDOMException('The operation was aborted', 'AbortError');
   }
-  return PromisePrototypeFinally(writeFileHandle(fd, data), fd.close);
+
+  const fd = await open(path, flag, options.mode);
+  const { signal } = options;
+  return PromisePrototypeFinally(writeFileHandle(fd, data, signal), fd.close);
 }
 
 async function appendFile(path, data, options) {
@@ -670,6 +674,10 @@ async function readFile(path, options) {
   if (path instanceof FileHandle)
     return readFileHandle(path, options);
 
+  if (options.signal?.aborted) {
+    throw lazyDOMException('The operation was aborted', 'AbortError');
+  }
+
   const fd = await open(path, flag, 0o666);
   return PromisePrototypeFinally(readFileHandle(fd, options), fd.close);
 }

From a80d2720b7c6e96151ad69ba475ea287e655b82b Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Thu, 11 Mar 2021 07:24:03 -0800
Subject: [PATCH 34/40] doc: recommend checking abortSignal.aborted first

Signed-off-by: James M Snell <jasnell@gmail.com>

PR-URL: https://github.com/nodejs/node/pull/37714
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: Darshan Sen <raisinten@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 doc/api/globals.md | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/doc/api/globals.md b/doc/api/globals.md
index da86cada230092..e92dd5fc47d732 100644
--- a/doc/api/globals.md
+++ b/doc/api/globals.md
@@ -89,11 +89,15 @@ ac.abort();
 ```
 
 The `AbortController` with which the `AbortSignal` is associated will only
-ever trigger the `'abort'` event once. Any event listeners attached to the
-`AbortSignal` *should* use the `{ once: true }` option (or, if using the
-`EventEmitter` APIs to attach a listener, use the `once()` method) to ensure
-that the event listener is removed as soon as the `'abort'` event is handled.
-Failure to do so may result in memory leaks.
+ever trigger the `'abort'` event once. We recommended that code check
+that the `abortSignal.aborted` attribute is `false` before adding an `'abort'`
+event listener.
+
+Any event listeners attached to the `AbortSignal` should use the
+`{ once: true }` option (or, if using the `EventEmitter` APIs to attach a
+listener, use the `once()` method) to ensure that the event listener is
+removed as soon as the `'abort'` event is handled. Failure to do so may
+result in memory leaks.
 
 #### `abortSignal.aborted`
 <!-- YAML

From 6b3a21cd8f9361157c96660097ec1a68788320a8 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Fri, 6 Nov 2020 08:09:42 -0800
Subject: [PATCH 35/40] events: add max listener warning for EventTarget

Signed-off-by: James M Snell <jasnell@gmail.com>

PR-URL: https://github.com/nodejs/node/pull/36001
Fixes: https://github.com/nodejs/node/issues/35990
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 doc/api/events.md                             | 23 ++++++
 lib/events.js                                 | 47 +++++++++++
 lib/internal/event_target.js                  | 59 +++++++-------
 .../test-eventtarget-memoryleakwarning.js     | 81 +++++++++++++++++++
 4 files changed, 180 insertions(+), 30 deletions(-)
 create mode 100644 test/parallel/test-eventtarget-memoryleakwarning.js

diff --git a/doc/api/events.md b/doc/api/events.md
index 014451f2179ed7..f02da7c37699d3 100644
--- a/doc/api/events.md
+++ b/doc/api/events.md
@@ -383,6 +383,29 @@ Installing a listener using this symbol does not change the behavior once an
 `'error'` event is emitted, therefore the process will still crash if no
 regular `'error'` listener is installed.
 
+### `EventEmitter.setMaxListeners(n[, ...eventTargets])`
+<!-- YAML
+added: REPLACEME
+-->
+
+* `n` {number} A non-negative number. The maximum number of listeners per
+  `EventTarget` event.
+* `...eventsTargets` {EventTarget[]|EventEmitter[]} Zero or more {EventTarget}
+  or {EventEmitter} instances. If none are specified, `n` is set as the default
+  max for all newly created {EventTarget} and {EventEmitter} objects.
+
+```js
+const {
+  setMaxListeners,
+  EventEmitter
+} = require('events');
+
+const target = new EventTarget();
+const emitter = new EventEmitter();
+
+setMaxListeners(5, target, emitter);
+```
+
 ### `emitter.addListener(eventName, listener)`
 <!-- YAML
 added: v0.1.26
diff --git a/lib/events.js b/lib/events.js
index c532d7024e9095..c80e6ae2eed3ac 100644
--- a/lib/events.js
+++ b/lib/events.js
@@ -30,6 +30,7 @@ const {
   NumberIsNaN,
   ObjectCreate,
   ObjectDefineProperty,
+  ObjectDefineProperties,
   ObjectGetPrototypeOf,
   ObjectSetPrototypeOf,
   Promise,
@@ -67,6 +68,9 @@ const {
 
 const kCapture = Symbol('kCapture');
 const kErrorMonitor = Symbol('events.errorMonitor');
+const kMaxEventTargetListeners = Symbol('events.maxEventTargetListeners');
+const kMaxEventTargetListenersWarned =
+  Symbol('events.maxEventTargetListenersWarned');
 
 let DOMException;
 const lazyDOMException = hideStackFrames((message, name) => {
@@ -120,6 +124,7 @@ EventEmitter.prototype._maxListeners = undefined;
 // By default EventEmitters will print a warning if more than 10 listeners are
 // added to it. This is a useful default which helps finding memory leaks.
 let defaultMaxListeners = 10;
+let isEventTarget;
 
 function checkListener(listener) {
   if (typeof listener !== 'function') {
@@ -142,6 +147,48 @@ ObjectDefineProperty(EventEmitter, 'defaultMaxListeners', {
   }
 });
 
+ObjectDefineProperties(EventEmitter, {
+  kMaxEventTargetListeners: {
+    value: kMaxEventTargetListeners,
+    enumerable: false,
+    configurable: false,
+    writable: false,
+  },
+  kMaxEventTargetListenersWarned: {
+    value: kMaxEventTargetListenersWarned,
+    enumerable: false,
+    configurable: false,
+    writable: false,
+  }
+});
+
+EventEmitter.setMaxListeners =
+  function(n = defaultMaxListeners, ...eventTargets) {
+    if (typeof n !== 'number' || n < 0 || NumberIsNaN(n))
+      throw new ERR_OUT_OF_RANGE('n', 'a non-negative number', n);
+    if (eventTargets.length === 0) {
+      defaultMaxListeners = n;
+    } else {
+      if (isEventTarget === undefined)
+        isEventTarget = require('internal/event_target').isEventTarget;
+
+      // Performance for forEach is now comparable with regular for-loop
+      eventTargets.forEach((target) => {
+        if (isEventTarget(target)) {
+          target[kMaxEventTargetListeners] = n;
+          target[kMaxEventTargetListenersWarned] = false;
+        } else if (typeof target.setMaxListeners === 'function') {
+          target.setMaxListeners(n);
+        } else {
+          throw new ERR_INVALID_ARG_TYPE(
+            'eventTargets',
+            ['EventEmitter', 'EventTarget'],
+            target);
+        }
+      });
+    }
+  };
+
 EventEmitter.init = function(opts) {
 
   if (this._events === undefined ||
diff --git a/lib/internal/event_target.js b/lib/internal/event_target.js
index 716a157f464557..31e23feeb55f67 100644
--- a/lib/internal/event_target.js
+++ b/lib/internal/event_target.js
@@ -25,13 +25,19 @@ const {
     ERR_INVALID_THIS,
   }
 } = require('internal/errors');
-const { validateInteger, validateObject } = require('internal/validators');
+const { validateObject } = require('internal/validators');
 
 const { customInspectSymbol } = require('internal/util');
 const { inspect } = require('util');
 
 const kIsEventTarget = SymbolFor('nodejs.event_target');
 
+const EventEmitter = require('events');
+const {
+  kMaxEventTargetListeners,
+  kMaxEventTargetListenersWarned,
+} = EventEmitter;
+
 const kEvents = Symbol('kEvents');
 const kStop = Symbol('kStop');
 const kTarget = Symbol('kTarget');
@@ -42,8 +48,6 @@ const kCreateEvent = Symbol('kCreateEvent');
 const kNewListener = Symbol('kNewListener');
 const kRemoveListener = Symbol('kRemoveListener');
 const kIsNodeStyleListener = Symbol('kIsNodeStyleListener');
-const kMaxListeners = Symbol('kMaxListeners');
-const kMaxListenersWarned = Symbol('kMaxListenersWarned');
 const kTrustEvent = Symbol('kTrustEvent');
 
 // Lazy load perf_hooks to avoid the additional overhead on startup
@@ -220,6 +224,8 @@ class Listener {
 
 function initEventTarget(self) {
   self[kEvents] = new SafeMap();
+  self[kMaxEventTargetListeners] = EventEmitter.defaultMaxListeners;
+  self[kMaxEventTargetListenersWarned] = false;
 }
 
 class EventTarget {
@@ -232,7 +238,24 @@ class EventTarget {
     initEventTarget(this);
   }
 
-  [kNewListener](size, type, listener, once, capture, passive) {}
+  [kNewListener](size, type, listener, once, capture, passive) {
+    if (this[kMaxEventTargetListeners] > 0 &&
+        size > this[kMaxEventTargetListeners] &&
+        !this[kMaxEventTargetListenersWarned]) {
+      this[kMaxEventTargetListenersWarned] = true;
+      // No error code for this since it is a Warning
+      // eslint-disable-next-line no-restricted-syntax
+      const w = new Error('Possible EventTarget memory leak detected. ' +
+                          `${size} ${type} listeners ` +
+                          `added to ${inspect(this, { depth: -1 })}. Use ` +
+                          'events.setMaxListeners() to increase limit');
+      w.name = 'MaxListenersExceededWarning';
+      w.target = this;
+      w.type = type;
+      w.count = size;
+      process.emitWarning(w);
+    }
+  }
   [kRemoveListener](size, type, listener, capture) {}
 
   addEventListener(type, listener, options = {}) {
@@ -416,9 +439,6 @@ Object.defineProperty(EventTarget.prototype, SymbolToStringTag, {
 
 function initNodeEventTarget(self) {
   initEventTarget(self);
-  // eslint-disable-next-line no-use-before-define
-  self[kMaxListeners] = NodeEventTarget.defaultMaxListeners;
-  self[kMaxListenersWarned] = false;
 }
 
 class NodeEventTarget extends EventTarget {
@@ -429,33 +449,12 @@ class NodeEventTarget extends EventTarget {
     initNodeEventTarget(this);
   }
 
-  [kNewListener](size, type, listener, once, capture, passive) {
-    if (this[kMaxListeners] > 0 &&
-        size > this[kMaxListeners] &&
-        !this[kMaxListenersWarned]) {
-      this[kMaxListenersWarned] = true;
-      // No error code for this since it is a Warning
-      // eslint-disable-next-line no-restricted-syntax
-      const w = new Error('Possible EventTarget memory leak detected. ' +
-                          `${size} ${type} listeners ` +
-                          `added to ${inspect(this, { depth: -1 })}. Use ` +
-                          'setMaxListeners() to increase limit');
-      w.name = 'MaxListenersExceededWarning';
-      w.target = this;
-      w.type = type;
-      w.count = size;
-      process.emitWarning(w);
-    }
-  }
-
   setMaxListeners(n) {
-    validateInteger(n, 'n', 0);
-    this[kMaxListeners] = n;
-    return this;
+    EventEmitter.setMaxListeners(n, this);
   }
 
   getMaxListeners() {
-    return this[kMaxListeners];
+    return this[kMaxEventTargetListeners];
   }
 
   eventNames() {
diff --git a/test/parallel/test-eventtarget-memoryleakwarning.js b/test/parallel/test-eventtarget-memoryleakwarning.js
new file mode 100644
index 00000000000000..e6932320cf4b14
--- /dev/null
+++ b/test/parallel/test-eventtarget-memoryleakwarning.js
@@ -0,0 +1,81 @@
+// Flags: --no-warnings --expose-internals --experimental-abortcontroller
+'use strict';
+const common = require('../common');
+const {
+  setMaxListeners,
+  EventEmitter
+} = require('events');
+const assert = require('assert');
+const { MessageChannel } = require('worker_threads');
+const { EventTarget } = require('internal/event_target');
+
+common.expectWarning({
+  MaxListenersExceededWarning: [
+    ['Possible EventTarget memory leak detected. 3 foo listeners added to ' +
+     'EventTarget. Use events.setMaxListeners() ' +
+     'to increase limit'],
+    ['Possible EventTarget memory leak detected. 3 foo listeners added to ' +
+     '[MessagePort [EventTarget]]. ' +
+     'Use events.setMaxListeners() to increase ' +
+     'limit'],
+    ['Possible EventTarget memory leak detected. 3 foo listeners added to ' +
+     '[MessagePort [EventTarget]]. ' +
+     'Use events.setMaxListeners() to increase ' +
+     'limit'],
+    ['Possible EventTarget memory leak detected. 3 foo listeners added to ' +
+     '[AbortSignal [EventTarget]]. ' +
+     'Use events.setMaxListeners() to increase ' +
+     'limit'],
+  ],
+  ExperimentalWarning: [[
+    'AbortController is an experimental feature. This feature could change ' +
+    'at any time'
+  ]]
+});
+
+
+{
+  const et = new EventTarget();
+  setMaxListeners(2, et);
+  et.addEventListener('foo', () => {});
+  et.addEventListener('foo', () => {});
+  et.addEventListener('foo', () => {});
+}
+
+{
+  // No warning emitted because prior limit was only for that
+  // one EventTarget.
+  const et = new EventTarget();
+  et.addEventListener('foo', () => {});
+  et.addEventListener('foo', () => {});
+  et.addEventListener('foo', () => {});
+}
+
+{
+  const mc = new MessageChannel();
+  setMaxListeners(2, mc.port1);
+  mc.port1.addEventListener('foo', () => {});
+  mc.port1.addEventListener('foo', () => {});
+  mc.port1.addEventListener('foo', () => {});
+}
+
+{
+  // Set the default for newly created EventTargets
+  setMaxListeners(2);
+  const mc = new MessageChannel();
+  mc.port1.addEventListener('foo', () => {});
+  mc.port1.addEventListener('foo', () => {});
+  mc.port1.addEventListener('foo', () => {});
+
+  const ac = new AbortController();
+  ac.signal.addEventListener('foo', () => {});
+  ac.signal.addEventListener('foo', () => {});
+  ac.signal.addEventListener('foo', () => {});
+}
+
+{
+  // It works for EventEmitters also
+  const ee = new EventEmitter();
+  setMaxListeners(2, ee);
+  assert.strictEqual(ee.getMaxListeners(), 2);
+}

From a2cf56345a942cbc6f8915d59dfad0c8389187f5 Mon Sep 17 00:00:00 2001
From: Benjamin Gruenbaum <benjamingr@gmail.com>
Date: Sat, 14 Nov 2020 13:46:29 +0200
Subject: [PATCH 36/40] lib: set abort-controller toStringTag

PR-URL: https://github.com/nodejs/node/pull/36115
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 lib/internal/abort_controller.js                 | 16 ++++++++++++++++
 test/parallel/test-abortcontroller.js            |  7 +++++++
 .../test-eventtarget-memoryleakwarning.js        |  2 +-
 3 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/lib/internal/abort_controller.js b/lib/internal/abort_controller.js
index f047a878ffedd0..a834b76b459227 100644
--- a/lib/internal/abort_controller.js
+++ b/lib/internal/abort_controller.js
@@ -6,7 +6,9 @@
 const {
   Object,
   ObjectSetPrototypeOf,
+  ObjectDefineProperty,
   Symbol,
+  SymbolToStringTag,
   TypeError,
 } = primordials;
 
@@ -54,6 +56,13 @@ Object.defineProperties(AbortSignal.prototype, {
   aborted: { enumerable: true }
 });
 
+ObjectDefineProperty(AbortSignal.prototype, SymbolToStringTag, {
+  writable: false,
+  enumerable: false,
+  configurable: true,
+  value: 'AbortSignal',
+});
+
 defineEventHandler(AbortSignal.prototype, 'abort');
 
 function createAbortSignal() {
@@ -97,6 +106,13 @@ Object.defineProperties(AbortController.prototype, {
   abort: { enumerable: true }
 });
 
+ObjectDefineProperty(AbortController.prototype, SymbolToStringTag, {
+  writable: false,
+  enumerable: false,
+  configurable: true,
+  value: 'AbortController',
+});
+
 module.exports = {
   AbortController,
   AbortSignal,
diff --git a/test/parallel/test-abortcontroller.js b/test/parallel/test-abortcontroller.js
index 3eba5fff051512..051b07ba389c2f 100644
--- a/test/parallel/test-abortcontroller.js
+++ b/test/parallel/test-abortcontroller.js
@@ -61,3 +61,10 @@ const { Event } = require('internal/event_target');
     /^TypeError: Illegal constructor$/
   );
 }
+{
+  // Symbol.toStringTag
+  const toString = (o) => Object.prototype.toString.call(o);
+  const ac = new AbortController();
+  strictEqual(toString(ac), '[object AbortController]');
+  strictEqual(toString(ac.signal), '[object AbortSignal]');
+}
diff --git a/test/parallel/test-eventtarget-memoryleakwarning.js b/test/parallel/test-eventtarget-memoryleakwarning.js
index e6932320cf4b14..46c68b9979cfcb 100644
--- a/test/parallel/test-eventtarget-memoryleakwarning.js
+++ b/test/parallel/test-eventtarget-memoryleakwarning.js
@@ -23,7 +23,7 @@ common.expectWarning({
      'Use events.setMaxListeners() to increase ' +
      'limit'],
     ['Possible EventTarget memory leak detected. 3 foo listeners added to ' +
-     '[AbortSignal [EventTarget]]. ' +
+     '[AbortSignal]. ' +
      'Use events.setMaxListeners() to increase ' +
      'limit'],
   ],

From 436a2d2bb899b0f553a5ab0366afea4c381ff091 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Wed, 10 Mar 2021 08:59:52 -0800
Subject: [PATCH 37/40] lib: implement AbortSignal.abort()
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Refs: https://github.com/whatwg/dom/pull/960

PR-URL: https://github.com/nodejs/node/pull/37693
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
---
 .eslintrc.js                          | 1 +
 doc/api/globals.md                    | 9 +++++++++
 lib/internal/abort_controller.js      | 8 ++++++--
 test/parallel/test-abortcontroller.js | 5 +++++
 4 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/.eslintrc.js b/.eslintrc.js
index 8464945125b678..06711298a7f0b2 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -283,6 +283,7 @@ module.exports = {
   },
   globals: {
     AbortController: 'readable',
+    AbortSignal: 'readable',
     Atomics: 'readable',
     BigInt: 'readable',
     BigInt64Array: 'readable',
diff --git a/doc/api/globals.md b/doc/api/globals.md
index e92dd5fc47d732..a4d591a44fe9d8 100644
--- a/doc/api/globals.md
+++ b/doc/api/globals.md
@@ -65,6 +65,15 @@ added: REPLACEME
 The `AbortSignal` is used to notify observers when the
 `abortController.abort()` method is called.
 
+#### Static method: `AbortSignal.abort()`
+<!-- YAML
+added: REPLACEME
+-->
+
+* Returns: {AbortSignal}
+
+Returns a new already aborted `AbortSignal`.
+
 #### Event: `'abort'`
 <!-- YAML
 added: REPLACEME
diff --git a/lib/internal/abort_controller.js b/lib/internal/abort_controller.js
index a834b76b459227..32fe2ef0126f36 100644
--- a/lib/internal/abort_controller.js
+++ b/lib/internal/abort_controller.js
@@ -50,6 +50,10 @@ class AbortSignal extends EventTarget {
       aborted: this.aborted
     }, depth, options);
   }
+
+  static abort() {
+    return createAbortSignal(true);
+  }
 }
 
 Object.defineProperties(AbortSignal.prototype, {
@@ -65,10 +69,10 @@ ObjectDefineProperty(AbortSignal.prototype, SymbolToStringTag, {
 
 defineEventHandler(AbortSignal.prototype, 'abort');
 
-function createAbortSignal() {
+function createAbortSignal(aborted = false) {
   const signal = new EventTarget();
   ObjectSetPrototypeOf(signal, AbortSignal.prototype);
-  signal[kAborted] = false;
+  signal[kAborted] = aborted;
   return signal;
 }
 
diff --git a/test/parallel/test-abortcontroller.js b/test/parallel/test-abortcontroller.js
index 051b07ba389c2f..13bdfc766afc51 100644
--- a/test/parallel/test-abortcontroller.js
+++ b/test/parallel/test-abortcontroller.js
@@ -68,3 +68,8 @@ const { Event } = require('internal/event_target');
   strictEqual(toString(ac), '[object AbortController]');
   strictEqual(toString(ac.signal), '[object AbortSignal]');
 }
+
+{
+  const signal = AbortSignal.abort();
+  ok(signal.aborted);
+}

From 63099e19b4c9e6335a1fcc674f12e262d105c20e Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Mon, 15 Mar 2021 07:27:06 -0700
Subject: [PATCH 38/40] test: update dom/abort tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: James M Snell <jasnell@gmail.com>

PR-URL: https://github.com/nodejs/node/pull/37693
Refs: https://github.com/whatwg/dom/pull/960
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
---
 test/fixtures/wpt/README.md              | 2 +-
 test/fixtures/wpt/dom/abort/event.any.js | 5 +++++
 test/fixtures/wpt/versions.json          | 2 +-
 3 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/test/fixtures/wpt/README.md b/test/fixtures/wpt/README.md
index 6d2fc11710d3b6..e498acc0985bc0 100644
--- a/test/fixtures/wpt/README.md
+++ b/test/fixtures/wpt/README.md
@@ -18,7 +18,7 @@ Last update:
 - html/webappapis/microtask-queuing: https://github.com/web-platform-tests/wpt/tree/0c3bed38df/html/webappapis/microtask-queuing
 - html/webappapis/timers: https://github.com/web-platform-tests/wpt/tree/ddfe9c089b/html/webappapis/timers
 - hr-time: https://github.com/web-platform-tests/wpt/tree/a5d1774ecf/hr-time
-- dom/abort: https://github.com/web-platform-tests/wpt/tree/7caa3de747/dom/abort
+- dom/abort: https://github.com/web-platform-tests/wpt/tree/1728d198c9/dom/abort
 
 [Web Platform Tests]: https://github.com/web-platform-tests/wpt
 [`git node wpt`]: https://github.com/nodejs/node-core-utils/blob/master/docs/git-node.md#git-node-wpt
diff --git a/test/fixtures/wpt/dom/abort/event.any.js b/test/fixtures/wpt/dom/abort/event.any.js
index a67e6f400fcf1d..2589ba1ce45091 100644
--- a/test/fixtures/wpt/dom/abort/event.any.js
+++ b/test/fixtures/wpt/dom/abort/event.any.js
@@ -64,4 +64,9 @@ test(t => {
   controller.abort();
 }, "the abort event should have the right properties");
 
+test(t => {
+  const signal = AbortSignal.abort();
+  assert_true(signal.aborted);
+}, "the AbortSignal.abort() static returns an already aborted signal");
+
 done();
diff --git a/test/fixtures/wpt/versions.json b/test/fixtures/wpt/versions.json
index 0bbc27a9ff1d1f..5d4fe8988cb0b3 100644
--- a/test/fixtures/wpt/versions.json
+++ b/test/fixtures/wpt/versions.json
@@ -32,7 +32,7 @@
     "path": "hr-time"
   },
   "dom/abort": {
-    "commit": "7caa3de7471cf19b78ee9efa313c7341a462b5e3",
+    "commit": "1728d198c92834d92f7f399ef35e7823d5bfa0e4",
     "path": "dom/abort"
   }
 }

From 10131cd641a3221ea5239178b850a8a36de89c04 Mon Sep 17 00:00:00 2001
From: Mattias Buelens <mattias@buelens.com>
Date: Thu, 11 Mar 2021 23:25:45 +0100
Subject: [PATCH 39/40] lib: add brand checks to AbortController and
 AbortSignal

PR-URL: https://github.com/nodejs/node/pull/37720
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
---
 lib/internal/abort_controller.js      | 32 ++++++++++++--
 test/parallel/test-abortcontroller.js | 60 +++++++++++++++++++++++++++
 2 files changed, 89 insertions(+), 3 deletions(-)

diff --git a/lib/internal/abort_controller.js b/lib/internal/abort_controller.js
index 32fe2ef0126f36..95584feeeecb84 100644
--- a/lib/internal/abort_controller.js
+++ b/lib/internal/abort_controller.js
@@ -23,6 +23,11 @@ const {
   emitExperimentalWarning
 } = require('internal/util');
 const { inspect } = require('internal/util/inspect');
+const {
+  codes: {
+    ERR_INVALID_THIS,
+  }
+} = require('internal/errors');
 
 const kAborted = Symbol('kAborted');
 
@@ -37,13 +42,21 @@ function customInspect(self, obj, depth, options) {
   return `${self.constructor.name} ${inspect(obj, opts)}`;
 }
 
+function validateAbortSignal(obj) {
+  if (obj?.[kAborted] === undefined)
+    throw new ERR_INVALID_THIS('AbortSignal');
+}
+
 class AbortSignal extends EventTarget {
   constructor() {
     // eslint-disable-next-line no-restricted-syntax
     throw new TypeError('Illegal constructor');
   }
 
-  get aborted() { return !!this[kAborted]; }
+  get aborted() {
+    validateAbortSignal(this);
+    return !!this[kAborted];
+  }
 
   [customInspectSymbol](depth, options) {
     return customInspect(this, {
@@ -89,14 +102,27 @@ function abortSignal(signal) {
 // initializers for now:
 // https://bugs.chromium.org/p/v8/issues/detail?id=10704
 const kSignal = Symbol('signal');
+
+function validateAbortController(obj) {
+  if (obj?.[kSignal] === undefined)
+    throw new ERR_INVALID_THIS('AbortController');
+}
+
 class AbortController {
   constructor() {
     this[kSignal] = createAbortSignal();
     emitExperimentalWarning('AbortController');
   }
 
-  get signal() { return this[kSignal]; }
-  abort() { abortSignal(this[kSignal]); }
+  get signal() {
+    validateAbortController(this);
+    return this[kSignal];
+  }
+
+  abort() {
+    validateAbortController(this);
+    abortSignal(this[kSignal]);
+  }
 
   [customInspectSymbol](depth, options) {
     return customInspect(this, {
diff --git a/test/parallel/test-abortcontroller.js b/test/parallel/test-abortcontroller.js
index 13bdfc766afc51..9df6f78b6165cc 100644
--- a/test/parallel/test-abortcontroller.js
+++ b/test/parallel/test-abortcontroller.js
@@ -73,3 +73,63 @@ const { Event } = require('internal/event_target');
   const signal = AbortSignal.abort();
   ok(signal.aborted);
 }
+
+{
+  // Test that AbortController properties and methods validate the receiver
+  const acSignalGet = Object.getOwnPropertyDescriptor(
+    AbortController.prototype,
+    'signal'
+  ).get;
+  const acAbort = AbortController.prototype.abort;
+
+  const goodController = new AbortController();
+  ok(acSignalGet.call(goodController));
+  acAbort.call(goodController);
+
+  const badAbortControllers = [
+    null,
+    undefined,
+    0,
+    NaN,
+    true,
+    'AbortController',
+    Object.create(AbortController.prototype)
+  ];
+  for (const badController of badAbortControllers) {
+    throws(
+      () => acSignalGet.call(badController),
+      { code: 'ERR_INVALID_THIS', name: 'TypeError' }
+    );
+    throws(
+      () => acAbort.call(badController),
+      { code: 'ERR_INVALID_THIS', name: 'TypeError' }
+    );
+  }
+}
+
+{
+  // Test that AbortSignal properties validate the receiver
+  const signalAbortedGet = Object.getOwnPropertyDescriptor(
+    AbortSignal.prototype,
+    'aborted'
+  ).get;
+
+  const goodSignal = new AbortController().signal;
+  strictEqual(signalAbortedGet.call(goodSignal), false);
+
+  const badAbortSignals = [
+    null,
+    undefined,
+    0,
+    NaN,
+    true,
+    'AbortSignal',
+    Object.create(AbortSignal.prototype)
+  ];
+  for (const badSignal of badAbortSignals) {
+    throws(
+      () => signalAbortedGet.call(badSignal),
+      { code: 'ERR_INVALID_THIS', name: 'TypeError' }
+    );
+  }
+}

From 9abc11ad77d1d5aaf6cf23cbeb9b3556f9df0716 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Thu, 12 Nov 2020 11:23:46 -0800
Subject: [PATCH 40/40] test: fix unreliable test-fs-write-file.js

The test uses a file name twice, causing unreliability in CI. In
particular, it's failing a lot on the Raspberry Pi devices.

Fixes: https://github.com/nodejs/node/issues/36090

PR-URL: https://github.com/nodejs/node/pull/36102
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Richard Lau <rlau@redhat.com>
---
 test/parallel/test-fs-write-file.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/parallel/test-fs-write-file.js b/test/parallel/test-fs-write-file.js
index 3484782a8d4071..129560e63601fa 100644
--- a/test/parallel/test-fs-write-file.js
+++ b/test/parallel/test-fs-write-file.js
@@ -88,7 +88,7 @@ fs.open(filename4, 'w+', common.mustSucceed((fd) => {
   // After the operation has started
   const controller = new AbortController();
   const signal = controller.signal;
-  const filename4 = join(tmpdir.path, 'test4.txt');
+  const filename4 = join(tmpdir.path, 'test5.txt');
 
   fs.writeFile(filename4, s, { signal }, common.mustCall((err) => {
     assert.strictEqual(err.name, 'AbortError');