Changeset 183991 in webkit

Timestamp:

May 8, 2015 3:44:06 AM (9 years ago)

Author:

youenn.fablet@crf.canon.fr

Message:

[Streams API] ReadableStream constructor start function should be able to error the stream
​https://bugs.webkit.org/show_bug.cgi?id=141162

Reviewed by Darin Adler.

Source/WebCore:

This patch implements the functionality of the ReadableStreamController error function.
It basically changes the state of the stream to errored, resolves the ready promise and rejects the closed promise.
Adding support to reject promise with any JSValue.

Support for storing the error is added to both reader and stream.

Test: streams/readable-stream-controller-error.html and rebased tests

• Modules/streams/ReadableStream.cpp:

(WebCore::ReadableStream::changeStateToErrored):

• Modules/streams/ReadableStream.h:
• Modules/streams/ReadableStreamReader.cpp:

(WebCore::ReadableStreamReader::initialize):
(WebCore::ReadableStreamReader::closed):
(WebCore::ReadableStreamReader::changeStateToClosed):
(WebCore::ReadableStreamReader::changeStateToErrored):

• Modules/streams/ReadableStreamReader.h:
• bindings/js/JSDOMPromise.h:

(WebCore::DeferredWrapper::reject):

• bindings/js/JSReadableStreamControllerCustom.cpp:

(WebCore::JSReadableStreamController::error):

• bindings/js/JSReadableStreamReaderCustom.cpp:

(WebCore::JSReadableStreamReader::closed):

• bindings/js/ReadableJSStream.cpp:

(WebCore::ReadableJSStream::createReader):
(WebCore::ReadableJSStream::storeError):
(WebCore::ReadableJSStream::Reader::storeError):
(WebCore::ReadableJSStream::jsController): Deleted.

• bindings/js/ReadableJSStream.h:

LayoutTests:

• streams/readable-stream-controller-error-expected.txt: Added.
• streams/readable-stream-controller-error.html: Added.
• streams/reference-implementation/bad-underlying-sources-expected.txt:
• streams/reference-implementation/readable-stream-templated-expected.txt:

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/streams/readable-stream-controller-error-expected.txt (added)
• LayoutTests/streams/readable-stream-controller-error.html (added)
• LayoutTests/streams/reference-implementation/bad-underlying-sources-expected.txt (modified) (1 diff)
• LayoutTests/streams/reference-implementation/readable-stream-templated-expected.txt (modified) (1 diff)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/Modules/streams/ReadableStream.cpp (modified) (1 diff)
• Source/WebCore/Modules/streams/ReadableStream.h (modified) (1 diff)
• Source/WebCore/Modules/streams/ReadableStreamReader.cpp (modified) (4 diffs)
• Source/WebCore/Modules/streams/ReadableStreamReader.h (modified) (3 diffs)
• Source/WebCore/bindings/js/JSDOMPromise.h (modified) (1 diff)
• Source/WebCore/bindings/js/JSReadableStreamControllerCustom.cpp (modified) (1 diff)
• Source/WebCore/bindings/js/JSReadableStreamReaderCustom.cpp (modified) (1 diff)
• Source/WebCore/bindings/js/ReadableJSStream.cpp (modified) (3 diffs)
• Source/WebCore/bindings/js/ReadableJSStream.h (modified) (2 diffs)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2015-05-08  Xabier Rodriguez Calvar  <calvaris@igalia.com> and Youenn Fablet <youenn.fablet@crf.canon.fr>
+
+        [Streams API] ReadableStream constructor start function should be able to error the stream
+        https://bugs.webkit.org/show_bug.cgi?id=141162
+
+        Reviewed by Darin Adler.
+
+        * streams/readable-stream-controller-error-expected.txt: Added.
+        * streams/readable-stream-controller-error.html: Added.
+        * streams/reference-implementation/bad-underlying-sources-expected.txt:
+        * streams/reference-implementation/readable-stream-templated-expected.txt:
+
 2015-05-08  Commit Queue  <commit-queue@webkit.org>
 

trunk/LayoutTests/streams/reference-implementation/bad-underlying-sources-expected.txt

@@ -22 +22 @@
 FAIL Underlying source: calling close on an empty canceled stream should not throw cancel is not implemented
 FAIL Underlying source: calling close on a non-empty canceled stream should not throw cancel is not implemented
-TIMEOUT Underlying source: calling close after error should throw Test timed out
-TIMEOUT Underlying source: calling error twice should throw the second time Test timed out
+PASS Underlying source: calling close after error should throw 
+PASS Underlying source: calling error twice should throw the second time 
 PASS Underlying source: calling error after close should throw 
 

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

@@ -29 +29 @@
 FAIL cancel() should return a distinct rejected promise each time cancel is not implemented
 FAIL reader cancel() should return a distinct rejected promise each time cancel is not implemented
-FAIL should be able to acquire multiple readers, since they are all auto-released ReadableStream is locked
+PASS should be able to acquire multiple readers, since they are all auto-released 
 PASS Running templatedRSErrored with ReadableStream (errored via returning a rejected promise in start) 
 FAIL getReader() should return a reader that acts errored read is not implemented

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2015-05-08  Xabier Rodriguez Calvar  <calvaris@igalia.com> and Youenn Fablet <youenn.fablet@crf.canon.fr>
+
+        [Streams API] ReadableStream constructor start function should be able to error the stream
+        https://bugs.webkit.org/show_bug.cgi?id=141162
+
+        Reviewed by Darin Adler.
+
+        This patch implements the functionality of the ReadableStreamController error function.
+        It basically changes the state of the stream to errored, resolves the ready promise and rejects the closed promise.
+        Adding support to reject promise with any JSValue.
+
+        Support for storing the error is added to both reader and stream.
+
+        Test: streams/readable-stream-controller-error.html and rebased tests
+
+        * Modules/streams/ReadableStream.cpp:
+        (WebCore::ReadableStream::changeStateToErrored):
+        * Modules/streams/ReadableStream.h:
+        * Modules/streams/ReadableStreamReader.cpp:
+        (WebCore::ReadableStreamReader::initialize):
+        (WebCore::ReadableStreamReader::closed):
+        (WebCore::ReadableStreamReader::changeStateToClosed):
+        (WebCore::ReadableStreamReader::changeStateToErrored):
+        * Modules/streams/ReadableStreamReader.h:
+        * bindings/js/JSDOMPromise.h:
+        (WebCore::DeferredWrapper::reject):
+        * bindings/js/JSReadableStreamControllerCustom.cpp:
+        (WebCore::JSReadableStreamController::error):
+        * bindings/js/JSReadableStreamReaderCustom.cpp:
+        (WebCore::JSReadableStreamReader::closed):
+        * bindings/js/ReadableJSStream.cpp:
+        (WebCore::ReadableJSStream::createReader):
+        (WebCore::ReadableJSStream::storeError):
+        (WebCore::ReadableJSStream::Reader::storeError):
+        (WebCore::ReadableJSStream::jsController): Deleted.
+        * bindings/js/ReadableJSStream.h:
+
 2015-05-08  Commit Queue  <commit-queue@webkit.org>
 

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

@@ -69 +69 @@
 }
 
+void ReadableStream::changeStateToErrored()
+{
+    if (m_state != State::Readable)
+        return;
+    m_state = State::Errored;
+    if (m_reader)
+        m_reader->changeStateToErrored();
+    ASSERT(!m_reader);
+}
+
 void ReadableStream::start()
 {

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

@@ -70 +70 @@
     void start();
     void changeStateToClosed();
+    void changeStateToErrored();
 
     ReadableStreamSource& source() { return m_source.get(); }

trunk/Source/WebCore/Modules/streams/ReadableStreamReader.cpp

@@ -70 +70 @@
         return;
     }
+    if (m_stream->internalState() == ReadableStream::State::Errored) {
+        changeStateToErrored();
+        return;
+    }
 }
 
@@ -79 +83 @@
 }
 
-void ReadableStreamReader::closed(ClosedSuccessCallback successCallback, ClosedErrorCallback)
+void ReadableStreamReader::closed(ClosedSuccessCallback successCallback, ClosedErrorCallback errorCallback)
 {
     if (m_state == State::Closed) {
@@ -85 +89 @@
         return;
     }
+    if (m_state == State::Errored) {
+        errorCallback();
+        return;
+    }
     m_closedSuccessCallback = WTF::move(successCallback);
+    m_closedErrorCallback = WTF::move(errorCallback);
 }
 
@@ -98 +107 @@
     }
     ASSERT(!m_closedSuccessCallback);
+    m_closedErrorCallback = nullptr;
+
+    // FIXME: Implement read promise fulfilling.
+
     releaseStream();
-    // FIXME: Implement read promise fulfilling.
+}
+
+void ReadableStreamReader::changeStateToErrored()
+{
+    ASSERT(m_state == State::Readable);
+    m_state = State::Errored;
+
+    if (m_closedErrorCallback) {
+        ClosedErrorCallback closedErrorCallback = WTF::move(m_closedErrorCallback);
+        closedErrorCallback();
+    }
+    ASSERT(!m_closedErrorCallback);
+    m_closedSuccessCallback = nullptr;
+
+    // FIXME: Implement read promise rejection.
+
+    releaseStream();
 }
 

trunk/Source/WebCore/Modules/streams/ReadableStreamReader.h

@@ -37 +37 @@
 #include "ScriptWrappable.h"
 #include <functional>
+#include <runtime/JSCJSValue.h>
 #include <wtf/Ref.h>
 #include <wtf/RefCounted.h>
@@ -62 +63 @@
 
     void changeStateToClosed();
+    void changeStateToErrored();
+
+    virtual JSC::JSValue error() = 0;
 
 protected:
@@ -78 +82 @@
 
     ClosedSuccessCallback m_closedSuccessCallback;
+    ClosedErrorCallback m_closedErrorCallback;
 };
 

trunk/Source/WebCore/bindings/js/JSDOMPromise.h

@@ -83 +83 @@
 
 template<>
+inline void DeferredWrapper::reject(const JSC::JSValue& value)
+{
+    JSC::ExecState* exec = m_globalObject->globalExec();
+    JSC::JSLockHolder locker(exec);
+    reject(exec, value);
+}
+
+template<>
 inline void DeferredWrapper::resolve<String>(const String& result)
 {

trunk/Source/WebCore/bindings/js/JSReadableStreamControllerCustom.cpp

@@ -63 +63 @@
     if (stream.internalState() != ReadableStream::State::Readable)
         return exec->vm().throwException(exec, createTypeError(exec, ASCIILiteral("Calling error on a stream which is not readable")));
-    notImplemented();
+    stream.storeError(*exec);
     return jsUndefined();
 }

trunk/Source/WebCore/bindings/js/JSReadableStreamReaderCustom.cpp

@@ -76 +76 @@
     };
     auto failureCallback = [this, wrapper]() mutable {
-        // FIXME: return stored error.
-        wrapper.reject(&impl());
+        wrapper.reject(impl().error());
     };
 

trunk/Source/WebCore/bindings/js/ReadableJSStream.cpp

@@ -142 +142 @@
 Ref<ReadableStreamReader> ReadableJSStream::createReader()
 {
-    return Reader::create(*this);
+    Ref<Reader> reader = Reader::create(*this);
+    if (m_error)
+        reader->storeError(*jsSource().globalObject()->globalExec(), m_error.get());
+    return static_reference_cast<ReadableStreamReader>(reader);
 }
 
@@ -162 +165 @@
 }
 
+void ReadableJSStream::storeError(JSC::ExecState& exec)
+{
+    if (m_error)
+        return;
+    JSValue error = exec.argumentCount() ? exec.argument(0) : createError(&exec, ASCIILiteral("Error function called."));
+    m_error.set(exec.vm(), error);
+
+    if (auto reader = static_cast<Reader*>(this->reader()))
+        reader->storeError(exec, error);
+
+    changeStateToErrored();
+}
+
 Ref<ReadableJSStream::Reader> ReadableJSStream::Reader::create(ReadableJSStream& stream)
 {
@@ -172 +188 @@
 }
 
+void ReadableJSStream::Reader::storeError(JSC::ExecState& exec, JSValue error)
+{
+    m_error.set(exec.vm(), error);
+}
+
 } // namespace WebCore
 

trunk/Source/WebCore/bindings/js/ReadableJSStream.h

@@ -52 +52 @@
     public:
         static Ref<Reader> create(ReadableJSStream&);
+        void storeError(JSC::ExecState&, JSC::JSValue);
+        JSC::JSValue error() { return m_error.get(); }
+
     private:
         explicit Reader(ReadableJSStream&);
+
+        JSC::Strong<JSC::Unknown> m_error;
     };
 
@@ -76 +81 @@
     JSC::JSValue jsController(JSC::ExecState&, JSDOMGlobalObject*);
 
+    void storeError(JSC::ExecState&);
+    JSC::JSValue error() { return m_error.get(); }
+
 private:
     ReadableJSStream(ScriptExecutionContext&, Ref<ReadableJSStream::Source>&&);
 
     std::unique_ptr<ReadableStreamController> m_controller;
+    JSC::Strong<JSC::Unknown> m_error;
 };