Changeset 191285 in webkit

Timestamp:

Oct 19, 2015 3:09:07 AM (9 years ago)

Author:

youenn.fablet@crf.canon.fr

Message:

[Streams API] Implement ReadableStream tee
​https://bugs.webkit.org/show_bug.cgi?id=146315

Reviewed by Darin Adler.

Source/WebCore:

Covered by rebased test.

• Modules/streams/ReadableStream.js:

(tee): Removing not implemented exception throwing.

• Modules/streams/ReadableStreamInternals.js:

(teeReadableStream): Implementing as per spec.
(teeReadableStreamPullFunction): Ditto.
(teeReadableStreamBranch2CancelFunction): Ditto.

LayoutTests:

• streams/reference-implementation/readable-stream-tee-expected.txt:

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/streams/reference-implementation/readable-stream-tee-expected.txt (modified) (1 diff)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/Modules/streams/ReadableStream.js (modified) (1 diff)
• Source/WebCore/Modules/streams/ReadableStreamInternals.js (modified) (1 diff)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2015-10-19  Youenn Fablet  <youenn.fablet@crf.canon.fr>
+
+        [Streams API] Implement ReadableStream tee
+        https://bugs.webkit.org/show_bug.cgi?id=146315
+
+        Reviewed by Darin Adler.
+
+        * streams/reference-implementation/readable-stream-tee-expected.txt:
+
 2015-10-19  Xabier Rodriguez Calvar  <calvaris@igalia.com>
 

trunk/LayoutTests/streams/reference-implementation/readable-stream-tee-expected.txt

@@ -1 +1 @@
 
-FAIL ReadableStream teeing: rs.tee() returns an array of two ReadableStreams tee is not implemented
-FAIL ReadableStream teeing: should be able to read one branch to the end without affecting the other tee is not implemented
-FAIL ReadableStream teeing: values should be equal across each branch tee is not implemented
-FAIL ReadableStream teeing: errors in the source should propagate to both branches tee is not implemented
-FAIL ReadableStream teeing: canceling branch1 should not impact branch2 tee is not implemented
-FAIL ReadableStream teeing: canceling branch2 should not impact branch1 tee is not implemented
-FAIL ReadableStream teeing: canceling both branches should aggregate the cancel reasons into an array tee is not implemented
-FAIL ReadableStream teeing: failing to cancel the original stream should cause cancel() to reject on branches tee is not implemented
-FAIL ReadableStream teeing: closing the original should immediately close the branches tee is not implemented
-FAIL ReadableStream teeing: erroring the original should immediately error the branches tee is not implemented
+PASS ReadableStream teeing: rs.tee() returns an array of two ReadableStreams 
+PASS ReadableStream teeing: should be able to read one branch to the end without affecting the other 
+PASS ReadableStream teeing: values should be equal across each branch 
+PASS ReadableStream teeing: errors in the source should propagate to both branches 
+PASS ReadableStream teeing: canceling branch1 should not impact branch2 
+PASS ReadableStream teeing: canceling branch2 should not impact branch1 
+PASS ReadableStream teeing: canceling both branches should aggregate the cancel reasons into an array 
+PASS ReadableStream teeing: failing to cancel the original stream should cause cancel() to reject on branches 
+PASS ReadableStream teeing: closing the original should immediately close the branches 
+PASS ReadableStream teeing: erroring the original should immediately error the branches 
 

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2015-10-19  Youenn Fablet  <youenn.fablet@crf.canon.fr>
+
+        [Streams API] Implement ReadableStream tee
+        https://bugs.webkit.org/show_bug.cgi?id=146315
+
+        Reviewed by Darin Adler.
+
+        Covered by rebased test.
+
+        * Modules/streams/ReadableStream.js:
+        (tee): Removing not implemented exception throwing.
+        * Modules/streams/ReadableStreamInternals.js:
+        (teeReadableStream): Implementing as per spec.
+        (teeReadableStreamPullFunction): Ditto.
+        (teeReadableStreamBranch2CancelFunction): Ditto.
+
 2015-10-19  Xabier Rodriguez Calvar  <calvaris@igalia.com>
 

trunk/Source/WebCore/Modules/streams/ReadableStream.js

@@ -122 +122 @@
         throw new @TypeError("Function should be called on a ReadableStream");
 
-    throw new @TypeError("tee is not implemented");
+    return @teeReadableStream(this, false);
 }
 

trunk/Source/WebCore/Modules/streams/ReadableStreamInternals.js

@@ -79 +79 @@
     "use strict";
 
-    throw new @TypeError("tee is not implemented");
+    // TODO: Assert: IsReadableStream(stream) is true.
+    // TODO: Assert: Type(shouldClone) is Boolean.
+
+    let reader = stream.getReader();
+
+    let teeState = {
+        closedOrErrored: false,
+        canceled1: false,
+        canceled2: false,
+        reason1: undefined,
+        reason: undefined,
+    };
+
+    teeState.cancelPromise = new @InternalPromise(function(resolve, reject) {
+       teeState.resolvePromise = resolve;
+       teeState.rejectPromise = reject;
+    });
+
+    let pullFunction = @teeReadableStreamPullFunction(teeState, reader, shouldClone);
+
+    let underlyingSource1 = {
+        "pull": pullFunction,
+        "cancel": @teeReadableStreamBranch1CancelFunction(teeState, stream)
+    };
+
+    let underlyingSource2 = {
+        "pull": pullFunction,
+        "cancel": @teeReadableStreamBranch2CancelFunction(teeState, stream)
+    };
+
+    let branch1 = new ReadableStream(underlyingSource1);
+    let branch2 = new ReadableStream(underlyingSource2);
+
+    reader.closed.catch(function(e) {
+        if (teeState.closedOrErrored)
+            return;
+        @errorReadableStream(branch1, e);
+        @errorReadableStream(branch2, e);
+        teeState.closedOrErrored = true;
+    });
+
+    // Additional fields compared to the spec, as they are needed within pull/cancel functions.
+    teeState.branch1 = branch1;
+    teeState.branch2 = branch2;
+
+    return [branch1, branch2];
+}
+
+function teeReadableStreamPullFunction(teeState, reader, shouldClone)
+{
+    return function() {
+        reader.read().then(function(result) {
+            if (result.done && !teeState.closedOrErrored) {
+                @closeReadableStream(teeState.branch1);
+                @closeReadableStream(teeState.branch2);
+                teeState.closedOrErrored = true;
+            }
+            if (teeState.closedOrErrored)
+                return;
+            if (!teeState.canceled1) {
+                // TODO: Implement cloning if shouldClone is true
+                @enqueueInReadableStream(teeState.branch1, result.value);
+            }
+            if (!teeState.canceled2) {
+                // TODO: Implement cloning if shouldClone is true
+                @enqueueInReadableStream(teeState.branch2, result.value);
+            }
+        });
+    }
+}
+
+function teeReadableStreamBranch1CancelFunction(teeState, stream)
+{
+    return function(r) {
+        teeState.canceled1 = true;
+        teeState.reason1 = r;
+        if (teeState.canceled2) {
+            @cancelReadableStream(stream, [teeState.reason1, teeState.reason2]).then(teeState.resolvePromise, teeState.rejectPromise);
+        }
+        return teeState.cancelPromise;
+    }
+}
+
+function teeReadableStreamBranch2CancelFunction(teeState, stream)
+{
+    return function(r) {
+        teeState.canceled2 = true;
+        teeState.reason2 = r;
+        if (teeState.canceled1) {
+            @cancelReadableStream(stream, [teeState.reason1, teeState.reason2]).then(teeState.resolvePromise, teeState.rejectPromise);
+        }
+        return teeState.cancelPromise;
+    }
 }