[Fetch API] |(new Response(stream)).body| should return |stream|

third_party/WebKit/Source/modules/fetch/BodyStreamBuffer.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 "modules/fetch/BodyStreamBuffer.h"
 
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8HiddenValue.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMTypedArray.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/streams/ReadableStreamController.h"
 #include "core/streams/ReadableStreamOperations.h"
 #include "modules/fetch/Body.h"
 #include "modules/fetch/DataConsumerHandleUtil.h"
+#include "modules/fetch/ReadableStreamDataConsumerHandle.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/blob/BlobData.h"
 #include "platform/network/EncodedFormData.h"
 
 namespace blink {
 
 class BodyStreamBuffer::LoaderClient final : public GarbageCollectedFinalized<LoaderClient>, public ActiveDOMObject, public FetchDataLoader::Client {
     WTF_MAKE_NONCOPYABLE(LoaderClient);
     USING_GARBAGE_COLLECTED_MIXIN(LoaderClient);
 public:
@@ skipping 51 matching lines @@
 
     Member<BodyStreamBuffer> m_buffer;
     Member<FetchDataLoader::Client> m_client;
 };
 
 BodyStreamBuffer::BodyStreamBuffer(ScriptState* scriptState, PassOwnPtr<FetchDataConsumerHandle> handle)
     : UnderlyingSourceBase(scriptState)
     , m_scriptState(scriptState)
     , m_handle(std::move(handle))
     , m_reader(m_handle->obtainReader(this))
+    , m_madeFromReadableStream(false)
 {
     if (RuntimeEnabledFeatures::responseBodyWithV8ExtraStreamEnabled()) {
         ScriptState::Scope scope(scriptState);
         v8::Local<v8::Value> bodyValue = toV8(this, scriptState);
         ASSERT(!bodyValue.IsEmpty());
         ASSERT(bodyValue->IsObject());
         v8::Local<v8::Object> body = bodyValue.As<v8::Object>();
 
         ScriptValue readableStream = ReadableStreamOperations::createReadableStream(
             scriptState, this, ReadableStreamOperations::createCountQueuingStrategy(scriptState, 0));
         V8HiddenValue::setHiddenValue(scriptState, body, V8HiddenValue::internalBodyStream(scriptState->isolate()), readableStream.v8Value());
     } else {
         m_stream = new ReadableByteStream(this, new ReadableByteStream::StrictStrategy);
         m_stream->didSourceStart();
     }
 }
 
+BodyStreamBuffer::BodyStreamBuffer(ScriptState* scriptState, ScriptValue stream)
+    : UnderlyingSourceBase(scriptState)
+    , m_scriptState(scriptState)
+    , m_madeFromReadableStream(true)
+{
+    ScriptState::Scope scope(scriptState);
+    ASSERT(RuntimeEnabledFeatures::responseBodyWithV8ExtraStreamEnabled());
+    ASSERT(ReadableStreamOperations::isReadableStream(scriptState, stream));

[haraken, 2016/05/12 08:22:57]

Use DCHECK.

[yhirano, 2016/05/12 08:28:15]

Done.

+    v8::Local<v8::Value> bodyValue = toV8(this, scriptState);
+    ASSERT(!bodyValue.IsEmpty());
+    ASSERT(bodyValue->IsObject());
+    v8::Local<v8::Object> body = bodyValue.As<v8::Object>();
+
+    V8HiddenValue::setHiddenValue(scriptState, body, V8HiddenValue::internalBodyStream(scriptState->isolate()), stream.v8Value());
+}
+
 ScriptValue BodyStreamBuffer::stream()
 {
     ScriptState::Scope scope(m_scriptState.get());
     if (RuntimeEnabledFeatures::responseBodyWithV8ExtraStreamEnabled()) {
         v8::Local<v8::Value> bodyValue = toV8(this, m_scriptState.get());
         ASSERT(!bodyValue.IsEmpty());
         ASSERT(bodyValue->IsObject());
         v8::Local<v8::Object> body = bodyValue.As<v8::Object>();
         return ScriptValue(m_scriptState.get(), V8HiddenValue::getHiddenValue(m_scriptState.get(), body, V8HiddenValue::internalBodyStream(m_scriptState->isolate())));
     }
     return ScriptValue(m_scriptState.get(), toV8(m_stream, m_scriptState.get()));
 }
 
 PassRefPtr<BlobDataHandle> BodyStreamBuffer::drainAsBlobDataHandle(FetchDataConsumerHandle::Reader::BlobSizePolicy policy)
 {
     ASSERT(!isStreamLocked());
     ASSERT(!isStreamDisturbed());
     if (isStreamClosed() || isStreamErrored())
         return nullptr;
 
+    if (m_madeFromReadableStream)
+        return nullptr;
+
     RefPtr<BlobDataHandle> blobDataHandle = m_reader->drainAsBlobDataHandle(policy);
     if (blobDataHandle) {
         closeAndLockAndDisturb();
         return blobDataHandle.release();
     }
     return nullptr;
 }
 
 PassRefPtr<EncodedFormData> BodyStreamBuffer::drainAsFormData()
 {
     ASSERT(!isStreamLocked());
     ASSERT(!isStreamDisturbed());
     if (isStreamClosed() || isStreamErrored())
         return nullptr;
 
+    if (m_madeFromReadableStream)
+        return nullptr;
+
     RefPtr<EncodedFormData> formData = m_reader->drainAsFormData();
     if (formData) {
         closeAndLockAndDisturb();
         return formData.release();
     }
     return nullptr;
 }
 
 PassOwnPtr<FetchDataConsumerHandle> BodyStreamBuffer::releaseHandle()
 {
     ASSERT(!isStreamLocked());
     ASSERT(!isStreamDisturbed());
+
+    if (m_madeFromReadableStream) {
+        ScriptState::Scope scope(m_scriptState.get());
+        NonThrowableExceptionState exceptionState;
+        ScriptValue reader = ReadableStreamOperations::getReader(m_scriptState.get(), stream(), exceptionState);

[haraken, 2016/05/12 08:22:57]

Is it okay to ignore the exception?

[yhirano, 2016/05/12 08:28:15]

Yes. It throws an exception only when locked, and we have an assertion for that
at L173.

+        // We need to have |reader| alive by some means (as written in
+        // ReadableStreamDataConsumerHandle). |this| BodyStreamBuffer will be
+        // kept alive while the stream is locked and readable, and the stream
+        // has a reference to the reader. Hence we don't need to keep the reader
+        // explicitly.
+        return ReadableStreamDataConsumerHandle::create(m_scriptState.get(), reader);
+    }
+
     // We need to call these before calling closeAndLockAndDisturb.
     const bool isClosed = isStreamClosed();
     const bool isErrored = isStreamErrored();
     OwnPtr<FetchDataConsumerHandle> handle = m_handle.release();
 
     closeAndLockAndDisturb();
 
     if (isClosed) {
         // Note that the stream cannot be "draining", because it doesn't have
         // the internal buffer.
@@ skipping 217 matching lines @@
 
 void BodyStreamBuffer::stopLoading()
 {
     if (!m_loader)
         return;
     m_loader->cancel();
     m_loader = nullptr;
 }
 
 } // namespace blink