Make ReadableStream implementation up to date.

Source/core/streams/ReadableStreamTest.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/streams/ReadableStream.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
@@ skipping 87 matching lines @@
     ScriptState* scriptState() { return ScriptState::forMainWorld(m_page->document().frame()); }
     v8::Isolate* isolate() { return scriptState()->isolate(); }
 
     v8::Handle<v8::Function> createCaptor(String* value)
     {
         return StringCapturingFunction::createFunction(scriptState(), value);
     }
 
     StringStream* construct()
     {
+        Checkpoint checkpoint;
+        {
+            InSequence s;
+            EXPECT_CALL(checkpoint, Call(0));
+            EXPECT_CALL(*m_underlyingSource, pullSource()).Times(1);
+            EXPECT_CALL(checkpoint, Call(1));
+        }
         StringStream* stream = new StringStream(scriptState()->executionContext(), m_underlyingSource);
+        checkpoint.Call(0);
         stream->didSourceStart();
+        checkpoint.Call(1);
         return stream;
     }
 
     OwnPtr<DummyPageHolder> m_page;
     ScriptState::Scope m_scope;
     Persistent<MockUnderlyingSource> m_underlyingSource;
     ExceptionState m_exceptionState;
 };
 
 TEST_F(ReadableStreamTest, Start)
 {
+    Checkpoint checkpoint;
+    {
+        InSequence s;
+        EXPECT_CALL(checkpoint, Call(0));
+        EXPECT_CALL(*m_underlyingSource, pullSource()).Times(1);
+        EXPECT_CALL(checkpoint, Call(1));
+    }
+
     StringStream* stream = new StringStream(scriptState()->executionContext(), m_underlyingSource);
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_FALSE(stream->isStarted());
     EXPECT_FALSE(stream->isDraining());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_EQ(stream->state(), ReadableStream::Waiting);
 
+    checkpoint.Call(0);
     stream->didSourceStart();
+    checkpoint.Call(1);
 
     EXPECT_TRUE(stream->isStarted());
     EXPECT_FALSE(stream->isDraining());
-    EXPECT_FALSE(stream->isPulling());
+    EXPECT_TRUE(stream->isPulling());
     EXPECT_EQ(stream->state(), ReadableStream::Waiting);
 }
 
 TEST_F(ReadableStreamTest, StartFail)
 {
     StringStream* stream = new StringStream(scriptState()->executionContext(), m_underlyingSource);
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_FALSE(stream->isStarted());
     EXPECT_FALSE(stream->isDraining());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_EQ(stream->state(), ReadableStream::Waiting);
 
     stream->error(DOMException::create(NotFoundError));
 
     EXPECT_FALSE(stream->isStarted());
     EXPECT_FALSE(stream->isDraining());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_EQ(stream->state(), ReadableStream::Errored);
 }
 
 TEST_F(ReadableStreamTest, WaitOnWaiting)
 {
     StringStream* stream = construct();
     Checkpoint checkpoint;
 
     EXPECT_EQ(ReadableStream::Waiting, stream->state());
     EXPECT_TRUE(stream->isStarted());
-    EXPECT_FALSE(stream->isPulling());
+    EXPECT_TRUE(stream->isPulling());
 
-    {
-        InSequence s;
-        EXPECT_CALL(checkpoint, Call(0));
-        EXPECT_CALL(*m_underlyingSource, pullSource()).Times(1);
-        EXPECT_CALL(checkpoint, Call(1));
-    }
-
-    checkpoint.Call(0);
     ScriptPromise p = stream->wait(scriptState());
     ScriptPromise q = stream->wait(scriptState());
-    checkpoint.Call(1);
 
     EXPECT_EQ(ReadableStream::Waiting, stream->state());
-    EXPECT_TRUE(stream->isPulling());
     EXPECT_EQ(q, p);
 }
 
 TEST_F(ReadableStreamTest, WaitDuringStarting)
 {
     StringStream* stream = new StringStream(scriptState()->executionContext(), m_underlyingSource);
     Checkpoint checkpoint;
 
     EXPECT_EQ(ReadableStream::Waiting, stream->state());
     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));
-        EXPECT_CALL(*m_underlyingSource, pullSource()).Times(1);
     }
 
+    stream->wait(scriptState());
     checkpoint.Call(0);
-    stream->wait(scriptState());
+    stream->didSourceStart();
     checkpoint.Call(1);
 
-    EXPECT_TRUE(stream->isPulling());
-
-    stream->didSourceStart();
-
     EXPECT_EQ(ReadableStream::Waiting, stream->state());
+    EXPECT_TRUE(stream->isStarted());
     EXPECT_TRUE(stream->isPulling());
 }
 
 TEST_F(ReadableStreamTest, WaitAndError)
 {
     StringStream* stream = construct();
     String onFulfilled, onRejected;
 
-    {
-        InSequence s;
-        EXPECT_CALL(*m_underlyingSource, pullSource()).Times(1);
-    }
-
     ScriptPromise promise = stream->wait(scriptState());
     promise.then(createCaptor(&onFulfilled), createCaptor(&onRejected));
     EXPECT_EQ(ReadableStream::Waiting, stream->state());
     EXPECT_TRUE(stream->isPulling());
     stream->error(DOMException::create(NotFoundError, "hello, error"));
     EXPECT_EQ(ReadableStream::Errored, stream->state());
     EXPECT_TRUE(stream->isPulling());
     EXPECT_TRUE(onFulfilled.isNull());
     EXPECT_TRUE(onRejected.isNull());
 
@@ skipping 49 matching lines @@
     EXPECT_EQ("undefined", onFulfilled);
     EXPECT_TRUE(onRejected.isNull());
 }
 
 TEST_F(ReadableStreamTest, WaitAndEnqueue)
 {
     StringStream* stream = construct();
     String onFulfilled, onRejected;
     EXPECT_EQ(ReadableStream::Waiting, stream->state());
 
-    {
-        InSequence s;
-        EXPECT_CALL(*m_underlyingSource, pullSource()).Times(1);
-    }
-
     stream->wait(scriptState()).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
     isolate()->RunMicrotasks();
 
     EXPECT_EQ(ReadableStream::Waiting, stream->state());
     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->state());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_TRUE(onFulfilled.isNull());
     EXPECT_TRUE(onRejected.isNull());
 
     isolate()->RunMicrotasks();
     EXPECT_EQ("undefined", onFulfilled);
     EXPECT_TRUE(onRejected.isNull());
 }
 
 TEST_F(ReadableStreamTest, WaitAndEnqueueAndError)
 {
     StringStream* stream = construct();
     String onFulfilled, onRejected;
     EXPECT_EQ(ReadableStream::Waiting, stream->state());
 
-    {
-        InSequence s;
-        EXPECT_CALL(*m_underlyingSource, pullSource()).Times(1);
-    }
-
     ScriptPromise promise = stream->wait(scriptState());
     promise.then(createCaptor(&onFulfilled), createCaptor(&onRejected));
     isolate()->RunMicrotasks();
 
     EXPECT_EQ(ReadableStream::Waiting, stream->state());
     EXPECT_TRUE(stream->isPulling());
     EXPECT_TRUE(onFulfilled.isNull());
     EXPECT_TRUE(onRejected.isNull());
 
     bool result = stream->enqueue("hello");
@@ skipping 13 matching lines @@
     EXPECT_NE(promise, stream->wait(scriptState()));
 }
 
 TEST_F(ReadableStreamTest, CloseWhenWaiting)
 {
     String onWaitFulfilled, onWaitRejected;
     String onClosedFulfilled, onClosedRejected;
 
     StringStream* stream = construct();
 
-    {
-        InSequence s;
-        EXPECT_CALL(*m_underlyingSource, pullSource()).Times(1);
-    }
-
     EXPECT_EQ(ReadableStream::Waiting, stream->state());
     stream->wait(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());
 
@@ skipping 98 matching lines @@
     EXPECT_FALSE(stream->isDraining());
 
     ScriptPromise newPromise = stream->wait(scriptState());
     newPromise.then(createCaptor(&onFulfilled), createCaptor(&onRejected));
     isolate()->RunMicrotasks();
     EXPECT_NE(promise, newPromise);
     EXPECT_TRUE(onFulfilled.isNull());
     EXPECT_TRUE(onRejected.isNull());
 }
 
-TEST_F(ReadableStreamTest, EnqueTwiceAndRead)
+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->wait(scriptState());
     EXPECT_EQ(ReadableStream::Readable, stream->state());
     EXPECT_FALSE(stream->isPulling());
 
+    String chunk;
     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::Readable, stream->state());
-    EXPECT_FALSE(stream->isPulling());
+    EXPECT_TRUE(stream->isPulling());
     EXPECT_FALSE(stream->isDraining());
 
     ScriptPromise newPromise = stream->wait(scriptState());
     EXPECT_EQ(promise, newPromise);
 }
 
 TEST_F(ReadableStreamTest, CloseWhenReadable)
 {
     StringStream* stream = construct();
-    String onWaitFulfilled, onWaitRejected;
     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->wait(scriptState());
     EXPECT_EQ(ReadableStream::Readable, stream->state());
     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->wait(scriptState()));
 
     isolate()->RunMicrotasks();
 
     EXPECT_EQ(ReadableStream::Readable, stream->state());
     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_NE(promise, stream->wait(scriptState()));
-    stream->wait(scriptState()).then(createCaptor(&onWaitFulfilled), createCaptor(&onWaitRejected));

[tyoshino (SeeGerritForStatus), 2014/11/11 12:43:33]

can't we keep this line?

[yhirano, 2014/11/12 04:20:29]

This is a test for "close when readable" case, and waitPromise is not related to
this test. I only want to check that close() don't reset the promise here.
Previously, close() reset waitPromise and resolved it with undefined, so I
checked that in this case.

[tyoshino (SeeGerritForStatus), 2014/11/12 04:27:16]

OK

+    EXPECT_EQ(promise, stream->wait(scriptState()));
 
     EXPECT_EQ(ReadableStream::Closed, stream->state());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_TRUE(stream->isDraining());
 
-    EXPECT_TRUE(onWaitFulfilled.isNull());
-    EXPECT_TRUE(onWaitRejected.isNull());

[tyoshino (SeeGerritForStatus), 2014/11/11 12:43:33]

and these

     EXPECT_TRUE(onClosedFulfilled.isNull());
     EXPECT_TRUE(onClosedRejected.isNull());
 
     isolate()->RunMicrotasks();
-    EXPECT_EQ("undefined", onWaitFulfilled);
-    EXPECT_TRUE(onWaitRejected.isNull());

[tyoshino (SeeGerritForStatus), 2014/11/11 12:43:33]

and these

     EXPECT_EQ("undefined", onClosedFulfilled);
     EXPECT_TRUE(onClosedRejected.isNull());
 }
 
 TEST_F(ReadableStreamTest, CancelWhenClosed)
 {
     StringStream* stream = construct();
     String onFulfilled, onRejected;
     stream->close();
     EXPECT_EQ(ReadableStream::Closed, stream->state());
@@ skipping 31 matching lines @@
 
 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, pullSource()).Times(1);
         EXPECT_CALL(*m_underlyingSource, cancelSource(scriptState(), reason)).WillOnce(Return(promise));
     }
 
     EXPECT_EQ(ReadableStream::Waiting, stream->state());
     ScriptPromise wait = stream->wait(scriptState());
-    EXPECT_EQ(promise, stream->cancel(scriptState(), reason));
+    EXPECT_NE(promise, stream->cancel(scriptState(), reason));
     EXPECT_EQ(ReadableStream::Closed, stream->state());
     EXPECT_EQ(stream->wait(scriptState()), wait);
 
     wait.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();
     String onFulfilled, onRejected;
+    String onCancelFulfilled, onCancelRejected;
     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));
     }
 
     stream->enqueue("hello");
     ScriptPromise wait = stream->wait(scriptState());
     EXPECT_EQ(ReadableStream::Readable, stream->state());
-    EXPECT_EQ(promise, stream->cancel(scriptState(), reason));
+
+    ScriptPromise cancelResult = stream->cancel(scriptState(), reason);
+    cancelResult.then(createCaptor(&onCancelFulfilled), createCaptor(&onCancelRejected));
+
+    EXPECT_NE(promise, cancelResult);
     EXPECT_EQ(ReadableStream::Closed, stream->state());
 
-    EXPECT_NE(stream->wait(scriptState()), wait);
+    EXPECT_EQ(stream->wait(scriptState()), wait);
 
-    stream->wait(scriptState()).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
-    EXPECT_TRUE(onFulfilled.isNull());
-    EXPECT_TRUE(onRejected.isNull());
+    EXPECT_TRUE(onCancelFulfilled.isNull());
+    EXPECT_TRUE(onCancelRejected.isNull());
 
     isolate()->RunMicrotasks();
-    EXPECT_EQ("undefined", onFulfilled);
-    EXPECT_TRUE(onRejected.isNull());
+    EXPECT_EQ("undefined", onCancelFulfilled);
+    EXPECT_TRUE(onCancelRejected.isNull());
 }
 
 TEST_F(ReadableStreamTest, ReadableArrayBufferCompileTest)
 {
     // This test tests if ReadableStreamImpl<DOMArrayBuffer> can be instantiated.
     new ReadableStreamImpl<ReadableStreamChunkTypeTraits<DOMArrayBuffer> >(scriptState()->executionContext(), m_underlyingSource);
 }
 
 } // namespace blink