Unified error handling for WritableStream

third_party/WebKit/Source/core/streams/WritableStream.js

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Implementation of WritableStream for Blink.  See
 // https://streams.spec.whatwg.org/#ws. The implementation closely follows the
 // standard, except where required for performance or integration with Blink. In
 // particular, classes, methods and abstract operations are implemented in the
 // same order as in the standard, to simplify side-by-side reading.
 
@@ skipping 26 matching lines @@
   const _queue = v8.createPrivateSymbol('[[queue]]');
   const _queueTotalSize = v8.createPrivateSymbol('[[queueTotalSize]]');
   const _started = v8.createPrivateSymbol('[[started]]');
   const _strategyHWM = v8.createPrivateSymbol('[[strategyHWM]]');
   const _strategySize = v8.createPrivateSymbol('[[strategySize]]');
   const _underlyingSink = v8.createPrivateSymbol('[[underlyingSink]]');
 
   // Numeric encodings of states
   const WRITABLE = 0;
   const CLOSED = 1;
-  const ERRORED = 2;
+  const ERRORING = 2;
+  const ERRORED = 3;

[domenic, 2017/04/17 22:20:28]

I guess the tests prove me wrong, but I would have thought this would have to be
a power of 2.

[Adam Rice, 2017/04/18 02:55:45]

Only one state is active at a time. That's why they don't need to be powers of
2.

 
   // Mask to extract or assign states to _stateAndFlags
   const STATE_MASK = 0xF;
 
   const BACKPRESSURE_FLAG = 0x10;
 
   // Javascript functions. It is important to use these copies, as the ones on
   // the global object may have been overwritten. See "V8 Extras Design Doc",
   // section "Security Considerations".
   // https://docs.google.com/document/d/1AT5-T0aHGp7Lt29vPWFr2-qG8r3l9CByyvKwEuA8Ec0/edit#heading=h.9yixony1a18r
@@ skipping 141 matching lines @@
   }
 
   function WritableStreamAbort(stream, reason) {
     const state = stream[_stateAndFlags] & STATE_MASK;
     if (state === CLOSED) {
       return Promise_resolve(undefined);
     }
     if (state === ERRORED) {
       return Promise_reject(stream[_storedError]);
     }
-    TEMP_ASSERT(state === WRITABLE,
-               'state is "writable".');
     const error = new TypeError(errStreamAborting);
     if (stream[_pendingAbortRequest] !== undefined) {
       return Promise_reject(error);
     }
 
-    const controller = stream[_writableStreamController];
-    TEMP_ASSERT(controller !== undefined,
-                'controller is not undefined');
-    if (!WritableStreamHasOperationMarkedInFlight(stream) &&
-        controller[_started]) {
-      WritableStreamFinishAbort(stream);
-      return WritableStreamDefaultControllerAbortSteps(controller, reason);
+    TEMP_ASSERT(state === WRITABLE || state === ERRORING,
+                '_state_ is `"writable"` or `"erroring"`');
+
+    const wasAlreadyErroring = state === ERRORING;
+    if (wasAlreadyErroring) {
+      reason = undefined;
     }
-    const writer = stream[_writer];
-    if (writer !== undefined) {
-      WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error);
+
+    const promise = v8.createPromise();
+    stream[_pendingAbortRequest] = {promise, reason, wasAlreadyErroring};
+
+    if (!wasAlreadyErroring) {
+      WritableStreamStartErroring(stream, error);
     }
-    const promise = v8.createPromise();
-    stream[_pendingAbortRequest] = {promise, reason};
     return promise;
   }
 
-  function WritableStreamError(stream, error) {
-    stream[_stateAndFlags] = (stream[_stateAndFlags] & ~STATE_MASK) | ERRORED;
-    stream[_storedError] = error;
-    WritableStreamDefaultControllerErrorSteps(stream[_writableStreamController]);
-    if (stream[_pendingAbortRequest] === undefined) {
-      const writer = stream[_writer];
-      if (writer !== undefined) {
-        WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error);
-      }
-    }
-    if (!WritableStreamHasOperationMarkedInFlight(stream)) {
-      WritableStreamRejectPromisesInReactionToError(stream);
-    }
-  }
-
-  function WritableStreamFinishAbort(stream) {
-    const error = new TypeError(errStreamAborted);
-    WritableStreamError(stream, error);
-  }
-
   // Writable Stream Abstract Operations Used by Controllers
 
   function WritableStreamAddWriteRequest(stream) {
     TEMP_ASSERT(IsWritableStreamLocked(stream),
                 '! IsWritableStreamLocked(writer) is true.');
     TEMP_ASSERT((stream[_stateAndFlags] & STATE_MASK) === WRITABLE,
                 'stream.[[state]] is "writable".');
     const promise = v8.createPromise();
     stream[_writeRequests].push(promise);
     return promise;
   }
 
+  function WritableStreamDealWithRejection(stream, error) {
+    const state = stream[_stateAndFlags] & STATE_MASK;
+    if (state === WRITABLE) {
+      WritableStreamStartErroring(stream, error);
+      return;
+    }
+
+    TEMP_ASSERT(state === ERRORING, '_state_ is `"erroring"`');
+    WritableStreamFinishErroring(stream);
+  }
+
+  function WritableStreamStartErroring(stream, reason) {
+    TEMP_ASSERT(stream[_storedError] === undefined,
+                '_stream_.[[storedError]] is *undefined*');
+    TEMP_ASSERT((stream[_stateAndFlags] & STATE_MASK) === WRITABLE,
+                '_stream_.[[state]] is `"writable"`');
+
+    const controller = stream[_writableStreamController];
+    TEMP_ASSERT(controller !== undefined, '_controller_ is not *undefined*');
+
+    stream[_stateAndFlags] = (stream[_stateAndFlags] & ~STATE_MASK) | ERRORING;
+    stream[_storedError] = reason;
+
+    const writer = stream[_writer];
+    if (writer !== undefined) {
+      WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason);
+    }
+
+    if (!WritableStreamHasOperationMarkedInFlight(stream) &&
+        controller[_started]) {
+      WritableStreamFinishErroring(stream);
+    }
+  }
+
+  function WritableStreamFinishErroring(stream) {
+    TEMP_ASSERT((stream[_stateAndFlags] & STATE_MASK) === ERRORING,
+                '_stream_.[[state]] is `"erroring"`');
+    TEMP_ASSERT(
+        !WritableStreamHasOperationMarkedInFlight(stream),
+        '! WritableStreamHasOperationMarkedInFlight(_stream_) is *false*');
+
+    stream[_stateAndFlags] = (stream[_stateAndFlags] & ~STATE_MASK) | ERRORED;
+
+    WritableStreamDefaultControllerErrorSteps(
+        stream[_writableStreamController]);
+
+    const storedError = stream[_storedError];
+    rejectPromises(stream[_writeRequests], storedError);
+    stream[_writeRequests] = new binding.SimpleQueue();
+
+    if (stream[_pendingAbortRequest] === undefined) {
+      WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
+      return;
+    }
+
+    const abortRequest = stream[_pendingAbortRequest];
+    stream[_pendingAbortRequest] = undefined;
+
+    if (abortRequest.wasAlreadyErroring === true) {
+      v8.rejectPromise(abortRequest.promise, storedError);
+      WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
+      return;
+    }
+
+    const promise = WritableStreamDefaultControllerAbortSteps(
+        stream[_writableStreamController], abortRequest.reason);
+
+    thenPromise(
+        promise,
+        () => {
+          v8.resolvePromise(abortRequest.promise, undefined);
+          WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
+        },
+        reason => {
+          v8.rejectPromise(abortRequest.promise, reason);
+          WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
+        });
+  }
+
   function WritableStreamFinishInFlightWrite(stream) {
     TEMP_ASSERT(stream[_inFlightWriteRequest] !== undefined,
                 '_stream_.[[inFlightWriteRequest]] is not *undefined*.');
     v8.resolvePromise(stream[_inFlightWriteRequest], undefined);
     stream[_inFlightWriteRequest] = undefined;
-    const state = stream[_stateAndFlags] & STATE_MASK;
-    if (state === ERRORED) {
-      WritableStreamFinishInFlightWriteInErroredState(stream);
-      return;
-    }
-    TEMP_ASSERT(state === WRITABLE, '_state_ is `"writable"`.');
-    WritableStreamHandleAbortRequestIfPending(stream);
-  }
-
-  function WritableStreamFinishInFlightWriteInErroredState(stream) {
-    WritableStreamRejectAbortRequestIfPending(stream);
-    WritableStreamRejectPromisesInReactionToError(stream);
   }
 
   function WritableStreamFinishInFlightWriteWithError(stream, error) {
     TEMP_ASSERT(stream[_inFlightWriteRequest] !== undefined,
                 '_stream_.[[inFlightWriteRequest]] is not *undefined*.');
     v8.rejectPromise(stream[_inFlightWriteRequest], error);
     stream[_inFlightWriteRequest] = undefined;
-    const state = stream[_stateAndFlags] & STATE_MASK;
-    if (state === ERRORED) {
-      WritableStreamFinishInFlightWriteInErroredState(stream);
-      return;
-    }
-    TEMP_ASSERT(state === WRITABLE, '_state_ is `"writable"`.');
-    WritableStreamError(stream, error);
-    WritableStreamRejectAbortRequestIfPending(stream);
+
+    let state = stream[_stateAndFlags] & STATE_MASK;
+    TEMP_ASSERT(state === WRITABLE || state === ERRORING,
+                '_stream_.[[state]] is `"writable"` or `"erroring"`');
+
+    WritableStreamDealWithRejection(stream, error);
   }
 
   function WritableStreamFinishInFlightClose(stream) {
     TEMP_ASSERT(stream[_inFlightCloseRequest] !== undefined,
                 '_stream_.[[inFlightCloseRequest]] is not *undefined*.');
     v8.resolvePromise(stream[_inFlightCloseRequest], undefined);
     stream[_inFlightCloseRequest] = undefined;
+
     const state = stream[_stateAndFlags] & STATE_MASK;
-    if (state === ERRORED) {
-      WritableStreamFinishInFlightCloseInErroredState(stream);
-      return;
+    TEMP_ASSERT(state === WRITABLE || state === ERRORING,
+                '_stream_.[[state]] is `"writable"` or `"erroring"`');
+
+    if (state === ERRORING) {
+      stream[_storedError] = undefined;
+      if (stream[_pendingAbortRequest] !== undefined) {
+        v8.resolvePromise(stream[_pendingAbortRequest].promise, undefined);
+        stream[_pendingAbortRequest] = undefined;
+      }
     }
-    TEMP_ASSERT(state === WRITABLE, '_state_ is `"writable"`.');
+
     stream[_stateAndFlags] = (stream[_stateAndFlags] & ~STATE_MASK) | CLOSED;
     const writer = stream[_writer];
     if (writer !== undefined) {
       v8.resolvePromise(writer[_closedPromise], undefined);
     }
-    if (stream[_pendingAbortRequest] !== undefined) {
-      v8.resolvePromise(stream[_pendingAbortRequest].promise, undefined);
-      stream[_pendingAbortRequest] = undefined;
-    }
-  }
 
-  function WritableStreamFinishInFlightCloseInErroredState(stream) {
-    WritableStreamRejectAbortRequestIfPending(stream);
-    WritableStreamRejectClosedPromiseInReactionToError(stream);
+    TEMP_ASSERT(stream[_pendingAbortRequest] === undefined,
+                '_stream_.[[pendingAbortRequest]] is *undefined*');
+    TEMP_ASSERT(stream[_storedError] === undefined,
+                '_stream_.[[storedError]] is *undefined*');
   }
 
   function WritableStreamFinishInFlightCloseWithError(stream, error) {
     TEMP_ASSERT(stream[_inFlightCloseRequest] !== undefined,
                 '_stream_.[[inFlightCloseRequest]] is not *undefined*.');
     v8.rejectPromise(stream[_inFlightCloseRequest], error);
     stream[_inFlightCloseRequest] = undefined;
+
     const state = stream[_stateAndFlags] & STATE_MASK;
-    if (state === ERRORED) {
-      WritableStreamFinishInFlightCloseInErroredState(stream);
-      return;
+    TEMP_ASSERT(state === WRITABLE || state === ERRORING,
+                '_stream_.[[state]] is `"writable"` or `"erroring"`');
+
+    if (stream[_pendingAbortRequest] !== undefined) {
+      v8.rejectPromise(stream[_pendingAbortRequest].promise, error);
+      stream[_pendingAbortRequest] = undefined;
     }
-    TEMP_ASSERT(state === WRITABLE, '_state_ is `"writable"`.');
-    WritableStreamError(stream, error);
-    WritableStreamRejectAbortRequestIfPending(stream);
+
+    WritableStreamDealWithRejection(stream, error);
   }
 
   function WritableStreamCloseQueuedOrInFlight(stream) {
     return stream[_closeRequest] !== undefined ||
         stream[_inFlightCloseRequest] !== undefined;
   }
 
-  function WritableStreamHandleAbortRequestIfPending(stream) {
-    if (stream[_pendingAbortRequest] === undefined) {
-      return;
-    }
-    WritableStreamFinishAbort(stream);
-    const abortRequest = stream[_pendingAbortRequest];
-    stream[_pendingAbortRequest] = undefined;
-    const promise =
-        WritableStreamDefaultControllerAbortSteps(stream[_writableStreamController],
-                                                  abortRequest.reason);
-    thenPromise(promise,
-                result => v8.resolvePromise(abortRequest.promise, result),
-                reason => v8.rejectPromise(abortRequest.promise, reason));
-  }
-
   function WritableStreamHasOperationMarkedInFlight(stream) {
     return stream[_inFlightWriteRequest] !== undefined ||
         stream[_inFlightCloseRequest] !== undefined;
   }
 
   function WritableStreamMarkCloseRequestInFlight(stream) {
     TEMP_ASSERT(stream[_inFlightCloseRequest] === undefined,
                 '_stream_.[[inFlightCloseRequest]] is *undefined*.');
     TEMP_ASSERT(stream[_closeRequest] !== undefined,
                 '_stream_.[[closeRequest]] is not *undefined*.');
     stream[_inFlightCloseRequest] = stream[_closeRequest];
     stream[_closeRequest] = undefined;
   }
 
   function WritableStreamMarkFirstWriteRequestInFlight(stream) {
     TEMP_ASSERT(stream[_inFlightWriteRequest] === undefined,
                 '_stream_.[[inFlightWriteRequest]] is *undefined*.');
     TEMP_ASSERT(stream[_writeRequests].length !== 0,
                 '_stream_.[[writeRequests]] is not empty.');
     const writeRequest = stream[_writeRequests].shift();
     stream[_inFlightWriteRequest] = writeRequest;
   }
 
-  function WritableStreamRejectClosedPromiseInReactionToError(stream) {
+  function WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
+    TEMP_ASSERT((stream[_stateAndFlags] & STATE_MASK) === ERRORED,
+                '_stream_.[[state]] is `"errored"`');
+
+    if (stream[_closeRequest] !== undefined) {
+      TEMP_ASSERT(stream[_inFlightCloseRequest] === undefined,
+                  '_stream_.[[inFlightCloseRequest]] is *undefined*');
+      v8.rejectPromise(stream[_closeRequest], stream[_storedError]);
+      stream[_closeRequest] = undefined;
+    }
+
     const writer = stream[_writer];
     if (writer !== undefined) {
       v8.rejectPromise(writer[_closedPromise], stream[_storedError]);
       v8.markPromiseAsHandled(writer[_closedPromise]);
     }
   }
 
-  function WritableStreamRejectAbortRequestIfPending(stream) {
-    if (stream[_pendingAbortRequest] !== undefined) {
-      v8.rejectPromise(stream[_pendingAbortRequest].promise,
-                       stream[_storedError]);
-      stream[_pendingAbortRequest] = undefined;
-    }
-  }
-
-  function WritableStreamRejectPromisesInReactionToError(stream) {
-    const storedError = stream[_storedError];
-    rejectPromises(stream[_writeRequests], storedError);
-    stream[_writeRequests] = new binding.SimpleQueue();
-
-    if (stream[_closeRequest] !== undefined) {
-      TEMP_ASSERT(stream[_inFlightCloseRequest] === undefined,
-                  '_stream_.[[inFlightCloseRequest]] is *undefined*.');
-      v8.rejectPromise(stream[_closeRequest], storedError);
-      stream[_closeRequest] = undefined;
-    }
-
-    WritableStreamRejectClosedPromiseInReactionToError(stream);
-  }
-
   function WritableStreamUpdateBackpressure(stream, backpressure) {
     TEMP_ASSERT((stream[_stateAndFlags] & STATE_MASK) === WRITABLE,
                 'stream.[[state]] is "writable".');
     TEMP_ASSERT(!WritableStreamCloseQueuedOrInFlight(stream),
                 'WritableStreamCloseQueuedOrInFlight(_stream_) is *false*.');
     const writer = stream[_writer];
     if (writer !== undefined &&
         backpressure !== Boolean(stream[_stateAndFlags] & BACKPRESSURE_FLAG)) {
       if (backpressure) {
         writer[_readyPromise] = v8.createPromise();
@@ skipping 34 matching lines @@
     constructor(stream) {
       if (!IsWritableStream(stream)) {
         throw new TypeError(streamErrors.illegalConstructor);
       }
       if (IsWritableStreamLocked(stream)) {
         throw new TypeError(streamErrors.illegalConstructor);
       }
       this[_ownerWritableStream] = stream;
       stream[_writer] = this;
       const state = stream[_stateAndFlags] & STATE_MASK;
-      if (state === WRITABLE) {
-        if (stream[_pendingAbortRequest] !== undefined) {
-          const error = new TypeError(errStreamAborting);
-          this[_readyPromise] = Promise_reject(error);
-          v8.markPromiseAsHandled(this[_readyPromise]);
-        } else if (!WritableStreamCloseQueuedOrInFlight(stream) &&
+      switch (state) {
+        case WRITABLE:

[domenic, 2017/04/17 22:20:28]

Nit: I personally like wrapping {}s around my case blocks (and indenting);
especially with let/const, that works out quite nicely.

[Adam Rice, 2017/04/18 02:55:45]

Done. Looks better. I was concerned that this was unreadable.

+        if (!WritableStreamCloseQueuedOrInFlight(stream) &&
             stream[_stateAndFlags] & BACKPRESSURE_FLAG) {
           this[_readyPromise] = v8.createPromise();
         } else {
           this[_readyPromise] = Promise_resolve(undefined);
         }
         this[_closedPromise] = v8.createPromise();
-      } else if (state === CLOSED) {
+        break;
+
+        case ERRORING:
+        this[_readyPromise] = Promise_reject(stream[_storedError]);
+        v8.markPromiseAsHandled(this[_readyPromise]);
+        this[_closedPromise] = v8.createPromise();
+        break;
+
+        case CLOSED:
         this[_readyPromise] = Promise_resolve(undefined);
         this[_closedPromise] = Promise_resolve(undefined);
-      } else {
+        break;
+
+        default:
         TEMP_ASSERT(state === ERRORED, '_state_ is `"errored"`.');
         const storedError = stream[_storedError];
         this[_readyPromise] = Promise_reject(storedError);
         v8.markPromiseAsHandled(this[_readyPromise]);
         this[_closedPromise] = Promise_reject(storedError);
         v8.markPromiseAsHandled(this[_closedPromise]);
+        break;
       }
     }
 
     get closed() {
       if (!IsWritableStreamDefaultWriter(this)) {
         return Promise_reject(new TypeError(streamErrors.illegalInvocation));
       }
       return this[_closedPromise];
     }
 
@@ skipping 76 matching lines @@
   }
 
   function WritableStreamDefaultWriterClose(writer) {
     const stream = writer[_ownerWritableStream];
     TEMP_ASSERT(stream !== undefined, 'stream is not undefined.');
     const state = stream[_stateAndFlags] & STATE_MASK;
     if (state === CLOSED || state === ERRORED) {
       return Promise_reject(
           createCannotActionOnStateStreamError('close', state));
     }
-    if (stream[_pendingAbortRequest] !== undefined) {
-      return Promise_reject(new TypeError(errStreamAborting));
-    }
-    TEMP_ASSERT(state === WRITABLE, '_state_ is `"writable"`.');
+
+    TEMP_ASSERT(state === WRITABLE || state === ERRORING,
+                '_state_ is `"writable"` or `"erroring"`.');
     TEMP_ASSERT(!WritableStreamCloseQueuedOrInFlight(stream),
                 '! WritableStreamCloseQueuedOrInFlight(_stream_) is *false*.');
     const promise = v8.createPromise();
     stream[_closeRequest] = promise;
-    if (stream[_stateAndFlags] & BACKPRESSURE_FLAG) {
+
+    if ((stream[_stateAndFlags] & BACKPRESSURE_FLAG) &&
+        state === WRITABLE) {
       v8.resolvePromise(writer[_readyPromise], undefined);
     }
     WritableStreamDefaultControllerClose(stream[_writableStreamController]);
     return promise;
   }
 
   function WritableStreamDefaultWriterCloseWithErrorPropagation(writer) {
     const stream = writer[_ownerWritableStream];
     TEMP_ASSERT(stream !== undefined, 'stream is not undefined.');
     const state = stream[_stateAndFlags] & STATE_MASK;
     if (WritableStreamCloseQueuedOrInFlight(stream) || state === CLOSED) {
       return Promise_resolve(undefined);
     }
     if (state === ERRORED) {
       return Promise_reject(stream[_storedError]);
     }
-    TEMP_ASSERT(state === WRITABLE, 'state is "writable".');
+
+    TEMP_ASSERT(state === WRITABLE || state === ERRORING,
+                '_state_ is `"writable"` or `"erroring"`.');
+
     return WritableStreamDefaultWriterClose(writer);
   }
 
-  function WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer,
-                                                                 error) {
+  function WritableStreamDefaultWriterEnsureClosedPromiseRejected(
+      writer, error) {
+    if (v8.promiseState(writer[_closedPromise]) === v8.kPROMISE_PENDING) {
+      v8.rejectPromise(writer[_closedPromise], error);
+    } else {
+      writer[_closedPromise] = Promise_reject(error);
+    }
+    v8.markPromiseAsHandled(writer[_closedPromise]);
+  }
+
+
+  function WritableStreamDefaultWriterEnsureReadyPromiseRejected(
+      writer, error) {
     if (v8.promiseState(writer[_readyPromise]) === v8.kPROMISE_PENDING) {
       v8.rejectPromise(writer[_readyPromise], error);
     } else {
       writer[_readyPromise] = Promise_reject(error);
     }
     v8.markPromiseAsHandled(writer[_readyPromise]);
   }
 
   function WritableStreamDefaultWriterGetDesiredSize(writer) {
     const stream = writer[_ownerWritableStream];
     const state = stream[_stateAndFlags] & STATE_MASK;
-    if (state === ERRORED || stream[_pendingAbortRequest] !== undefined) {
+    if (state === ERRORED || state === ERRORING) {
       return null;
     }
     if (state === CLOSED) {
       return 0;
     }
     return WritableStreamDefaultControllerGetDesiredSize(
         stream[_writableStreamController]);
   }
 
   function WritableStreamDefaultWriterRelease(writer) {
     const stream = writer[_ownerWritableStream];
     TEMP_ASSERT(stream !== undefined,
                 'stream is not undefined.');
     TEMP_ASSERT(stream[_writer] === writer,
                 'stream.[[writer]] is writer.');
     const releasedError = new TypeError(errReleasedWriterClosedPromise);
-    const state = stream[_stateAndFlags] & STATE_MASK;
-    WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer,
-                                                          releasedError);
-    if (state === WRITABLE ||
-        WritableStreamHasOperationMarkedInFlight(stream)) {
-      v8.rejectPromise(writer[_closedPromise], releasedError);
-    } else {
-      writer[_closedPromise] = Promise_reject(releasedError);
-    }
-    v8.markPromiseAsHandled(writer[_closedPromise]);
+    WritableStreamDefaultWriterEnsureReadyPromiseRejected(
+        writer, releasedError);
+    WritableStreamDefaultWriterEnsureClosedPromiseRejected(
+        writer, releasedError);
     stream[_writer] = undefined;
     writer[_ownerWritableStream] = undefined;
   }
 
   function WritableStreamDefaultWriterWrite(writer, chunk) {
     const stream = writer[_ownerWritableStream];
     TEMP_ASSERT(stream !== undefined, 'stream is not undefined.');
     const controller = stream[_writableStreamController];
     const chunkSize =
         WritableStreamDefaultControllerGetChunkSize(controller, chunk);
     if (stream !== writer[_ownerWritableStream]) {
       return Promise_reject(createWriterLockReleasedError(verbWrittenTo));
     }
     const state = stream[_stateAndFlags] & STATE_MASK;
     if (state === ERRORED) {
       return Promise_reject(stream[_storedError]);
     }
     if (WritableStreamCloseQueuedOrInFlight(stream)) {
       return Promise_reject(new TypeError(
           templateErrorCannotActionOnStateStream('write to', 'closing')));
     }
     if (state === CLOSED) {
       return Promise_reject(
           createCannotActionOnStateStreamError('write to', CLOSED));
     }
-    if (stream[_pendingAbortRequest] !== undefined) {
-      return Promise_reject(new TypeError(errStreamAborting));
+    if (state === ERRORING) {
+      return Promise_reject(stream[_storedError]);
     }
+    TEMP_ASSERT(state === WRITABLE, '_state_ is `"writable"`');
     const promise = WritableStreamAddWriteRequest(stream);
     WritableStreamDefaultControllerWrite(controller, chunk, chunkSize);
     return promise;
   }
 
   // Functions to expose internals for ReadableStream.pipeTo. These do not
   // appear in the standard.
   function getWritableStreamDefaultWriterClosedPromise(writer) {
     TEMP_ASSERT(
         IsWritableStreamDefaultWriter(writer),
@@ skipping 29 matching lines @@
       this[_strategySize] = normalizedStrategy.size;
       this[_strategyHWM] = normalizedStrategy.highWaterMark;
       const backpressure = WritableStreamDefaultControllerGetBackpressure(this);
       WritableStreamUpdateBackpressure(stream, backpressure);
     }
 
     error(e) {
       if (!IsWritableStreamDefaultController(this)) {
         throw new TypeError(streamErrors.illegalInvocation);
       }
-      const state = this[_controlledWritableStream][_stateAndFlags] & STATE_MASK;
-      if (state === CLOSED || state === ERRORED) {
-        throw createCannotActionOnStateStreamError('error', state);
+      const state =
+          this[_controlledWritableStream][_stateAndFlags] & STATE_MASK;
+      if (state !== WRITABLE) {
+        return;
       }
       WritableStreamDefaultControllerError(this, e);
     }
   }
 
   // Writable Stream Default Controller Internal Methods
 
   // TODO(ricea): Virtual dispatch via V8 Private Symbols seems to be difficult
   // or impossible, so use static dispatch for now. This will have to be fixed
   // when adding a byte controller.
   function WritableStreamDefaultControllerAbortSteps(controller, reason) {
-    const sinkAbortPromise =
-        PromiseInvokeOrNoop(controller[_underlyingSink], 'abort', [reason]);
-    return thenPromise(sinkAbortPromise, () => undefined);
+    return PromiseInvokeOrNoop(controller[_underlyingSink], 'abort', [reason]);
   }
 
   function WritableStreamDefaultControllerErrorSteps(controller) {
     ResetQueue(controller);
   }
 
   function WritableStreamDefaultControllerStartSteps(controller) {
     const startResult =
         InvokeOrNoop(controller[_underlyingSink], 'start', [controller]);
     const stream = controller[_controlledWritableStream];
     const startPromise = Promise_resolve(startResult);
     thenPromise(
         startPromise,
         () => {
+          const state = stream[_stateAndFlags] & STATE_MASK;
+          TEMP_ASSERT(state === WRITABLE || state === ERRORING,
+                      '_stream_.[[state]] is `"writable"` or `"erroring"`');
           controller[_started] = true;
-          if ((stream[_stateAndFlags] & STATE_MASK) === ERRORED) {
-            WritableStreamRejectAbortRequestIfPending(stream);
-          } else {
-            WritableStreamHandleAbortRequestIfPending(stream);
-          }
           WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
         },
         r => {
-          TEMP_ASSERT(
-              (stream[_stateAndFlags] & STATE_MASK) === WRITABLE ||
-                  (stream[_stateAndFlags] & STATE_MASK) === ERRORED,
-              '_stream_.[[state]] is `"writable"` or `"errored"`.');
-          WritableStreamDefaultControllerErrorIfNeeded(controller, r);
-          WritableStreamRejectAbortRequestIfPending(stream);
+          const state = stream[_stateAndFlags] & STATE_MASK;
+          TEMP_ASSERT(state === WRITABLE || state === ERRORING,
+                      '_stream_.[[state]] is `"writable"` or `"erroring"`');
+          controller[_started] = true;
+          WritableStreamDealWithRejection(stream, r);
         });
   }
 
   // Writable Stream Default Controller Abstract Operations
 
   function IsWritableStreamDefaultController(x) {
     return hasOwnProperty(x, _underlyingSink);
   }
 
   function WritableStreamDefaultControllerClose(controller) {
@@ skipping 22 matching lines @@
 
   function WritableStreamDefaultControllerWrite(controller, chunk, chunkSize) {
     const writeRecord = {chunk};
     try {
       EnqueueValueWithSize(controller, writeRecord, chunkSize);
     } catch (e) {
       WritableStreamDefaultControllerErrorIfNeeded(controller, e);
       return;
     }
     const stream = controller[_controlledWritableStream];
-    if (!WritableStreamCloseQueuedOrInFlight(stream)) {
+    if (!WritableStreamCloseQueuedOrInFlight(stream) &&
+        (stream[_stateAndFlags] & STATE_MASK) === WRITABLE) {
       const backpressure =
           WritableStreamDefaultControllerGetBackpressure(controller);
       WritableStreamUpdateBackpressure(stream, backpressure);
     }
     WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
   }
 
   function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {
     const stream = controller[_controlledWritableStream];
-    const state = stream[_stateAndFlags] & STATE_MASK;
-    if (state === CLOSED || state === ERRORED) {
-      return;
-    }
     if (!controller[_started]) {
       return;
     }
     if (stream[_inFlightWriteRequest] !== undefined) {
       return;
     }
+    const state = stream[_stateAndFlags] & STATE_MASK;
+    if (state === CLOSED || state === ERRORED) {
+      return;
+    }
+    if (state === ERRORING) {
+      WritableStreamFinishErroring(stream);
+      return;
+    }
     if (controller[_queue].length === 0) {
       return;
     }
     const writeRecord = PeekQueueValue(controller);
     if (writeRecord === 'close') {
       WritableStreamDefaultControllerProcessClose(controller);
     } else {
       WritableStreamDefaultControllerProcessWrite(controller,
                                                   writeRecord.chunk);
     }
   }
 
   function WritableStreamDefaultControllerErrorIfNeeded(controller, error) {
-    const state = controller[_controlledWritableStream][_stateAndFlags] & STATE_MASK;
+    const state =
+        controller[_controlledWritableStream][_stateAndFlags] & STATE_MASK;
     if (state === WRITABLE) {
       WritableStreamDefaultControllerError(controller, error);
     }
   }
 
   function WritableStreamDefaultControllerProcessClose(controller) {
     const stream = controller[_controlledWritableStream];
     WritableStreamMarkCloseRequestInFlight(stream);
     DequeueValue(controller);
     TEMP_ASSERT(controller[_queue].length === 0,
                 'controller.[[queue]] is empty.');
-    const sinkClosePromise = PromiseInvokeOrNoop(controller[_underlyingSink],
-                                                 'close', [controller]);
+    const sinkClosePromise = PromiseInvokeOrNoop(
+        controller[_underlyingSink], 'close', []);
     thenPromise(
         sinkClosePromise,
         () => WritableStreamFinishInFlightClose(stream),
         reason => WritableStreamFinishInFlightCloseWithError(stream, reason)
         );
   }
 
   function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
     const stream = controller[_controlledWritableStream];
     WritableStreamMarkFirstWriteRequestInFlight(stream);
     const sinkWritePromise = PromiseInvokeOrNoop(controller[_underlyingSink],
                                                  'write', [chunk, controller]);
     thenPromise(
         sinkWritePromise,
         () => {
           WritableStreamFinishInFlightWrite(stream);
           const state = stream[_stateAndFlags] & STATE_MASK;
-          if (state === ERRORED) {
-            return;
-          }
-          TEMP_ASSERT(state === WRITABLE, '_state_ is `"writable"`.');
+          TEMP_ASSERT(state === WRITABLE || state === ERRORING,
+                      '_state_ is `"writable"` or `"erroring"`');
           DequeueValue(controller);
-          if (!WritableStreamCloseQueuedOrInFlight(stream)) {
+          if (!WritableStreamCloseQueuedOrInFlight(stream) &&
+              state === WRITABLE) {
             const backpressure =
                 WritableStreamDefaultControllerGetBackpressure(controller);
             WritableStreamUpdateBackpressure(stream, backpressure);
           }
           WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
         },
         reason => {
-          const wasErrored = (stream[_stateAndFlags] & STATE_MASK) === ERRORED;
           WritableStreamFinishInFlightWriteWithError(stream, reason);
-          TEMP_ASSERT((stream[_stateAndFlags] & STATE_MASK) === ERRORED,
-                      '_stream_.[[state]] is `"errored"`.');
-          if (!wasErrored) {
-            ResetQueue(controller);
-          }
         });
   }
 
   function WritableStreamDefaultControllerGetBackpressure(controller) {
     const desiredSize =
         WritableStreamDefaultControllerGetDesiredSize(controller);
     return desiredSize <= 0;
   }
 
   function WritableStreamDefaultControllerError(controller, error) {
     const stream = controller[_controlledWritableStream];
     TEMP_ASSERT((stream[_stateAndFlags] & STATE_MASK) === WRITABLE,
                 '_stream_.[[state]] is `"writable"`.');
-    WritableStreamError(stream, error);
+    WritableStreamStartErroring(stream, error);
   }
 
   // Queue-with-Sizes Operations
   //
   // TODO(ricea): Share these operations with ReadableStream.js.
   function DequeueValue(container) {
     TEMP_ASSERT(
         hasOwnProperty(container, _queue) &&
             hasOwnProperty(container, _queueTotalSize),
         'Assert: _container_ has [[queue]] and [[queueTotalSize]] internal ' +
@@ skipping 124 matching lines @@
       getWritableStreamDefaultWriterClosedPromise;
   binding.WritableStreamDefaultWriterGetDesiredSize =
       WritableStreamDefaultWriterGetDesiredSize;
   binding.getWritableStreamDefaultWriterReadyPromise =
       getWritableStreamDefaultWriterReadyPromise;
   binding.WritableStreamDefaultWriterRelease =
       WritableStreamDefaultWriterRelease;
   binding.WritableStreamDefaultWriterWrite = WritableStreamDefaultWriterWrite;
   binding.getWritableStreamStoredError = getWritableStreamStoredError;
 });