ReadableStream and WritableStream share strings

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 52 matching lines @@
   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.
-  // TODO(ricea): Share strings with ReadableStream that are identical in both.
-  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 streamErrors = binding.streamErrors;
+  const errAbortLockedStream = 'Cannot abort a writable stream that is locked to a writer';
   const errStreamAborted = 'The stream has been aborted';
   const errWriterLockReleasedPrefix = 'This writable stream writer has been released and cannot be ';
   const errCloseCloseRequestedStream =
       'Cannot close a writable stream that has already been requested to be closed';
   const errWriteCloseRequestedStream =
       'Cannot write to a writable stream that is due to be closed';
   const templateErrorCannotActionOnStateStream =
       (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 templateErrorIsNotAFunction = f => `${f} is not a function`;
-  const errSizeNotAFunction =
-      'A queuing strategy\'s size property must be a function';
-  const errInvalidHWM =
-      'A queuing strategy\'s highWaterMark property must be a non-negative, non-NaN number';
-  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 verbWrittenTo = 'written to';
 
   // Utility functions (not from the standard).
   function createWriterLockReleasedError(verb) {
     return new TypeError(errWriterLockReleasedPrefix + verb);
@@ skipping 60 matching lines @@
 
   class WritableStream {
     constructor(underlyingSink = {}, { size, highWaterMark = 1 } = {}) {
       this[_state] = WRITABLE;
       this[_storedError] = undefined;
       this[_writer] = undefined;
       this[_writableStreamController] = undefined;
       this[_writeRequests] = new v8.InternalPackedArray();
       const type = underlyingSink.type;
       if (type !== undefined) {
-        throw new RangeError(errInvalidType);
+        throw new RangeError(streamErrors.invalidType);
       }
       this[_writableStreamController] =
           new WritableStreamDefaultController(this, underlyingSink, size,
                                               highWaterMark);
     }
 
     get locked() {
       if (!IsWritableStream(this)) {
-        throw new TypeError(errIllegalInvocation);
+        throw new TypeError(streamErrors.illegalInvocation);
       }
       return IsWritableStreamLocked(this);
     }
 
     abort(reason) {
       if (!IsWritableStream(this)) {
-        return Promise_reject(new TypeError(errIllegalInvocation));
+        return Promise_reject(new TypeError(streamErrors.illegalInvocation));
       }
       if (IsWritableStreamLocked(this)) {
         return Promise_reject(new TypeError(errAbortLockedStream));
       }
       return WritableStreamAbort(this, reason);
     }
 
     getWriter() {
       if (!IsWritableStream(this)) {
-         throw new TypeError(errIllegalInvocation);
+         throw new TypeError(streamErrors.illegalInvocation);
       }
       return AcquireWritableStreamDefaultWriter(this);
     }
   }
 
   // General Writable Stream Abstract Operations
 
   function AcquireWritableStreamDefaultWriter(stream) {
     return new WritableStreamDefaultWriter(stream);
   }
@@ skipping 85 matching lines @@
     } else {
       TEMP_ASSERT(backpressure === false,
                   'backpressure is false.');
       v8.resolvePromise(writer[_readyPromise], undefined);
     }
   }
 
   class WritableStreamDefaultWriter {
     constructor(stream) {
       if (!IsWritableStream(stream)) {
-        throw new TypeError(errIllegalConstructor);
+        throw new TypeError(streamErrors.illegalConstructor);
       }
       if (IsWritableStreamLocked(stream)) {
-        throw new TypeError(errIllegalConstructor);
+        throw new TypeError(streamErrors.illegalConstructor);
       }
       this[_ownerWritableStream] = stream;
       stream[_writer] = this;
       const 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 Promise_reject(new TypeError(streamErrors.illegalInvocation));
       }
       return this[_closedPromise];
     }
 
     get desiredSize() {
       if (!IsWritableStreamDefaultWriter(this)) {
-        throw new TypeError(errIllegalInvocation);
+        throw new TypeError(streamErrors.illegalInvocation);
       }
       if (this[_ownerWritableStream] === undefined) {
         throw createWriterLockReleasedError(verbUsedToGetTheDesiredSize);
       }
       return WritableStreamDefaultWriterGetDesiredSize(this);
     }
 
     get ready() {
       if (!IsWritableStreamDefaultWriter(this)) {
-        return Promise_reject(new TypeError(errIllegalInvocation));
+        return Promise_reject(new TypeError(streamErrors.illegalInvocation));
       }
       return this[_readyPromise];
     }
 
     abort(reason) {
      if (!IsWritableStreamDefaultWriter(this)) {
-        return Promise_reject(new TypeError(errIllegalInvocation));
+        return Promise_reject(new TypeError(streamErrors.illegalInvocation));
       }
       if (this[_ownerWritableStream] === undefined) {
         return Promise_reject(createWriterLockReleasedError(verbAborted));
       }
       return WritableStreamDefaultWriterAbort(this, reason);
     }
 
     close() {
       if (!IsWritableStreamDefaultWriter(this)) {
-        return Promise_reject(new TypeError(errIllegalInvocation));
+        return Promise_reject(new TypeError(streamErrors.illegalInvocation));
       }
       const 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)) {
-        throw new TypeError(errIllegalInvocation);
+        throw new TypeError(streamErrors.illegalInvocation);
       }
       const stream = this[_ownerWritableStream];
       if (stream === undefined) {
         return;
       }
       TEMP_ASSERT(stream[_writer] !== undefined,
                   'stream.[[writer]] is not undefined.');
       WritableStreamDefaultWriterRelease(this);
     }
 
     write(chunk) {
       if (!IsWritableStreamDefaultWriter(this)) {
-        return Promise_reject(new TypeError(errIllegalInvocation));
+        return Promise_reject(new TypeError(streamErrors.illegalInvocation));
       }
       const 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);
     }
@@ skipping 83 matching lines @@
                 'state is "writable".');
     const promise = WritableStreamAddWriteRequest(stream);
     WritableStreamDefaultControllerWrite(stream[_writableStreamController],
                                          chunk);
     return promise;
   }
 
   class WritableStreamDefaultController {
     constructor(stream, underlyingSink, size, highWaterMark) {
       if (!IsWritableStream(stream)) {
-        throw new TypeError(errIllegalConstructor);
+        throw new TypeError(streamErrors.illegalConstructor);
       }
       if (stream[_writableStreamController] !== undefined) {
-        throw new TypeError(errIllegalConstructor);
+        throw new TypeError(streamErrors.illegalConstructor);
       }
       this[_controlledWritableStream] = stream;
       this[_underlyingSink] = underlyingSink;
       this[_queue] = new v8.InternalPackedArray();
       this[_queueSize] = 0;
       this[_defaultControllerFlags] = 0;
       const normalizedStrategy =
           ValidateAndNormalizeQueuingStrategy(size, highWaterMark);
       this[_strategySize] = normalizedStrategy.size;
       this[_strategyHWM] = normalizedStrategy.highWaterMark;
       const backpressure = WritableStreamDefaultControllerGetBackpressure(this);
       if (backpressure) {
         WritableStreamUpdateBackpressure(stream, backpressure);
       }
       const controller = this;
       const startResult = InvokeOrNoop(underlyingSink, 'start', [this]);
       const onFulfilled = () => {
         setDefaultControllerStartedFlag(controller, true);
         WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
       };
       const onRejected = r => {
         WritableStreamDefaultControllerErrorIfNeeded(controller, r);
       };
       thenPromise(Promise_resolve(startResult), onFulfilled, onRejected);
     }
 
     error(e) {
       if (!IsWritableStreamDefaultController(this)) {
-        throw new TypeError(errIllegalInvocation);
+        throw new TypeError(streamErrors.illegalInvocation);
       }
       const state = this[_controlledWritableStream][_state];
       if (state === CLOSED || state === ERRORED) {
         throw createCannotActionOnStateStreamError('error', state);
       }
       WritableStreamDefaultControllerError(this, e);
     }
   }
 
   // Writable Stream Default Controller Abstract Operations
@@ skipping 163 matching lines @@
     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);
+      throw new RangeError(streamErrors.invalidSize);
     }
 
     controller[_queueSize] += size;
     controller[_queue].push({value, size});
   }
 
   function GetTotalQueueSizeForController(controller) {
     return controller[_queueSize];
   }
 
@@ skipping 53 matching lines @@
     try {
       return Promise_resolve(InvokeOrNoop(O, P, args));
     } catch (e) {
       return Promise_reject(e);
     }
   }
 
   // TODO(ricea): Share this operation with ReadableStream.js.
   function ValidateAndNormalizeQueuingStrategy(size, highWaterMark) {
     if (size !== undefined && typeof size !== 'function') {
-      throw new TypeError(errSizeNotAFunction);
+      throw new TypeError(streamErrors.sizeNotAFunction);
     }
 
     highWaterMark = Number(highWaterMark);
-    if (Number_isNaN(highWaterMark) || highWaterMark < 0) {
-      throw new RangeError(errInvalidHWM);
+    if (Number_isNaN(highWaterMark)) {
+      throw new RangeError(streamErrors.errInvalidHWM);
+    }
+    if (highWaterMark < 0) {
+      throw new RangeError(streamErrors.invalidHWM);
     }
 
     return {size, highWaterMark};
   }
 
   //
   // Additions to the global object
   //
 
   defineProperty(global, 'WritableStream', {
     value: WritableStream,
     enumerable: false,
     configurable: true,
     writable: true
   });
 
   // TODO(ricea): Exports to Blink
 });