Comment out asserts in WritableStream.js

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 89 matching lines @@
   const verbClosed = 'closed';
   const verbWrittenTo = 'written to';
 
   // Utility functions (not from the standard).
   function createWriterLockReleasedError(verb) {
     return new TypeError(errWriterLockReleasedPrefix + verb);
   }
 
   const stateNames = {[CLOSED]: 'closed', [ERRORED]: 'errored'};
   function createCannotActionOnStateStreamError(action, state) {
-    TEMP_ASSERT(stateNames[state] !== undefined,
-                `name for state ${state} exists in stateNames`);
+    // assert(stateNames[state] !== undefined,
+    //        `name for state ${state} exists in stateNames`);
     return new TypeError(
         templateErrorCannotActionOnStateStream(action, stateNames[state]));
   }
 
   function rejectPromises(queue, e) {
     queue.forEach(promise => v8.rejectPromise(promise, e));
   }
 
-  // https://tc39.github.io/ecma262/#sec-ispropertykey
-  // TODO(ricea): Remove this when the asserts using it are removed.
-  function IsPropertyKey(argument) {
-    return typeof argument === 'string' || typeof argument === 'symbol';
-  }
-
-  // TODO(ricea): Remove all asserts once the implementation has stabilised.
-  function TEMP_ASSERT(predicate, message) {
-    if (predicate) {
-      return;
-    }
-    v8.log(`Assertion failed: ${message}\n`);
-    v8.logStackTrace();
-    class WritableStreamInternalError extends Error {
-      constructor(message) {
-        super(message);
-      }
-    }
-    throw new WritableStreamInternalError(message);
-  }
-
   class WritableStream {
     constructor(underlyingSink = {}, { size, highWaterMark = 1 } = {}) {
       this[_stateAndFlags] = WRITABLE;
       this[_storedError] = undefined;
       this[_writer] = undefined;
       this[_writableStreamController] = undefined;
       this[_inFlightWriteRequest] = undefined;
       this[_closeRequest] = undefined;
       this[_inFlightCloseRequest] = undefined;
       this[_pendingAbortRequest] = undefined;
@@ skipping 37 matching lines @@
 
   function AcquireWritableStreamDefaultWriter(stream) {
     return new WritableStreamDefaultWriter(stream);
   }
 
   function IsWritableStream(x) {
     return hasOwnProperty(x, _writableStreamController);
   }
 
   function IsWritableStreamLocked(stream) {
-    TEMP_ASSERT(IsWritableStream(stream),
-                '! IsWritableStream(stream) is true.');
+    // assert(IsWritableStream(stream),
+    //        '! IsWritableStream(stream) is true.');
     return stream[_writer] !== undefined;
   }
 
   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]);
     }
     const error = new TypeError(errStreamAborting);
     if (stream[_pendingAbortRequest] !== undefined) {
       return Promise_reject(error);
     }
 
-    TEMP_ASSERT(state === WRITABLE || state === ERRORING,
-                '_state_ is `"writable"` or `"erroring"`');
+    // assert(state === WRITABLE || state === ERRORING,
+    //        '_state_ is `"writable"` or `"erroring"`');
 
     const wasAlreadyErroring = state === ERRORING;
     if (wasAlreadyErroring) {
       reason = undefined;
     }
 
     const promise = v8.createPromise();
     stream[_pendingAbortRequest] = {promise, reason, wasAlreadyErroring};
 
     if (!wasAlreadyErroring) {
       WritableStreamStartErroring(stream, error);
     }
     return promise;
   }
 
   // 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".');
+    // assert(IsWritableStreamLocked(stream),
+    //        '! IsWritableStreamLocked(writer) is true.');
+    // 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"`');
+    // 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"`');
+    // assert(stream[_storedError] === undefined,
+    //        '_stream_.[[storedError]] is *undefined*');
+    // assert((stream[_stateAndFlags] & STATE_MASK) === WRITABLE,
+    //        '_stream_.[[state]] is `"writable"`');
 
     const controller = stream[_writableStreamController];
-    TEMP_ASSERT(controller !== undefined, '_controller_ is not *undefined*');
+    // 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*');
+    // assert((stream[_stateAndFlags] & STATE_MASK) === ERRORING,
+    //        '_stream_.[[state]] is `"erroring"`');
+    // assert(
+    //     !WritableStreamHasOperationMarkedInFlight(stream),
+    //     '! WritableStreamHasOperationMarkedInFlight(_stream_) is *false*');

[tyoshino (SeeGerritForStatus), 2017/04/19 07:13:32]

indent

[Adam Rice, 2017/04/20 06:30:20]

Done.

 
     stream[_stateAndFlags] = (stream[_stateAndFlags] & ~STATE_MASK) | ERRORED;
 
     WritableStreamDefaultControllerErrorSteps(
         stream[_writableStreamController]);
 
     const storedError = stream[_storedError];
     rejectPromises(stream[_writeRequests], storedError);
     stream[_writeRequests] = new binding.SimpleQueue();
 
@@ skipping 20 matching lines @@
           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*.');
+    // assert(stream[_inFlightWriteRequest] !== undefined,
+    //        '_stream_.[[inFlightWriteRequest]] is not *undefined*.');
     v8.resolvePromise(stream[_inFlightWriteRequest], undefined);
     stream[_inFlightWriteRequest] = undefined;
   }
 
   function WritableStreamFinishInFlightWriteWithError(stream, error) {
-    TEMP_ASSERT(stream[_inFlightWriteRequest] !== undefined,
-                '_stream_.[[inFlightWriteRequest]] is not *undefined*.');
+    // assert(stream[_inFlightWriteRequest] !== undefined,
+    //        '_stream_.[[inFlightWriteRequest]] is not *undefined*.');
     v8.rejectPromise(stream[_inFlightWriteRequest], error);
     stream[_inFlightWriteRequest] = undefined;
 
     let state = stream[_stateAndFlags] & STATE_MASK;
-    TEMP_ASSERT(state === WRITABLE || state === ERRORING,
-                '_stream_.[[state]] is `"writable"` or `"erroring"`');
+    // 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*.');
+    // assert(stream[_inFlightCloseRequest] !== undefined,
+    //        '_stream_.[[inFlightCloseRequest]] is not *undefined*.');
     v8.resolvePromise(stream[_inFlightCloseRequest], undefined);
     stream[_inFlightCloseRequest] = undefined;
 
     const state = stream[_stateAndFlags] & STATE_MASK;
-    TEMP_ASSERT(state === WRITABLE || state === ERRORING,
-                '_stream_.[[state]] is `"writable"` or `"erroring"`');
+    // 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;
       }
     }
 
     stream[_stateAndFlags] = (stream[_stateAndFlags] & ~STATE_MASK) | CLOSED;
     const writer = stream[_writer];
     if (writer !== undefined) {
       v8.resolvePromise(writer[_closedPromise], undefined);
     }
 
-    TEMP_ASSERT(stream[_pendingAbortRequest] === undefined,
-                '_stream_.[[pendingAbortRequest]] is *undefined*');
-    TEMP_ASSERT(stream[_storedError] === undefined,
-                '_stream_.[[storedError]] is *undefined*');
+    // assert(stream[_pendingAbortRequest] === undefined,
+    //        '_stream_.[[pendingAbortRequest]] is *undefined*');
+    // assert(stream[_storedError] === undefined,
+    //        '_stream_.[[storedError]] is *undefined*');
   }
 
   function WritableStreamFinishInFlightCloseWithError(stream, error) {
-    TEMP_ASSERT(stream[_inFlightCloseRequest] !== undefined,
-                '_stream_.[[inFlightCloseRequest]] is not *undefined*.');
+    // assert(stream[_inFlightCloseRequest] !== undefined,
+    //        '_stream_.[[inFlightCloseRequest]] is not *undefined*.');
     v8.rejectPromise(stream[_inFlightCloseRequest], error);
     stream[_inFlightCloseRequest] = undefined;
 
     const state = stream[_stateAndFlags] & STATE_MASK;
-    TEMP_ASSERT(state === WRITABLE || state === ERRORING,
-                '_stream_.[[state]] is `"writable"` or `"erroring"`');
+    // assert(state === WRITABLE || state === ERRORING,
+    //        '_stream_.[[state]] is `"writable"` or `"erroring"`');
 
     if (stream[_pendingAbortRequest] !== undefined) {
       v8.rejectPromise(stream[_pendingAbortRequest].promise, error);
       stream[_pendingAbortRequest] = undefined;
     }
 
     WritableStreamDealWithRejection(stream, error);
   }
 
   function WritableStreamCloseQueuedOrInFlight(stream) {
     return stream[_closeRequest] !== undefined ||
         stream[_inFlightCloseRequest] !== undefined;
   }
 
   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*.');
+    // assert(stream[_inFlightCloseRequest] === undefined,
+    //        '_stream_.[[inFlightCloseRequest]] is *undefined*.');
+    // 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.');
+    // assert(stream[_inFlightWriteRequest] === undefined,
+    //        '_stream_.[[inFlightWriteRequest]] is *undefined*.');
+    // assert(stream[_writeRequests].length !== 0,
+    //        '_stream_.[[writeRequests]] is not empty.');
     const writeRequest = stream[_writeRequests].shift();
     stream[_inFlightWriteRequest] = writeRequest;
   }
 
   function WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
-    TEMP_ASSERT((stream[_stateAndFlags] & STATE_MASK) === ERRORED,
-                '_stream_.[[state]] is `"errored"`');
+    // assert((stream[_stateAndFlags] & STATE_MASK) === ERRORED,
+    //        '_stream_.[[state]] is `"errored"`');
 
     if (stream[_closeRequest] !== undefined) {
-      TEMP_ASSERT(stream[_inFlightCloseRequest] === undefined,
-                  '_stream_.[[inFlightCloseRequest]] is *undefined*');
+      // 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 WritableStreamUpdateBackpressure(stream, backpressure) {
-    TEMP_ASSERT((stream[_stateAndFlags] & STATE_MASK) === WRITABLE,
-                'stream.[[state]] is "writable".');
-    TEMP_ASSERT(!WritableStreamCloseQueuedOrInFlight(stream),
-                'WritableStreamCloseQueuedOrInFlight(_stream_) is *false*.');
+    // assert((stream[_stateAndFlags] & STATE_MASK) === WRITABLE,
+    //        'stream.[[state]] is "writable".');
+    // 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();
       } else {
-        TEMP_ASSERT(!backpressure, '_backpressure_ is *false*.');
+        // assert(!backpressure, '_backpressure_ is *false*.');
         v8.resolvePromise(writer[_readyPromise], undefined);
       }
     }
     if (backpressure) {
       stream[_stateAndFlags] |= BACKPRESSURE_FLAG;
     } else {
       stream[_stateAndFlags] &= ~BACKPRESSURE_FLAG;
     }
   }
 
   // Functions to expose internals for ReadableStream.pipeTo. These are not
   // part of the standard.
   function isWritableStreamErrored(stream) {
-    TEMP_ASSERT(
-        IsWritableStream(stream), '! IsWritableStream(stream) is true.');
+    // assert(
+    //     IsWritableStream(stream), '! IsWritableStream(stream) is true.');
     return (stream[_stateAndFlags] & STATE_MASK) === ERRORED;
   }
 
   function isWritableStreamClosingOrClosed(stream) {
-    TEMP_ASSERT(
-        IsWritableStream(stream), '! IsWritableStream(stream) is true.');
+    // assert(
+    //     IsWritableStream(stream), '! IsWritableStream(stream) is true.');
     return WritableStreamCloseQueuedOrInFlight(stream) ||
         (stream[_stateAndFlags] & STATE_MASK) === CLOSED;
   }
 
   function getWritableStreamStoredError(stream) {
-    TEMP_ASSERT(
-        IsWritableStream(stream), '! IsWritableStream(stream) is true.');
+    // assert(
+    //     IsWritableStream(stream), '! IsWritableStream(stream) is true.');
     return stream[_storedError];
   }
 
   class WritableStreamDefaultWriter {
     constructor(stream) {
       if (!IsWritableStream(stream)) {
         throw new TypeError(streamErrors.illegalConstructor);
       }
       if (IsWritableStreamLocked(stream)) {
         throw new TypeError(streamErrors.illegalConstructor);
@@ skipping 24 matching lines @@
 
         case CLOSED:
         {
           this[_readyPromise] = Promise_resolve(undefined);
           this[_closedPromise] = Promise_resolve(undefined);
           break;
         }
 
         default:
         {
-          TEMP_ASSERT(state === ERRORED, '_state_ is `"errored"`.');
+          // 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;
         }
       }
     }
 
@@ skipping 46 matching lines @@
     }
 
     releaseLock() {
       if (!IsWritableStreamDefaultWriter(this)) {
         throw new TypeError(streamErrors.illegalInvocation);
       }
       const stream = this[_ownerWritableStream];
       if (stream === undefined) {
         return;
       }
-      TEMP_ASSERT(stream[_writer] !== undefined,
-                  'stream.[[writer]] is not undefined.');
+      // assert(stream[_writer] !== undefined,
+      //        'stream.[[writer]] is not undefined.');
       WritableStreamDefaultWriterRelease(this);
     }
 
     write(chunk) {
       if (!IsWritableStreamDefaultWriter(this)) {
         return Promise_reject(new TypeError(streamErrors.illegalInvocation));
       }
       if (this[_ownerWritableStream] === undefined) {
         return Promise_reject(createWriterLockReleasedError(verbWrittenTo));
       }
       return WritableStreamDefaultWriterWrite(this, chunk);
     }
   }
 
   // Writable Stream Writer Abstract Operations
 
   function IsWritableStreamDefaultWriter(x) {
     return hasOwnProperty(x, _ownerWritableStream);
   }
 
   function WritableStreamDefaultWriterAbort(writer, reason) {
     const stream = writer[_ownerWritableStream];
-    TEMP_ASSERT(stream !== undefined,
-                'stream is not undefined.');
+    // assert(stream !== undefined,
+    //        'stream is not undefined.');
     return WritableStreamAbort(stream, reason);
   }
 
   function WritableStreamDefaultWriterClose(writer) {
     const stream = writer[_ownerWritableStream];
-    TEMP_ASSERT(stream !== undefined, 'stream is not undefined.');
+    // assert(stream !== undefined, 'stream is not undefined.');
     const state = stream[_stateAndFlags] & STATE_MASK;
     if (state === CLOSED || state === ERRORED) {
       return Promise_reject(
           createCannotActionOnStateStreamError('close', state));
     }
 
-    TEMP_ASSERT(state === WRITABLE || state === ERRORING,
-                '_state_ is `"writable"` or `"erroring"`.');
-    TEMP_ASSERT(!WritableStreamCloseQueuedOrInFlight(stream),
-                '! WritableStreamCloseQueuedOrInFlight(_stream_) is *false*.');
+    // assert(state === WRITABLE || state === ERRORING,
+    //        '_state_ is `"writable"` or `"erroring"`.');
+    // assert(!WritableStreamCloseQueuedOrInFlight(stream),
+    //        '! WritableStreamCloseQueuedOrInFlight(_stream_) is *false*.');
     const promise = v8.createPromise();
     stream[_closeRequest] = promise;
 
     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.');
+    // 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 === ERRORING,
-                '_state_ is `"writable"` or `"erroring"`.');
+    // assert(state === WRITABLE || state === ERRORING,
+    //        '_state_ is `"writable"` or `"erroring"`.');
 
     return WritableStreamDefaultWriterClose(writer);
   }
 
   function WritableStreamDefaultWriterEnsureClosedPromiseRejected(
       writer, error) {
     if (v8.promiseState(writer[_closedPromise]) === v8.kPROMISE_PENDING) {
       v8.rejectPromise(writer[_closedPromise], error);
     } else {
       writer[_closedPromise] = Promise_reject(error);
@@ skipping 20 matching lines @@
     }
     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.');
+    // assert(stream !== undefined,
+    //        'stream is not undefined.');
+    // assert(stream[_writer] === writer,
+    //        'stream.[[writer]] is writer.');
     const releasedError = new TypeError(errReleasedWriterClosedPromise);
     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.');
+    // 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 (state === ERRORING) {
       return Promise_reject(stream[_storedError]);
     }
-    TEMP_ASSERT(state === WRITABLE, '_state_ is `"writable"`');
+    // 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),
-        'writer is a WritableStreamDefaultWriter.');
+    // assert(
+    //     IsWritableStreamDefaultWriter(writer),
+    //     'writer is a WritableStreamDefaultWriter.');
     return writer[_closedPromise];
   }
 
   function getWritableStreamDefaultWriterReadyPromise(writer) {
-    TEMP_ASSERT(
-        IsWritableStreamDefaultWriter(writer),
-        'writer is a WritableStreamDefaultWriter.');
+    // assert(
+    //     IsWritableStreamDefaultWriter(writer),
+    //     'writer is a WritableStreamDefaultWriter.');
     return writer[_readyPromise];
   }
 
   class WritableStreamDefaultController {
     constructor(stream, underlyingSink, size, highWaterMark) {
       if (!IsWritableStream(stream)) {
         throw new TypeError(streamErrors.illegalConstructor);
       }
       if (stream[_writableStreamController] !== undefined) {
         throw new TypeError(streamErrors.illegalConstructor);
@@ skipping 42 matching lines @@
 
   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"`');
+          // assert(state === WRITABLE || state === ERRORING,
+          //        '_stream_.[[state]] is `"writable"` or `"erroring"`');
           controller[_started] = true;
           WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
         },
         r => {
           const state = stream[_stateAndFlags] & STATE_MASK;
-          TEMP_ASSERT(state === WRITABLE || state === ERRORING,
-                      '_stream_.[[state]] is `"writable"` or `"erroring"`');
+          // 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);
   }
@@ skipping 73 matching lines @@
         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.');
+    // assert(controller[_queue].length === 0,
+    //        'controller.[[queue]] is empty.');
     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;
-          TEMP_ASSERT(state === WRITABLE || state === ERRORING,
-                      '_state_ is `"writable"` or `"erroring"`');
+          // assert(state === WRITABLE || state === ERRORING,
+          //        '_state_ is `"writable"` or `"erroring"`');
           DequeueValue(controller);
           if (!WritableStreamCloseQueuedOrInFlight(stream) &&
               state === WRITABLE) {
             const backpressure =
                 WritableStreamDefaultControllerGetBackpressure(controller);
             WritableStreamUpdateBackpressure(stream, backpressure);
           }
           WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
         },
         reason => {
           WritableStreamFinishInFlightWriteWithError(stream, reason);
         });
   }
 
   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"`.');
+    // assert((stream[_stateAndFlags] & STATE_MASK) === WRITABLE,
+    //        '_stream_.[[state]] is `"writable"`.');
     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 ' +
-            'slots.');
-    TEMP_ASSERT(container[_queue].length !== 0,
-                '_container_.[[queue]] is not empty.');
+    // assert(
+    //     hasOwnProperty(container, _queue) &&
+    //         hasOwnProperty(container, _queueTotalSize),
+    //     'Assert: _container_ has [[queue]] and [[queueTotalSize]] internal ' +
+    //         'slots.');
+    // assert(container[_queue].length !== 0,
+    //        '_container_.[[queue]] is not empty.');
     const pair = container[_queue].shift();
     container[_queueTotalSize] -= pair.size;
     if (container[_queueTotalSize] < 0) {
       container[_queueTotalSize] = 0;
     }
     return pair.value;
   }
 
   function EnqueueValueWithSize(container, value, size) {
-    TEMP_ASSERT(
-        hasOwnProperty(container, _queue) &&
-            hasOwnProperty(container, _queueTotalSize),
-        'Assert: _container_ has [[queue]] and [[queueTotalSize]] internal ' +
-            'slots.');
+    // assert(
+    //     hasOwnProperty(container, _queue) &&
+    //         hasOwnProperty(container, _queueTotalSize),
+    //     'Assert: _container_ has [[queue]] and [[queueTotalSize]] internal ' +
+    //         'slots.');
     size = Number(size);
     if (!IsFiniteNonNegativeNumber(size)) {
       throw new RangeError(streamErrors.invalidSize);
     }
 
     container[_queue].push({value, size});
     container[_queueTotalSize] += size;
   }
 
   function PeekQueueValue(container) {
-    TEMP_ASSERT(
-        hasOwnProperty(container, _queue) &&
-            hasOwnProperty(container, _queueTotalSize),
-        'Assert: _container_ has [[queue]] and [[queueTotalSize]] internal ' +
-            'slots.');
-    TEMP_ASSERT(container[_queue].length !== 0,
-                '_container_.[[queue]] is not empty.');
+    // assert(
+    //     hasOwnProperty(container, _queue) &&
+    //         hasOwnProperty(container, _queueTotalSize),
+    //     'Assert: _container_ has [[queue]] and [[queueTotalSize]] internal ' +
+    //         'slots.');
+    // assert(container[_queue].length !== 0,
+    //        '_container_.[[queue]] is not empty.');
     const pair = container[_queue].peek();
     return pair.value;
   }
 
   function ResetQueue(container) {
-    TEMP_ASSERT(
-        hasOwnProperty(container, _queue) &&
-            hasOwnProperty(container, _queueTotalSize),
-        'Assert: _container_ has [[queue]] and [[queueTotalSize]] internal ' +
-            'slots.');
+    // assert(
+    //     hasOwnProperty(container, _queue) &&
+    //         hasOwnProperty(container, _queueTotalSize),
+    //     'Assert: _container_ has [[queue]] and [[queueTotalSize]] internal ' +
+    //         'slots.');
     container[_queue] = new binding.SimpleQueue();
     container[_queueTotalSize] = 0;
   }
 
   // Miscellaneous Operations
 
   // This differs from "CallOrNoop" in the ReadableStream implementation in
   // that it takes the arguments as an array, so that multiple arguments can be
   // passed.
   //
   // TODO(ricea): Consolidate with ReadableStream implementation.
   function InvokeOrNoop(O, P, args) {
-    TEMP_ASSERT(IsPropertyKey(P),
-                'P is a valid property key.');
+    // assert(IsPropertyKey(P),
+    //        'P is a valid property key.');
     if (args === undefined) {
       args = [];
     }
     const method = O[P];
     if (method === undefined) {
       return undefined;
     }
     if (typeof method !== 'function') {
       throw new TypeError(templateErrorIsNotAFunction(P));
     }
@@ skipping 56 matching lines @@
       getWritableStreamDefaultWriterClosedPromise;
   binding.WritableStreamDefaultWriterGetDesiredSize =
       WritableStreamDefaultWriterGetDesiredSize;
   binding.getWritableStreamDefaultWriterReadyPromise =
       getWritableStreamDefaultWriterReadyPromise;
   binding.WritableStreamDefaultWriterRelease =
       WritableStreamDefaultWriterRelease;
   binding.WritableStreamDefaultWriterWrite = WritableStreamDefaultWriterWrite;
   binding.getWritableStreamStoredError = getWritableStreamStoredError;
 });