Add 'stream' to XMLHttpRequest response type.

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 31 matching lines @@
         *m_value = toCoreString(value.v8Value()->ToString());
         return value;
     }
 
 private:
     StringCapturingFunction(v8::Isolate* isolate, String* value) : ScriptFunction(isolate), m_value(value) { }
 
     String* m_value;
 };
 
-class MockUnderlyingSource : public UnderlyingSource {
+class MockUnderlyingSource : public GarbageCollectedFinalized<MockUnderlyingSource>, public UnderlyingSource {
+    USING_GARBAGE_COLLECTED_MIXIN(MockUnderlyingSource);
 public:
     virtual ~MockUnderlyingSource() { }
 
-    MOCK_METHOD1(startSource, ScriptPromise(ExceptionState*));
     MOCK_METHOD0(pullSource, void());
     MOCK_METHOD2(cancelSource, ScriptPromise(ScriptState*, ScriptValue));
 };
 
 class ThrowError {
 public:
     explicit ThrowError(const String& message)
         : m_message(message) { }
 
     void operator()(ExceptionState* exceptionState)
@@ skipping 22 matching lines @@
     }
 
     ScriptState* scriptState() { return ScriptState::forMainWorld(m_page->document().frame()); }
     v8::Isolate* isolate() { return scriptState()->isolate(); }
 
     PassOwnPtr<StringCapturingFunction> createCaptor(String* value)
     {
         return StringCapturingFunction::create(isolate(), value);
     }
 
-    // Note: This function calls RunMicrotasks.
     StringStream* construct()
     {
-        RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState());
-        ScriptPromise promise = resolver->promise();
-        resolver->resolve();
-        EXPECT_CALL(*m_underlyingSource, startSource(&m_exceptionState)).WillOnce(Return(promise));
-
-        StringStream* stream = new StringStream(scriptState(), m_underlyingSource, &m_exceptionState);
-        isolate()->RunMicrotasks();
+        StringStream* stream = new StringStream(scriptState()->executionContext(), m_underlyingSource);
+        stream->didSourceStart();
         return stream;
     }
 
     OwnPtr<DummyPageHolder> m_page;
     ScriptState::Scope m_scope;
     Persistent<MockUnderlyingSource> m_underlyingSource;
     ExceptionState m_exceptionState;
 };
 
-TEST_F(ReadableStreamTest, Construct)
+TEST_F(ReadableStreamTest, Start)
 {
-    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState());
-    ScriptPromise promise = resolver->promise();
-    {
-        InSequence s;
-        EXPECT_CALL(*m_underlyingSource, startSource(&m_exceptionState)).WillOnce(Return(promise));
-    }
-    StringStream* stream = new StringStream(scriptState(), m_underlyingSource, &m_exceptionState);
+    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);
 
-    isolate()->RunMicrotasks();
-
-    EXPECT_FALSE(stream->isStarted());
-
-    resolver->resolve();
-    isolate()->RunMicrotasks();
+    stream->didSourceStart();
 
     EXPECT_TRUE(stream->isStarted());
     EXPECT_FALSE(stream->isDraining());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_EQ(stream->state(), ReadableStream::Waiting);
 }
 
-TEST_F(ReadableStreamTest, ConstructError)
+TEST_F(ReadableStreamTest, StartFail)
 {
-    {
-        InSequence s;
-        EXPECT_CALL(*m_underlyingSource, startSource(&m_exceptionState))
-            .WillOnce(DoAll(Invoke(ThrowError("hello")), Return(ScriptPromise())));
-    }
-    new StringStream(scriptState(), m_underlyingSource, &m_exceptionState);
-    EXPECT_TRUE(m_exceptionState.hadException());
-}
-
-TEST_F(ReadableStreamTest, StartFailAsynchronously)
-{
-    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState());
-    ScriptPromise promise = resolver->promise();
-    {
-        InSequence s;
-        EXPECT_CALL(*m_underlyingSource, startSource(&m_exceptionState)).WillOnce(Return(promise));
-    }
-    StringStream* stream = new StringStream(scriptState(), m_underlyingSource, &m_exceptionState);
+    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);
 
-    isolate()->RunMicrotasks();
+    stream->error(DOMException::create(NotFoundError));
 
     EXPECT_FALSE(stream->isStarted());
     EXPECT_FALSE(stream->isDraining());
-    EXPECT_FALSE(stream->isPulling());
-    EXPECT_EQ(stream->state(), ReadableStream::Waiting);
-
-    resolver->reject();
-    stream->error(DOMException::create(NotFoundError));
-    isolate()->RunMicrotasks();
-
-    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());
@@ skipping 12 matching lines @@
     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)
 {
-    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState());
-    ScriptPromise promise = resolver->promise();
-    {
-        InSequence s;
-        EXPECT_CALL(*m_underlyingSource, startSource(&m_exceptionState)).WillOnce(Return(promise));
-    }
-    StringStream* stream = new StringStream(scriptState(), m_underlyingSource, &m_exceptionState);
+    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(checkpoint, Call(1));
         EXPECT_CALL(*m_underlyingSource, pullSource()).Times(1);
     }
 
     checkpoint.Call(0);
     stream->wait(scriptState());
     checkpoint.Call(1);
 
     EXPECT_TRUE(stream->isPulling());
 
-    resolver->resolve();
-    isolate()->RunMicrotasks();
+    stream->didSourceStart();
 
     EXPECT_EQ(ReadableStream::Waiting, stream->state());
     EXPECT_TRUE(stream->isPulling());
 }
 
 TEST_F(ReadableStreamTest, WaitAndError)
 {
     StringStream* stream = construct();
     String onFulfilled, onRejected;
 
@@ skipping 180 matching lines @@
     EXPECT_TRUE(onFulfilled.isNull());
     EXPECT_EQ("NotFoundError: error", onRejected);
 }
 
 TEST_F(ReadableStreamTest, ReadWhenWaiting)
 {
     StringStream* stream = construct();
     EXPECT_EQ(ReadableStream::Waiting, stream->state());
     EXPECT_FALSE(m_exceptionState.hadException());
 
-    stream->read(scriptState(), &m_exceptionState);
+    stream->read(scriptState(), m_exceptionState);
     EXPECT_EQ(ReadableStream::Waiting, stream->state());
     EXPECT_TRUE(m_exceptionState.hadException());
     EXPECT_EQ(V8TypeError, m_exceptionState.code());
     EXPECT_EQ("read is called while state is waiting", m_exceptionState.message());
 }
 
 TEST_F(ReadableStreamTest, ReadWhenClosed)
 {
     StringStream* stream = construct();
     stream->close();
 
     EXPECT_EQ(ReadableStream::Closed, stream->state());
     EXPECT_FALSE(m_exceptionState.hadException());
 
-    stream->read(scriptState(), &m_exceptionState);
+    stream->read(scriptState(), m_exceptionState);
     EXPECT_EQ(ReadableStream::Closed, stream->state());
     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->state());
     EXPECT_FALSE(m_exceptionState.hadException());
 
-    stream->read(scriptState(), &m_exceptionState);
+    stream->read(scriptState(), m_exceptionState);
     EXPECT_EQ(ReadableStream::Errored, stream->state());
     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->wait(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));
+    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());
     newPromise.then(createCaptor(&onFulfilled), createCaptor(&onRejected));
     isolate()->RunMicrotasks();
@@ skipping 14 matching lines @@
     }
 
     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());
 
     checkpoint.Call(0);
     String chunk;
-    EXPECT_TRUE(stream->read(scriptState(), &m_exceptionState).toString(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_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_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_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));
 
     EXPECT_EQ(ReadableStream::Closed, stream->state());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_TRUE(stream->isDraining());
 
@@ skipping 100 matching lines @@
     EXPECT_TRUE(onRejected.isNull());
 
     isolate()->RunMicrotasks();
     EXPECT_EQ("undefined", onFulfilled);
     EXPECT_TRUE(onRejected.isNull());
 }
 
 TEST_F(ReadableStreamTest, ReadableArrayBufferCompileTest)
 {
     // This test tests if ReadableStreamImpl<ArrayBuffer> can be instantiated.
-    {
-        InSequence s;
-        EXPECT_CALL(*m_underlyingSource, startSource(&m_exceptionState)).WillOnce(Return(ScriptPromise()));
-    }
-
-    new ReadableStreamImpl<ReadableStreamChunkTypeTraits<ArrayBuffer> >(scriptState(), m_underlyingSource, &m_exceptionState);
+    new ReadableStreamImpl<ReadableStreamChunkTypeTraits<ArrayBuffer> >(scriptState()->executionContext(), m_underlyingSource);
 }
 
 } // namespace blink