Introduce ExclusiveStreamReader.

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 945d802364a3347baba7d9dd0e42f1409d222808..8056e6435a6ad125a51658345cabbb12df229ba9 100644
--- a/Source/core/streams/ReadableStreamTest.cpp
+++ b/Source/core/streams/ReadableStreamTest.cpp
@@ -13,6 +13,7 @@
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
+#include "core/streams/ExclusiveStreamReader.h"
 #include "core/streams/ReadableStreamImpl.h"
 #include "core/streams/UnderlyingSource.h"
 #include "core/testing/DummyPageHolder.h"
@@ -28,8 +29,8 @@ using ::testing::Return;
 
 namespace {
 
-typedef ::testing::StrictMock<::testing::MockFunction<void(int)> > Checkpoint;
-typedef ReadableStreamImpl<ReadableStreamChunkTypeTraits<String> > StringStream;
+typedef ::testing::StrictMock<::testing::MockFunction<void(int)>> Checkpoint;
+typedef ReadableStreamImpl<ReadableStreamChunkTypeTraits<String>>  StringStream;

[tyoshino (SeeGerritForStatus), 2015/02/03 06:33:25]

just remove the space than moving to after >?

[yhirano, 2015/02/03 07:56:20]

Done.

 
 class StringCapturingFunction : public ScriptFunction {
 public:
@@ -172,7 +173,7 @@ TEST_F(ReadableStreamTest, Start)
     EXPECT_FALSE(stream->isStarted());
     EXPECT_FALSE(stream->isDraining());
     EXPECT_FALSE(stream->isPulling());
-    EXPECT_EQ(stream->state(), ReadableStream::Waiting);
+    EXPECT_EQ(stream->stateInternal(), ReadableStream::Waiting);
 
     checkpoint.Call(0);
     stream->didSourceStart();
@@ -181,7 +182,7 @@ TEST_F(ReadableStreamTest, Start)
     EXPECT_TRUE(stream->isStarted());
     EXPECT_FALSE(stream->isDraining());
     EXPECT_TRUE(stream->isPulling());
-    EXPECT_EQ(stream->state(), ReadableStream::Waiting);
+    EXPECT_EQ(stream->stateInternal(), ReadableStream::Waiting);
 
     // We need to call |error| in order to make
     // ActiveDOMObject::hasPendingActivity return false.
@@ -195,14 +196,14 @@ TEST_F(ReadableStreamTest, StartFail)
     EXPECT_FALSE(stream->isStarted());
     EXPECT_FALSE(stream->isDraining());
     EXPECT_FALSE(stream->isPulling());
-    EXPECT_EQ(stream->state(), ReadableStream::Waiting);
+    EXPECT_EQ(stream->stateInternal(), 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);
+    EXPECT_EQ(stream->stateInternal(), ReadableStream::Errored);
 }
 
 TEST_F(ReadableStreamTest, WaitOnWaiting)
@@ -210,15 +211,11 @@ TEST_F(ReadableStreamTest, WaitOnWaiting)
     StringStream* stream = construct();
     Checkpoint checkpoint;
 
-    EXPECT_EQ(ReadableStream::Waiting, stream->state());
+    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
     EXPECT_TRUE(stream->isStarted());
     EXPECT_TRUE(stream->isPulling());
 
-    ScriptPromise p = stream->ready(scriptState());
-    ScriptPromise q = stream->ready(scriptState());
-
-    EXPECT_EQ(ReadableStream::Waiting, stream->state());
-    EXPECT_EQ(q, p);
+    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
 
     stream->error(DOMException::create(AbortError, "done"));
 }
@@ -228,7 +225,7 @@ TEST_F(ReadableStreamTest, WaitDuringStarting)
     StringStream* stream = new StringStream(scriptState()->executionContext(), m_underlyingSource);
     Checkpoint checkpoint;
 
-    EXPECT_EQ(ReadableStream::Waiting, stream->state());
+    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
     EXPECT_FALSE(stream->isStarted());
     EXPECT_FALSE(stream->isPulling());
 
@@ -244,7 +241,7 @@ TEST_F(ReadableStreamTest, WaitDuringStarting)
     stream->didSourceStart();
     checkpoint.Call(1);
 
-    EXPECT_EQ(ReadableStream::Waiting, stream->state());
+    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
     EXPECT_TRUE(stream->isStarted());
     EXPECT_TRUE(stream->isPulling());
 
@@ -258,17 +255,16 @@ TEST_F(ReadableStreamTest, WaitAndError)
 
     ScriptPromise promise = stream->ready(scriptState());
     promise.then(createCaptor(&onFulfilled), createCaptor(&onRejected));
-    EXPECT_EQ(ReadableStream::Waiting, stream->state());
+    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
     EXPECT_TRUE(stream->isPulling());
     stream->error(DOMException::create(NotFoundError, "hello, error"));
-    EXPECT_EQ(ReadableStream::Errored, stream->state());
+    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(promise, stream->ready(scriptState()));
     EXPECT_EQ("NotFoundError: hello, error", onRejected);
 }
 
@@ -277,11 +273,11 @@ TEST_F(ReadableStreamTest, ErrorAndEnqueue)
     StringStream* stream = construct();
 
     stream->error(DOMException::create(NotFoundError, "error"));
-    EXPECT_EQ(ReadableStream::Errored, stream->state());
+    EXPECT_EQ(ReadableStream::Errored, stream->stateInternal());
 
     bool result = stream->enqueue("hello");
     EXPECT_FALSE(result);
-    EXPECT_EQ(ReadableStream::Errored, stream->state());
+    EXPECT_EQ(ReadableStream::Errored, stream->stateInternal());
 }
 
 TEST_F(ReadableStreamTest, CloseAndEnqueue)
@@ -289,31 +285,31 @@ TEST_F(ReadableStreamTest, CloseAndEnqueue)
     StringStream* stream = construct();
 
     stream->close();
-    EXPECT_EQ(ReadableStream::Closed, stream->state());
+    EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
 
     bool result = stream->enqueue("hello");
     EXPECT_FALSE(result);
-    EXPECT_EQ(ReadableStream::Closed, stream->state());
+    EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
 }
 
 TEST_F(ReadableStreamTest, EnqueueAndWait)
 {
     StringStream* stream = construct();
     String onFulfilled, onRejected;
-    EXPECT_EQ(ReadableStream::Waiting, stream->state());
+    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
 
     bool result = stream->enqueue("hello");
     EXPECT_TRUE(result);
-    EXPECT_EQ(ReadableStream::Readable, stream->state());
+    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
 
     stream->ready(scriptState()).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
-    EXPECT_EQ(ReadableStream::Readable, stream->state());
+    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->state());
+    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_EQ("undefined", onFulfilled);
     EXPECT_TRUE(onRejected.isNull());
@@ -325,19 +321,19 @@ TEST_F(ReadableStreamTest, WaitAndEnqueue)
 {
     StringStream* stream = construct();
     String onFulfilled, onRejected;
-    EXPECT_EQ(ReadableStream::Waiting, stream->state());
+    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
 
     stream->ready(scriptState()).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
     isolate()->RunMicrotasks();
 
-    EXPECT_EQ(ReadableStream::Waiting, stream->state());
+    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->state());
+    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_TRUE(onFulfilled.isNull());
     EXPECT_TRUE(onRejected.isNull());
@@ -353,20 +349,20 @@ TEST_F(ReadableStreamTest, WaitAndEnqueueAndError)
 {
     StringStream* stream = construct();
     String onFulfilled, onRejected;
-    EXPECT_EQ(ReadableStream::Waiting, stream->state());
+    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
 
     ScriptPromise promise = stream->ready(scriptState());
     promise.then(createCaptor(&onFulfilled), createCaptor(&onRejected));
     isolate()->RunMicrotasks();
 
-    EXPECT_EQ(ReadableStream::Waiting, stream->state());
+    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->state());
+    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_TRUE(onFulfilled.isNull());
     EXPECT_TRUE(onRejected.isNull());
@@ -376,7 +372,7 @@ TEST_F(ReadableStreamTest, WaitAndEnqueueAndError)
     EXPECT_TRUE(onRejected.isNull());
 
     stream->error(DOMException::create(NotFoundError, "error"));
-    EXPECT_EQ(ReadableStream::Errored, stream->state());
+    EXPECT_EQ(ReadableStream::Errored, stream->stateInternal());
 
     EXPECT_NE(promise, stream->ready(scriptState()));
 }
@@ -388,7 +384,7 @@ TEST_F(ReadableStreamTest, CloseWhenWaiting)
 
     StringStream* stream = construct();
 
-    EXPECT_EQ(ReadableStream::Waiting, stream->state());
+    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
     stream->ready(scriptState()).then(createCaptor(&onWaitFulfilled), createCaptor(&onWaitRejected));
     stream->closed(scriptState()).then(createCaptor(&onClosedFulfilled), createCaptor(&onClosedRejected));
 
@@ -399,7 +395,7 @@ TEST_F(ReadableStreamTest, CloseWhenWaiting)
     EXPECT_TRUE(onClosedRejected.isNull());
 
     stream->close();
-    EXPECT_EQ(ReadableStream::Closed, stream->state());
+    EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
     isolate()->RunMicrotasks();
     EXPECT_EQ("undefined", onWaitFulfilled);
     EXPECT_TRUE(onWaitRejected.isNull());
@@ -411,13 +407,13 @@ TEST_F(ReadableStreamTest, CloseWhenErrored)
 {
     String onFulfilled, onRejected;
     StringStream* stream = construct();
-    EXPECT_EQ(ReadableStream::Waiting, stream->state());
+    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
     stream->closed(scriptState()).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
 
     stream->error(DOMException::create(NotFoundError, "error"));
     stream->close();
 
-    EXPECT_EQ(ReadableStream::Errored, stream->state());
+    EXPECT_EQ(ReadableStream::Errored, stream->stateInternal());
     isolate()->RunMicrotasks();
 
     EXPECT_TRUE(onFulfilled.isNull());
@@ -427,11 +423,11 @@ TEST_F(ReadableStreamTest, CloseWhenErrored)
 TEST_F(ReadableStreamTest, ReadWhenWaiting)
 {
     StringStream* stream = construct();
-    EXPECT_EQ(ReadableStream::Waiting, stream->state());
+    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
     EXPECT_FALSE(m_exceptionState.hadException());
 
     stream->read(scriptState(), m_exceptionState);
-    EXPECT_EQ(ReadableStream::Waiting, stream->state());
+    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());
@@ -444,11 +440,11 @@ TEST_F(ReadableStreamTest, ReadWhenClosed)
     StringStream* stream = construct();
     stream->close();
 
-    EXPECT_EQ(ReadableStream::Closed, stream->state());
+    EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
     EXPECT_FALSE(m_exceptionState.hadException());
 
     stream->read(scriptState(), m_exceptionState);
-    EXPECT_EQ(ReadableStream::Closed, stream->state());
+    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());
@@ -462,11 +458,11 @@ TEST_F(ReadableStreamTest, ReadWhenErrored)
     StringStream* stream = construct();
     stream->error(DOMException::create(NotFoundError, "error"));
 
-    EXPECT_EQ(ReadableStream::Errored, stream->state());
+    EXPECT_EQ(ReadableStream::Errored, stream->stateInternal());
     EXPECT_FALSE(m_exceptionState.hadException());
 
     stream->read(scriptState(), m_exceptionState);
-    EXPECT_EQ(ReadableStream::Errored, stream->state());
+    EXPECT_EQ(ReadableStream::Errored, stream->stateInternal());
     EXPECT_TRUE(m_exceptionState.hadException());
     EXPECT_EQ(notFoundExceptionCode, m_exceptionState.code());
     EXPECT_EQ("error", m_exceptionState.message());
@@ -487,7 +483,7 @@ TEST_F(ReadableStreamTest, EnqueuedAndRead)
 
     stream->enqueue("hello");
     ScriptPromise promise = stream->ready(scriptState());
-    EXPECT_EQ(ReadableStream::Readable, stream->state());
+    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
     EXPECT_FALSE(stream->isPulling());
 
     checkpoint.Call(0);
@@ -496,7 +492,7 @@ TEST_F(ReadableStreamTest, EnqueuedAndRead)
     checkpoint.Call(1);
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ("hello", chunk);
-    EXPECT_EQ(ReadableStream::Waiting, stream->state());
+    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
     EXPECT_TRUE(stream->isPulling());
     EXPECT_FALSE(stream->isDraining());
 
@@ -526,7 +522,7 @@ TEST_F(ReadableStreamTest, EnqueueTwiceAndRead)
     EXPECT_TRUE(stream->enqueue("hello"));
     EXPECT_TRUE(stream->enqueue("bye"));
     ScriptPromise promise = stream->ready(scriptState());
-    EXPECT_EQ(ReadableStream::Readable, stream->state());
+    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
     EXPECT_FALSE(stream->isPulling());
 
     String chunk;
@@ -535,7 +531,7 @@ TEST_F(ReadableStreamTest, EnqueueTwiceAndRead)
     checkpoint.Call(1);
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ("hello", chunk);
-    EXPECT_EQ(ReadableStream::Readable, stream->state());
+    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
     EXPECT_TRUE(stream->isPulling());
     EXPECT_FALSE(stream->isDraining());
 
@@ -545,7 +541,7 @@ TEST_F(ReadableStreamTest, EnqueueTwiceAndRead)
     stream->error(DOMException::create(AbortError, "done"));
 }
 
-TEST_F(ReadableStreamTest, InternalRead)
+TEST_F(ReadableStreamTest, ReadQueue)
 {
     StringStream* stream = construct();
     Checkpoint checkpoint;
@@ -561,19 +557,19 @@ TEST_F(ReadableStreamTest, InternalRead)
 
     EXPECT_TRUE(stream->enqueue("hello"));
     EXPECT_TRUE(stream->enqueue("bye"));
-    EXPECT_EQ(ReadableStream::Readable, stream->state());
+    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
     EXPECT_FALSE(stream->isPulling());
 
     String chunk;
     checkpoint.Call(0);
-    stream->read(queue);
+    stream->readInternal(queue);
     checkpoint.Call(1);
     ASSERT_EQ(2u, queue.size());
 
     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->state());
+    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
     EXPECT_TRUE(stream->isPulling());
     EXPECT_FALSE(stream->isDraining());
 }
@@ -590,7 +586,7 @@ TEST_F(ReadableStreamTest, CloseWhenReadable)
     EXPECT_FALSE(stream->enqueue("should be ignored"));
 
     ScriptPromise promise = stream->ready(scriptState());
-    EXPECT_EQ(ReadableStream::Readable, stream->state());
+    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_TRUE(stream->isDraining());
 
@@ -601,7 +597,7 @@ TEST_F(ReadableStreamTest, CloseWhenReadable)
 
     isolate()->RunMicrotasks();
 
-    EXPECT_EQ(ReadableStream::Readable, stream->state());
+    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_TRUE(stream->isDraining());
 
@@ -611,7 +607,7 @@ TEST_F(ReadableStreamTest, CloseWhenReadable)
 
     EXPECT_EQ(promise, stream->ready(scriptState()));
 
-    EXPECT_EQ(ReadableStream::Closed, stream->state());
+    EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_TRUE(stream->isDraining());
 
@@ -628,10 +624,10 @@ TEST_F(ReadableStreamTest, CancelWhenClosed)
     StringStream* stream = construct();
     String onFulfilled, onRejected;
     stream->close();
-    EXPECT_EQ(ReadableStream::Closed, stream->state());
+    EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
 
     ScriptPromise promise = stream->cancel(scriptState(), ScriptValue());
-    EXPECT_EQ(ReadableStream::Closed, stream->state());
+    EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
 
     promise.then(createCaptor(&onFulfilled), createCaptor(&onRejected));
     EXPECT_TRUE(onFulfilled.isNull());
@@ -647,10 +643,10 @@ TEST_F(ReadableStreamTest, CancelWhenErrored)
     StringStream* stream = construct();
     String onFulfilled, onRejected;
     stream->error(DOMException::create(NotFoundError, "error"));
-    EXPECT_EQ(ReadableStream::Errored, stream->state());
+    EXPECT_EQ(ReadableStream::Errored, stream->stateInternal());
 
     ScriptPromise promise = stream->cancel(scriptState(), ScriptValue());
-    EXPECT_EQ(ReadableStream::Errored, stream->state());
+    EXPECT_EQ(ReadableStream::Errored, stream->stateInternal());
 
     promise.then(createCaptor(&onFulfilled), createCaptor(&onRejected));
     EXPECT_TRUE(onFulfilled.isNull());
@@ -673,11 +669,10 @@ TEST_F(ReadableStreamTest, CancelWhenWaiting)
         EXPECT_CALL(*m_underlyingSource, cancelSource(scriptState(), reason)).WillOnce(Return(promise));
     }
 
-    EXPECT_EQ(ReadableStream::Waiting, stream->state());
+    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
     ScriptPromise ready = stream->ready(scriptState());
     EXPECT_NE(promise, stream->cancel(scriptState(), reason));
-    EXPECT_EQ(ReadableStream::Closed, stream->state());
-    EXPECT_EQ(stream->ready(scriptState()), ready);
+    EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
 
     ready.then(createCaptor(&onFulfilled), createCaptor(&onRejected));
     EXPECT_TRUE(onFulfilled.isNull());
@@ -703,13 +698,13 @@ TEST_F(ReadableStreamTest, CancelWhenReadable)
 
     stream->enqueue("hello");
     ScriptPromise ready = stream->ready(scriptState());
-    EXPECT_EQ(ReadableStream::Readable, stream->state());
+    EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
 
     ScriptPromise cancelResult = stream->cancel(scriptState(), reason);
     cancelResult.then(createCaptor(&onCancelFulfilled), createCaptor(&onCancelRejected));
 
     EXPECT_NE(promise, cancelResult);
-    EXPECT_EQ(ReadableStream::Closed, stream->state());
+    EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
 
     EXPECT_EQ(stream->ready(scriptState()), ready);
 
@@ -734,7 +729,7 @@ TEST_F(ReadableStreamTest, BackpressureOnEnqueueing)
     Checkpoint checkpoint;
 
     StringStream* stream = construct(strategy);
-    EXPECT_EQ(ReadableStream::Waiting, stream->state());
+    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
 
     {
         InSequence s;
@@ -766,7 +761,7 @@ TEST_F(ReadableStreamTest, BackpressureOnReading)
     Checkpoint checkpoint;
 
     StringStream* stream = construct(strategy);
-    EXPECT_EQ(ReadableStream::Waiting, stream->state());
+    EXPECT_EQ(ReadableStream::Waiting, stream->stateInternal());
 
     {
         InSequence s;
@@ -811,4 +806,22 @@ TEST_F(ReadableStreamTest, BackpressureOnReading)
     stream->error(DOMException::create(AbortError, "done"));
 }
 
+// Note: Detailed tests are on ExclusiveStreamReaderTest.
+TEST_F(ReadableStreamTest, ExclusiveStreamReader)
+{
+    StringStream* stream = construct();
+    ExclusiveStreamReader* reader = stream->getReader(m_exceptionState);
+
+    ASSERT_TRUE(reader);
+    EXPECT_FALSE(m_exceptionState.hadException());
+    EXPECT_TRUE(reader->isActive());
+    EXPECT_TRUE(stream->isLockedTo(reader));
+
+    ExclusiveStreamReader* another = stream->getReader(m_exceptionState);
+    ASSERT_EQ(nullptr, another);
+    EXPECT_TRUE(m_exceptionState.hadException());
+    EXPECT_TRUE(reader->isActive());
+    EXPECT_TRUE(stream->isLockedTo(reader));
+}
+
 } // namespace blink