AbortableGovernor should probably use AbortSignal

[bakkot]

It gets annoying to compose with other things if it uses a different aborting mechanism.

A common pattern in the web platform is to have a single AbortSignal passed in to a function, and have all async work within the function listen on that signal so that you can easily cancel the function. If this uses a bespoke mechanism for aborting, then instead of being able to do that for everything in your function you have to carve out a different (and more annoying) mechanism for this specific function: compare

let task = await normalTask({ signal });
let token = await governor.acquire({ signal });

vs

let task = await normalTask({ signal });
let { abort, tokenPromise } = governor.acquireAbortable();
signal.addEventListener('abort', abort);
let token = await tokenPromise;

Also you'd better hope that normalTask doesn't ever do any async work which isn't guarded by the signal, because if it does then you also need to remember to add signal.throwIfAborted() or else it doesn't actually work.

[michaelficarra]

What do you think about acquireAbortable taking an optional signal parameter?

[bakkot]

I think the base acquire should take an optional signal parameter, at which point there's not all much reason to have an AbortableGovernor subclass.

[bakkot]

My preferred route is to write this against the AbortSignal interface, but not try to pull in all of AbortController. Unfortunately, the logic for consuming an actual AbortSignal is pretty gross today: you have to check if it's aborted, and then call .addEventListener('abort', (e) => { if (!e.isTrusted) return; ... }) if it's not, which is a lot of pretty strange steps.

But if we could get whatwg/dom#1289 through, then we could just say that if there is a signal argument then we call signal.addTeardown() and pass it the abort function. That's relatively straightforward.

It does leave us in the odd situation where the only ergonomic way to use abortable governors would be by using AbortController, which is not in the language. Without it you have to do something like

let abort;
let promise = governor.acquire({ signal: {
  addTeardown(_abort) {
    if (abort) return;
    abort = _abort;
  }
} });

which is weird.

So we could pull in the minimal parts of AbortController into the language: just say it's a class which gives you an object with { abort, signal } properties, where signal has an addTeardown method. Then the web platform could extend this (or rather, would already extend this). There's some hiccups like signal being a prototype getter on the web, but we could maybe change that on the web, or make it an allowable extension.