[2a] Implement FetchDataLoader

Source/modules/fetch/FetchDataLoader.cpp

+// Copyright 2015 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/FetchDataLoader.h"
+
+#include "wtf/ArrayBufferBuilder.h"
+#include "wtf/text/WTFString.h"
+
+namespace blink {
+
+namespace {
+
+class FetchDataLoaderAsBlobHandle
+    : public FetchDataLoader
+    , public WebDataConsumerHandle::Client {
+public:
+    explicit FetchDataLoaderAsBlobHandle(const String& mimeType)
+        : m_client(nullptr)
+        , m_mimeType(mimeType) { }
+
+private:
+    void start(FetchDataConsumerHandle* handle, FetchDataLoader::Client* client) override
+    {
+        ASSERT(!m_client);
+        ASSERT(!m_reader);
+
+        m_client = client;
+        // Passing |this| here is safe because |this| owns |m_reader|.
+        m_reader = handle->obtainReader(this);
+        RefPtr<BlobDataHandle> blobHandle = m_reader->blobDataHandle();
+        if (blobHandle && blobHandle->size() != kuint64max) {

[yhirano, 2015/06/17 09:27:58]

Hmm, If taking a non-null BlobDataHandle drains all data from the reader, this
object creates an empty blob when blobHandle != null and blobHandle->size() ==
kuint64max at L33. Is my understanding correct?

[hiroshige, 2015/06/17 18:27:29]

Agree; I add a restriction that drainAsBlobDataHandle()->size() is valid (if
non-null) https://codereview.chromium.org/1176243004/ and updated this CL.

+            // If the size of |blobHandle| is set correctly, creates Blob from
+            // it.
+            m_reader.clear();
+            auto client = m_client;
+            m_client = nullptr;
+            if (blobHandle->type() != m_mimeType) {
+                // A new BlobDataHandle is created to override the Blob's type.
+                client->didFetchDataLoadedBlobHandle(BlobDataHandle::create(blobHandle->uuid(), m_mimeType, blobHandle->size()));
+            } else {
+                client->didFetchDataLoadedBlobHandle(blobHandle);
+            }
+            // Here |this| might be already destructed.
+            return;
+        }
+
+        // If the size is not set, read from |m_reader| and create a new blob.
+        m_blobData = BlobData::create();
+        m_blobData->setContentType(m_mimeType);
+    }
+
+    void didGetReadable() override
+    {
+        ASSERT(m_client);
+        ASSERT(m_reader);
+
+        while (true) {
+            const void* buffer;
+            size_t available;
+            WebDataConsumerHandle::Result result = m_reader->beginRead(&buffer, WebDataConsumerHandle::FlagNone, &available);
+
+            switch (result) {
+            case WebDataConsumerHandle::Ok:
+                m_blobData->appendBytes(buffer, available);
+                m_reader->endRead(available);
+                break;
+
+            case WebDataConsumerHandle::Done: {
+                m_reader.clear();
+                long long size = m_blobData->length();
+                auto client = m_client;
+                m_client = nullptr;
+                client->didFetchDataLoadedBlobHandle(BlobDataHandle::create(m_blobData.release(), size));
+                return;
+            }
+
+            case WebDataConsumerHandle::ShouldWait:
+                return;
+
+            case WebDataConsumerHandle::Busy:
+            case WebDataConsumerHandle::ResourceExhausted:
+            case WebDataConsumerHandle::UnexpectedError: {
+                m_reader.clear();
+                auto client = m_client;
+                m_client = nullptr;
+                client->didFetchDataLoadFailed();
+                return;
+            }
+            }
+        }
+    }
+
+    OwnPtr<FetchDataConsumerHandle::Reader> m_reader;
+    Client* m_client;
+
+    String m_mimeType;
+    OwnPtr<BlobData> m_blobData;
+};
+
+class FetchDataLoaderAsArrayBufferOrString
+    : public FetchDataLoader
+    , public WebDataConsumerHandle::Client {
+public:
+    enum LoadType {
+        LoadAsArrayBuffer,
+        LoadAsString
+    };
+
+    explicit FetchDataLoaderAsArrayBufferOrString(LoadType loadType)
+        : m_client(nullptr)
+        , m_loadType(loadType) { }
+
+protected:
+    void start(FetchDataConsumerHandle* handle, FetchDataLoader::Client* client) override
+    {
+        ASSERT(!m_client);
+        ASSERT(!m_rawData);
+        ASSERT(!m_reader);
+        m_client = client;
+        m_rawData = adoptPtr(new ArrayBufferBuilder());
+        m_reader = handle->obtainReader(this);
+    }
+
+    void didGetReadable() override
+    {
+        ASSERT(m_client);
+        ASSERT(m_rawData);
+        ASSERT(m_reader);
+
+        while (true) {
+            const void* buffer;
+            size_t available;
+            WebDataConsumerHandle::Result result = m_reader->beginRead(&buffer, WebDataConsumerHandle::FlagNone, &available);
+
+            switch (result) {
+            case WebDataConsumerHandle::Ok:
+                if (available > 0) {
+                    unsigned bytesAppended = m_rawData->append(static_cast<const char*>(buffer), available);
+                    if (!bytesAppended) {
+                        m_reader->endRead(0);
+                        error();
+                        return;
+                    }
+                    ASSERT(bytesAppended == available);
+                }
+                m_reader->endRead(available);
+                break;
+
+            case WebDataConsumerHandle::Done: {
+                m_reader.clear();
+                auto client = m_client;
+                m_client = nullptr;
+                switch (m_loadType) {
+                case LoadAsArrayBuffer:
+                    client->didFetchDataLoadedArrayBuffer(DOMArrayBuffer::create(m_rawData->toArrayBuffer()));
+                    break;
+                case LoadAsString:
+                    client->didFetchDataLoadedString(m_rawData->toString());
+                    break;
+                }
+                // Here |this| might be already destructed.
+                return;
+            }
+
+            case WebDataConsumerHandle::ShouldWait:
+                return;
+
+            case WebDataConsumerHandle::Busy:
+            case WebDataConsumerHandle::ResourceExhausted:
+            case WebDataConsumerHandle::UnexpectedError:
+                error();
+                return;
+            }
+        }
+    }
+
+    void error()
+    {
+        m_reader.clear();
+        m_rawData.clear();
+        auto client = m_client;
+        m_client = nullptr;
+        client->didFetchDataLoadFailed();
+        // Here |this| might be already destructed.
+    }
+
+    OwnPtr<FetchDataConsumerHandle::Reader> m_reader;
+    Client* m_client;
+
+    LoadType m_loadType;
+    OwnPtr<ArrayBufferBuilder> m_rawData;
+};
+
+} // namespace
+
+PassOwnPtr<FetchDataLoader> FetchDataLoader::createLoaderAsBlobHandle(const String& mimeType)
+{
+    return adoptPtr(new FetchDataLoaderAsBlobHandle(mimeType));
+}
+
+PassOwnPtr<FetchDataLoader> FetchDataLoader::createLoaderAsArrayBuffer()
+{
+    return adoptPtr(new FetchDataLoaderAsArrayBufferOrString(FetchDataLoaderAsArrayBufferOrString::LoadAsArrayBuffer));
+}
+
+PassOwnPtr<FetchDataLoader> FetchDataLoader::createLoaderAsString()
+{
+    return adoptPtr(new FetchDataLoaderAsArrayBufferOrString(FetchDataLoaderAsArrayBufferOrString::LoadAsString));
+}
+
+} // namespace blink