Streams Implementation Update: async read

Source/core/streams/ReadableStreamTest.cpp

Index: Source/core/streams/ReadableStreamTest.cpp
diff --git a/Source/core/streams/ReadableStreamTest.cpp b/Source/core/streams/ReadableStreamTest.cpp
index 7221ee4d319bb1ddb1a132480d96b71e3ebfa430..162002a5d970827e911a29a3faffbf09c9478e8e 100644
--- a/Source/core/streams/ReadableStreamTest.cpp
+++ b/Source/core/streams/ReadableStreamTest.cpp
@@ -99,6 +99,8 @@ private:
 
 } // unnamed namespace
 
+// ReadableStream::read and some related functionalities are tested in
+// ReadableStreamReaderTest.
 class ReadableStreamTest : public ::testing::Test {
 public:
     ReadableStreamTest()
@@ -173,7 +175,7 @@ TEST_F(ReadableStreamTest, Start)
     EXPECT_FALSE(stream->isStarted());
     EXPECT_FALSE(stream->isDraining());
     EXPECT_FALSE(stream->isPulling());
-    EXPECT_EQ(stream->stateInternal(), ReadableStream::Waiting);
+    EXPECT_EQ(stream->stateInternal(), ReadableStream::Readable);
 
     checkpoint.Call(0);
     stream->didSourceStart();
@@ -182,7 +184,7 @@ TEST_F(ReadableStreamTest, Start)
     EXPECT_TRUE(stream->isStarted());
     EXPECT_FALSE(stream->isDraining());
     EXPECT_TRUE(stream->isPulling());
-    EXPECT_EQ(stream->stateInternal(), ReadableStream::Waiting);
+    EXPECT_EQ(stream->stateInternal(), ReadableStream::Readable);
 
     // We need to call |error| in order to make
     // ActiveDOMObject::hasPendingActivity return false.
@@ -196,7 +198,7 @@ TEST_F(ReadableStreamTest, StartFail)
     EXPECT_FALSE(stream->isStarted());
     EXPECT_FALSE(stream->isDraining());
     EXPECT_FALSE(stream->isPulling());
-    EXPECT_EQ(stream->stateInternal(), ReadableStream::Waiting);
+    EXPECT_EQ(stream->stateInternal(), ReadableStream::Readable);
 
     stream->error(DOMException::create(NotFoundError));
 
@@ -206,68 +208,6 @@ TEST_F(ReadableStreamTest, StartFail)
     EXPECT_EQ(stream->stateInternal(), ReadableStream::Errored);
 }
 
-TEST_F(ReadableStreamTest, WaitOnWaiting)
-{
-    StringStream* stream = construct();
-    Checkpoint checkpoint;
-
-    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
-    EXPECT_TRUE(stream->isStarted());
-    EXPECT_TRUE(stream->isPulling());
-
-    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
-
-    stream->error(DOMException::create(AbortError, "done"));
-}
-
-TEST_F(ReadableStreamTest, WaitDuringStarting)
-{
-    StringStream* stream = new StringStream(scriptState()->executionContext(), m_underlyingSource);
-    Checkpoint checkpoint;
-
-    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
-    EXPECT_FALSE(stream->isStarted());
-    EXPECT_FALSE(stream->isPulling());
-
-    {
-        InSequence s;
-        EXPECT_CALL(checkpoint, Call(0));
-        EXPECT_CALL(*m_underlyingSource, pullSource()).Times(1);
-        EXPECT_CALL(checkpoint, Call(1));
-    }
-
-    stream->ready(scriptState());
-    checkpoint.Call(0);
-    stream->didSourceStart();
-    checkpoint.Call(1);
-
-    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
-    EXPECT_TRUE(stream->isStarted());
-    EXPECT_TRUE(stream->isPulling());
-
-    stream->error(DOMException::create(AbortError, "done"));
-}
-
-TEST_F(ReadableStreamTest, WaitAndError)
-{
-    StringStream* stream = construct();
-    String onFulfilled, onRejected;
-
-    ScriptPromise promise = stream->ready(scriptState());
-    promise.then(createCaptor(&onFulfilled), createCaptor(&onRejected));
-    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
-    EXPECT_TRUE(stream->isPulling());
-    stream->error(DOMException::create(NotFoundError, "hello, error"));
-    EXPECT_EQ(ReadableStream::Errored, stream->stateInternal());
-    EXPECT_TRUE(stream->isPulling());
-    EXPECT_TRUE(onFulfilled.isNull());
-    EXPECT_TRUE(onRejected.isNull());
-
-    isolate()->RunMicrotasks();
-    EXPECT_TRUE(onFulfilled.isNull());
-    EXPECT_EQ("NotFoundError: hello, error", onRejected);
-}
-
 TEST_F(ReadableStreamTest, ErrorAndEnqueue)
 {
     StringStream* stream = construct();
@@ -292,253 +232,15 @@ TEST_F(ReadableStreamTest, CloseAndEnqueue)
     EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
 }
 
-TEST_F(ReadableStreamTest, EnqueueAndWait)
-{
-    StringStream* stream = construct();
-    String onFulfilled, onRejected;
-    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
-
-    bool result = stream->enqueue("hello");
-    EXPECT_TRUE(result);
-    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
-
-    stream->ready(scriptState()).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
-    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
-    EXPECT_FALSE(stream->isPulling());
-    EXPECT_TRUE(onFulfilled.isNull());
-    EXPECT_TRUE(onRejected.isNull());
-
-    isolate()->RunMicrotasks();
-    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
-    EXPECT_FALSE(stream->isPulling());
-    EXPECT_EQ("undefined", onFulfilled);
-    EXPECT_TRUE(onRejected.isNull());
-
-    stream->error(DOMException::create(AbortError, "done"));
-}
-
-TEST_F(ReadableStreamTest, WaitAndEnqueue)
-{
-    StringStream* stream = construct();
-    String onFulfilled, onRejected;
-    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
-
-    stream->ready(scriptState()).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
-    isolate()->RunMicrotasks();
-
-    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
-    EXPECT_TRUE(stream->isPulling());
-    EXPECT_TRUE(onFulfilled.isNull());
-    EXPECT_TRUE(onRejected.isNull());
-
-    bool result = stream->enqueue("hello");
-    EXPECT_TRUE(result);
-    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
-    EXPECT_FALSE(stream->isPulling());
-    EXPECT_TRUE(onFulfilled.isNull());
-    EXPECT_TRUE(onRejected.isNull());
-
-    isolate()->RunMicrotasks();
-    EXPECT_EQ("undefined", onFulfilled);
-    EXPECT_TRUE(onRejected.isNull());
-
-    stream->error(DOMException::create(AbortError, "done"));
-}
-
-TEST_F(ReadableStreamTest, WaitAndEnqueueAndError)
-{
-    StringStream* stream = construct();
-    String onFulfilled, onRejected;
-    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
-
-    ScriptPromise promise = stream->ready(scriptState());
-    promise.then(createCaptor(&onFulfilled), createCaptor(&onRejected));
-    isolate()->RunMicrotasks();
-
-    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
-    EXPECT_TRUE(stream->isPulling());
-    EXPECT_TRUE(onFulfilled.isNull());
-    EXPECT_TRUE(onRejected.isNull());
-
-    bool result = stream->enqueue("hello");
-    EXPECT_TRUE(result);
-    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
-    EXPECT_FALSE(stream->isPulling());
-    EXPECT_TRUE(onFulfilled.isNull());
-    EXPECT_TRUE(onRejected.isNull());
-
-    isolate()->RunMicrotasks();
-    EXPECT_EQ("undefined", onFulfilled);
-    EXPECT_TRUE(onRejected.isNull());
-
-    stream->error(DOMException::create(NotFoundError, "error"));
-    EXPECT_EQ(ReadableStream::Errored, stream->stateInternal());
-
-    EXPECT_NE(promise, stream->ready(scriptState()));
-}
-
-TEST_F(ReadableStreamTest, CloseWhenWaiting)
-{
-    String onWaitFulfilled, onWaitRejected;
-    String onClosedFulfilled, onClosedRejected;
-
-    StringStream* stream = construct();
-
-    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
-    stream->ready(scriptState()).then(createCaptor(&onWaitFulfilled), createCaptor(&onWaitRejected));
-    stream->closed(scriptState()).then(createCaptor(&onClosedFulfilled), createCaptor(&onClosedRejected));
-
-    isolate()->RunMicrotasks();
-    EXPECT_TRUE(onWaitFulfilled.isNull());
-    EXPECT_TRUE(onWaitRejected.isNull());
-    EXPECT_TRUE(onClosedFulfilled.isNull());
-    EXPECT_TRUE(onClosedRejected.isNull());
-
-    stream->close();
-    EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
-    isolate()->RunMicrotasks();
-    EXPECT_EQ("undefined", onWaitFulfilled);
-    EXPECT_TRUE(onWaitRejected.isNull());
-    EXPECT_EQ("undefined", onClosedFulfilled);
-    EXPECT_TRUE(onClosedRejected.isNull());
-}
-
 TEST_F(ReadableStreamTest, CloseWhenErrored)
 {
-    String onFulfilled, onRejected;
     StringStream* stream = construct();
-    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
-    stream->closed(scriptState()).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
+    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
 
     stream->error(DOMException::create(NotFoundError, "error"));
     stream->close();
 
     EXPECT_EQ(ReadableStream::Errored, stream->stateInternal());
-    isolate()->RunMicrotasks();
-
-    EXPECT_TRUE(onFulfilled.isNull());
-    EXPECT_EQ("NotFoundError: error", onRejected);
-}
-
-TEST_F(ReadableStreamTest, ReadWhenWaiting)
-{
-    StringStream* stream = construct();
-    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
-    EXPECT_FALSE(m_exceptionState.hadException());
-
-    stream->read(scriptState(), m_exceptionState);
-    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
-    EXPECT_TRUE(m_exceptionState.hadException());
-    EXPECT_EQ(V8TypeError, m_exceptionState.code());
-    EXPECT_EQ("read is called while state is waiting", m_exceptionState.message());
-
-    stream->error(DOMException::create(AbortError, "done"));
-}
-
-TEST_F(ReadableStreamTest, ReadWhenClosed)
-{
-    StringStream* stream = construct();
-    stream->close();
-
-    EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
-    EXPECT_FALSE(m_exceptionState.hadException());
-
-    stream->read(scriptState(), m_exceptionState);
-    EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
-    EXPECT_TRUE(m_exceptionState.hadException());
-    EXPECT_EQ(V8TypeError, m_exceptionState.code());
-    EXPECT_EQ("read is called while state is closed", m_exceptionState.message());
-}
-
-TEST_F(ReadableStreamTest, ReadWhenErrored)
-{
-    // DOMException values specified in the spec are different from enum values
-    // defined in ExceptionCode.h.
-    const int notFoundExceptionCode = 8;
-    StringStream* stream = construct();
-    stream->error(DOMException::create(NotFoundError, "error"));
-
-    EXPECT_EQ(ReadableStream::Errored, stream->stateInternal());
-    EXPECT_FALSE(m_exceptionState.hadException());
-
-    stream->read(scriptState(), m_exceptionState);
-    EXPECT_EQ(ReadableStream::Errored, stream->stateInternal());
-    EXPECT_TRUE(m_exceptionState.hadException());
-    EXPECT_EQ(notFoundExceptionCode, m_exceptionState.code());
-    EXPECT_EQ("error", m_exceptionState.message());
-}
-
-TEST_F(ReadableStreamTest, EnqueuedAndRead)
-{
-    StringStream* stream = construct();
-    String onFulfilled, onRejected;
-    Checkpoint checkpoint;
-
-    {
-        InSequence s;
-        EXPECT_CALL(checkpoint, Call(0));
-        EXPECT_CALL(*m_underlyingSource, pullSource()).Times(1);
-        EXPECT_CALL(checkpoint, Call(1));
-    }
-
-    stream->enqueue("hello");
-    ScriptPromise promise = stream->ready(scriptState());
-    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
-    EXPECT_FALSE(stream->isPulling());
-
-    checkpoint.Call(0);
-    String chunk;
-    EXPECT_TRUE(stream->read(scriptState(), m_exceptionState).toString(chunk));
-    checkpoint.Call(1);
-    EXPECT_FALSE(m_exceptionState.hadException());
-    EXPECT_EQ("hello", chunk);
-    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
-    EXPECT_TRUE(stream->isPulling());
-    EXPECT_FALSE(stream->isDraining());
-
-    ScriptPromise newPromise = stream->ready(scriptState());
-    newPromise.then(createCaptor(&onFulfilled), createCaptor(&onRejected));
-    isolate()->RunMicrotasks();
-    EXPECT_NE(promise, newPromise);
-    EXPECT_TRUE(onFulfilled.isNull());
-    EXPECT_TRUE(onRejected.isNull());
-
-    stream->error(DOMException::create(AbortError, "done"));
-    isolate()->RunMicrotasks();
-}
-
-TEST_F(ReadableStreamTest, EnqueueTwiceAndRead)
-{
-    StringStream* stream = construct();
-    Checkpoint checkpoint;
-
-    {
-        InSequence s;
-        EXPECT_CALL(checkpoint, Call(0));
-        EXPECT_CALL(*m_underlyingSource, pullSource()).Times(1);
-        EXPECT_CALL(checkpoint, Call(1));
-    }
-
-    EXPECT_TRUE(stream->enqueue("hello"));
-    EXPECT_TRUE(stream->enqueue("bye"));
-    ScriptPromise promise = stream->ready(scriptState());
-    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
-    EXPECT_FALSE(stream->isPulling());
-
-    String chunk;
-    checkpoint.Call(0);
-    EXPECT_TRUE(stream->read(scriptState(), m_exceptionState).toString(chunk));
-    checkpoint.Call(1);
-    EXPECT_FALSE(m_exceptionState.hadException());
-    EXPECT_EQ("hello", chunk);
-    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
-    EXPECT_TRUE(stream->isPulling());
-    EXPECT_FALSE(stream->isDraining());
-
-    ScriptPromise newPromise = stream->ready(scriptState());
-    EXPECT_EQ(promise, newPromise);
-
-    stream->error(DOMException::create(AbortError, "done"));
 }
 
 TEST_F(ReadableStreamTest, ReadQueue)
@@ -560,7 +262,6 @@ TEST_F(ReadableStreamTest, ReadQueue)
     EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
     EXPECT_FALSE(stream->isPulling());
 
-    String chunk;
     checkpoint.Call(0);
     stream->readInternal(queue);
     checkpoint.Call(1);
@@ -569,7 +270,7 @@ TEST_F(ReadableStreamTest, ReadQueue)
     EXPECT_EQ(std::make_pair(String("hello"), static_cast<size_t>(5)), queue[0]);
     EXPECT_EQ(std::make_pair(String("bye"), static_cast<size_t>(3)), queue[1]);
 
-    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
+    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
     EXPECT_TRUE(stream->isPulling());
     EXPECT_FALSE(stream->isDraining());
 }
@@ -577,23 +278,17 @@ TEST_F(ReadableStreamTest, ReadQueue)
 TEST_F(ReadableStreamTest, CloseWhenReadable)
 {
     StringStream* stream = construct();
-    String onClosedFulfilled, onClosedRejected;
 
-    stream->closed(scriptState()).then(createCaptor(&onClosedFulfilled), createCaptor(&onClosedRejected));
     EXPECT_TRUE(stream->enqueue("hello"));
     EXPECT_TRUE(stream->enqueue("bye"));
     stream->close();
     EXPECT_FALSE(stream->enqueue("should be ignored"));
 
-    ScriptPromise promise = stream->ready(scriptState());
     EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_TRUE(stream->isDraining());
 
-    String chunk;
-    EXPECT_TRUE(stream->read(scriptState(), m_exceptionState).toString(chunk));
-    EXPECT_EQ("hello", chunk);
-    EXPECT_EQ(promise, stream->ready(scriptState()));
+    stream->read(scriptState());
 
     isolate()->RunMicrotasks();
 
@@ -601,22 +296,11 @@ TEST_F(ReadableStreamTest, CloseWhenReadable)
     EXPECT_FALSE(stream->isPulling());
     EXPECT_TRUE(stream->isDraining());
 
-    EXPECT_TRUE(stream->read(scriptState(), m_exceptionState).toString(chunk));
-    EXPECT_EQ("bye", chunk);
-    EXPECT_FALSE(m_exceptionState.hadException());
-
-    EXPECT_EQ(promise, stream->ready(scriptState()));
+    stream->read(scriptState());
 
     EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_TRUE(stream->isDraining());
-
-    EXPECT_TRUE(onClosedFulfilled.isNull());
-    EXPECT_TRUE(onClosedRejected.isNull());
-
-    isolate()->RunMicrotasks();
-    EXPECT_EQ("undefined", onClosedFulfilled);
-    EXPECT_TRUE(onClosedRejected.isNull());
 }
 
 TEST_F(ReadableStreamTest, CancelWhenClosed)
@@ -657,32 +341,6 @@ TEST_F(ReadableStreamTest, CancelWhenErrored)
     EXPECT_EQ("NotFoundError: error", onRejected);
 }
 
-TEST_F(ReadableStreamTest, CancelWhenWaiting)
-{
-    StringStream* stream = construct();
-    String onFulfilled, onRejected;
-    ScriptValue reason(scriptState(), v8String(scriptState()->isolate(), "reason"));
-    ScriptPromise promise = ScriptPromise::cast(scriptState(), v8String(scriptState()->isolate(), "hello"));
-
-    {
-        InSequence s;
-        EXPECT_CALL(*m_underlyingSource, cancelSource(scriptState(), reason)).WillOnce(Return(promise));
-    }
-
-    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
-    ScriptPromise ready = stream->ready(scriptState());
-    EXPECT_NE(promise, stream->cancel(scriptState(), reason));
-    EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
-
-    ready.then(createCaptor(&onFulfilled), createCaptor(&onRejected));
-    EXPECT_TRUE(onFulfilled.isNull());
-    EXPECT_TRUE(onRejected.isNull());
-
-    isolate()->RunMicrotasks();
-    EXPECT_EQ("undefined", onFulfilled);
-    EXPECT_TRUE(onRejected.isNull());
-}
-
 TEST_F(ReadableStreamTest, CancelWhenReadable)
 {
     StringStream* stream = construct();
@@ -697,7 +355,6 @@ TEST_F(ReadableStreamTest, CancelWhenReadable)
     }
 
     stream->enqueue("hello");
-    ScriptPromise ready = stream->ready(scriptState());
     EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
 
     ScriptPromise cancelResult = stream->cancel(scriptState(), reason);
@@ -706,8 +363,6 @@ TEST_F(ReadableStreamTest, CancelWhenReadable)
     EXPECT_NE(promise, cancelResult);
     EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
 
-    EXPECT_EQ(stream->ready(scriptState()), ready);
-
     EXPECT_TRUE(onCancelFulfilled.isNull());
     EXPECT_TRUE(onCancelRejected.isNull());
 
@@ -716,6 +371,29 @@ TEST_F(ReadableStreamTest, CancelWhenReadable)
     EXPECT_TRUE(onCancelRejected.isNull());
 }
 
+TEST_F(ReadableStreamTest, CancelWhenLocked)
+{
+    String onFulfilled, onRejected;
+    StringStream* stream = construct();
+    ReadableStreamReader* reader = stream->getReader(m_exceptionState);
+
+    EXPECT_TRUE(reader->isActive());
+    EXPECT_FALSE(m_exceptionState.hadException());
+    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
+
+    stream->cancel(scriptState(), ScriptValue(scriptState(), v8::Undefined(isolate()))).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
+
+    EXPECT_TRUE(onFulfilled.isNull());
+    EXPECT_TRUE(onRejected.isNull());
+
+    isolate()->RunMicrotasks();
+
+    EXPECT_TRUE(onFulfilled.isNull());
+    EXPECT_EQ("TypeError: this stream is locked to a ReadableStreamReader", onRejected);
+    EXPECT_TRUE(reader->isActive());
+    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
+}
+
 TEST_F(ReadableStreamTest, ReadableArrayBufferCompileTest)
 {
     // This test tests if ReadableStreamImpl<DOMArrayBuffer> can be
@@ -729,7 +407,7 @@ TEST_F(ReadableStreamTest, BackpressureOnEnqueueing)
     Checkpoint checkpoint;
 
     StringStream* stream = construct(strategy);
-    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
+    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
 
     {
         InSequence s;
@@ -759,9 +437,11 @@ TEST_F(ReadableStreamTest, BackpressureOnReading)
 {
     auto strategy = MockStrategy::create();
     Checkpoint checkpoint;
+    String onFulfilled, onRejected;
+    String onFulfilled2, onRejected2;

[tyoshino (SeeGerritForStatus), 2015/03/19 07:54:52]

unused?

[yhirano, 2015/03/19 08:39:02]

Thanks, done.

 
     StringStream* stream = construct(strategy);
-    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
+    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
 
     {
         InSequence s;
@@ -788,19 +468,15 @@ TEST_F(ReadableStreamTest, BackpressureOnReading)
     stream->enqueue("hello");
     stream->enqueue("world");
 
-    String chunk;
     checkpoint.Call(0);
-    EXPECT_TRUE(stream->read(scriptState(), m_exceptionState).toString(chunk));
-    EXPECT_EQ("hello", chunk);
+    stream->read(scriptState());
     checkpoint.Call(1);
-    EXPECT_TRUE(stream->read(scriptState(), m_exceptionState).toString(chunk));
-    EXPECT_EQ("world", chunk);
+    stream->read(scriptState());
     checkpoint.Call(2);
     stream->enqueue("foo");
     stream->enqueue("bar");
     checkpoint.Call(3);
-    EXPECT_TRUE(stream->read(scriptState(), m_exceptionState).toString(chunk));
-    EXPECT_EQ("foo", chunk);
+    stream->read(scriptState());
     checkpoint.Call(4);
 
     stream->error(DOMException::create(AbortError, "done"));
@@ -824,4 +500,46 @@ TEST_F(ReadableStreamTest, ReadableStreamReader)
     EXPECT_TRUE(stream->isLockedTo(reader));
 }
 
+TEST_F(ReadableStreamTest, GetClosedReader)
+{
+    StringStream* stream = construct();
+    stream->close();
+    ReadableStreamReader* reader = stream->getReader(m_exceptionState);
+
+    ASSERT_TRUE(reader);
+    EXPECT_FALSE(m_exceptionState.hadException());
+
+    String onFulfilled, onRejected;
+    reader->closed(scriptState()).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
+
+    EXPECT_FALSE(reader->isActive());
+    EXPECT_TRUE(onFulfilled.isNull());
+    EXPECT_TRUE(onRejected.isNull());
+
+    isolate()->RunMicrotasks();
+    EXPECT_EQ("undefined", onFulfilled);
+    EXPECT_TRUE(onRejected.isNull());
+}
+
+TEST_F(ReadableStreamTest, GetErroredReader)
+{
+    StringStream* stream = construct();
+    stream->error(DOMException::create(SyntaxError, "some error"));
+    ReadableStreamReader* reader = stream->getReader(m_exceptionState);
+
+    ASSERT_TRUE(reader);
+    EXPECT_FALSE(m_exceptionState.hadException());
+
+    String onFulfilled, onRejected;
+    reader->closed(scriptState()).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
+
+    EXPECT_FALSE(reader->isActive());
+    EXPECT_TRUE(onFulfilled.isNull());
+    EXPECT_TRUE(onRejected.isNull());
+
+    isolate()->RunMicrotasks();
+    EXPECT_TRUE(onFulfilled.isNull());
+    EXPECT_EQ("SyntaxError: some error", onRejected);
+}
+
 } // namespace blink