**** [WIP] Blink-side: Implement FetchBlobDataConsumerHandle ****

Source/modules/fetch/FetchManager.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/FetchManager.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8ThrowException.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/fetch/FetchUtils.h"
 #include "core/fileapi/Blob.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/loader/ThreadableLoader.h"
 #include "core/loader/ThreadableLoaderClient.h"
 #include "modules/fetch/Body.h"
 #include "modules/fetch/BodyStreamBuffer.h"
+#include "modules/fetch/DataConsumerHandleUtil.h"
 #include "modules/fetch/FetchRequestData.h"
 #include "modules/fetch/Response.h"
 #include "modules/fetch/ResponseInit.h"
 #include "platform/network/ResourceError.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/ResourceResponse.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/WebURLRequest.h"
 #include "wtf/HashSet.h"
 
 namespace blink {
 
 class FetchManager::Loader final : public NoBaseWillBeGarbageCollectedFinalized<FetchManager::Loader>, public ThreadableLoaderClient, public ContextLifecycleObserver {
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(FetchManager::Loader);
 public:
     static PassOwnPtrWillBeRawPtr<Loader> create(ExecutionContext* executionContext, FetchManager* fetchManager, PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver, FetchRequestData* request)
     {
         return adoptPtrWillBeNoop(new Loader(executionContext, fetchManager, resolver, request));
     }
 
     ~Loader() override;
     DECLARE_VIRTUAL_TRACE();
 
     void didReceiveResponse(unsigned long, const ResourceResponse&, PassOwnPtr<WebDataConsumerHandle>) override;
-    void didReceiveData(const char*, unsigned) override;
     void didFinishLoading(unsigned long, double) override;
     void didFail(const ResourceError&) override;
     void didFailAccessControlCheck(const ResourceError&) override;
     void didFailRedirectCheck() override;
 
     void start();
     void cancel();
     void dispose();
 
 private:
-    class Canceller : public BodyStreamBuffer::Canceller {
-    public:
-        explicit Canceller(Loader* loader) : m_loader(loader) { }
-        void cancel() override
-        {
-            if (m_loader)
-                m_loader->cancel();
-        }
-
-#if !ENABLE(OILPAN)
-        // FIXME: This function should go away once Oilpan is shipped.
-        void disconnect() { m_loader = nullptr; }
-#endif
-
-        DEFINE_INLINE_VIRTUAL_TRACE()
-        {
-            visitor->trace(m_loader);
-            BodyStreamBuffer::Canceller::trace(visitor);
-        }
-
-    private:
-        // |m_loader| is a raw ptr in non-oilpan circumstance to avoid
-        // circular reference. It will be cleared when the loader is destructed.
-        RawPtrWillBeMember<Loader> m_loader;
-    };
-
-
     Loader(ExecutionContext*, FetchManager*, PassRefPtrWillBeRawPtr<ScriptPromiseResolver>, FetchRequestData*);
 
     void performBasicFetch();
     void performNetworkError(const String& message);
     void performHTTPFetch(bool corsFlag, bool corsPreflightFlag);
     void failed(const String& message);
     void notifyFinished();
 
     RawPtrWillBeMember<FetchManager> m_fetchManager;
     RefPtrWillBeMember<ScriptPromiseResolver> m_resolver;
     PersistentWillBeMember<FetchRequestData> m_request;
-    PersistentWillBeMember<BodyStreamBuffer> m_responseBuffer;
     RefPtr<ThreadableLoader> m_loader;
-    // Hold as a member in order to call |disconnect|. This member can be
-    // eliminated once Oilpan is shipped.
-    PersistentWillBeMember<Canceller> m_canceller;
     bool m_failed;
     bool m_finished;
 };
 
 FetchManager::Loader::Loader(ExecutionContext* executionContext, FetchManager* fetchManager, PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver, FetchRequestData* request)
     : ContextLifecycleObserver(executionContext)
     , m_fetchManager(fetchManager)
     , m_resolver(resolver)
     , m_request(request)
-    , m_canceller(new Canceller(this))
     , m_failed(false)
     , m_finished(false)
 {
 }
 
 FetchManager::Loader::~Loader()
 {
     ASSERT(!m_loader);
-#if !ENABLE(OILPAN)
-    // FIXME: This should go away once Oilpan is shipped.
-    m_canceller->disconnect();
-#endif
 }
 
 DEFINE_TRACE(FetchManager::Loader)
 {
     visitor->trace(m_fetchManager);
     visitor->trace(m_resolver);
     visitor->trace(m_request);
-    visitor->trace(m_responseBuffer);
-    visitor->trace(m_canceller);
     ContextLifecycleObserver::trace(visitor);
 }
 
 void FetchManager::Loader::didReceiveResponse(unsigned long, const ResourceResponse& response, PassOwnPtr<WebDataConsumerHandle> handle)
 {
-    // FIXME: Use |handle|.
-    ASSERT_UNUSED(handle, !handle);
+    ASSERT(handle);
     // Recompute the tainting if the request was redirected to a different
     // origin.
     if (!SecurityOrigin::create(response.url())->isSameSchemeHostPort(m_request->origin().get())) {
         switch (m_request->mode()) {
         case WebURLRequest::FetchRequestModeSameOrigin:
             ASSERT_NOT_REACHED();
             break;
         case WebURLRequest::FetchRequestModeNoCORS:
             m_request->setResponseTainting(FetchRequestData::OpaqueTainting);
             break;
         case WebURLRequest::FetchRequestModeCORS:
         case WebURLRequest::FetchRequestModeCORSWithForcedPreflight:
             m_request->setResponseTainting(FetchRequestData::CORSTainting);
             break;
         }
     }
-    m_responseBuffer = new BodyStreamBuffer(m_canceller);
-    FetchResponseData* responseData = FetchResponseData::createWithBuffer(m_responseBuffer);
+    FetchResponseData* responseData = FetchResponseData::createWithBuffer(createFetchDataConsumerHandleFromWebHandle(handle));
     responseData->setStatus(response.httpStatusCode());
     responseData->setStatusMessage(response.httpStatusText());
     for (auto& it : response.httpHeaderFields())
         responseData->headerList()->append(it.key, it.value);
     responseData->setURL(response.url());
     responseData->setMIMEType(response.mimeType());
 
     FetchResponseData* taintedResponse = responseData;
     switch (m_request->tainting()) {
     case FetchRequestData::BasicTainting:
         taintedResponse = responseData->createBasicFilteredResponse();
         break;
     case FetchRequestData::CORSTainting:
         taintedResponse = responseData->createCORSFilteredResponse();
         break;
     case FetchRequestData::OpaqueTainting:
         taintedResponse = responseData->createOpaqueFilteredResponse();
         break;
     }
     Response* r = Response::create(m_resolver->executionContext(), taintedResponse);
     r->headers()->setGuard(Headers::ImmutableGuard);
     m_resolver->resolve(r);
     m_resolver.clear();
 }
 
-void FetchManager::Loader::didReceiveData(const char* data, unsigned size)
-{
-    m_responseBuffer->write(DOMArrayBuffer::create(data, size));
-}
-
 void FetchManager::Loader::didFinishLoading(unsigned long, double)
 {
-    ASSERT(m_responseBuffer);
     ASSERT(!m_failed);
-    m_responseBuffer->close();
-    m_responseBuffer.clear();
     m_finished = true;
     notifyFinished();
 }
 
 void FetchManager::Loader::didFail(const ResourceError& error)
 {
     if (error.isCancellation() || error.isTimeout() || error.domain() != errorDomainBlinkInternal)
         failed(String());
     else
         failed("Fetch API cannot load " + error.failingURL() + ". " + error.localizedDescription());
@@ skipping 103 matching lines @@
     performHTTPFetch(true, false);
 }
 
 void FetchManager::Loader::cancel()
 {
     m_finished = true;
     if (m_loader) {
         m_loader->cancel();
         m_loader.clear();
     }
-    if (m_responseBuffer) {
-        m_responseBuffer->close();
-        m_responseBuffer.clear();
-    }
     if (m_resolver) {
         // Note: In the current implementation this branch is never taken
         // because this function can be called only through the body stream.
         ScriptState* scriptState = m_resolver->scriptState();
         ScriptState::Scope scope(scriptState);
         m_resolver->reject(V8ThrowException::createTypeError(scriptState->isolate(), "fetch is cancelled"));
         m_resolver.clear();
     }
 
     notifyFinished();
@@ skipping 46 matching lines @@
 
     if (m_request->method() != "GET" && m_request->method() != "HEAD") {
         RefPtr<BlobDataHandle> blobDataHandle = m_request->blobDataHandle();
         if (blobDataHandle.get()) {
             RefPtr<FormData> httpBody(FormData::create());
             httpBody->appendBlob(blobDataHandle->uuid(), blobDataHandle);
             request.setHTTPBody(httpBody);
         }
     }
 
+    request.setUseStreamOnResponse(true);
+
     // "2. Append `Referer`/empty byte sequence, if |HTTPRequest|'s |referrer|
     // is none, and `Referer`/|HTTPRequest|'s referrer, serialized and utf-8
     // encoded, otherwise, to HTTPRequest's header list.
     // We set the referrer using workerGlobalScope's URL in
     // WorkerThreadableLoader.
 
     // "3. Append `Host`, ..."
     // FIXME: Implement this when the spec is fixed.
 
     // "4.If |HTTPRequest|'s force Origin header flag is set, append `Origin`/
@@ skipping 36 matching lines @@
         performNetworkError("Can't create ThreadableLoader");
 }
 
 void FetchManager::Loader::failed(const String& message)
 {
     if (m_failed || m_finished)
         return;
     m_failed = true;
     if (!message.isEmpty())
         executionContext()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, message));
-    if (m_responseBuffer) {
-        m_responseBuffer->error(DOMException::create(NetworkError, "Failed to fetch"));
-        m_responseBuffer.clear();
-    } else if (m_resolver) {
+    if (m_resolver) {
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
         ScriptState* state = m_resolver->scriptState();
         ScriptState::Scope scope(state);
         m_resolver->reject(V8ThrowException::createTypeError(state->isolate(), "Failed to fetch"));
     }
     notifyFinished();
 }
 
 void FetchManager::Loader::notifyFinished()
@@ skipping 47 matching lines @@
 
 DEFINE_TRACE(FetchManager)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_executionContext);
     visitor->trace(m_loaders);
 #endif
 }
 
 } // namespace blink