Editorial: remove forAuthorCode and use dictionaries for read()

Fixes whatwg#1036.

reference-implementation/lib/ReadableByteStreamController-impl.js

@@ -1,7 +1,6 @@
 'use strict';
 const assert = require('assert');
 
-const { promiseResolvedWith, promiseRejectedWith } = require('./helpers/webidl.js');
 const { CancelSteps, PullSteps } = require('./abstract-ops/internal-methods.js');
 const { ResetQueue } = require('./abstract-ops/queue-with-sizes.js');
 const aos = require('./abstract-ops/readable-streams.js');
@@ -79,7 +78,7 @@ exports.implementation = class ReadableByteStreamControllerImpl {
     return result;
   }
 
-  [PullSteps]() {
+  [PullSteps](readRequest) {
     const stream = this._controlledReadableStream;
     assert(aos.ReadableStreamHasDefaultReader(stream) === true);
 
@@ -93,7 +92,8 @@ exports.implementation = class ReadableByteStreamControllerImpl {
 
       const view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);
 
-      return promiseResolvedWith(aos.ReadableStreamCreateReadResult(view, false, stream._reader._forAuthorCode));
+      readRequest.chunkSteps(view);
+      return;
     }
 
     const autoAllocateChunkSize = this._autoAllocateChunkSize;
@@ -102,7 +102,8 @@ exports.implementation = class ReadableByteStreamControllerImpl {
       try {
         buffer = new ArrayBuffer(autoAllocateChunkSize);
       } catch (bufferE) {
-        return promiseRejectedWith(bufferE);
+        readRequest.errorSteps(bufferE);
+        return;
       }
 
       const pullIntoDescriptor = {
@@ -118,10 +119,7 @@ exports.implementation = class ReadableByteStreamControllerImpl {
       this._pendingPullIntos.push(pullIntoDescriptor);
     }
 
-    const promise = aos.ReadableStreamAddReadRequest(stream);
-
+    aos.ReadableStreamAddReadRequest(stream, readRequest);
     aos.ReadableByteStreamControllerCallPullIfNeeded(this);
-
-    return promise;
   }
 };

reference-implementation/lib/ReadableStream-impl.js

@@ -1,9 +1,8 @@
 'use strict';
 const assert = require('assert');
 
-const { promiseResolvedWith, promiseRejectedWith, setPromiseIsHandledToTrue, transformPromiseWith } =
-  require('./helpers/webidl.js');
-const { typeIsObject } = require('./helpers/miscellaneous.js');
+const { newPromise, resolvePromise, rejectPromise, promiseResolvedWith, promiseRejectedWith,
+        setPromiseIsHandledToTrue } = require('./helpers/webidl.js');
 const { ExtractHighWaterMark, ExtractSizeAlgorithm } = require('./abstract-ops/queuing-strategy.js');
 const aos = require('./abstract-ops/readable-streams.js');
 const wsAOs = require('./abstract-ops/writable-streams.js');
@@ -53,11 +52,11 @@ exports.implementation = class ReadableStreamImpl {
 
   getReader(options) {
     if (!('mode' in options)) {
-      return aos.AcquireReadableStreamDefaultReader(this, true);
+      return aos.AcquireReadableStreamDefaultReader(this);
     }
 
     assert(options.mode === 'byob');
-    return aos.AcquireReadableStreamBYOBReader(this, true);
+    return aos.AcquireReadableStreamBYOBReader(this);
   }
 
   pipeThrough(transform, options) {
@@ -126,27 +125,20 @@ exports.implementation = class ReadableStreamImpl {
       );
     }
 
-    return transformPromiseWith(
-      aos.ReadableStreamDefaultReaderRead(reader),
-      result => {
-        assert(typeIsObject(result));
-
-        const { done } = result;
-        assert(typeof done === 'boolean');
-
-        if (done === true) {
-          aos.ReadableStreamReaderGenericRelease(reader);
-          return idlUtils.asyncIteratorEOI;
-        }
-
-        const { value } = result;
-        return value;
+    const promise = newPromise();
+    const readRequest = {
+      chunkSteps: chunk => resolvePromise(promise, chunk),
+      closeSteps: () => {
+        aos.ReadableStreamReaderGenericRelease(reader);
+        resolvePromise(promise, idlUtils.asyncIteratorEOI);
       },
-      reason => {
+      errorSteps: e => {
         aos.ReadableStreamReaderGenericRelease(reader);
-        throw reason;
+        rejectPromise(promise, e);
       }
-    );
+    };
+    aos.ReadableStreamDefaultReaderRead(reader, readRequest);
+    return promise;
   }
 
   [idlUtils.asyncIteratorReturn](iterator, arg) {

reference-implementation/lib/ReadableStreamBYOBReadResult.webidl

@@ -0,0 +1,4 @@
+dictionary ReadableStreamBYOBReadResult {
+  ArrayBufferView chunk;
+  boolean done;
+};

reference-implementation/lib/ReadableStreamBYOBReader-impl.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { promiseRejectedWith } = require('./helpers/webidl.js');
+const { newPromise, resolvePromise, rejectPromise, promiseRejectedWith } = require('./helpers/webidl.js');
 const aos = require('./abstract-ops/readable-streams.js');
 
 exports.implementation = class ReadableStreamBYOBReaderImpl {
@@ -32,7 +32,14 @@ exports.implementation = class ReadableStreamBYOBReaderImpl {
       return promiseRejectedWith(readerLockException('read'));
     }
 
-    return aos.ReadableStreamBYOBReaderRead(this, view);
+    const promise = newPromise();
+    const readIntoRequest = {
+      chunkSteps: chunk => resolvePromise(promise, { value: chunk, done: false }),
+      closeSteps: chunk => resolvePromise(promise, { value: chunk, done: true }),
+      errorSteps: e => rejectPromise(promise, e)
+    };
+    aos.ReadableStreamBYOBReaderRead(this, view, readIntoRequest);
+    return promise;
   }
 
   releaseLock() {

reference-implementation/lib/ReadableStreamBYOBReader.webidl

@@ -5,6 +5,6 @@ interface ReadableStreamBYOBReader {
   readonly attribute Promise<void> closed;
 
   Promise<void> cancel(optional any reason);
-  Promise<any> read(ArrayBufferView view);
+  Promise<ReadableStreamBYOBReadResult> read(ArrayBufferView view);
   void releaseLock();
 };

reference-implementation/lib/ReadableStreamDefaultController-impl.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const { promiseResolvedWith } = require('./helpers/webidl.js');
 const { CancelSteps, PullSteps } = require('./abstract-ops/internal-methods.js');
 const { DequeueValue, ResetQueue } = require('./abstract-ops/queue-with-sizes.js');
 const aos = require('./abstract-ops/readable-streams.js');
@@ -37,7 +36,7 @@ exports.implementation = class ReadableStreamDefaultControllerImpl {
     return result;
   }
 
-  [PullSteps]() {
+  [PullSteps](readRequest) {
     const stream = this._controlledReadableStream;
 
     if (this._queue.length > 0) {
@@ -50,11 +49,10 @@ exports.implementation = class ReadableStreamDefaultControllerImpl {
         aos.ReadableStreamDefaultControllerCallPullIfNeeded(this);
       }
 
-      return promiseResolvedWith(aos.ReadableStreamCreateReadResult(chunk, false, stream._reader._forAuthorCode));
+      readRequest.chunkSteps(chunk);
+    } else {
+      aos.ReadableStreamAddReadRequest(stream, readRequest);
+      aos.ReadableStreamDefaultControllerCallPullIfNeeded(this);
     }
-
-    const pendingPromise = aos.ReadableStreamAddReadRequest(stream);
-    aos.ReadableStreamDefaultControllerCallPullIfNeeded(this);
-    return pendingPromise;
   }
 };

reference-implementation/lib/ReadableStreamDefaultReadResult.webidl

@@ -0,0 +1,4 @@
+dictionary ReadableStreamDefaultReadResult {
+  any chunk;
+  boolean done;
+};

reference-implementation/lib/ReadableStreamDefaultReader-impl.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { promiseRejectedWith } = require('./helpers/webidl.js');
+const { newPromise, resolvePromise, rejectPromise, promiseRejectedWith } = require('./helpers/webidl.js');
 const aos = require('./abstract-ops/readable-streams.js');
 
 exports.implementation = class ReadableStreamDefaultReaderImpl {
@@ -25,7 +25,15 @@ exports.implementation = class ReadableStreamDefaultReaderImpl {
       return promiseRejectedWith(readerLockException('read from'));
     }
 
-    return aos.ReadableStreamDefaultReaderRead(this);
+    const promise = newPromise();
+    const readRequest = {
+      chunkSteps: chunk => resolvePromise(promise, { value: chunk, done: false }),
+      closeSteps: () => resolvePromise(promise, { value: undefined, done: true }),
+      errorSteps: e => rejectPromise(promise, e)
+    };
+
+    aos.ReadableStreamDefaultReaderRead(this, readRequest);
+    return promise;
   }
 
   releaseLock() {

reference-implementation/lib/ReadableStreamDefaultReader.webidl

@@ -5,6 +5,6 @@ interface ReadableStreamDefaultReader {
   readonly attribute Promise<void> closed;
 
   Promise<void> cancel(optional any reason);
-  Promise<any> read();
+  Promise<ReadableStreamDefaultReadResult> read();
   void releaseLock();
 };