[Streams API] Add write method to writable stream
authorcalvaris@igalia.com <calvaris@igalia.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 28 Oct 2015 15:14:39 +0000 (15:14 +0000)
committercalvaris@igalia.com <calvaris@igalia.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 28 Oct 2015 15:14:39 +0000 (15:14 +0000)
https://bugs.webkit.org/show_bug.cgi?id=150589

Reviewed by Darin Adler.

Source/WebCore:

Write method implemented on writable streams according to the spec.

Current test set suffices. Expectations are updated accordingly.

* Modules/streams/WritableStream.js:
(write):

LayoutTests:

Updated expectations.

* streams/reference-implementation/bad-strategies-expected.txt:
* streams/reference-implementation/bad-underlying-sinks-expected.txt:
* streams/reference-implementation/brand-checks-expected.txt:
* streams/reference-implementation/byte-length-queuing-strategy-expected.txt:
* streams/reference-implementation/count-queuing-strategy-expected.txt:
* streams/reference-implementation/pipe-to-expected.txt:
* streams/reference-implementation/writable-stream-abort-expected.txt:
* streams/reference-implementation/writable-stream-expected.txt:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@191669 268f45cc-cd09-0410-ab3c-d52691b4dbfc

LayoutTests/ChangeLog
LayoutTests/streams/reference-implementation/bad-strategies-expected.txt
LayoutTests/streams/reference-implementation/bad-underlying-sinks-expected.txt
LayoutTests/streams/reference-implementation/brand-checks-expected.txt
LayoutTests/streams/reference-implementation/byte-length-queuing-strategy-expected.txt
LayoutTests/streams/reference-implementation/count-queuing-strategy-expected.txt
LayoutTests/streams/reference-implementation/pipe-to-expected.txt
LayoutTests/streams/reference-implementation/writable-stream-abort-expected.txt
LayoutTests/streams/reference-implementation/writable-stream-expected.txt
Source/WebCore/ChangeLog
Source/WebCore/Modules/streams/WritableStream.js

index 567ee53dd39c7892540de2fbf8c13ae0df43660d..857fad26201b6e94afcc2563d80b0c27cecd7b4e 100644 (file)
@@ -1,3 +1,21 @@
+2015-10-28  Xabier Rodriguez Calvar  <calvaris@igalia.com>
+
+        [Streams API] Add write method to writable stream
+        https://bugs.webkit.org/show_bug.cgi?id=150589
+
+        Reviewed by Darin Adler.
+
+        Updated expectations.
+
+        * streams/reference-implementation/bad-strategies-expected.txt:
+        * streams/reference-implementation/bad-underlying-sinks-expected.txt:
+        * streams/reference-implementation/brand-checks-expected.txt:
+        * streams/reference-implementation/byte-length-queuing-strategy-expected.txt:
+        * streams/reference-implementation/count-queuing-strategy-expected.txt:
+        * streams/reference-implementation/pipe-to-expected.txt:
+        * streams/reference-implementation/writable-stream-abort-expected.txt:
+        * streams/reference-implementation/writable-stream-expected.txt:
+
 2015-10-28  Hunseop Jeong  <hs85.jeong@samsung.com>
 
         Unreviewed. EFL gardening: rebaseline tests after r191623.
index 18df1eefe48368557b4bf7aebac103519aa1423a..aae57be2af3d75d6d3179b4fde33f2d3691ecb20 100644 (file)
@@ -5,8 +5,8 @@ PASS Readable stream: throwing strategy.highWaterMark getter
 PASS Readable stream: invalid strategy.highWaterMark 
 PASS Readable stream: invalid strategy.size return value 
 PASS Writable stream: throwing strategy.size getter 
-FAIL Writable stream: throwing strategy.size method write not implemented
-FAIL Writable stream: invalid strategy.size return value write not implemented
+PASS Writable stream: throwing strategy.size method 
+PASS Writable stream: invalid strategy.size return value 
 PASS Writable stream: throwing strategy.highWaterMark getter 
 PASS Writable stream: invalid strategy.highWaterMark 
 
index 9646ebc904648f378f83a1faf5c22aadbdc97553..e88afe3cec152fca7de68be7cadbf6a2df7a6642 100644 (file)
@@ -1,8 +1,8 @@
 
 PASS Underlying sink: throwing start getter 
 PASS Underlying sink: throwing start method 
-FAIL Underlying sink: throwing write getter write not implemented
-FAIL Underlying sink: throwing write method write not implemented
+PASS Underlying sink: throwing write getter 
+PASS Underlying sink: throwing write method 
 PASS Underlying sink: throwing abort getter 
 PASS Underlying sink: throwing abort method 
 PASS Underlying sink: throwing close getter 
index 5ec77b12745c902a29aed2c43a6c06afc8ec3543..85b525581019600dd5ee457a0689352abee6e385 100644 (file)
@@ -21,7 +21,7 @@ PASS WritableStream.prototype.closed enforces a brand check
 PASS WritableStream.prototype.ready enforces a brand check 
 PASS WritableStream.prototype.state enforces a brand check 
 PASS WritableStream.prototype.abort enforces a brand check 
-FAIL WritableStream.prototype.write enforces a brand check write not implemented
+PASS WritableStream.prototype.write enforces a brand check 
 PASS WritableStream.prototype.close enforces a brand check 
 PASS ByteLengthQueuingStrategy.prototype.size should work generically on its this and its arguments 
 PASS CountQueuingStrategy.prototype.size should work generically on its this and its arguments 
index 5b296292c9c7ff25d18582cbe201a56c40d9fe62..19127ae57882486d631033e53b4c2a6703fd8dcc 100644 (file)
@@ -4,5 +4,5 @@ PASS Can construct a ByteLengthQueuingStrategy with any value as its high water
 PASS ByteLengthQueuingStrategy constructor behaves as expected with wrong arguments 
 PASS ByteLengthQueuingStrategy size behaves as expected with wrong arguments 
 PASS ByteLengthQueuingStrategy instances have the correct properties 
-FAIL Closing a writable stream with in-flight writes below the high water mark delays the close call properly write not implemented
+PASS Closing a writable stream with in-flight writes below the high water mark delays the close call properly 
 
index f3b9c0d715080f7aceb1f05fce82fed858f518a7..131f50ffe354364953fa03ddc7ab59db045abffb 100644 (file)
@@ -9,6 +9,6 @@ PASS Correctly governs the return value of a ReadableStream's enqueue function (
 PASS Correctly governs a ReadableStreamController's desiredSize property (HWM = 1) 
 PASS Correctly governs a ReadableStreamController's desiredSize property (HWM = 4) 
 PASS Can construct a writable stream with a valid CountQueuingStrategy 
-FAIL Correctly governs the value of a WritableStream's state property (HWM = 0) write not implemented
-FAIL Correctly governs the value of a WritableStream's state property (HWM = 4) write not implemented
+PASS Correctly governs the value of a WritableStream's state property (HWM = 0) 
+PASS Correctly governs the value of a WritableStream's state property (HWM = 4) 
 
index 855dfeea87fb436b22a52f6495856e6a9cb4ec94..9af81b30564079d70a11d7c916329eda54a94a49 100644 (file)
@@ -1,19 +1,19 @@
 
 FAIL Piping from a ReadableStream from which lots of data are readable synchronously pipeTo is not implemented
 FAIL Piping from a ReadableStream in readable state to a WritableStream in closing state pipeTo is not implemented
-FAIL Piping from a ReadableStream in readable state to a WritableStream in errored state write not implemented
+FAIL Piping from a ReadableStream in readable state to a WritableStream in errored state pipeTo is not implemented
 FAIL Piping from a ReadableStream in the readable state which becomes closed after pipeTo call to a WritableStream in the writable state pipeTo is not implemented
 FAIL Piping from a ReadableStream in the readable state which becomes errored after pipeTo call to a WritableStream in the writable state pipeTo is not implemented
 FAIL Piping from an empty ReadableStream which becomes non-empty after pipeTo call to a WritableStream in the writable state pipeTo is not implemented
 FAIL Piping from an empty ReadableStream which becomes errored after pipeTo call to a WritableStream in the writable state pipeTo is not implemented
 FAIL Piping from an empty ReadableStream to a WritableStream in the writable state which becomes errored after a pipeTo call pipeTo is not implemented
-FAIL Piping from a non-empty ReadableStream to a WritableStream in the waiting state which becomes writable after a pipeTo call write not implemented
-FAIL Piping from a non-empty ReadableStream to a WritableStream in waiting state which becomes errored after a pipeTo call write not implemented
-FAIL Piping from a non-empty ReadableStream which becomes errored after pipeTo call to a WritableStream in the waiting state write not implemented
-FAIL Piping from a non-empty ReadableStream to a WritableStream in the waiting state where both become ready after a pipeTo write not implemented
-FAIL Piping from an empty ReadableStream to a WritableStream in the waiting state which becomes writable after a pipeTo call write not implemented
-FAIL Piping from an empty ReadableStream which becomes closed after a pipeTo call to a WritableStream in the waiting state whose writes never complete write not implemented
-FAIL Piping from an empty ReadableStream which becomes errored after a pipeTo call to a WritableStream in the waiting state write not implemented
+FAIL Piping from a non-empty ReadableStream to a WritableStream in the waiting state which becomes writable after a pipeTo call pipeTo is not implemented
+FAIL Piping from a non-empty ReadableStream to a WritableStream in waiting state which becomes errored after a pipeTo call pipeTo is not implemented
+FAIL Piping from a non-empty ReadableStream which becomes errored after pipeTo call to a WritableStream in the waiting state pipeTo is not implemented
+FAIL Piping from a non-empty ReadableStream to a WritableStream in the waiting state where both become ready after a pipeTo pipeTo is not implemented
+FAIL Piping from an empty ReadableStream to a WritableStream in the waiting state which becomes writable after a pipeTo call pipeTo is not implemented
+FAIL Piping from an empty ReadableStream which becomes closed after a pipeTo call to a WritableStream in the waiting state whose writes never complete pipeTo is not implemented
+FAIL Piping from an empty ReadableStream which becomes errored after a pipeTo call to a WritableStream in the waiting state pipeTo is not implemented
 FAIL Piping to a duck-typed asynchronous "writable stream" works pipeTo is not implemented
 FAIL Piping to a stream that has been aborted passes through the error as the cancellation reason pipeTo is not implemented
 FAIL Piping to a stream and then aborting it passes through the error as the cancellation reason pipeTo is not implemented
index 9d24281a906451cd190d8bb9adbfab543e8ddcdf..c816bacea8bc556f31705ec33423d3782f6acf9a 100644 (file)
@@ -1,12 +1,12 @@
 
-FAIL Aborting a WritableStream immediately prevents future writes write not implemented
-FAIL Aborting a WritableStream prevents further writes after any that are in progress write not implemented
+PASS Aborting a WritableStream immediately prevents future writes 
+PASS Aborting a WritableStream prevents further writes after any that are in progress 
 PASS Fulfillment value of ws.abort() call must be undefined even if the underlying sink returns a non-undefined value 
 PASS WritableStream if sink's abort throws, the promise returned by ws.abort() rejects 
 PASS Aborting a WritableStream passes through the given reason 
-FAIL Aborting a WritableStream puts it in an errored state, with stored error equal to the abort reason write not implemented
-FAIL Aborting a WritableStream causes any outstanding ready promises to be fulfilled immediately write not implemented
-FAIL Aborting a WritableStream causes any outstanding write() promises to be rejected with the abort reason write not implemented
+PASS Aborting a WritableStream puts it in an errored state, with stored error equal to the abort reason 
+PASS Aborting a WritableStream causes any outstanding ready promises to be fulfilled immediately 
+PASS Aborting a WritableStream causes any outstanding write() promises to be rejected with the abort reason 
 PASS Closing but then immediately aborting a WritableStream causes the stream to error 
 PASS Closing a WritableStream and aborting it while it closes causes the stream to error 
 PASS Aborting a WritableStream after it is closed is a no-op 
index 8ece7f15cbe28c3500e1bce723b2ce69d32c0061..da0d11433b5c20fff802eb6a7039c11f8d59856a 100644 (file)
@@ -1,14 +1,14 @@
 
 PASS error argument is given to start method 
-FAIL Underlying sink's write won't be called until start finishes write not implemented
+PASS Underlying sink's write won't be called until start finishes 
 PASS Underlying sink's close won't be called until start finishes 
 PASS Fulfillment value of ws.close() call must be undefined even if the underlying sink returns a non-undefined value 
 PASS Underlying sink's write or close are never invoked if start throws 
 PASS Underlying sink's write or close are never invoked if the promise returned by start is rejected 
 PASS WritableStream can be constructed with no arguments 
 PASS WritableStream instances have the correct methods and properties 
-FAIL WritableStream with simple input, processed asynchronously write not implemented
-FAIL WritableStream with simple input, processed synchronously write not implemented
+PASS WritableStream with simple input, processed asynchronously 
+PASS WritableStream with simple input, processed synchronously 
 PASS WritableStream is writable and ready fulfills immediately if the strategy does not apply backpressure 
-FAIL Fulfillment value of ws.write() call must be undefined even if the underlying sink returns a non-undefined ovalue write not implemented
+PASS Fulfillment value of ws.write() call must be undefined even if the underlying sink returns a non-undefined ovalue 
 
index 4da6f1bb32b4c8cab0ce8c8a27dfb52a28ca19ae..6f066dc41ded06fdd9dcb44ef123c1207b6392ee 100644 (file)
@@ -1,3 +1,17 @@
+2015-10-28  Xabier Rodriguez Calvar  <calvaris@igalia.com>
+
+        [Streams API] Add write method to writable stream
+        https://bugs.webkit.org/show_bug.cgi?id=150589
+
+        Reviewed by Darin Adler.
+
+        Write method implemented on writable streams according to the spec.
+
+        Current test set suffices. Expectations are updated accordingly.
+
+        * Modules/streams/WritableStream.js:
+        (write):
+
 2015-10-27  Hunseop Jeong  <hs85.jeong@samsung.com>
 
         [Cairo] Incorrect dashed and dotted border painting after r177686.
index feee3fcac807fca89c0e6279549fa0d8a6ed82fb..ee121322375c05779bd652d70cdd3837e6bf65ca 100644 (file)
@@ -111,7 +111,40 @@ function write(chunk)
 {
     "use strict";
 
-    throw new EvalError("write not implemented");
+    if (!@isWritableStream(this))
+        return Promise.reject(new @TypeError("The WritableStream.close method can only be used on instances of WritableStream"));
+
+    if (this.@state === "closed" || this.@state === "closing")
+        return Promise.reject(new @TypeError("Cannot write on a WritableString that is closed or closing"));
+
+    if (this.@state === "errored")
+        return Promise.reject(this.@storedError);
+
+    // FIXME
+    // assert(this.@state === "writable" || this.@state === "waiting" || this.@state === undefined);
+
+    let chunkSize = 1;
+    if (this.@strategy.size !== undefined) {
+        try {
+            chunkSize = this.@strategy.size.@call(undefined, chunk);
+        } catch(e) {
+            @errorWritableStream.@call(this, e);
+            return Promise.reject(e);
+        }
+    }
+
+    const promise = @createNewStreamsPromise();
+    try {
+        @enqueueValueWithSize(this.@queue, { promise: promise, chunk: chunk }, chunkSize);
+    } catch (e) {
+        @errorWritableStream.@call(this, e);
+        return Promise.reject(e);
+    }
+
+    @syncWritableStreamStateWithQueue(this);
+    @callOrScheduleWritableStreamAdvanceQueue(this);
+
+    return promise;
 }
 
 function closed()