[Fetch API] Remove DrainingBuffer.

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 "config.h"
 #include "modules/fetch/Request.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExecutionContext.h"
@@ skipping 31 matching lines @@
     request->setMode(original->mode());
     request->setCredentials(original->credentials());
     // FIXME: Set cache mode.
     // TODO(yhirano): Set redirect mode.
     return request;
 }
 
 Request* Request::createRequestWithRequestOrString(ScriptState* scriptState, Request* inputRequest, const String& inputString, const RequestInit& init, ExceptionState& exceptionState)
 {
     // "1. Let |temporaryBody| be null."
-    Request* temporaryBodyRequest = nullptr;
-    BodyStreamBuffer* temporaryBodyBuffer = nullptr;
+    BodyStreamBuffer* temporaryBody = nullptr;
 
     if (inputRequest) {
         // We check bodyUsed even when the body is null in spite of the
         // spec. See https://github.com/whatwg/fetch/issues/61 for details.
         if (inputRequest->bodyUsed()) {
             exceptionState.throwTypeError("Cannot construct a Request with a Request object that has already been used.");
             return nullptr;
         }
     }
 
     // "2. If |input| is a Request object and |input|'s body is non-null, run
     // these substeps:"
     if (inputRequest && inputRequest->hasBody()) {
         // "1. If |input|'s used flag is set, throw a TypeError."
         // "2. Set |temporaryBody| to |input|'s body."
         if (inputRequest->bodyUsed()) {
             exceptionState.throwTypeError("Cannot construct a Request with a Request object that has already been used.");
             return nullptr;
         }
-        // We call createDrainingStream() later and not here, because
-        // createDrainingStream() has side effects on |inputRequest|'s body.
-        temporaryBodyRequest = inputRequest;
+        temporaryBody = inputRequest->bodyBuffer();
     }
 
     // "3. Let |request| be |input|'s request, if |input| is a Request object,
     // and a new request otherwise."
     // "4. Set |request| to a new request whose url is |request|'s url, method
     // is |request|'s method, header list is a copy of |request|'s header list,
     // unsafe request flag is set, client is entry settings object, origin is
     // entry settings object's origin, force Origin header flag is set,
     // same-origin data URL flag is set, context is the empty string, mode is
     // |request|'s mode, credentials mode is |request|'s credentials mode,
@@ skipping 93 matching lines @@
     // "22. Let |headers| be a copy of |r|'s Headers object."
     // "23. 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->headers()->clone();
     }
     // "24. Empty |r|'s request's header list."
-    r->clearHeaderList();
+    r->m_request->headerList()->clearList();
     // "25. If |r|'s request's mode is no CORS, run these substeps:
     if (r->request()->mode() == WebURLRequest::FetchRequestModeNoCORS) {
         // "1. If |r|'s request's method is not a simple method, throw a
         // TypeError."
         if (!FetchUtils::isSimpleMethod(r->request()->method())) {
             exceptionState.throwTypeError("'" + r->request()->method() + "' is unsupported in no-cors mode.");
             return nullptr;
         }
         // "Set |r|'s Headers object's guard to |request-no-CORS|.
         r->headers()->setGuard(Headers::RequestNoCORSGuard);
     }
     // "26. Fill |r|'s Headers object with |headers|. Rethrow any exceptions."
     if (init.headers) {
         ASSERT(init.headersDictionary.isUndefinedOrNull());
         r->headers()->fillWith(init.headers.get(), exceptionState);
     } else if (!init.headersDictionary.isUndefinedOrNull()) {
         r->headers()->fillWith(init.headersDictionary, exceptionState);
     } else {
         ASSERT(headers);
         r->headers()->fillWith(headers, exceptionState);
     }
     if (exceptionState.hadException())
         return nullptr;
 
     // "27. If either |init|'s body member is present or |temporaryBody| is
     // non-null, and |request|'s method is `GET` or `HEAD`, throw a TypeError.
-    if (init.bodyBlobHandle || temporaryBodyRequest) {
+    if (init.bodyBlobHandle || temporaryBody) {
         if (request->method() == "GET" || request->method() == "HEAD") {
             exceptionState.throwTypeError("Request with GET/HEAD method cannot have body.");
             return nullptr;
         }
     }
 
     // "28. If |init|'s body member is present, run these substeps:"
     if (init.bodyBlobHandle) {
         // "1. Let |stream| and |Content-Type| be the result of extracting
         //  |init|'s body member."
         // "2. Set |temporaryBody| to |stream|.
         // "3. 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."
-        temporaryBodyBuffer = BodyStreamBuffer::create(FetchBlobDataConsumerHandle::create(scriptState->executionContext(), init.bodyBlobHandle));
-        temporaryBodyRequest = nullptr;
+        temporaryBody = new BodyStreamBuffer(FetchBlobDataConsumerHandle::create(scriptState->executionContext(), 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 nullptr;
     }
 
     // "29. Set |r|'s body to |temporaryBody|.
-    if (temporaryBodyBuffer)
-        r->setBuffer(temporaryBodyBuffer);
-    else if (temporaryBodyRequest)
-        r->setBuffer(temporaryBodyRequest->createDrainingStream()->leakBuffer());
+    if (temporaryBody)
+        r->m_request->setBuffer(temporaryBody);
 
     // "30. 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());
 
     // "31. If |input| is a Request object and |input|'s body is non-null, run
     // these substeps:"
     // We set bodyUsed even when the body is null in spite of the
     // spec. See https://github.com/whatwg/fetch/issues/61 for details.
     if (inputRequest) {
         // "1. Set |input|'s body to null."
-        inputRequest->setBuffer(nullptr);
+        inputRequest->m_request->setBuffer(new BodyStreamBuffer);
         // "2. Set |input|'s used flag."
-        inputRequest->lockBody(PassBody);
+        inputRequest->setBodyPassed();
     }
 
     // "32. 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)
 {
     return createRequestWithRequestOrString(scriptState, input, String(), RequestInit(scriptState->executionContext(), init, exceptionState), exceptionState);
 }
 
 Request* Request::create(ExecutionContext* context, FetchRequestData* request)
 {
-    Request* r = new Request(context, request);
-    r->suspendIfNeeded();
-    return r;
+    return new Request(context, request);
 }
 
 Request::Request(ExecutionContext* context, FetchRequestData* request)
     : Body(context)
     , m_request(request)
     , m_headers(Headers::create(m_request->headerList()))
 {
     m_headers->setGuard(Headers::RequestGuard);
-
-    refreshBody();
 }
 
 Request::Request(ExecutionContext* context, FetchRequestData* request, Headers* headers)
-    : Body(context) , m_request(request) , m_headers(headers)
-{
-    refreshBody();
-}
+    : Body(context) , m_request(request) , m_headers(headers) {}
 
 Request* Request::create(ExecutionContext* context, const WebServiceWorkerRequest& webRequest)
 {
-    Request* r = new Request(context, webRequest);
-    r->suspendIfNeeded();
-    return r;
+    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);
-
-    refreshBody();
 }
 
 String Request::method() const
 {
     // "The method attribute's getter must return request's method."
     return m_request->method();
 }
 
 KURL Request::url() const
 {
@@ skipping 128 matching lines @@
     return "";
 }
 
 Request* Request::clone(ExceptionState& exceptionState)
 {
     if (bodyUsed()) {
         exceptionState.throwTypeError("Request body is already used");
         return nullptr;
     }
 
-    if (OwnPtr<DrainingBodyStreamBuffer> buffer = createDrainingStream())
-        m_request->setBuffer(buffer->leakBuffer());
-
     FetchRequestData* request = m_request->clone(executionContext());
     Headers* headers = Headers::create(request->headerList());
     headers->setGuard(m_headers->guard());
-    Request* r = new Request(executionContext(), request, headers);
-    r->suspendIfNeeded();
-
-    // Lock the old body and set |body| property to the new one.
-    lockBody();
-    refreshBody();
-    return r;
+    return new Request(executionContext(), request, headers);
 }
 
 FetchRequestData* Request::passRequestData()
 {
     ASSERT(!bodyUsed());
+    setBodyPassed();
+    FetchRequestData* newRequestData = m_request->pass(executionContext());
+    return newRequestData;
+}
 
-    if (OwnPtr<DrainingBodyStreamBuffer> buffer = createDrainingStream())
-        m_request->setBuffer(buffer->leakBuffer());
-
-    lockBody(PassBody);
-    FetchRequestData* newRequestData = m_request->pass(executionContext());
-    refreshBody();
-    return newRequestData;
+bool Request::hasBody() const
+{
+    return bodyBuffer()->hasBody();
 }
 
 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);
         webRequest.appendHeader(header.first, header.second);
     }
 
     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::setBuffer(BodyStreamBuffer* buffer)
-{
-    m_request->setBuffer(buffer);
-    refreshBody();
-}
-
-void Request::refreshBody()
-{
-    setBody(m_request->buffer());
-}
-
-void Request::clearHeaderList()
-{
-    m_request->headerList()->clearList();
-}
-
 String Request::mimeType() const
 {
     return m_request->mimeType();
 }
 
 DEFINE_TRACE(Request)
 {
     Body::trace(visitor);
     visitor->trace(m_request);
     visitor->trace(m_headers);
 }
 
 } // namespace blink