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

third_party/WebKit/Source/modules/fetch/Request.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/Request.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/fetch/FetchUtils.h"
@@ skipping 251 matching lines @@
         if (FetchUtils::isForbiddenMethod(init.method)) {
             exceptionState.throwTypeError("'" + init.method + "' HTTP method is unsupported.");
             return nullptr;
         }
         // "Normalize |method|."
         // "Set |request|'s method to |method|."
         request->setMethod(FetchUtils::normalizeMethod(AtomicString(init.method)));
     }
     // "Let |r| be a new Request object associated with |request| and a new
     // Headers object whose guard is "request"."
-    Request* r = Request::create(scriptState->getExecutionContext(), request);
+    Request* r = Request::create(scriptState, request);
     // Perform the following steps:
     // - "Let |headers| be a copy of |r|'s Headers object."
     // - "If |init|'s headers member is present, set |headers| to |init|'s
     //   headers member."
     //
     // We don't create a copy of r's Headers object when init's headers member
     // is present.
     Headers* headers = nullptr;
     if (!init.headers && init.headersDictionary.isUndefinedOrNull()) {
         headers = r->getHeaders()->clone();
@@ skipping 54 matching lines @@
     // "If |init|'s body member is present, run these substeps:"
     if (init.body) {
         // Perform the following steps:
         // - "Let |stream| and |Content-Type| be the result of extracting
         //   |init|'s body member."
         // - "Set |temporaryBody| to |stream|.
         // - "If |Content-Type| is non-null and |r|'s request's header list
         //   contains no header named `Content-Type`, append
         //   `Content-Type`/|Content-Type| to |r|'s Headers object. Rethrow any
         //   exception."
-        temporaryBody = new BodyStreamBuffer(init.body.release());
+        temporaryBody = new BodyStreamBuffer(scriptState, init.body.release());
         if (!init.contentType.isEmpty() && !r->getHeaders()->has(HTTPNames::Content_Type, exceptionState)) {
             r->getHeaders()->append(HTTPNames::Content_Type, init.contentType, exceptionState);
         }
         if (exceptionState.hadException())
             return nullptr;
     }
 
     // "Set |r|'s request's body to |temporaryBody|.
     if (temporaryBody)
         r->m_request->setBuffer(temporaryBody);
 
     // "Set |r|'s MIME type to the result of extracting a MIME type from |r|'s
     // request's header list."
     r->m_request->setMIMEType(r->m_request->headerList()->extractMIMEType());
 
     // "If |input| is a Request object and |input|'s request's body is
     // non-null, run these substeps:"
     if (inputRequest && inputRequest->bodyBuffer()) {
         // "Set |input|'s body to an empty byte stream."
-        inputRequest->m_request->setBuffer(new BodyStreamBuffer(createFetchDataConsumerHandleFromWebHandle(createDoneDataConsumerHandle())));
+        inputRequest->m_request->setBuffer(new BodyStreamBuffer(scriptState, createFetchDataConsumerHandleFromWebHandle(createDoneDataConsumerHandle())));
         // "Set |input|'s disturbed flag."
-        inputRequest->bodyBuffer()->stream()->setIsDisturbed();
+        inputRequest->bodyBuffer()->setDisturbed();
     }
 
     // "Return |r|."
     return r;
 }
 
 Request* Request::create(ScriptState* scriptState, const RequestInfo& input, const Dictionary& init, ExceptionState& exceptionState)
 {
     ASSERT(!input.isNull());
     if (input.isUSVString())
@@ skipping 16 matching lines @@
 {
     return create(scriptState, input, Dictionary(), exceptionState);
 }
 
 Request* Request::create(ScriptState* scriptState, Request* input, const Dictionary& init, ExceptionState& exceptionState)
 {
     RequestInit requestInit(scriptState->getExecutionContext(), init, exceptionState);
     return createRequestWithRequestOrString(scriptState, input, String(), requestInit, exceptionState);
 }
 
-Request* Request::create(ExecutionContext* context, FetchRequestData* request)
+Request* Request::create(ScriptState* scriptState, FetchRequestData* request)
 {
-    return new Request(context, request);
+    return new Request(scriptState, request);
 }
 
-Request::Request(ExecutionContext* context, FetchRequestData* request)
-    : Body(context)
+Request* Request::create(ScriptState* scriptState, const WebServiceWorkerRequest& webRequest)
+{
+    return new Request(scriptState, webRequest);
+}
+
+Request::Request(ScriptState* scriptState, FetchRequestData* request, Headers* headers)
+    : Body(scriptState->getExecutionContext())
     , m_request(request)
-    , m_headers(Headers::create(m_request->headerList()))
+    , m_headers(headers)
+{
+}
+
+Request::Request(ScriptState* scriptState, FetchRequestData* request)
+    : Request(scriptState, request, Headers::create(request->headerList()))
 {
     m_headers->setGuard(Headers::RequestGuard);
 }
 
-Request::Request(ExecutionContext* context, FetchRequestData* request, Headers* headers)
-    : Body(context) , m_request(request) , m_headers(headers) {}
-
-Request* Request::create(ExecutionContext* context, const WebServiceWorkerRequest& webRequest)
+Request::Request(ScriptState* scriptState, const WebServiceWorkerRequest& request)
+    : Request(scriptState, FetchRequestData::create(scriptState, request))
 {
-    return new Request(context, webRequest);
-}
-
-Request::Request(ExecutionContext* context, const WebServiceWorkerRequest& webRequest)
-    : Body(context)
-    , m_request(FetchRequestData::create(context, webRequest))
-    , m_headers(Headers::create(m_request->headerList()))
-{
-    m_headers->setGuard(Headers::RequestGuard);
 }
 
 String Request::method() const
 {
     // "The method attribute's getter must return request's method."
     return m_request->method();
 }
 
 KURL Request::url() const
 {
@@ skipping 166 matching lines @@
     }
     ASSERT_NOT_REACHED();
     return "";
 }
 
 String Request::integrity() const
 {
     return m_request->integrity();
 }
 
-Request* Request::clone(ExceptionState& exceptionState)
+Request* Request::clone(ScriptState* scriptState, ExceptionState& exceptionState)
 {
     if (isBodyLocked() || bodyUsed()) {
         exceptionState.throwTypeError("Request body is already used");
         return nullptr;
     }
 
-    FetchRequestData* request = m_request->clone(getExecutionContext());
+    FetchRequestData* request = m_request->clone(scriptState);
     Headers* headers = Headers::create(request->headerList());
     headers->setGuard(m_headers->getGuard());
-    return new Request(getExecutionContext(), request, headers);
+    return new Request(scriptState, request, headers);
 }
 
-FetchRequestData* Request::passRequestData()
+FetchRequestData* Request::passRequestData(ScriptState* scriptState)
 {
     ASSERT(!bodyUsed());
-    return m_request->pass(getExecutionContext());
+    return m_request->pass(scriptState);
 }
 
 bool Request::hasBody() const
 {
     return bodyBuffer();
 }
 
-void Request::stop()
-{
-    if (bodyBuffer())
-        bodyBuffer()->stop();
-}
-
 void Request::populateWebServiceWorkerRequest(WebServiceWorkerRequest& webRequest) const
 {
     webRequest.setMethod(method());
     webRequest.setRequestContext(m_request->context());
     // This strips off the fragment part.
     webRequest.setURL(url());
 
     const FetchHeaderList* headerList = m_headers->headerList();
     for (size_t i = 0, size = headerList->size(); i < size; ++i) {
         const FetchHeaderList::Header& header = headerList->entry(i);
@@ skipping 11 matching lines @@
 }
 
 DEFINE_TRACE(Request)
 {
     Body::trace(visitor);
     visitor->trace(m_request);
     visitor->trace(m_headers);
 }
 
 } // namespace blink