[Fetch API] Put body members directly on Response/Request

Source/modules/serviceworkers/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 "config.h"
 #include "Request.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/fetch/FetchUtils.h"
@@ skipping 26 matching lines @@
     virtual bool handleItem(const String& value, const String& key, Headers*)
     {
         m_webRequest->setHeader(key, value);
         return true;
     }
 
 private:
     WebServiceWorkerRequest* m_webRequest;
 };
 
-Request* createRequestWithRequestData(FetchRequestData* request, const RequestInit& init, FetchRequestData::Mode mode, FetchRequestData::Credentials credentials, ExceptionState& exceptionState)
+Request* createRequestWithRequestData(ExecutionContext* context, FetchRequestData* request, const RequestInit& init, FetchRequestData::Mode mode, FetchRequestData::Credentials credentials, ExceptionState& exceptionState)
 {
     // "6. Let |mode| be |init|'s mode member if it is present, and
     // |fallbackMode| otherwise."
     // "7. If |mode| is non-null, set |request|'s mode to |mode|."
     if (init.mode == "same-origin") {
         request->setMode(FetchRequestData::SameOriginMode);
     } else if (init.mode == "no-cors") {
         request->setMode(mode = FetchRequestData::NoCORSMode);
     } else if (init.mode == "cors") {
         request->setMode(FetchRequestData::CORSMode);
@@ skipping 29 matching lines @@
         }
         if (!isValidHTTPToken(init.method)) {
             exceptionState.throwTypeError("'" + init.method + "' is not a valid HTTP method.");
             return 0;
         }
         // FIXME: "2. Add case correction as in XMLHttpRequest?"
         // "3. Set |request|'s method to |method|."
         request->setMethod(XMLHttpRequest::uppercaseKnownHTTPMethod(AtomicString(init.method)));
     }
     // "11. Let |r| be a new Request object associated with |request|, Headers
-    // object, and FetchBodyStream object."
-    Request* r = Request::create(request);
+    // object."
+    Request* r = Request::create(context, request);
 
     // "12. Let |headers| be a copy of |r|'s Headers object."
     // "13. 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 = 0;
     if (!init.headers && init.headersDictionary.isUndefinedOrNull()) {
         headers = r->headers()->createCopy();
     }
@@ skipping 33 matching lines @@
         //  contains no header named `Content-Type`, append
         // `Content-Type`/|Content-Type| to |r|'s Headers object. Rethrow any
         // exception."
         r->setBodyBlobHandle(init.bodyBlobHandle);
         if (!init.bodyBlobHandle->type().isEmpty() && !r->headers()->has("Content-Type", exceptionState)) {
             r->headers()->append("Content-Type", init.bodyBlobHandle->type(), exceptionState);
         }
         if (exceptionState.hadException())
             return 0;
     }
-    // "18. Set |r|'s FetchBodyStream object's MIME type to the result of
-    // extracting a MIME type from |r|'s request's header list."
-    // FIXME: We don't have MIME type in FetchBodyStream object yet.
+    // "18. Set |r|'s MIME type to the result of extracting a MIME type from
+    // |r|'s request's header list."
+    // FIXME: We don't have MIME type in Request object yet.
 
     // "19. Return |r|."
     return r;
 }
 
 } // namespace
 
 Request* Request::create(ExecutionContext* context, const String& input, ExceptionState& exceptionState)
 {
     return create(context, input, Dictionary(), exceptionState);
@@ skipping 12 matching lines @@
     KURL parsedURL = context->completeURL(input);
     // "2. If |parsedURL| is failure, throw a TypeError."
     if (!parsedURL.isValid()) {
         exceptionState.throwTypeError("Invalid URL");
         return 0;
     }
     // "3. Set |request|'s url to |parsedURL|."
     request->setURL(parsedURL);
     // "4. Set |fallbackMode| to CORS."
     // "5. Set |fallbackCredentials| to omit."
-    return createRequestWithRequestData(request, RequestInit(context, init, exceptionState), FetchRequestData::CORSMode, FetchRequestData::OmitCredentials, exceptionState);
+    return createRequestWithRequestData(context, request, RequestInit(context, init, exceptionState), FetchRequestData::CORSMode, FetchRequestData::OmitCredentials, exceptionState);
 }
 
 Request* Request::create(ExecutionContext* context, Request* input, ExceptionState& exceptionState)
 {
     return create(context, input, Dictionary(), exceptionState);
 }
 
 Request* Request::create(ExecutionContext* context, Request* input, const Dictionary& init, ExceptionState& exceptionState)
 {
     // "1. Let |request| be |input|'s associated request, if |input| is a
     // Request object, and a new request otherwise."
     // "2. Set |request| to a restricted copy of itself."
     FetchRequestData* request(input->request()->createRestrictedCopy(context, SecurityOrigin::create(context->url())));
     // "3. Let |fallbackMode| be null."
     // "4. Let |fallbackCredentials| be null."
     // Instead of using null as a special fallback value, just pass the current
     // mode and credentials; it has the same effect.
     const FetchRequestData::Mode currentMode = request->mode();
     const FetchRequestData::Credentials currentCredentials = request->credentials();
-    return createRequestWithRequestData(request, RequestInit(context, init, exceptionState), currentMode, currentCredentials, exceptionState);
+    return createRequestWithRequestData(context, request, RequestInit(context, init, exceptionState), currentMode, currentCredentials, exceptionState);
 }
 
-Request* Request::create(FetchRequestData* request)
+Request* Request::create(ExecutionContext* context, FetchRequestData* request)
 {
-    return new Request(request);
+    Request* r = new Request(context, request);
+    r->suspendIfNeeded();
+    return r;
 }
 
-Request::Request(FetchRequestData* request)
-    : m_request(request)
+Request::Request(ExecutionContext* context, FetchRequestData* request)
+    : Body(context)
+    , m_request(request)
     , m_headers(Headers::create(m_request->headerList()))
 {
     m_headers->setGuard(Headers::RequestGuard);
 }
 
-Request* Request::create(const WebServiceWorkerRequest& webRequest)
+Request* Request::create(ExecutionContext* context, const WebServiceWorkerRequest& webRequest)
 {
-    return new Request(webRequest);
+    Request* r = new Request(context, webRequest);
+    r->suspendIfNeeded();
+    return r;
 }
 
-Request::Request(const WebServiceWorkerRequest& webRequest)
-    : m_request(FetchRequestData::create(webRequest))
+Request::Request(ExecutionContext* context, const WebServiceWorkerRequest& webRequest)
+    : Body(context)
+    , m_request(FetchRequestData::create(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();
 }
 
 String Request::url() const
 {
     // The url attribute's getter must return request's url, serialized with the exclude fragment flag set.
     if (!m_request->url().hasFragmentIdentifier())
         return m_request->url();
     KURL url(m_request->url());
     url.removeFragmentIdentifier();
     return url;
 }
 
-FetchBodyStream* Request::body(ExecutionContext* context)
-{
-    if (!m_request->blobDataHandle())
-        return 0;
-    if (!m_fetchBodyStream)
-        m_fetchBodyStream = FetchBodyStream::create(context, m_request->blobDataHandle());
-    return m_fetchBodyStream;
-}
-
-
 String Request::referrer() const
 {
     // "The referrer attribute's getter must return the empty string if
     // request's referrer is none, and request's referrer, serialized,
     // otherwise."
     return m_request->referrer().referrer().referrer;
 }
 
 String Request::mode() const
 {
@@ skipping 32 matching lines @@
 void Request::populateWebServiceWorkerRequest(WebServiceWorkerRequest& webRequest)
 {
     webRequest.setMethod(method());
     webRequest.setURL(m_request->url());
     m_headers->forEach(adoptPtrWillBeNoop(new FillWebRequestHeaders(&webRequest)));
     webRequest.setReferrer(m_request->referrer().referrer().referrer, static_cast<WebReferrerPolicy>(m_request->referrer().referrer().referrerPolicy));
     // FIXME: How can we set isReload properly? What is the correct place to load it in to the Request object? We should investigate the right way
     // to plumb this information in to here.
 }
 
-void Request::setBodyBlobHandle(PassRefPtr<BlobDataHandle>blobHandle)
+void Request::setBodyBlobHandle(PassRefPtr<BlobDataHandle> blobDataHandle)
 {
-    m_request->setBlobDataHandle(blobHandle);
+    m_request->setBlobDataHandle(blobDataHandle);
+}
+
+PassRefPtr<BlobDataHandle> Request::blobDataHandle()
+{
+    return m_request->blobDataHandle();
 }
 
 void Request::trace(Visitor* visitor)
 {
+    Body::trace(visitor);
     visitor->trace(m_request);
     visitor->trace(m_headers);
-    visitor->trace(m_fetchBodyStream);
 }
 
 } // namespace blink