[Fetch API] Remove DrainingBuffer.

Source/modules/serviceworkers/RespondWithObserver.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/serviceworkers/RespondWithObserver.h"
 
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/modules/v8/V8Response.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/streams/Stream.h"
 #include "modules/fetch/BodyStreamBuffer.h"
 #include "modules/serviceworkers/ServiceWorkerGlobalScopeClient.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "public/platform/WebServiceWorkerResponse.h"
 #include "wtf/Assertions.h"
 #include "wtf/RefPtr.h"
 #include <v8.h>
 
 namespace blink {
 
+namespace {
+
+class LoaderClient final : public GarbageCollectedFinalized<LoaderClient>, public FetchDataLoader::Client {
+    WTF_MAKE_NONCOPYABLE(LoaderClient);
+    USING_GARBAGE_COLLECTED_MIXIN(LoaderClient);
+public:
+    LoaderClient() = default;
+    void didFetchDataLoadedStream() override {}
+    void didFetchDataLoadFailed() override {}
+    DEFINE_INLINE_TRACE() { FetchDataLoader::Client::trace(visitor); }
+};
+
+} // namespace
+
 class RespondWithObserver::ThenFunction final : public ScriptFunction {
 public:
     enum ResolveType {
         Fulfilled,
         Rejected,
     };
 
     static v8::Local<v8::Function> createFunction(ScriptState* scriptState, RespondWithObserver* observer, ResolveType type)
     {
         ThenFunction* self = new ThenFunction(scriptState, observer, type);
@@ skipping 106 matching lines @@
     }
     if (m_frameType != WebURLRequest::FrameTypeNone && responseType != FetchResponseData::BasicType && responseType != FetchResponseData::DefaultType) {
         responseWasRejected(WebServiceWorkerResponseErrorResponseTypeNotBasicOrDefault);
         return;
     }
     if (response->bodyUsed()) {
         responseWasRejected(WebServiceWorkerResponseErrorBodyUsed);
         return;
     }
 
-    response->lockBody(Body::PassBody);
-    if (OwnPtr<DrainingBodyStreamBuffer> buffer = response->createInternalDrainingStream()) {
-        WebServiceWorkerResponse webResponse;
-        response->populateWebServiceWorkerResponse(webResponse);
-        if (RefPtr<BlobDataHandle> blobDataHandle = buffer->drainAsBlobDataHandle(FetchDataConsumerHandle::Reader::AllowBlobWithInvalidSize)) {
-            webResponse.setBlobDataHandle(blobDataHandle);
-            ServiceWorkerGlobalScopeClient::from(executionContext())->didHandleFetchEvent(m_eventID, webResponse);
-            m_state = Done;
-            return;
-        }
-        Stream* outStream = Stream::create(executionContext(), "");
-        webResponse.setStreamURL(outStream->url());
-        ServiceWorkerGlobalScopeClient::from(executionContext())->didHandleFetchEvent(m_eventID, webResponse);
-        FetchDataLoader* loader = FetchDataLoader::createLoaderAsStream(outStream);
-        buffer->startLoading(loader, nullptr);
-        m_state = Done;
-        return;
-    }
+    response->setBodyPassed();
     WebServiceWorkerResponse webResponse;
     response->populateWebServiceWorkerResponse(webResponse);
+    BodyStreamBuffer* buffer = response->internalBodyBuffer();
+    if (buffer->hasBody()) {
+        OwnPtr<FetchDataConsumerHandle> handle = buffer->lock(executionContext());
+        RefPtr<BlobDataHandle> blobDataHandle = handle->obtainReader(nullptr)->drainAsBlobDataHandle(FetchDataConsumerHandle::Reader::AllowBlobWithInvalidSize);
+        buffer->unlock(handle.release());

[hiroshige, 2015/07/21 12:14:01]

Same for the comment in FetchManager.cpp.

[yhirano, 2015/07/22 09:42:45]

Done.

+        if (blobDataHandle) {
+            webResponse.setBlobDataHandle(blobDataHandle);
+        } else {
+            Stream* outStream = Stream::create(executionContext(), "");
+            webResponse.setStreamURL(outStream->url());
+            buffer->startLoading(executionContext(), FetchDataLoader::createLoaderAsStream(outStream), new LoaderClient);
+        }
+    }
     ServiceWorkerGlobalScopeClient::from(executionContext())->didHandleFetchEvent(m_eventID, webResponse);
     m_state = Done;
 }
 
 RespondWithObserver::RespondWithObserver(ExecutionContext* context, int eventID, WebURLRequest::FetchRequestMode requestMode, WebURLRequest::FrameType frameType)
     : ContextLifecycleObserver(context)
     , m_eventID(eventID)
     , m_requestMode(requestMode)
     , m_frameType(frameType)
     , m_state(Initial)
 {
 }
 
 DEFINE_TRACE(RespondWithObserver)
 {
     ContextLifecycleObserver::trace(visitor);
 }
 
 } // namespace blink