Define WritableStreamDefaultController's signal and abortReason

This allows an underlying sink to signal abort to the streams machinery even when it has a pending write or close operation.

Fixes #1015.

Author: yutakahirano

index.bs

@@ -4041,6 +4041,8 @@ The Web IDL definition for the {{WritableStreamDefaultController}} class is give
 <xmp class="idl">
 [Exposed=(Window,Worker,Worklet)]
 interface WritableStreamDefaultController {
+  readonly attribute any abortReason;
+  readonly attribute AbortSignal signal;
   undefined error(optional any e);
 };
 </xmp>
@@ -4060,6 +4062,9 @@ the following table:
    <td><dfn>\[[abortAlgorithm]]</dfn>
    <td class="non-normative">A promise-returning algorithm, taking one argument (the abort reason),
    which communicates a requested abort to the [=underlying sink=]
+  <tr>
+   <td><dfn>\[[abortReason]]</dfn>
+   <td class="non-normative">The argument given to [$WritableStreamAbort$], or undefined.
   <tr>
    <td><dfn>\[[closeAlgorithm]]</dfn>
    <td class="non-normative">A promise-returning algorithm which communicates a requested close to
@@ -4071,6 +4076,10 @@ the following table:
    <td><dfn>\[[queueTotalSize]]</dfn>
    <td class="non-normative">The total size of all the chunks stored in
    [=WritableStreamDefaultController/[[queue]]=] (see [[#queue-with-sizes]])
+  <tr>
+   <td><dfn>\[[signal]]</dfn>
+   <td class="non-normative">An {{AbortSignal}} that can be used to abort the pending write or
+   close operation when the stream is [=abort a writable stream|aborted=].
   <tr>
    <td><dfn>\[[started]]</dfn>
    <td class="non-normative">A boolean flag indicating whether the [=underlying sink=] has finished
@@ -4097,9 +4106,13 @@ The <dfn>close sentinel</dfn> is a unique value enqueued into
 [=WritableStreamDefaultController/[[queue]]=], in lieu of a [=chunk=], to signal that the stream is
 closed. It is only used internally, and is never exposed to web developers.
 
-<h4 id="ws-default-controller-prototype">Methods</h4>
+<h4 id="ws-default-controller-prototype">Methods and properties</h4>
 
 <dl class="domintro non-normative">
+ <dt><code><var ignore>controller</var>.{{WritableStreamDefaultController/signal}}</code>
+ <dd>
+  <p>An AbortSignal that can be used to abort the pending write or close operation when the stream is
+  [=abort a writable stream|aborted=].
  <dt><code><var ignore>controller</var>.{{WritableStreamDefaultController/error()|error}}(<var ignore>e</var>)</code>
  <dd>
   <p>Closes the controlled writable stream, making all future interactions with it fail with the
@@ -4111,6 +4124,20 @@ closed. It is only used internally, and is never exposed to web developers.
   sink=].
 </dl>
 
+<div algorithm>
+ The <dfn id="ws-default-controller-abort-reason" attribute
+ for="WritableStreamDefaultController">abortReason</dfn> getter steps are:
+
+ 1. Return [=this=].[=WritableStreamDefaultController/[[abortReason]]=].
+</div>
+
+<div algorithm>
+ The <dfn id="ws-default-controller-signal" attribute
+ for="WritableStreamDefaultController">signal</dfn> getter steps are:
+
+ 1. Return [=this=].[=WritableStreamDefaultController/[[signal]]=].
+</div>
+
 <div algorithm>
  The <dfn id="ws-default-controller-error" method
  for="WritableStreamDefaultController">error(|e|)</dfn> method steps are:
@@ -4252,8 +4279,19 @@ The following abstract operations operate on {{WritableStream}} instances at a h
  id="writable-stream-abort">WritableStreamAbort(|stream|, |reason|)</dfn> performs the following
  steps:
 
+ 1. If |stream|.[=WritableStream/[[state]]=] is "`closed`" or "`errored`", return
+    [=a promise resolved with=] undefined.
+ 1. Set
+    |stream|.[=WritableStream/[[controller]]=].[=WritableStreamDefaultController/[[abortReason]]=]
+    to |reason|.
+ 1. [=Signal abort=] on
+    |stream|.[=WritableStream/[[controller]]=].[=WritableStreamDefaultController/[[signal]]=].
  1. Let |state| be |stream|.[=WritableStream/[[state]]=].
  1. If |state| is "`closed`" or "`errored`", return [=a promise resolved with=] undefined.
+
+ <p class="note">We re-check the state because [=signaling abort=] runs author code and that might
+ have changed the state.
+
  1. If |stream|.[=WritableStream/[[pendingAbortRequest]]=] is not undefined, return
     |stream|.[=WritableStream/[[pendingAbortRequest]]=]'s [=pending abort request/promise=].
  1. Assert: |state| is "`writable`" or "`erroring`".
@@ -4677,6 +4715,8 @@ The following abstract operations support the implementation of the
  1. Set |controller|.[=WritableStreamDefaultController/[[stream]]=] to |stream|.
  1. Set |stream|.[=WritableStream/[[controller]]=] to |controller|.
  1. Perform ! [$ResetQueue$](|controller|).
+ 1. Set |controller|.[=WritableStreamDefaultController/[[abortReason]]=] to undefined.
+ 1. Set |controller|.[=WritableStreamDefaultController/[[signal]]=] to a new {{AbortSignal}}.
  1. Set |controller|.[=WritableStreamDefaultController/[[started]]=] to false.
  1. Set |controller|.[=WritableStreamDefaultController/[[strategySizeAlgorithm]]=] to
     |sizeAlgorithm|.

reference-implementation/lib/WritableStreamDefaultController-impl.js

@@ -5,6 +5,13 @@ const { AbortSteps, ErrorSteps } = require('./abstract-ops/internal-methods.js')
 const { ResetQueue } = require('./abstract-ops/queue-with-sizes.js');
 
 exports.implementation = class WritableStreamDefaultControllerImpl {
+  get abortReason() {
+    return this._abortReason;
+  }
+  get signal() {
+    return this._abortController.signal;
+  }
+
   error(e) {
     const state = this._stream._state;
 

reference-implementation/lib/WritableStreamDefaultController.webidl

@@ -1,4 +1,6 @@
 [Exposed=(Window,Worker,Worklet)]
 interface WritableStreamDefaultController {
+  readonly attribute any abortReason;
+  readonly attribute AbortSignal signal;
   void error(optional any e);
 };

reference-implementation/lib/abstract-ops/writable-streams.js

@@ -104,6 +104,11 @@ function IsWritableStreamLocked(stream) {
 }
 
 function WritableStreamAbort(stream, reason) {
+  if (stream._state === 'closed' || stream._state === 'errored') {
+    return promiseResolvedWith(undefined);
+  }
+  stream._controller._abortReason = reason;
+  stream._controller._abortController.abort();
   const state = stream._state;
   if (state === 'closed' || state === 'errored') {
     return promiseResolvedWith(undefined);
@@ -537,6 +542,8 @@ function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm
   controller._queueTotalSize = undefined;
   ResetQueue(controller);
 
+  controller._abortReason = undefined;
+  controller._abortController = new AbortController();
   controller._started = false;
 
   controller._strategySizeAlgorithm = sizeAlgorithm;