Implementation of 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 performanc or integration with Blink. In

[tyoshino (SeeGerritForStatus), 2016/11/01 05:54:09]

typo: performance

[Adam Rice, 2016/11/02 11:54:42]

Done.

+// particular, classes, methods and abstract operations are implemented in the
+// same order as in the standard, to simplify side-by-side reading.
+
+(function(global, binding, v8) {
+  'use strict';
+
+  // Private symbols. These correspond to the internal slots in the standard.
+  // "[[X]]" in the standard is spelt _X in this implementation.
+  const _state = v8.createPrivateSymbol('[[state]]');
+  const _storedError = v8.createPrivateSymbol('[[storedError]]');
+  const _writer = v8.createPrivateSymbol('[[writer]]');
+  const _writableStreamController =
+      v8.createPrivateSymbol('[[writableStreamController]]');
+  const _writeRequests = v8.createPrivateSymbol('[[writeRequests]]');
+  const _closedPromise = v8.createPrivateSymbol('[[closedPromise]]');
+  const _ownerWritableStream =
+      v8.createPrivateSymbol('[[ownerWritableStream]]');
+  const _readyPromise = v8.createPrivateSymbol('[[readyPromise]]');
+  const _controlledWritableStream =
+      v8.createPrivateSymbol('[[controlledWritableStream]]');
+  const _queue = v8.createPrivateSymbol('[[queue]]');
+  const _queueSize = v8.createPrivateSymbol('[[queueSize]]');
+  const _started = v8.createPrivateSymbol('[[started]]');
+  const _strategyHWM = v8.createPrivateSymbol('[[strategyHWM]]');
+  const _strategySize = v8.createPrivateSymbol('[[strategySize]]');
+  const _underlyingSink = v8.createPrivateSymbol('[[underlyingSink]]');
+  const _writing = v8.createPrivateSymbol('[[writing]]');
+
+  // _defaultControllerFlags combines WritableStreamDefaultController's internal
+  // slots [[started]] and [[writing]] into a single bitmask for efficiency.
+  const _defaultControllerFlags =
+      v8.createPrivateSymbol('[[defaultControllerFlags]]');
+  const FLAG_STARTED = 0b1;
+  const FLAG_WRITING = 0b10;
+
+  // For efficiency, WritableStream [[state]] contains numeric values.
+  const WRITABLE = 0;
+  const CLOSING = 1;
+  const CLOSED = 2;
+  const ERRORED = 3;
+
+  // 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
+  const undefined = global.undefined;
+
+  const defineProperty = global.Object.defineProperty;
+  const hasOwnProperty = v8.uncurryThis(global.Object.hasOwnProperty);
+
+  const Function_call = v8.uncurryThis(global.Function.prototype.call);
+  const Function_apply = v8.uncurryThis(global.Function.prototype.apply);
+
+  const TypeError = global.TypeError;
+  const RangeError = global.RangeError;
+
+  const Boolean = global.Boolean;
+  const Number = global.Number;
+  const Number_isNaN = Number.isNaN;
+  const Number_isFinite = Number.isFinite;
+
+  const Promise = global.Promise;
+  const thenPromise = v8.uncurryThis(Promise.prototype.then);
+  const Promise_resolve = v8.simpleBind(Promise.resolve, Promise);
+  const Promise_reject = v8.simpleBind(Promise.reject, Promise);
+
+  // User-visible strings. Many of these should be shared with ReadableStream.
+  const errIllegalInvocation = 'Illegal invocation';
+  const errIllegalConstructor = 'Illegal constructor';
+  const errInvalidType = 'Invalid type is specified';
+  const errAbortLockedStream =  'Cannot abort a writable stream that is locked to a writer';
+  const errStreamAborted = 'The stream has been aborted';
+  const errDesiredSizeReleasedLock = 'Attempt to read desiredSize after releaseLock';

[tyoshino (SeeGerritForStatus), 2016/11/01 07:43:40]

unused?

[Adam Rice, 2016/11/02 11:54:42]

Sorry, yes. I changed the code to use errWriterLockReleasedPrefix instead but
forgot to remove it.

+  const errWriterLockReleasedPrefix = 'This writable stream writer has been released and cannot be ';
+  const errCloseCloseRequestedStream =
+      'Cannot close a readable stream that has already been requested to be closed';
+  const errWriteCloseRequestedStream =
+      'Cannot write to a readable stream that has already been requested to be closed';
+  const errClosing =

[tyoshino (SeeGerritForStatus), 2016/11/01 07:43:40]

unused?

[Adam Rice, 2016/11/02 11:54:42]

Sorry. Same thing as with errDesiredSizeReleasedLock above.

+      'Cannot release the lock on a closing stream';
+  const templateCannotActionOnStateStream =

[tyoshino (SeeGerritForStatus), 2016/11/01 07:43:40]

errTemplate... or templateError...?

[Adam Rice, 2016/11/02 11:54:41]

I went with templateError.

+      (action, state) => "`Cannot ${action} a ${state} writable stream`";
+  const errReleasedWriterClosedPromise =
+      'This writable stream writer has been released and cannot be used to monitor the stream\'s state';
+  const templateIsNotAFunction = f => "`${f} is not a function`";
+  const errSizeNotAFunction =
+      'A queuing strategy\'s size property must be a function';
+  const errInvalidHWM =
+      'A queueing strategy\'s highWaterMark property must be a nonnegative, non-NaN number';

[tyoshino (SeeGerritForStatus), 2016/11/01 07:43:40]

how about non-negative? if nonnegative would be better for you as native, it's
ok. then, use either of them everywhere

[tyoshino (SeeGerritForStatus), 2016/11/01 07:43:41]

use either of queueing or queuing everywhere?

[Adam Rice, 2016/11/02 11:54:42]

The Streams Standard doesn't agree on this either. I filed an issue
https://github.com/whatwg/streams/issues/585 and chose "non-negative" for this
file.

[Adam Rice, 2016/11/02 11:54:42]

It seems the standard spelling changed while I wasn't looking 😢 
http://english.stackexchange.com/questions/60852/queueing-or-queuing

Changed to queuing.

[tyoshino (SeeGerritForStatus), 2016/11/04 06:04:18]

Thanks for filing that!

+  const errInvalidSize =
+      'The return value of a queuing strategy\'s size function must be a finite, non-NaN, non-negative number';
+
+  // These verbs are used after errWriterLockReleasedPrefix
+  const verbUsedToGetTheDesiredSize = 'used to get the desiredSize';
+  const verbAborted = 'aborted';
+  const verbClosed = 'closed';
+  const verbReleasedAgain = 'released again';
+  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) {
+    return new TypeError(templateCannotActionOnStateStream(action,

[tyoshino (SeeGerritForStatus), 2016/11/01 07:43:40]

assert that we have an entry for state in stateNames?

[Adam Rice, 2016/11/02 11:54:42]

Done.

+                                                           stateNames[state]));
+  }
+
+  function getDefaultControllerStartedFlag(controller) {
+    return Boolean(controller[_defaultControllerFlags] & FLAG_STARTED);
+  }
+
+  function setDefaultControllerFlag(controller, flag, value) {

[tyoshino (SeeGerritForStatus), 2016/11/01 07:43:40]

move this to above getDefaultControllerStartedFlag

[Adam Rice, 2016/11/02 11:54:42]

Done.

+    let flags = controller[_defaultControllerFlags];
+    flags = (flags & ~flag) | (value ? flag : 0);

[tyoshino (SeeGerritForStatus), 2016/11/01 07:43:41]

how about this?

if (value) {
  flags = flags | flag;
} else {
  flags = flags & ~flag;
}

[Adam Rice, 2016/11/02 11:54:42]

Done, thanks.

+    controller[_defaultControllerFlags] = flags;
+  }
+
+  function setDefaultControllerStartedFlag(controller, value) {
+    setDefaultControllerFlag(controller, FLAG_STARTED, value);
+  }
+
+  function getDefaultControllerWritingFlag(controller) {
+    return Boolean(controller[_defaultControllerFlags] & FLAG_WRITING);
+  }
+
+  function setDefaultControllerWritingFlag(controller, value) {
+    setDefaultControllerFlag(controller, FLAG_WRITING, value);
+  }
+
+  function rejectPromises(array, e) {
+    // array is an InternalPackedArray so forEach won't work.
+    for (let i = 0; i < array.length; ++i) {
+      v8.rejectPromise(array[i], e);
+    }
+  }
+
+  // https://tc39.github.io/ecma262/#sec-ispropertykey
+  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) {

[tyoshino (SeeGerritForStatus), 2016/11/01 07:43:40]

early return when predicate is true?

[Adam Rice, 2016/11/02 11:54:42]

Done.

+      v8.log(`Assertion failed: ${message}\n`);
+      v8.logStackTrace();
+      class WritableStreamInternalError {
+      }
+      throw new WritableStreamInternalError();
+    }
+  }
+
+  function TEMP_LOG(message) {

[tyoshino (SeeGerritForStatus), 2016/11/01 07:43:40]

unused?

[Adam Rice, 2016/11/02 11:54:42]

Removed.

+    v8.log(message + '\n');
+  }
+
+  class WritableStream {
+    constructor(underlyingSink = {}, { size, highWaterMark = 1 } = {}) {
+      this[_state] = WRITABLE;
+      this[_storedError] = undefined;
+      this[_writer] = undefined;
+      this[_writableStreamController] = undefined;
+      this[_writeRequests] = new v8.InternalPackedArray();
+      let type = underlyingSink.type;

[tyoshino (SeeGerritForStatus), 2016/11/01 05:54:09]

use const where possible though "let" is the same as the spec wording.

[Adam Rice, 2016/11/02 11:54:42]

Sorry. I had a todo to change all the "let"s to "const" once it was working, and
then I forgot to do it.

[tyoshino (SeeGerritForStatus), 2016/11/04 06:04:19]

ok. no problem. thanks!

+      if (type !== undefined) {
+        throw new RangeError(errInvalidType);
+      }
+      this[_writableStreamController] =
+          new WritableStreamDefaultController(this, underlyingSink, size,
+                                              highWaterMark);
+    }
+
+    get locked() {
+      if (!IsWritableStream(this)) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      return IsWritableStreamLocked(this);
+    }
+
+    abort(reason) {
+      if (!IsWritableStream(this)) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      if (IsWritableStreamLocked(this)) {
+        return Promise_reject(new TypeError(errAbortLockedStream));
+      }
+      return WritableStreamAbort(this, reason);
+    }

[tyoshino (SeeGerritForStatus), 2016/11/01 05:54:09]

blank line

[Adam Rice, 2016/11/02 11:54:42]

Done.

+    getWriter() {
+      if (!IsWritableStream(this)) {
+         throw new TypeError(errIllegalInvocation);
+      }
+      return AcquireWritableStreamDefaultWriter(this);
+    }
+  }
+
+  // General Writable Stream Abstract Operations

[tyoshino (SeeGerritForStatus), 2016/11/01 05:54:09]

blank line

[Adam Rice, 2016/11/02 11:54:42]

Done.

+  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.');
+    return stream[_writer] !== undefined;
+  }
+
+  function WritableStreamAbort(stream, reason) {
+    let state = stream[_state];
+    if (state === CLOSED) {
+      return Promise_resolve(undefined);
+    }
+    if (state === ERRORED) {
+      return Promise_reject(stream[_storedError]);
+    }
+    TEMP_ASSERT(state === WRITABLE || state === CLOSING,
+               'state is "writable" or "closing".');
+    let error = new TypeError(errStreamAborted);
+    WritableStreamError(stream, error);
+    return WritableStreamDefaultControllerAbort(
+        stream[_writableStreamController], reason);
+  }
+
+  // Writable Stream Abstract Operations Used by Controllers
+
+  function WritableStreamAddWriteRequest(stream) {
+    TEMP_ASSERT(IsWritableStreamLocked(stream),
+                '! IsWritableStreamLocked(writer) is true.');
+    TEMP_ASSERT(stream[_state] === WRITABLE,
+                'stream.[[state]] is "writable".');
+    let promise = v8.createPromise();
+    stream[_writeRequests].push(promise);
+    return promise;
+  }
+
+  function WritableStreamError(stream, e) {
+    let state = stream[_state];
+    TEMP_ASSERT(state === WRITABLE || state === CLOSING,
+                'state is "writable" or "closing".');
+    rejectPromises(stream[_writeRequests], e);
+    stream[_writeRequests] = new v8.InternalPackedArray();
+    let writer = stream[_writer];
+    if (writer !== undefined) {
+      v8.rejectPromise(writer[_closedPromise], e);
+      if (state === WRITABLE &&
+          WritableStreamDefaultControllerGetBackpressure(
+              stream[_writableStreamController])) {
+        v8.rejectPromise(writer[_readyPromise], e);
+      } else {
+        writer[_readyPromise] = Promise_reject(e);
+      }
+    }
+    stream[_state] = ERRORED;
+    stream[_storedError] = e;
+  }
+
+  function WritableStreamFinishClose(stream) {
+    TEMP_ASSERT(stream[_state] === CLOSING,
+                'stream.[[state]] is "closing".');
+    TEMP_ASSERT(stream[_writer] !== undefined,
+                'stream.[[writer]] is not undefined.');
+    stream[_state] = CLOSED;
+    v8.resolvePromise(stream[_writer][_closedPromise], undefined);
+  }
+
+  function WritableStreamFulfillWriteRequest(stream) {
+    TEMP_ASSERT(stream[_writeRequests].length !== 0,
+               'stream.[[writeRequests]] is not empty.');
+    let writeRequest = stream[_writeRequests].shift();
+    v8.resolvePromise(writeRequest, undefined);
+  }
+
+  function WritableStreamUpdateBackpressure(stream, backpressure) {
+    TEMP_ASSERT(stream[_state] === WRITABLE,
+                'stream.[[state]] is "writable".');
+    let writer = stream[_writer];
+    if (writer === undefined) {
+      return;
+    }
+    if (backpressure) {
+      writer[_readyPromise] = v8.createPromise();
+    } else {
+      TEMP_ASSERT(backpressure === false,
+                  'backpressure is false.');
+      v8.resolvePromise(writer[_readyPromise], undefined);
+    }
+  }
+
+  class WritableStreamDefaultWriter {
+    constructor(stream) {
+      if (!IsWritableStream(stream)) {
+        throw TypeError(errInvalidType);

[tyoshino (SeeGerritForStatus), 2016/11/01 05:54:09]

For now, this should be errIllegalConstructor? errorInvalidType is for the type
argument.

That said, I find that errIllegalConstructor's message is not clear about what's
wrong. We should improve it separately.

[Adam Rice, 2016/11/02 11:54:42]

Fixed. I agree the clarity of the error could be improved.

+      }
+      if (IsWritableStreamLocked(stream)) {
+        throw TypeError(errIllegalConstructor);
+      }
+      this[_ownerWritableStream] = stream;
+      stream[_writer] = this;
+      let state = stream[_state];
+      if (state === WRITABLE || state === CLOSING) {
+        this[_closedPromise] = v8.createPromise();
+      } else if (state === CLOSED) {
+        this[_closedPromise] = Promise_resolve(undefined);
+      } else {
+        TEMP_ASSERT(state === ERRORED,
+                    'state is "errored".');
+        this[_closedPromise] = Promise_reject(stream[_storedError]);
+      }
+      if (state === WRITABLE &&
+          WritableStreamDefaultControllerGetBackpressure(
+              stream[_writableStreamController])) {
+        this[_readyPromise] = v8.createPromise();
+      } else {
+        this[_readyPromise] = Promise_resolve(undefined);
+      }
+    }
+
+    get closed() {
+      if (!IsWritableStreamDefaultWriter(this)) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      return this[_closedPromise];
+    }
+
+    get desiredSize() {
+      if (!IsWritableStreamDefaultWriter(this)) {
+        throw TypeError(errIllegalInvocation);
+      }
+      if (this[_ownerWritableStream] === undefined) {
+        throw createWriterLockReleasedError(verbUsedToGetTheDesiredSize);
+      }
+      return WritableStreamDefaultWriterGetDesiredSize(this);
+    }
+
+    get ready() {
+      if (!IsWritableStreamDefaultWriter(this)) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      return this[_readyPromise];
+    }
+
+    abort(reason) {
+     if (!IsWritableStreamDefaultWriter(this)) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      if (this[_ownerWritableStream] === undefined) {
+        return Promise_reject(createWriterLockReleasedError(verbAborted));
+      }
+      return WritableStreamDefaultWriterAbort(this, reason);
+    }
+
+    close() {
+      if (!IsWritableStreamDefaultWriter(this)) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      let stream = this[_ownerWritableStream];
+      if (stream === undefined) {
+        return Promise_reject(createWriterLockReleasedError(verbClosed));
+      }
+      if (stream[_state] === CLOSING) {
+        return Promise_reject(new TypeError(errCloseCloseRequestedStream));
+      }
+      return WritableStreamDefaultWriterClose(this);
+    }
+
+    releaseLock() {
+      if (!IsWritableStreamDefaultWriter(this)) {
+        return Promise_reject(TypeError(errIllegalInvocation));

[tyoshino (SeeGerritForStatus), 2016/11/01 07:43:40]

just throw

[Adam Rice, 2016/11/02 11:54:42]

Fixed. I seem to have done a particular poor job translating this function from
English. I have double-checked it and it looks okay now.

I think this will be covered once I've ported the brand-checks to w-p-t, so
there's not a serious testing gap here.

[tyoshino (SeeGerritForStatus), 2016/11/04 06:04:19]

ok!

+      }
+      let stream = this[_ownerWritableStream];
+      if (stream === undefined) {
+        return Promise_reject(createWriterLockReleasedError(verbReleasedAgain));

[tyoshino (SeeGerritForStatus), 2016/11/01 07:43:40]

return undefined. i.e. no-op

[Adam Rice, 2016/11/02 11:54:42]

Done. I'm adding a test for this upstream.

[tyoshino (SeeGerritForStatus), 2016/11/04 06:04:19]

Great!

+      }
+      TEMP_ASSERT(stream[_writer] !== undefined,
+                  'stream.[[writer]] is not undefined.');
+      return WritableStreamDefaultWriterRelease(this);
+    }
+
+    write(chunk) {
+      if (!IsWritableStreamDefaultWriter(this)) {
+        return Promise_reject(TypeError(errIllegalInvocation));

[tyoshino (SeeGerritForStatus), 2016/11/01 07:43:40]

new TypeError

[Adam Rice, 2016/11/02 11:54:42]

Done.

+      }
+      let stream = this[_ownerWritableStream];
+      if (stream === undefined) {
+        return Promise_reject(createWriterLockReleasedError(verbWrittenTo));
+      }
+      if (stream[_state] === CLOSING) {
+        return Promise_reject(new TypeError(errWriteCloseRequestedStream));
+      }
+      return WritableStreamDefaultWriterWrite(this, chunk);
+    }
+  }
+
+  // Writable Stream Writer Abstract Operations
+
+  function IsWritableStreamDefaultWriter(x) {
+    return hasOwnProperty(x, _ownerWritableStream);
+  }
+
+  function WritableStreamDefaultWriterAbort(writer, reason) {
+    let stream = writer[_ownerWritableStream];
+    TEMP_ASSERT(stream !== undefined,
+                'stream is not undefined.');
+    return WritableStreamAbort(stream, reason);
+  }
+
+  function WritableStreamDefaultWriterClose(writer) {
+    let stream = writer[_ownerWritableStream];
+    TEMP_ASSERT(stream !== undefined,
+                'stream is not undefined.');
+    let state = stream[_state];
+    if (state === CLOSED || state === ERRORED) {
+      return Promise_reject(
+          createCannotActionOnStateStreamError('close', state));
+    }
+    TEMP_ASSERT(state === WRITABLE,
+                'state is "writable".');
+    let promise = WritableStreamAddWriteRequest(stream);
+    if (WritableStreamDefaultControllerGetBackpressure(
+        stream[_writableStreamController])) {
+      v8.resolvePromise(writer[_readyPromise], undefined);
+    }
+    stream[_state] = CLOSING;
+    WritableStreamDefaultControllerClose(stream[_writableStreamController]);
+    return promise;
+  }
+
+  function WritableStreamDefaultWriterGetDesiredSize(writer) {
+    let stream = writer[_ownerWritableStream];
+    let state = stream[_state];
+    if (state === ERRORED) {
+      return null;
+    }
+    if (state === CLOSED) {
+      return 0;
+    }
+    return WritableStreamDefaultControllerGetDesiredSize(
+        stream[_writableStreamController]);
+  }
+
+  function WritableStreamDefaultWriterRelease(writer) {
+    let stream = writer[_ownerWritableStream];
+    TEMP_ASSERT(stream !== undefined,
+                'stream is not undefined.');
+    TEMP_ASSERT(stream[_writer] === writer,
+                'stream.[[writer]] is writer.');
+    let releasedError = new TypeError(errReleasedWriterClosedPromise);
+    let state = stream[_state];
+    if (state === WRITABLE || state === CLOSING) {
+      v8.rejectPromise(writer[_closedPromise], releasedError);
+    } else {
+      writer[_closedPromise] = Promise_reject(releasedError);
+    }
+    if (state === WRITABLE &&
+        WritableStreamDefaultControllerGetBackpressure(
+            stream[_writableStreamController])) {
+      v8.rejectPromise(writer[_readyPromise], releasedError);
+    } else {
+      writer[_readyPromise] = Promise_reject(releasedError);
+    }
+    stream[_writer] = undefined;
+    writer[_ownerWritableStream] = undefined;
+  }
+
+  function WritableStreamDefaultWriterWrite(writer, chunk) {
+    let stream = writer[_ownerWritableStream];
+    TEMP_ASSERT(stream !== undefined,
+                'stream is not undefined.');
+    let state = stream[_state];
+    if (state === CLOSED || state === ERRORED) {
+      return Promise_reject(
+          createCannotActionOnStateStreamError('write to', state));
+    }
+    TEMP_ASSERT(state === WRITABLE,
+                'state is "writable".');
+    let promise = WritableStreamAddWriteRequest(stream);
+    WritableStreamDefaultControllerWrite(stream[_writableStreamController],
+                                         chunk);
+    return promise;
+  }
+
+  class WritableStreamDefaultController {
+    constructor(stream, underlyingSink, size, highWaterMark) {
+      if (!IsWritableStream(stream)) {
+        throw new TypeError(errIllegalConstructor);
+      }
+      if (stream[_controlledWritableStream] !== undefined) {
+        throw new TypeError(errIllegalInvocation);

[tyoshino (SeeGerritForStatus), 2016/11/01 07:43:40]

use errIllegalConstructor for now? or shall we decide to apply this message to
all the invocation with unexpected state (incl ReadableStream.*)?

[Adam Rice, 2016/11/02 11:54:42]

I think errIllegalConstructor is fine. Since calling this constructor directly
will never do anything useful, I think the error messages are not too important.
Although I suppose we could have a "this will never work; give up" message if we
wanted to be extra helpful.

+      }
+      this[_controlledWritableStream] = stream;
+      this[_underlyingSink] = underlyingSink;
+      this[_queue] = new v8.InternalPackedArray();
+      this[_queueSize] = 0;
+      this[_defaultControllerFlags] = 0;
+      let normalizedStrategy =
+          ValidateAndNormalizeQueuingStrategy(size, highWaterMark);
+      this[_strategySize] = normalizedStrategy.size;
+      this[_strategyHWM] = normalizedStrategy.highWaterMark;
+      let backpressure = WritableStreamDefaultControllerGetBackpressure(this);
+      if (backpressure) {
+        WritableStreamUpdateBackpressure(stream, backpressure);
+      }
+      let controller = this;
+      let startResult = InvokeOrNoop(underlyingSink, 'start', [this]);
+      Promise_resolve(startResult)
+          .then(
+              () => {
+                setDefaultControllerStartedFlag(controller, true);
+                WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
+              },
+              r => WritableStreamDefaultControllerErrorIfNeeded(controller, r)
+              );
+    }
+
+    error(e) {
+      if (!IsWritableStreamDefaultController(this)) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      let state = this[_controlledWritableStream][_state];
+      if (state === CLOSED || state === ERRORED) {
+        throw createCannotActionOnStateStreamError('error', state);
+      }
+      WritableStreamDefaultControllerError(this, e);
+    }
+  }
+
+  // Writable Stream Default Controller Abstract Operations
+
+  function IsWritableStreamDefaultController(x) {
+    return hasOwnProperty(x, _underlyingSink);
+  }
+
+  function WritableStreamDefaultControllerAbort(controller, reason) {
+    controller[_queue] = v8.InternalPackedArray();
+    controller[_queueSize] = 0;
+    let sinkAbortPromise =
+        PromiseInvokeOrFallbackOrNoop(controller[_underlyingSink],
+                                      'abort', [reason], 'close', [controller]);
+    return thenPromise(sinkAbortPromise, () => undefined);
+  }
+
+  function WritableStreamDefaultControllerClose(controller) {
+    EnqueueValueWithSizeForController(controller, 'close', 0);
+    WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
+  }
+
+  function WritableStreamDefaultControllerGetDesiredSize(controller) {
+    let queueSize = GetTotalQueueSizeForController(controller);
+    return controller[_strategyHWM] - queueSize;
+  }
+
+  function WritableStreamDefaultControllerWrite(controller, chunk) {
+    let stream = controller[_controlledWritableStream];
+    TEMP_ASSERT(stream[_state] === WRITABLE,
+                'stream.[[state]] is "writable".');
+    let chunkSize = 1;
+    if (controller[_strategySize] !== undefined) {
+      try {
+        chunkSize = Function_call(controller[_strategySize], undefined, chunk);
+      } catch (e) {
+        WritableStreamDefaultControllerErrorIfNeeded(controller, e);
+        return Promise_reject(e);
+      }
+    }
+    let writeRecord = {chunk};
+    let lastBackpressure =
+        WritableStreamDefaultControllerGetBackpressure(controller);
+    try {
+      let enqueueResult =
+          EnqueueValueWithSizeForController(controller, writeRecord, chunkSize);
+    } catch (e) {
+      WritableStreamDefaultControllerErrorIfNeeded(controller, e);
+      return Promise_reject(e);
+    }
+    if (stream[_state] === WRITABLE) {
+      let backpressure =
+          WritableStreamDefaultControllerGetBackpressure(controller);
+      if (lastBackpressure !== backpressure) {
+        WritableStreamUpdateBackpressure(stream, backpressure);
+      }
+    }
+    WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
+  }
+
+  function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {
+    let state = controller[_controlledWritableStream][_state];
+    if (state === CLOSED || state === ERRORED) {
+      return;
+    }
+    if (!getDefaultControllerStartedFlag(controller)) {
+      return;
+    }
+    if (getDefaultControllerWritingFlag(controller)) {
+      return;
+    }
+    if (controller[_queue].length === 0) {
+      return;
+    }
+    let writeRecord = PeekQueueValue(controller[_queue]);
+    if (writeRecord === 'close') {
+      WritableStreamDefaultControllerProcessClose(controller);
+    } else {
+      WritableStreamDefaultControllerProcessWrite(controller,
+                                                  writeRecord.chunk);
+    }
+  }
+
+  function WritableStreamDefaultControllerErrorIfNeeded(controller, e) {
+    let state = controller[_controlledWritableStream][_state];
+    if (state === WRITABLE || state === CLOSING) {
+      WritableStreamDefaultControllerError(controller, e);
+    }
+  }
+
+  function WritableStreamDefaultControllerProcessClose(controller) {
+    let stream = controller[_controlledWritableStream];
+    TEMP_ASSERT(stream[_state] === CLOSING,
+                'stream.[[state]] is "closing".');
+    DequeueValueForController(controller);
+    TEMP_ASSERT(controller[_queue].length === 0,
+                'controller.[[queue]] is empty.');
+    let sinkClosePromise = PromiseInvokeOrNoop(controller[_underlyingSink],
+                                               'close', [controller]);
+    thenPromise(sinkClosePromise,
+                () => {
+                  if (stream[_state] !== CLOSING) {
+                    return;
+                  }
+                  WritableStreamFulfillWriteRequest(stream);
+                  WritableStreamFinishClose(stream);
+                },
+                r => WritableStreamDefaultControllerErrorIfNeeded(controller, r)
+               );

[tyoshino (SeeGerritForStatus), 2016/11/01 07:43:40]

this is also formatted by PRESUBMIT?

[Adam Rice, 2016/11/02 11:54:42]

No. Any formatting errors in this file are purely my fault.

+  }
+
+  function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
+    setDefaultControllerWritingFlag(controller, true);
+    let sinkWritePromise = PromiseInvokeOrNoop(controller[_underlyingSink],
+                                               'write', [chunk, controller]);
+    thenPromise(
+        sinkWritePromise,
+        () => {
+          let stream = controller[_controlledWritableStream];
+          let state = stream[_state];
+          if (state === ERRORED || state === CLOSED) {
+            return;
+          }
+          setDefaultControllerWritingFlag(controller, false);
+          WritableStreamFulfillWriteRequest(stream);
+          let lastBackpressure =
+              WritableStreamDefaultControllerGetBackpressure(controller);
+          DequeueValueForController(controller);
+          if (state !== CLOSING) {
+            let backpressure =
+                WritableStreamDefaultControllerGetBackpressure(controller);
+            if (lastBackpressure !== backpressure) {
+              WritableStreamUpdateBackpressure(
+                  controller[_controlledWritableStream], backpressure);
+            }
+          }
+          WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
+        },
+        r => WritableStreamDefaultControllerErrorIfNeeded(controller, r)
+        );
+  }
+
+  function WritableStreamDefaultControllerGetBackpressure(controller) {
+    let desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller);
+    return desiredSize <= 0;
+  }
+
+  function WritableStreamDefaultControllerError(controller, e) {
+    let stream = controller[_controlledWritableStream];
+    let state = stream[_state];
+    TEMP_ASSERT(state === WRITABLE || state === CLOSING,
+                'stream.[[state]] is "writable" or "closing".');
+    WritableStreamError(stream, e);
+    controller[_queue] = new v8.InternalPackedArray();
+    controller[_queueSize] = 0;
+  }
+
+  // Queue-with-Sizes Operations
+  //
+  // These differ from the versions in the standard: they take a controller
+  // argument in order to cache the total queue size. This is necessary to avoid
+  // O(N^2) behaviour.
+  function DequeueValueForController(controller) {
+    TEMP_ASSERT(controller[_queue].length !== 0,
+                'queue is not empty.');
+    const result = controller[_queue].shift();
+    controller[_queueSize] -= result.size;
+    return result.value;
+  }
+
+  function EnqueueValueWithSizeForController(controller, value, size) {
+    size = Number(size);
+    if (!IsFiniteNonNegativeNumber(size)) {
+      throw new RangeError(errInvalidSize);
+    }
+
+    controller[_queueSize] += size;
+    controller[_queue].push({value, size});
+  }
+
+  function GetTotalQueueSizeForController(controller) {
+    return controller[_queueSize];
+  }
+
+  function PeekQueueValue(queue) {
+    TEMP_ASSERT(queue.length !== 0,
+                'queue is not empty.');
+    return queue[0].value;
+  }
+
+  // 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.
+  function InvokeOrNoop(O, P, args) {
+    TEMP_ASSERT(IsPropertyKey(P),
+                'P is a valid property key.');
+    if (args === undefined) {
+      args = [];
+    }
+    let method = O[P];
+    if (method === undefined) {
+      return undefined;
+    }
+    if (typeof method !== 'function') {
+      throw new TypeError(templateIsNotAFunction(P));
+    }
+    return Function_apply(method, O, args);
+  }
+
+  function IsFiniteNonNegativeNumber(v) {
+    return !Number_isNaN(v) && Number_isFinite(v) && v >= 0;

[tyoshino (SeeGerritForStatus), 2016/11/01 07:43:41]

Isn't it sufficient to have only
  Number_isFinite(v) && v >= 0
?

[Adam Rice, 2016/11/02 11:54:42]

Yes. Done.

+  }
+
+  function PromiseInvokeOrFallbackOrNoop(O, P1, args1, P2, args2) {
+    TEMP_ASSERT(IsPropertyKey(P1),
+                'P1 is a valid property key.');
+    TEMP_ASSERT(IsPropertyKey(P2),
+                'P2 is a valid property key.');
+    try {
+      let method = O[P1];
+      if (method === undefined) {
+        return PromiseInvokeOrNoop(O, P2, args2);
+      }
+      if (typeof method !== 'function') {
+        return Promise_reject(new TypeError(templateIsNotAFunction(P1)));
+      }
+      return Promise_resolve(Function_apply(method, O, args1));
+    } catch (e) {
+      return Promise_reject(e);
+    }
+  }
+
+  function PromiseInvokeOrNoop(O, P, args) {
+    try {
+      return Promise_resolve(InvokeOrNoop(O, P, args));
+    } catch (e) {
+      return Promise_reject(e);
+    }
+  }
+
+  // This is identical to the version in ReadableStream.js and should be shared.
+  function ValidateAndNormalizeQueuingStrategy(size, highWaterMark) {
+    if (size !== undefined && typeof size !== 'function') {
+      throw new TypeError(errSizeNotAFunction);
+    }
+
+    highWaterMark = Number(highWaterMark);
+    if (Number_isNaN(highWaterMark)) {
+      throw new TypeError(errInvalidHWM);
+    }
+    if (highWaterMark < 0) {
+      throw new RangeError(errInvalidHWM);
+    }
+
+    return {size, highWaterMark};
+  }
+
+  //
+  // Additions to the global object
+  //
+
+  defineProperty(global, 'WritableStream', {
+    value: WritableStream,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+
+  // TODO(ricea): Exports to Blink
+});