[2c] Replace Body::readAsyncFromBlob with readAsyncFromFetchDataConsumerHandle

Source/modules/fetch/Body.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/Body.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8ArrayBuffer.h"
 #include "bindings/core/v8/V8ThrowException.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMTypedArray.h"
 #include "core/fileapi/Blob.h"
 #include "core/fileapi/FileReaderLoader.h"
 #include "core/fileapi/FileReaderLoaderClient.h"
 #include "core/frame/UseCounter.h"
 #include "core/streams/ReadableByteStream.h"
 #include "core/streams/ReadableByteStreamReader.h"
 #include "core/streams/UnderlyingSource.h"
 #include "modules/fetch/BodyStreamBuffer.h"
+#include "modules/fetch/DataConsumerHandleUtil.h"
+#include "modules/fetch/FetchBlobDataConsumerHandle.h"
 
 namespace blink {
 
 class Body::BlobHandleReceiver final : public BodyStreamBuffer::BlobHandleCreatorClient {
 public:
     explicit BlobHandleReceiver(Body* body)
         : m_body(body)
     {
     }
     void didCreateBlobHandle(PassRefPtr<BlobDataHandle> handle) override
@@ skipping 309 matching lines @@
     } else if (isBodyConsumed()) {
         m_streamSource->createDrainingStream()->readAllAndCreateBlobHandle(mimeType(), new BlobHandleReceiver(this));
     } else if (buffer()) {
         buffer()->readAllAndCreateBlobHandle(mimeType(), new BlobHandleReceiver(this));
     } else {
         readAsyncFromBlob(blobDataHandle());
     }
     return promise;
 }
 
-void Body::readAsyncFromBlob(PassRefPtr<BlobDataHandle> handle)
+void Body::readAsyncFromFetchDataConsumerHandle(FetchDataConsumerHandle* handle, const String& mimeType)
 {
-    FileReaderLoader::ReadType readType = FileReaderLoader::ReadAsText;
-    RefPtr<BlobDataHandle> blobHandle = handle;
-    if (!blobHandle)
-        blobHandle = BlobDataHandle::create(BlobData::create(), 0);
+    ASSERT(!m_fetchDataLoader);
+
     switch (m_responseType) {
     case ResponseAsArrayBuffer:
-        readType = FileReaderLoader::ReadAsArrayBuffer;
+        m_fetchDataLoader = FetchDataLoader::createLoaderAsArrayBuffer();
         break;
+
+    case ResponseAsJSON:
+    case ResponseAsText:
+        m_fetchDataLoader = FetchDataLoader::createLoaderAsString();
+        break;
+
     case ResponseAsBlob:
-        if (blobHandle->size() != kuint64max) {
-            // If the size of |blobHandle| is set correctly, creates Blob from
-            // it.
-            if (blobHandle->type() != mimeType()) {
-                // A new BlobDataHandle is created to override the Blob's type.
-                m_resolver->resolve(Blob::create(BlobDataHandle::create(blobHandle->uuid(), mimeType(), blobHandle->size())));
-            } else {
-                m_resolver->resolve(Blob::create(blobHandle));
-            }
-            m_stream->close();
-            m_resolver.clear();
-            return;
-        }
-        // If the size is not set, read as ArrayBuffer and create a new blob to
-        // get the size.
-        // FIXME: This workaround is not good for performance.
-        // When we will stop using Blob as a base system of Body to support
-        // stream, this problem should be solved.
-        readType = FileReaderLoader::ReadAsArrayBuffer;
+        m_fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle(mimeType);
         break;
+
     case ResponseAsFormData:
         // FIXME: Implement this.
         ASSERT_NOT_REACHED();
-        break;
-    case ResponseAsJSON:
-    case ResponseAsText:
-        break;
+        return;
+
     default:
         ASSERT_NOT_REACHED();
+        return;
     }
 
-    m_loader = adoptPtr(new FileReaderLoader(readType, this));
-    m_loader->start(m_resolver->scriptState()->executionContext(), blobHandle);
+    if (handle)
+        m_fetchDataLoader->start(handle, this);
+    else
+        m_fetchDataLoader->start(createFetchDataConsumerHandleFromWebHandle(createDoneDataConsumerHandle()).get(), this);

[yhirano, 2015/06/25 04:37:08]

|handle| will never be null.

[hiroshige, 2015/06/25 05:39:17]

Done.

+}
 
-    return;
+
+void Body::readAsyncFromBlob(PassRefPtr<BlobDataHandle> handle)
+{
+    readAsyncFromFetchDataConsumerHandle(FetchBlobDataConsumerHandle::create(executionContext(), handle).get(), mimeType());
 }
 
 ScriptPromise Body::arrayBuffer(ScriptState* scriptState)
 {
     return readAsync(scriptState, ResponseAsArrayBuffer);
 }
 
 ScriptPromise Body::blob(ScriptState* scriptState)
 {
     return readAsync(scriptState, ResponseAsBlob);
@@ skipping 61 matching lines @@
     m_streamSource->startStream(m_stream);
 }
 
 BodyStreamBuffer* Body::createDrainingStream()
 {
     return m_streamSource->createDrainingStream();
 }
 
 void Body::stop()
 {
-    // Canceling the load will call didFail which will remove the resolver.
-    if (m_loader)
-        m_loader->cancel();
+    if (m_fetchDataLoader) {
+        m_fetchDataLoader->cancel();
+        m_fetchDataLoader.clear();
+    }
 }
 
 bool Body::hasPendingActivity() const
 {
     if (executionContext()->activeDOMObjectsAreStopped())
         return false;
     if (m_resolver)
         return true;
     if (m_stream->isLocked())
         return true;
     return false;
 }
 
 Body::ReadableStreamSource* Body::createBodySource(PassRefPtr<BlobDataHandle> handle)
 {
     return new ReadableStreamSource(executionContext(), handle);
 }
 
 Body::ReadableStreamSource* Body::createBodySource(BodyStreamBuffer* buffer)
 {
     return new ReadableStreamSource(executionContext(), buffer);
 }
 
 DEFINE_TRACE(Body)
 {
+    visitor->trace(m_fetchDataLoader);
     visitor->trace(m_resolver);
     visitor->trace(m_stream);
     visitor->trace(m_streamSource);
     ActiveDOMObject::trace(visitor);
+    FetchDataLoader::Client::trace(visitor);
 }
 
 Body::Body(ExecutionContext* context)
     : ActiveDOMObject(context)
     , m_bodyUsed(false)
     , m_responseType(ResponseType::ResponseUnknown)
     , m_streamSource(new ReadableStreamSource(context))
     , m_stream(new ReadableByteStream(m_streamSource, new ReadableByteStream::StrictStrategy))
 {
     m_streamSource->startStream(m_stream);
 }
 
 void Body::resolveJSON(const String& string)
 {
     ASSERT(m_responseType == ResponseAsJSON);
     ScriptState::Scope scope(m_resolver->scriptState());
     v8::Isolate* isolate = m_resolver->scriptState()->isolate();
     v8::Local<v8::String> inputString = v8String(isolate, string);
     v8::TryCatch trycatch;
     v8::Local<v8::Value> parsed;
     if (v8Call(v8::JSON::Parse(isolate, inputString), parsed, trycatch))
         m_resolver->resolve(parsed);
     else
         m_resolver->reject(trycatch.Exception());
 }
 
-// FileReaderLoaderClient functions.
-void Body::didStartLoading() { }
-void Body::didReceiveData() { }
-void Body::didFinishLoading()
+// FetchDataLoader::Client functions.
+void Body::didFetchDataLoadFailed()
 {
-    if (!executionContext() || executionContext()->activeDOMObjectsAreStopped())
-        return;
+    ASSERT(m_fetchDataLoader);
+    m_fetchDataLoader.clear();
 
-    switch (m_responseType) {
-    case ResponseAsArrayBuffer:
-        m_resolver->resolve(m_loader->arrayBufferResult());
-        break;
-    case ResponseAsBlob: {
-        ASSERT(blobDataHandle()->size() == kuint64max);
-        OwnPtr<BlobData> blobData = BlobData::create();
-        RefPtr<DOMArrayBuffer> buffer = m_loader->arrayBufferResult();
-        blobData->appendBytes(buffer->data(), buffer->byteLength());
-        blobData->setContentType(mimeType());
-        const size_t length = blobData->length();
-        m_resolver->resolve(Blob::create(BlobDataHandle::create(blobData.release(), length)));
-        break;
-    }
-    case ResponseAsFormData:
-        ASSERT_NOT_REACHED();
-        break;
-    case ResponseAsJSON:
-        resolveJSON(m_loader->stringResult());
-        break;
-    case ResponseAsText:
-        m_resolver->resolve(m_loader->stringResult());
-        break;
-    default:
-        ASSERT_NOT_REACHED();
-    }
-    m_streamSource->close();
-    m_resolver.clear();
-}
-
-void Body::didFail(FileError::ErrorCode code)
-{
     if (!executionContext() || executionContext()->activeDOMObjectsAreStopped())
         return;
 
     m_streamSource->error();
     if (m_resolver) {
-        // FIXME: We should reject the promise.
-        m_resolver->resolve("");
+        if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped()) {
+            m_resolver.clear();
+            return;
+        }
+        ScriptState* state = m_resolver->scriptState();
+        ScriptState::Scope scope(state);
+        m_resolver->reject(V8ThrowException::createTypeError(state->isolate(), "Failed to fetch"));

[hiroshige, 2015/06/23 13:14:26]

didFetchDataLoadFailed() can be called e.g. in
http/tests/serviceworker/resources/invalid-chunked-encoding.php.
Previously, didFail() of ThreadableLoaderClient was called and so I copied the
reject() code from FetchManager::Loader::failed().

However, in terms of the spec, there seem no conditions where we can reject in
text().

         m_resolver.clear();
     }
 }
 
+void Body::didFetchDataLoadedBlobHandle(PassRefPtr<BlobDataHandle> blobDataHandle)
+{
+    ASSERT(m_fetchDataLoader);
+    m_fetchDataLoader.clear();
+
+    if (!executionContext() || executionContext()->activeDOMObjectsAreStopped())
+        return;
+
+    ASSERT(m_responseType == ResponseAsBlob);
+    m_resolver->resolve(Blob::create(blobDataHandle));
+    m_streamSource->close();
+    m_resolver.clear();
+}
+
+void Body::didFetchDataLoadedArrayBuffer(PassRefPtr<DOMArrayBuffer> arrayBuffer)
+{
+    ASSERT(m_fetchDataLoader);
+    m_fetchDataLoader.clear();
+
+    if (!executionContext() || executionContext()->activeDOMObjectsAreStopped())
+        return;
+
+    ASSERT(m_responseType == ResponseAsArrayBuffer);
+    m_resolver->resolve(arrayBuffer);
+    m_streamSource->close();
+    m_resolver.clear();
+}
+
+void Body::didFetchDataLoadedString(const String& str)
+{
+    ASSERT(m_fetchDataLoader);
+    m_fetchDataLoader.clear();
+
+    if (!executionContext() || executionContext()->activeDOMObjectsAreStopped())
+        return;
+
+    switch (m_responseType) {
+    case ResponseAsJSON:
+        resolveJSON(str);
+        break;
+    case ResponseAsText:
+        m_resolver->resolve(str);
+        break;
+    default:
+        ASSERT_NOT_REACHED();
+    }
+
+    m_streamSource->close();
+    m_resolver.clear();
+}
+
 void Body::didBlobHandleReceiveError(DOMException* exception)
 {
     if (!m_resolver)
         return;
     m_streamSource->error();
     m_resolver->reject(exception);
     m_resolver.clear();
 }
 
 } // namespace blink