Make Response::body return v8-extra based stream behind flag

third_party/WebKit/Source/modules/fetch/Response.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/Response.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8ArrayBuffer.h"
@@ skipping 16 matching lines @@
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/network/EncodedFormData.h"
 #include "platform/network/HTTPHeaderMap.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerResponse.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
 
 namespace {
 
-FetchResponseData* createFetchResponseDataFromWebResponse(ExecutionContext* executionContext, const WebServiceWorkerResponse& webResponse)
+FetchResponseData* createFetchResponseDataFromWebResponse(ScriptState* scriptState, const WebServiceWorkerResponse& webResponse)
 {
     FetchResponseData* response = nullptr;
     if (webResponse.status() > 0)
         response = FetchResponseData::create();
     else
         response = FetchResponseData::createNetworkErrorResponse();
 
     response->setURL(webResponse.url());
     response->setStatus(webResponse.status());
     response->setStatusMessage(webResponse.statusText());
     response->setResponseTime(webResponse.responseTime());
     response->setCacheStorageCacheName(webResponse.cacheStorageCacheName());
 
     for (HTTPHeaderMap::const_iterator i = webResponse.headers().begin(), end = webResponse.headers().end(); i != end; ++i) {
         response->headerList()->append(i->key, i->value);
     }
 
-    response->replaceBodyStreamBuffer(new BodyStreamBuffer(FetchBlobDataConsumerHandle::create(executionContext, webResponse.blobDataHandle())));
+    response->replaceBodyStreamBuffer(new BodyStreamBuffer(scriptState, FetchBlobDataConsumerHandle::create(scriptState->getExecutionContext(), webResponse.blobDataHandle())));
 
     // Filter the response according to |webResponse|'s ResponseType.
     switch (webResponse.responseType()) {
     case WebServiceWorkerResponseTypeBasic:
         response = response->createBasicFilteredResponse();
         break;
     case WebServiceWorkerResponseTypeCORS:
         response = response->createCORSFilteredResponse();
         break;
     case WebServiceWorkerResponseTypeOpaque:
@@ skipping 36 matching lines @@
             || (0x80 <= c && c <= 0xFF))) // obs-text
             return false;
     }
     return true;
 }
 
 } // namespace
 
 Response* Response::create(ScriptState* scriptState, ExceptionState& exceptionState)
 {
-    return create(scriptState->getExecutionContext(), nullptr, String(), ResponseInit(), exceptionState);
+    return create(scriptState, nullptr, String(), ResponseInit(), exceptionState);
 }
 
 Response* Response::create(ScriptState* scriptState, ScriptValue bodyValue, const Dictionary& init, ExceptionState& exceptionState)
 {
     v8::Local<v8::Value> body = bodyValue.v8Value();
     ScriptValue reader;
     v8::Isolate* isolate = scriptState->isolate();
     ExecutionContext* executionContext = scriptState->getExecutionContext();
 
     OwnPtr<FetchDataConsumerHandle> bodyHandle;
@@ skipping 26 matching lines @@
             bodyHandle = ReadableStreamDataConsumerHandle::create(scriptState, reader);
         }
     } else {
         String string = toUSVString(isolate, body, exceptionState);
         if (exceptionState.hadException())
             return nullptr;
         bodyHandle = FetchFormDataConsumerHandle::create(string);
         contentType = "text/plain;charset=UTF-8";
     }
     // TODO(yhirano): Add the URLSearchParams case.
-    Response* response = create(executionContext, bodyHandle.release(), contentType, ResponseInit(init, exceptionState), exceptionState);
+    Response* response = create(scriptState, bodyHandle.release(), contentType, ResponseInit(init, exceptionState), exceptionState);
     if (!exceptionState.hadException() && !reader.isEmpty()) {
         // Add a hidden reference so that the weak persistent in the
         // ReadableStreamDataConsumerHandle will be valid as long as the
         // Response is valid.
         v8::Local<v8::Value> wrapper = toV8(response, scriptState);
         if (wrapper.IsEmpty()) {
             exceptionState.throwTypeError("Cannot create a Response wrapper");
             return nullptr;
         }
         ASSERT(wrapper->IsObject());
         V8HiddenValue::setHiddenValue(scriptState, wrapper.As<v8::Object>(), V8HiddenValue::readableStreamReaderInResponse(scriptState->isolate()), reader.v8Value());
     }
     return response;
 }
 
-Response* Response::create(ExecutionContext* context, PassOwnPtr<FetchDataConsumerHandle> bodyHandle, const String& contentType, const ResponseInit& init, ExceptionState& exceptionState)
+Response* Response::create(ScriptState* scriptState, PassOwnPtr<FetchDataConsumerHandle> bodyHandle, const String& contentType, const ResponseInit& init, ExceptionState& exceptionState)
 {
     unsigned short status = init.status;
 
     // "1. If |init|'s status member is not in the range 200 to 599, inclusive, throw a
     // RangeError."
     if (status < 200 || 599 < status) {
         exceptionState.throwRangeError(ExceptionMessages::indexOutsideRange<unsigned>("status", status, 200, ExceptionMessages::InclusiveBound, 599, ExceptionMessages::InclusiveBound));
         return nullptr;
     }
 
     // "2. If |init|'s statusText member does not match the Reason-Phrase
     // token production, throw a TypeError."
     if (!isValidReasonPhrase(init.statusText)) {
         exceptionState.throwTypeError("Invalid statusText");
         return nullptr;
     }
 
     // "3. Let |r| be a new Response object, associated with a new response,
     // Headers object, and Body object."
-    Response* r = new Response(context);
+    Response* r = new Response(scriptState->getExecutionContext());
 
     // "4. Set |r|'s response's status to |init|'s status member."
     r->m_response->setStatus(init.status);
 
     // "5. Set |r|'s response's status message to |init|'s statusText member."
     r->m_response->setStatusMessage(AtomicString(init.statusText));
 
     // "6. If |init|'s headers member is present, run these substeps:"
     if (init.headers) {
         // "1. Empty |r|'s response's header list."
@@ skipping 23 matching lines @@
         // contains no header named `Content-Type`, append `Content-Type`/
         // |Content-Type| to |r|'s response's header list."
         // https://fetch.spec.whatwg.org/#concept-bodyinit-extract
         // Step 3, Blob:
         // "If object's type attribute is not the empty byte sequence, set
         // Content-Type to its value."
         if (isNullBodyStatus(status)) {
             exceptionState.throwTypeError("Response with null body status cannot have body");
             return nullptr;
         }
-        r->m_response->replaceBodyStreamBuffer(new BodyStreamBuffer(bodyHandle));
+        r->m_response->replaceBodyStreamBuffer(new BodyStreamBuffer(scriptState, bodyHandle));
         if (!contentType.isEmpty() && !r->m_response->headerList()->has("Content-Type"))
             r->m_response->headerList()->append("Content-Type", contentType);
     }
 
     // "8. Set |r|'s MIME type to the result of extracting a MIME type
     // from |r|'s response's header list."
     r->m_response->setMIMEType(r->m_response->headerList()->extractMIMEType());
 
     // "9. Return |r|."
     return r;
 }
 
 Response* Response::create(ExecutionContext* context, FetchResponseData* response)
 {
     return new Response(context, response);
 }
 
-Response* Response::create(ExecutionContext* context, const WebServiceWorkerResponse& webResponse)
+Response* Response::create(ScriptState* scriptState, const WebServiceWorkerResponse& webResponse)
 {
-    FetchResponseData* responseData = createFetchResponseDataFromWebResponse(context, webResponse);
-    return new Response(context, responseData);
+    FetchResponseData* responseData = createFetchResponseDataFromWebResponse(scriptState, webResponse);
+    return new Response(scriptState->getExecutionContext(), responseData);
 }
 
 Response* Response::error(ExecutionContext* context)
 {
     FetchResponseData* responseData = FetchResponseData::createNetworkErrorResponse();
     Response* r = new Response(context, responseData);
     r->m_headers->setGuard(Headers::ImmutableGuard);
     return r;
 }
 
@@ skipping 69 matching lines @@
     // "The statusText attribute's getter must return response's status message."
     return m_response->statusMessage();
 }
 
 Headers* Response::headers() const
 {
     // "The headers attribute's getter must return the associated Headers object."
     return m_headers;
 }
 
-Response* Response::clone(ExceptionState& exceptionState)
+Response* Response::clone(ScriptState* scriptState, ExceptionState& exceptionState)
 {
     if (isBodyLocked() || bodyUsed()) {
         exceptionState.throwTypeError("Response body is already used");
         return nullptr;
     }
 
-    FetchResponseData* response = m_response->clone(getExecutionContext());
+    FetchResponseData* response = m_response->clone(scriptState);
     Headers* headers = Headers::create(response->headerList());
     headers->setGuard(m_headers->getGuard());
     return new Response(getExecutionContext(), response, headers);
 }
 
 bool Response::hasPendingActivity() const
 {
     if (!getExecutionContext() || getExecutionContext()->activeDOMObjectsAreStopped())
         return false;
     if (!internalBodyBuffer())
         return false;
     if (internalBodyBuffer()->hasPendingActivity())
         return true;
     return Body::hasPendingActivity();
 }
 
 void Response::stop()
 {
     if (m_response->internalBuffer())
         m_response->internalBuffer()->stop();
 }
 
 void Response::populateWebServiceWorkerResponse(WebServiceWorkerResponse& response)
 {
     m_response->populateWebServiceWorkerResponse(response);
 }
 
 Response::Response(ExecutionContext* context)
-    : Body(context)
-    , m_response(FetchResponseData::create())
-    , m_headers(Headers::create(m_response->headerList()))
+    : Response(context, FetchResponseData::create())
 {
     m_headers->setGuard(Headers::ResponseGuard);

[tyoshino (SeeGerritForStatus), 2016/04/21 07:46:24]

ditto

[yhirano, 2016/04/21 08:14:22]

Done.

 }
 
 Response::Response(ExecutionContext* context, FetchResponseData* response)
-    : Body(context)
-    , m_response(response)
-    , m_headers(Headers::create(m_response->headerList()))
+    : Response(context, response, Headers::create(response->headerList()))
 {
     m_headers->setGuard(Headers::ResponseGuard);
 }
 
 Response::Response(ExecutionContext* context, FetchResponseData* response, Headers* headers)
-    : Body(context) , m_response(response) , m_headers(headers) {}
+    : Body(context)
+    , m_response(response)
+    , m_headers(headers)
+{
+}
 
 bool Response::hasBody() const
 {
     return m_response->internalBuffer();
 }
 
 bool Response::bodyUsed()
 {
     return internalBodyBuffer() && internalBodyBuffer()->isStreamDisturbed();
 }
 
 String Response::mimeType() const
 {
     return m_response->mimeType();
 }
 
 String Response::internalMIMEType() const
 {
     return m_response->internalMIMEType();
 }
 
 DEFINE_TRACE(Response)
 {
     Body::trace(visitor);
     visitor->trace(m_response);
     visitor->trace(m_headers);
 }
 
 } // namespace blink