Change BodyStreamBuffer to be FetchDataConsumerHandle-based and enable backpressure in Fetch API

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 56 matching lines @@
             exceptionState.throwTypeError("Cannot construct a Request with a Request object that has already been used.");
             return nullptr;
         }
         if (inputRequest->isBodyConsumed()) {
             // Currently the only methods that can consume body data without
             // setting 'body passed' flag consume entire body (e.g. text()).
             // Thus we can set an empty blob to the new request instead of
             // creating a draining stream.
             // TODO(yhirano): Fix this once Request.body is introduced.
             OwnPtr<BlobData> blobData = BlobData::create();
-            blobData->setContentType(inputRequest->blobDataHandle()->type());
+            blobData->setContentType(inputRequest->m_request->blobDataHandle()->type());
             temporaryBody = BlobDataHandle::create(blobData.release(), 0);
         } else {
             temporaryBody = inputRequest->m_request->blobDataHandle();
         }
     }
 
     // "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,
@@ skipping 225 matching lines @@
 
 Request* Request::create(ExecutionContext* context, const WebServiceWorkerRequest& webRequest)
 {
     Request* r = new Request(context, webRequest);
     r->suspendIfNeeded();
     return r;
 }
 
 Request::Request(ExecutionContext* context, const WebServiceWorkerRequest& webRequest)
     : Body(context)
-    , m_request(FetchRequestData::create(webRequest))
+    , 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();
 }
@@ skipping 131 matching lines @@
     return "";
 }
 
 Request* Request::clone(ExceptionState& exceptionState) const
 {
     if (bodyUsed()) {
         exceptionState.throwTypeError("Request body is already used");
         return nullptr;
     }
 
-    FetchRequestData* request = m_request->clone();
-    if (blobDataHandle() && isBodyConsumed()) {
+    FetchRequestData* request = m_request->clone(executionContext());
+    if (m_request->blobDataHandle() && isBodyConsumed()) {
         // Currently the only methods that can consume body data without
         // setting 'body passed' flag consume entire body (e.g. text()). Thus
         // we can set an empty blob to the new request instead of creating a
         // draining stream.
         // TODO(yhirano): Fix this once Request.body is introduced.
         OwnPtr<BlobData> blobData = BlobData::create();
-        blobData->setContentType(blobDataHandle()->type());
-        request->setBlobDataHandle(BlobDataHandle::create(blobData.release(), 0));
+        blobData->setContentType(m_request->blobDataHandle()->type());
+        request->setBlobDataHandle(executionContext(), BlobDataHandle::create(blobData.release(), 0));
     }
 
     Headers* headers = Headers::create(request->headerList());
     headers->setGuard(m_headers->guard());
     Request* r = new Request(executionContext(), request, headers);
     r->suspendIfNeeded();
     return r;
 }
 
 FetchRequestData* Request::passRequestData()
 {
     ASSERT(!bodyUsed());
     lockBody(PassBody);
-    return m_request->pass();
+    return m_request->pass(executionContext());
 }
 
 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::setBodyBlobHandle(PassRefPtr<BlobDataHandle> blobDataHandle)
 {
-    m_request->setBlobDataHandle(blobDataHandle);
-    setBody(m_request->blobDataHandle());
+    m_request->setBlobDataHandle(executionContext(), blobDataHandle);
+    setBody(m_request->buffer());
 }
 
 void Request::clearHeaderList()
 {
     m_request->headerList()->clearList();
 }
 
-PassRefPtr<BlobDataHandle> Request::blobDataHandle() const
+BodyStreamBuffer2* Request::buffer() const
 {
-    return m_request->blobDataHandle();
-}
-
-BodyStreamBuffer* Request::buffer() const
-{
-    // We don't support BodyStreamBuffer for Request yet.
-    return nullptr;
+    return m_request->buffer();
 }
 
 String Request::mimeType() const
 {
     return m_request->mimeType();
 }
 
 DEFINE_TRACE(Request)
 {
     Body::trace(visitor);
     visitor->trace(m_request);
     visitor->trace(m_headers);
 }
 
 } // namespace blink