[2c] Replace Body::readAsyncFromBlob with readAsyncFromFetchDataConsumerHandle

Source/modules/fetch/Body.cpp

Index: Source/modules/fetch/Body.cpp
diff --git a/Source/modules/fetch/Body.cpp b/Source/modules/fetch/Body.cpp
index 0be313e412339d2df44a9ff3303435e9b7786011..acf9a3d2b827a9f4c17d647ded9a53490b6bcae0 100644
--- a/Source/modules/fetch/Body.cpp
+++ b/Source/modules/fetch/Body.cpp
@@ -20,6 +20,8 @@
 #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 {
 
@@ -349,52 +351,44 @@ ScriptPromise Body::readAsync(ScriptState* scriptState, ResponseType type)
     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);
+}
+
 
-    return;
+void Body::readAsyncFromBlob(PassRefPtr<BlobDataHandle> handle)
+{
+    readAsyncFromFetchDataConsumerHandle(FetchBlobDataConsumerHandle::create(executionContext(), handle).get(), mimeType());
 }
 
 ScriptPromise Body::arrayBuffer(ScriptState* scriptState)
@@ -477,8 +471,10 @@ BodyStreamBuffer* Body::createDrainingStream()
 void Body::stop()
 {
     // Canceling the load will call didFail which will remove the resolver.

[hiroshige, 2015/06/19 10:05:55]

Currently Patch Set doesn't remove the resolver, because I thought, despite of
this comment, didFail() does nothing after stop() due to:
    if (!executionContext() || executionContext()->activeDOMObjectsAreStopped())
        return;

[yhirano, 2015/06/19 13:39:15]

I think this comment says that m_resolver will be cleared in didFail. By the
way, we don't have didFail any more. You can update the comment, or delete it -
the comment doesn't look so helpful.

[hiroshige, 2015/06/22 11:22:19]

Done.

-    if (m_loader)
-        m_loader->cancel();
+    if (m_fetchDataLoader) {
+        m_fetchDataLoader->cancel();
+        m_fetchDataLoader.clear();
+    }
 }
 
 bool Body::hasPendingActivity() const
@@ -504,10 +500,12 @@ Body::ReadableStreamSource* Body::createBodySource(BodyStreamBuffer* 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)
@@ -534,55 +532,71 @@ void Body::resolveJSON(const String& string)
         m_resolver->reject(trycatch.Exception());
 }
 
-// FileReaderLoaderClient functions.
-void Body::didStartLoading() { }
-void Body::didReceiveData() { }
-void Body::didFinishLoading()
+// FetchDataLoader::Client functions.
+void Body::didFetchDataLoadFailed()
 {
+    ASSERT(m_fetchDataLoader);
+    m_fetchDataLoader.clear();
+
     if (!executionContext() || executionContext()->activeDOMObjectsAreStopped())
         return;
 
-    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->error();
+    if (m_resolver) {
+        m_resolver->reject("");
+        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::didFail(FileError::ErrorCode code)
+void Body::didFetchDataLoadedArrayBuffer(PassRefPtr<DOMArrayBuffer> arrayBuffer)
 {
+    ASSERT(m_fetchDataLoader);
+    m_fetchDataLoader.clear();
+
     if (!executionContext() || executionContext()->activeDOMObjectsAreStopped())
         return;
 
-    m_streamSource->error();
-    if (m_resolver) {
-        // FIXME: We should reject the promise.
-        m_resolver->resolve("");

[hiroshige, 2015/06/19 10:05:55]

I changed this resolve() to reject() to pass layout tests.
Was there any dependencies that left this resolve() despite of the FIXME
comment?

[yhirano, 2015/06/19 13:39:15]

This was added at
https://codereview.chromium.org/745143002/diff2/20001:80001/Source/modules/se...
I don't remember why.

-        m_resolver.clear();
+    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)