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 <[email protected]>
Fixes: #35748

PR-URL: #35811
Backport-PR-URL: #38386
Reviewed-By: Anna Henningsen <[email protected]>
Reviewed-By: Rich Trott <[email protected]>
Reviewed-By: James M Snell <[email protected]>

Author: benjamingr

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

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);
   }

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,
 };

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 {}

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);
+}