ReadableStream and WritableStream share strings

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

 // Copyright 2015 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.
 
 (function(global, binding, v8) {
   'use strict';
 
   const _reader = v8.createPrivateSymbol('[[reader]]');
   const _storedError = v8.createPrivateSymbol('[[storedError]]');
   const _controller = v8.createPrivateSymbol('[[controller]]');
@@ skipping 44 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);
 
-  const errIllegalInvocation = 'Illegal invocation';
-  const errIllegalConstructor = 'Illegal constructor';
+  const streamErrors = binding.streamErrors;
   const errCancelLockedStream =
       'Cannot cancel a readable stream that is locked to a reader';
   const errEnqueueCloseRequestedStream =
       'Cannot enqueue a chunk into a readable stream that is closed or has been requested to be closed';
   const errCancelReleasedReader =
       'This readable stream reader has been released and cannot be used to cancel its previous owner stream';
   const errReadReleasedReader =
       'This readable stream reader has been released and cannot be used to read from its previous owner stream';
   const errCloseCloseRequestedStream =
       'Cannot close a readable stream that has already been requested to be closed';
   const errEnqueueClosedStream = 'Cannot enqueue a chunk into a closed readable stream';
   const errEnqueueErroredStream = 'Cannot enqueue a chunk into an errored readable stream';
   const errCloseClosedStream = 'Cannot close a closed readable stream';
   const errCloseErroredStream = 'Cannot close an errored readable stream';
   const errErrorClosedStream = 'Cannot error a close readable stream';
   const errErrorErroredStream =
       'Cannot error a readable stream that is already errored';
   const errGetReaderNotByteStream = 'This readable stream does not support BYOB readers';
   const errGetReaderBadMode = 'Invalid reader mode given: expected undefined or "byob"';
   const errReaderConstructorBadArgument =
       'ReadableStreamReader constructor argument is not a readable stream';
   const errReaderConstructorStreamAlreadyLocked =
       'ReadableStreamReader constructor can only accept readable streams that are not yet locked to a reader';
   const errReleaseReaderWithPendingRead =
       'Cannot release a readable stream reader when it still has outstanding read() calls that have not yet settled';
   const errReleasedReaderClosedPromise =
       'This readable stream reader has been released and cannot be used to monitor the stream\'s state';
-  const errInvalidSize =
-      'The return value of a queuing strategy\'s size function must be a finite, non-NaN, non-negative number';
-  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';
+
   const errTmplMustBeFunctionOrUndefined = name =>
       `${name} must be a function or undefined`;
 
   class ReadableStream {
     constructor() {
       // TODO(domenic): when V8 gets default parameters and destructuring, all
       // this can be cleaned up.
       const underlyingSource = arguments[0] === undefined ? {} : arguments[0];
       const strategy = arguments[1] === undefined ? {} : arguments[1];
       const size = strategy.size;
@@ skipping 12 matching lines @@
       // methods will disregard their controller argument in such situations
       // (but see below).
 
       this[_controller] = undefined;
 
       const type = underlyingSource.type;
       const typeString = String(type);
       if (typeString === 'bytes') {
         throw new RangeError('bytes type is not yet implemented');
       } else if (type !== undefined) {
-        throw new RangeError('Invalid type is specified');
+        throw new RangeError(streamErrors.invalidType);
       }
 
       this[_controller] =
           new ReadableStreamDefaultController(this, underlyingSource, size, highWaterMark, arguments[2] === createWithExternalControllerSentinel);
     }
 
     get locked() {
       if (IsReadableStream(this) === false) {
-        throw new TypeError(errIllegalInvocation);
+        throw new TypeError(streamErrors.illegalInvocation);
       }
 
       return IsReadableStreamLocked(this);
     }
 
     cancel(reason) {
       if (IsReadableStream(this) === false) {
-        return Promise_reject(new TypeError(errIllegalInvocation));
+        return Promise_reject(new TypeError(streamErrors.illegalInvocation));
       }
 
       if (IsReadableStreamLocked(this) === true) {
         return Promise_reject(new TypeError(errCancelLockedStream));
       }
 
       return ReadableStreamCancel(this, reason);
     }
 
     getReader({ mode } = {}) {
       if (IsReadableStream(this) === false) {
-        throw new TypeError(errIllegalInvocation);
+        throw new TypeError(streamErrors.illegalInvocation);
       }
 
       if (mode === 'byob') {
         // TODO(ricea): When BYOB readers are supported:
         //
         // a. If
         // ! IsReadableByteStreamController(this.[[_controller]])
         // is false, throw a TypeError exception.
         // b. Return ? AcquireReadableStreamBYOBReader(this).
         throw new TypeError(errGetReaderNotByteStream);
       }
 
       if (mode === undefined) {
         return AcquireReadableStreamDefaultReader(this);
       }
 
       throw new RangeError(errGetReaderBadMode);
     }
 
     tee() {
       if (IsReadableStream(this) === false) {
-        throw new TypeError(errIllegalInvocation);
+        throw new TypeError(streamErrors.illegalInvocation);
       }
 
       return ReadableStreamTee(this);
     }
   }
 
   class ReadableStreamDefaultController {
     constructor(stream, underlyingSource, size, highWaterMark, isExternallyControlled) {
       if (IsReadableStream(stream) === false) {
-        throw new TypeError(errIllegalConstructor);
+        throw new TypeError(streamErrors.illegalConstructor);
       }
 
       if (stream[_controller] !== undefined) {
-        throw new TypeError(errIllegalConstructor);
+        throw new TypeError(streamErrors.illegalConstructor);
       }
 
       this[_controlledReadableStream] = stream;
 
       this[_underlyingSource] = underlyingSource;
 
       this[_queue] = new v8.InternalPackedArray();
       this[_totalQueuedSize] = 0;
 
       this[_readableStreamDefaultControllerBits] = 0b0;
@@ skipping 17 matching lines @@
           },
           r => {
             if (ReadableStreamGetState(stream) === STATE_READABLE) {
               ReadableStreamDefaultControllerError(controller, r);
             }
           });
     }
 
     get desiredSize() {
       if (IsReadableStreamDefaultController(this) === false) {
-        throw new TypeError(errIllegalInvocation);
+        throw new TypeError(streamErrors.illegalInvocation);
       }
 
       return ReadableStreamDefaultControllerGetDesiredSize(this);
     }
 
     close() {
       if (IsReadableStreamDefaultController(this) === false) {
-        throw new TypeError(errIllegalInvocation);
+        throw new TypeError(streamErrors.illegalInvocation);
       }
 
       const stream = this[_controlledReadableStream];
 
       if (this[_readableStreamDefaultControllerBits] & CLOSE_REQUESTED) {
         throw new TypeError(errCloseCloseRequestedStream);
       }
 
       const state = ReadableStreamGetState(stream);
       if (state === STATE_ERRORED) {
         throw new TypeError(errCloseErroredStream);
       }
       if (state === STATE_CLOSED) {
         throw new TypeError(errCloseClosedStream);
       }
 
       return ReadableStreamDefaultControllerClose(this);
     }
 
     enqueue(chunk) {
       if (IsReadableStreamDefaultController(this) === false) {
-        throw new TypeError(errIllegalInvocation);
+        throw new TypeError(streamErrors.illegalInvocation);
       }
 
       const stream = this[_controlledReadableStream];
 
       if (this[_readableStreamDefaultControllerBits] & CLOSE_REQUESTED) {
         throw new TypeError(errEnqueueCloseRequestedStream);
       }
 
       const state = ReadableStreamGetState(stream);
       if (state === STATE_ERRORED) {
         throw new TypeError(errEnqueueErroredStream);
       }
       if (state === STATE_CLOSED) {
         throw new TypeError(errEnqueueClosedStream);
       }
 
       return ReadableStreamDefaultControllerEnqueue(this, chunk);
     }
 
     error(e) {
       if (IsReadableStreamDefaultController(this) === false) {
-        throw new TypeError(errIllegalInvocation);
+        throw new TypeError(streamErrors.illegalInvocation);
       }
 
       const stream = this[_controlledReadableStream];
 
       const state = ReadableStreamGetState(stream);
       if (state === STATE_ERRORED) {
         throw new TypeError(errErrorErroredStream);
       }
       if (state === STATE_CLOSED) {
         throw new TypeError(errErrorClosedStream);
@@ skipping 46 matching lines @@
         throw new TypeError(errReaderConstructorStreamAlreadyLocked);
       }
 
       ReadableStreamReaderGenericInitialize(this, stream);
 
       this[_readRequests] = new v8.InternalPackedArray();
     }
 
     get closed() {
       if (IsReadableStreamDefaultReader(this) === false) {
-        return Promise_reject(new TypeError(errIllegalInvocation));
+        return Promise_reject(new TypeError(streamErrors.illegalInvocation));
       }
 
       return this[_closedPromise];
     }
 
     cancel(reason) {
       if (IsReadableStreamDefaultReader(this) === false) {
-        return Promise_reject(new TypeError(errIllegalInvocation));
+        return Promise_reject(new TypeError(streamErrors.illegalInvocation));
       }
 
       const stream = this[_ownerReadableStream];
       if (stream === undefined) {
         return Promise_reject(new TypeError(errCancelReleasedReader));
       }
 
       return ReadableStreamReaderGenericCancel(this, reason);
     }
 
     read() {
       if (IsReadableStreamDefaultReader(this) === false) {
-        return Promise_reject(new TypeError(errIllegalInvocation));
+        return Promise_reject(new TypeError(streamErrors.illegalInvocation));
       }
 
       if (this[_ownerReadableStream] === undefined) {
         return Promise_reject(new TypeError(errReadReleasedReader));
       }
 
       return ReadableStreamDefaultReaderRead(this);
     }
 
     releaseLock() {
       if (IsReadableStreamDefaultReader(this) === false) {
-        throw new TypeError(errIllegalInvocation);
+        throw new TypeError(streamErrors.illegalInvocation);
       }
 
       const stream = this[_ownerReadableStream];
       if (stream === undefined) {
         return undefined;
       }
 
       if (this[_readRequests].length > 0) {
         throw new TypeError(errReleaseReaderWithPendingRead);
       }
@@ skipping 403 matching lines @@
 
   function DequeueValue(controller) {
     const result = controller[_queue].shift();
     controller[_totalQueuedSize] -= result.size;
     return result.value;
   }
 
   function EnqueueValueWithSize(controller, value, size) {
     size = Number(size);
     if (Number_isNaN(size) || size === +Infinity || size < 0) {
-      throw new RangeError(errInvalidSize);
+      throw new RangeError(streamErrors.invalidSize);
     }
 
     controller[_totalQueuedSize] += size;
     controller[_queue].push({value, size});
   }
 
   function GetTotalQueueSize(controller) { return controller[_totalQueuedSize]; }
 
   //
   // Other helpers
   //
 
   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};
   }
 
   // Modified from InvokeOrNoop in spec
   function CallOrNoop(O, P, arg, nameForError) {
     const method = O[P];
     if (method === undefined) {
       return undefined;
@@ skipping 63 matching lines @@
   binding.ReadableStreamDefaultControllerGetDesiredSize = ReadableStreamDefaultControllerGetDesiredSize;
   binding.ReadableStreamDefaultControllerEnqueue = ReadableStreamDefaultControllerEnqueue;
   binding.ReadableStreamDefaultControllerError = ReadableStreamDefaultControllerError;
 
   binding.createReadableStreamWithExternalController =
       (underlyingSource, strategy) => {
         return new ReadableStream(
             underlyingSource, strategy, createWithExternalControllerSentinel);
       };
 });