Introduce FetchFormDataConsumerHandle.

Source/modules/fetch/FetchFormDataConsumerHandle.cpp

Index: Source/modules/fetch/FetchFormDataConsumerHandle.cpp
diff --git a/Source/modules/fetch/FetchFormDataConsumerHandle.cpp b/Source/modules/fetch/FetchFormDataConsumerHandle.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..86ae78b6c5974ee4728d447f466bcfffe9b8b1a8
--- /dev/null
+++ b/Source/modules/fetch/FetchFormDataConsumerHandle.cpp
@@ -0,0 +1,250 @@
+// 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/FetchFormDataConsumerHandle.h"
+
+#include "core/dom/DOMArrayBuffer.h"
+#include "modules/fetch/DataConsumerHandleUtil.h"
+#include "modules/fetch/FetchBlobDataConsumerHandle.h"
+#include "platform/network/FormData.h"
+#include "wtf/ThreadSafeRefCounted.h"
+#include "wtf/ThreadingPrimitives.h"
+#include "wtf/Vector.h"
+#include "wtf/text/TextCodec.h"
+#include "wtf/text/TextEncoding.h"
+#include "wtf/text/WTFString.h"
+
+#include <utility>
+
+namespace blink {
+
+using Result = FetchDataConsumerHandle::Result;
+
+class FetchFormDataConsumerHandle::Context final : public ThreadSafeRefCounted<Context> {
+    WTF_MAKE_NONCOPYABLE(Context);
+public:
+    static PassRefPtr<Context> create(const String& body) { return adoptRef(new Context(body)); }
+    static PassRefPtr<Context> create(PassRefPtr<DOMArrayBuffer> body) { return adoptRef(new Context(body)); }
+    static PassRefPtr<Context> create(ExecutionContext* executionContext, PassRefPtr<FormData> body, FetchBlobDataConsumerHandle::LoaderFactory* factory)
+    {
+        return adoptRef(new Context(executionContext, body, factory));
+    }
+
+    void obtainReader(Client* client)
+    {
+        if (m_handleForComplexFormData) {

[hiroshige, 2015/08/10 13:27:03]

Switching by |m_handleForComplexFormData| seems complex and somehow prone to
error.
Can we split this mixed logic of FetchFormDataConsumerHandle::Context into two
separate logics, i.e.
- One for flattenable FormData only, and
- One for complex FormData.

A possible implementation would be:
- Add |FetchBlobDataConsumerHandle::ReaderContext::m_formDataForDrain|,
- Make |FetchFormDataConsumerHandle| only for flatten FormData, and
- Return FetchBlobDataConsumerHandle in FetchFormDataConsumerHandle::create() if
the formdata is complex, and return FetchFormDataConsumerHandle otherwise.

pros:
- We can merge branches by |m_handleForComplexFormData| into single if-statement
in create().
- We can merge logic for clearing |m_formData| for complex FormData case (e.g.
L51--54) into the similar logic in FetchBlobDataConsumerHandle.
- Having |FetchBlobDataConsumerHandle::ReaderContext::m_formDataForDrain| in
addition to |m_blobDataHandleForDrain| adds little complexity to
FetchBlobDataConsumerHandle (just we set and clear |m_formDataForDrain| when we
set and clear |m_blobDataHandleForDrain|).

cons:
- Having FormData support is a little conflicting with the name of
FetchBlobDataConsumerHandle.

[yhirano, 2015/08/11 06:08:43]

I split Context into SimpleContext and ComplexContext. I don't like conflating
FetchBlobDataConsumerHandle with FetchFormDataConsumerHandle though.

+            m_readerForComplexFormData = m_handleForComplexFormData->obtainReader(client);
+        }
+    }
+
+    void releaseReader()
+    {
+        m_readerForComplexFormData = nullptr;
+    }
+
+    Result read(void* data, size_t size, Flags flags, size_t* readSize)
+    {
+        if (m_readerForComplexFormData) {
+            Result r = m_readerForComplexFormData->read(data, size, flags, readSize);
+            if (!((r == WebDataConsumerHandle::Ok && *readSize == 0) || r == WebDataConsumerHandle::ShouldWait)) {
+                // Something is read, so the form data should be disposed.
+                m_formData = nullptr;
+            }
+            return r;
+        }
+
+        *readSize = 0;
+        if (size == 0) {
+            if (!m_formData && m_flattenFormData.size() == m_flattenFormDataOffset)
+                return WebDataConsumerHandle::Done;
+            return WebDataConsumerHandle::Ok;
+        }
+        flatten();
+
+        *readSize = std::min(size, m_flattenFormData.size() - m_flattenFormDataOffset);
+        if (*readSize == 0)
+            return WebDataConsumerHandle::Done;
+        memcpy(data, &m_flattenFormData[m_flattenFormDataOffset], *readSize);
+        m_flattenFormDataOffset += *readSize;
+        return WebDataConsumerHandle::Ok;
+    }
+
+    Result beginRead(const void** buffer, Flags flags, size_t* available)
+    {
+        if (m_readerForComplexFormData) {
+            Result r = m_readerForComplexFormData->beginRead(buffer, flags, available);
+            if (r != WebDataConsumerHandle::ShouldWait) {
+                // Something is read, so the form data should be disposed.
+                m_formData = nullptr;
+            }
+            return r;
+        }
+
+        *buffer = nullptr;
+        *available = 0;
+
+        flatten();
+        if (m_flattenFormData.size() == m_flattenFormDataOffset)
+            return WebDataConsumerHandle::Done;
+        *buffer = &m_flattenFormData[m_flattenFormDataOffset];
+        *available = m_flattenFormData.size() - m_flattenFormDataOffset;
+        return WebDataConsumerHandle::Ok;
+    }
+
+    Result endRead(size_t read)
+    {
+        if (m_readerForComplexFormData)
+            return m_readerForComplexFormData->endRead(read);
+
+        m_flattenFormDataOffset += read;
+        return WebDataConsumerHandle::Ok;
+    }
+
+    PassRefPtr<FormData> drainFormData()
+    {
+        if (!m_formData)
+            return nullptr;
+
+        ASSERT(m_formData->hasOneRef());
+        if (m_readerForComplexFormData) {
+            // Note that m_formData must be null in a two-phase read and hence
+            // we can release the reader here.
+            m_readerForComplexFormData = nullptr;
+            m_handleForComplexFormData = nullptr;
+        }
+        ASSERT(!m_handleForComplexFormData);
+        return m_formData.release();
+    }
+
+private:
+    explicit Context(const String& body)
+        : m_formData(FormData::create(UTF8Encoding().encode(body, WTF::EntitiesForUnencodables)))
+        , m_flattenFormDataOffset(0) {}
+    explicit Context(PassRefPtr<DOMArrayBuffer> body)
+        : m_formData(FormData::create(body->data(), body->byteLength()))
+        , m_flattenFormDataOffset(0) {}
+    explicit Context(ExecutionContext* executionContext, PassRefPtr<FormData> body, FetchBlobDataConsumerHandle::LoaderFactory* factory)
+        : m_formData(body->deepCopy())
+        , m_flattenFormDataOffset(0)
+    {
+        for (const auto& element : m_formData->elements()) {
+            if (element.m_type != FormDataElement::data) {
+                // Non data type is found, so we need to use
+                // FetchBlobDataConsumerHandle.
+                createDataConsumerHandleForComplexFormData(executionContext, factory);
+                break;
+            }
+        }
+    }
+
+    void createDataConsumerHandleForComplexFormData(ExecutionContext* executionContext, FetchBlobDataConsumerHandle::LoaderFactory* factory)
+    {
+        OwnPtr<BlobData> blobData = BlobData::create();
+        for (const auto& element : m_formData->elements()) {
+            switch (element.m_type) {
+            case FormDataElement::data: {

[hiroshige, 2015/08/10 13:27:03]

nit: can we remove "{" here and "}" in L150?

[yhirano, 2015/08/11 06:08:43]

Done.

+                blobData->appendBytes(element.m_data.data(), element.m_data.size());
+                break;
+            }
+            case FormDataElement::encodedFile:
+                blobData->appendFile(element.m_filename, element.m_fileStart, element.m_fileLength, element.m_expectedFileModificationTime);
+                break;
+            case FormDataElement::encodedBlob:
+                if (element.m_optionalBlobDataHandle)
+                    blobData->appendBlob(element.m_optionalBlobDataHandle, 0, element.m_optionalBlobDataHandle->size());
+                break;
+            case FormDataElement::encodedFileSystemURL:
+                blobData->appendFileSystemURL(element.m_fileSystemURL, element.m_fileStart, element.m_fileLength, element.m_expectedFileModificationTime);
+                break;
+            }
+        }
+        blobData->setContentType("multipart/form-data; boundary=" + String(m_formData->boundary().data(), m_formData->boundary().size()));
+        auto size = blobData->length();
+        if (factory) {
+            // For testing
+            m_handleForComplexFormData = FetchBlobDataConsumerHandle::create(executionContext, BlobDataHandle::create(blobData.release(), size), factory);
+        } else {
+            m_handleForComplexFormData = FetchBlobDataConsumerHandle::create(executionContext, BlobDataHandle::create(blobData.release(), size));
+        }
+    }
+
+    void flatten()
+    {
+        ASSERT(!m_handleForComplexFormData);
+        if (!m_formData) {
+            // It's already flatten or drained.
+            return;
+        }
+        m_formData->flatten(m_flattenFormData);
+        m_formData = nullptr;
+    }
+
+    // Note this data is not shared by anyone and hence it is safe to pass
+    // around the data between threads.
+    RefPtr<FormData> m_formData;
+    Vector<char> m_flattenFormData;
+    size_t m_flattenFormDataOffset;
+    OwnPtr<WebDataConsumerHandle> m_handleForComplexFormData;
+    OwnPtr<WebDataConsumerHandle::Reader> m_readerForComplexFormData;
+};
+
+class FetchFormDataConsumerHandle::ReaderImpl final : public FetchDataConsumerHandle::Reader {
+    WTF_MAKE_NONCOPYABLE(ReaderImpl);
+public:
+    ReaderImpl(PassRefPtr<Context> context, Client* client)
+        : m_context(context)
+        , m_notifier(client)
+    {
+        // For memory barrier.
+        Mutex m;
+        MutexLocker locker(m);
+        m_context->obtainReader(client);
+    }
+    ~ReaderImpl() override
+    {
+        // For memory barrier.
+        Mutex m;
+        MutexLocker locker(m);
+        m_context->releaseReader();
+    }
+
+    Result read(void* data, size_t size, Flags flags, size_t* readSize) override
+    {
+        return m_context->read(data, size, flags, readSize);
+    }
+    Result beginRead(const void** buffer, Flags flags, size_t* available) override
+    {
+        return m_context->beginRead(buffer, flags, available);
+    }
+    Result endRead(size_t read) override
+    {
+        return m_context->endRead(read);
+    }
+    PassRefPtr<FormData> drainAsFormData() override
+    {
+        return m_context->drainFormData();
+    }
+
+private:
+    RefPtr<Context> m_context;
+    NotifyOnReaderCreationHelper m_notifier;
+};
+
+FetchFormDataConsumerHandle::FetchFormDataConsumerHandle(const String& body) : m_context(Context::create(body)) {}
+FetchFormDataConsumerHandle::FetchFormDataConsumerHandle(PassRefPtr<DOMArrayBuffer> body) : m_context(Context::create(body)) {}
+FetchFormDataConsumerHandle::FetchFormDataConsumerHandle(ExecutionContext* executionContext,
+    PassRefPtr<FormData> body,
+    FetchBlobDataConsumerHandle::LoaderFactory* loaderFactory)
+    : m_context(Context::create(executionContext, body, loaderFactory))
+{
+}
+FetchFormDataConsumerHandle::~FetchFormDataConsumerHandle() {}
+
+FetchDataConsumerHandle::Reader* FetchFormDataConsumerHandle::obtainReaderInternal(Client* client)
+{
+    return new ReaderImpl(m_context, client);
+}
+
+} // namespace blink