Rename ReadableStream.wait() to ReadableStream.ready.

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 192 matching lines @@
 
 TEST_F(ReadableStreamTest, WaitOnWaiting)
 {
     StringStream* stream = construct();
     Checkpoint checkpoint;
 
     EXPECT_EQ(ReadableStream::Waiting, stream->state());
     EXPECT_TRUE(stream->isStarted());
     EXPECT_TRUE(stream->isPulling());
 
-    ScriptPromise p = stream->wait(scriptState());
-    ScriptPromise q = stream->wait(scriptState());
+    ScriptPromise p = stream->ready(scriptState());
+    ScriptPromise q = stream->ready(scriptState());
 
     EXPECT_EQ(ReadableStream::Waiting, stream->state());
     EXPECT_EQ(q, p);
 
     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->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));
     }
 
-    stream->wait(scriptState());
+    stream->ready(scriptState());
     checkpoint.Call(0);
     stream->didSourceStart();
     checkpoint.Call(1);
 
     EXPECT_EQ(ReadableStream::Waiting, stream->state());
     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->wait(scriptState());
+    ScriptPromise promise = stream->ready(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());
 
     isolate()->RunMicrotasks();
     EXPECT_TRUE(onFulfilled.isNull());
-    EXPECT_EQ(promise, stream->wait(scriptState()));
+    EXPECT_EQ(promise, stream->ready(scriptState()));
     EXPECT_EQ("NotFoundError: hello, error", onRejected);
 }
 
 TEST_F(ReadableStreamTest, ErrorAndEnqueue)
 {
     StringStream* stream = construct();
 
     stream->error(DOMException::create(NotFoundError, "error"));
     EXPECT_EQ(ReadableStream::Errored, stream->state());
 
@@ skipping 17 matching lines @@
 TEST_F(ReadableStreamTest, EnqueueAndWait)
 {
     StringStream* stream = construct();
     String onFulfilled, onRejected;
     EXPECT_EQ(ReadableStream::Waiting, stream->state());
 
     bool result = stream->enqueue("hello");
     EXPECT_TRUE(result);
     EXPECT_EQ(ReadableStream::Readable, stream->state());
 
-    stream->wait(scriptState()).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
+    stream->ready(scriptState()).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
     EXPECT_EQ(ReadableStream::Readable, stream->state());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_TRUE(onFulfilled.isNull());
     EXPECT_TRUE(onRejected.isNull());
 
     isolate()->RunMicrotasks();
     EXPECT_EQ(ReadableStream::Readable, stream->state());
     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->state());
 
-    stream->wait(scriptState()).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
+    stream->ready(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());
 
     stream->error(DOMException::create(AbortError, "done"));
 }
 
 TEST_F(ReadableStreamTest, WaitAndEnqueueAndError)
 {
     StringStream* stream = construct();
     String onFulfilled, onRejected;
     EXPECT_EQ(ReadableStream::Waiting, stream->state());
 
-    ScriptPromise promise = stream->wait(scriptState());
+    ScriptPromise promise = stream->ready(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");
     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());
 
     stream->error(DOMException::create(NotFoundError, "error"));
     EXPECT_EQ(ReadableStream::Errored, stream->state());
 
-    EXPECT_NE(promise, stream->wait(scriptState()));
+    EXPECT_NE(promise, stream->ready(scriptState()));
 }
 
 TEST_F(ReadableStreamTest, CloseWhenWaiting)
 {
     String onWaitFulfilled, onWaitRejected;
     String onClosedFulfilled, onClosedRejected;
 
     StringStream* stream = construct();
 
     EXPECT_EQ(ReadableStream::Waiting, stream->state());
-    stream->wait(scriptState()).then(createCaptor(&onWaitFulfilled), createCaptor(&onWaitRejected));
+    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->state());
@@ skipping 76 matching lines @@
     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->wait(scriptState());
+    ScriptPromise promise = stream->ready(scriptState());
     EXPECT_EQ(ReadableStream::Readable, stream->state());
     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->state());
     EXPECT_TRUE(stream->isPulling());
     EXPECT_FALSE(stream->isDraining());
 
-    ScriptPromise newPromise = stream->wait(scriptState());
+    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->wait(scriptState());
+    ScriptPromise promise = stream->ready(scriptState());
     EXPECT_EQ(ReadableStream::Readable, stream->state());
     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->state());
     EXPECT_TRUE(stream->isPulling());
     EXPECT_FALSE(stream->isDraining());
 
-    ScriptPromise newPromise = stream->wait(scriptState());
+    ScriptPromise newPromise = stream->ready(scriptState());
     EXPECT_EQ(promise, newPromise);
 
     stream->error(DOMException::create(AbortError, "done"));
 }
 
 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->wait(scriptState());
+    ScriptPromise promise = stream->ready(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()));
+    EXPECT_EQ(promise, stream->ready(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_EQ(promise, stream->wait(scriptState()));
+    EXPECT_EQ(promise, stream->ready(scriptState()));
 
     EXPECT_EQ(ReadableStream::Closed, stream->state());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_TRUE(stream->isDraining());
 
     EXPECT_TRUE(onClosedFulfilled.isNull());
     EXPECT_TRUE(onClosedRejected.isNull());
 
     isolate()->RunMicrotasks();
     EXPECT_EQ("undefined", onClosedFulfilled);
@@ skipping 44 matching lines @@
     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->state());
-    ScriptPromise wait = stream->wait(scriptState());
+    ScriptPromise ready = stream->ready(scriptState());
     EXPECT_NE(promise, stream->cancel(scriptState(), reason));
     EXPECT_EQ(ReadableStream::Closed, stream->state());
-    EXPECT_EQ(stream->wait(scriptState()), wait);
+    EXPECT_EQ(stream->ready(scriptState()), ready);
 
-    wait.then(createCaptor(&onFulfilled), createCaptor(&onRejected));
+    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();
     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());
+    ScriptPromise ready = stream->ready(scriptState());
     EXPECT_EQ(ReadableStream::Readable, stream->state());
 
     ScriptPromise cancelResult = stream->cancel(scriptState(), reason);
     cancelResult.then(createCaptor(&onCancelFulfilled), createCaptor(&onCancelRejected));
 
     EXPECT_NE(promise, cancelResult);
     EXPECT_EQ(ReadableStream::Closed, stream->state());
 
-    EXPECT_EQ(stream->wait(scriptState()), wait);
+    EXPECT_EQ(stream->ready(scriptState()), ready);
 
     EXPECT_TRUE(onCancelFulfilled.isNull());
     EXPECT_TRUE(onCancelRejected.isNull());
 
     isolate()->RunMicrotasks();
     EXPECT_EQ("undefined", onCancelFulfilled);
     EXPECT_TRUE(onCancelRejected.isNull());
 }
 
 TEST_F(ReadableStreamTest, ReadableArrayBufferCompileTest)
@@ skipping 80 matching lines @@
     stream->enqueue("bar");
     checkpoint.Call(3);
     EXPECT_TRUE(stream->read(scriptState(), m_exceptionState).toString(chunk));
     EXPECT_EQ("foo", chunk);
     checkpoint.Call(4);
 
     stream->error(DOMException::create(AbortError, "done"));
 }
 
 } // namespace blink