Introduce FetchFormDataConsumerHandle.

Source/modules/fetch/FetchFormDataConsumerHandle.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/FetchFormDataConsumerHandle.h"
+
+#include "modules/fetch/DataConsumerHandleUtil.h"
+#include "modules/fetch/FetchBlobDataConsumerHandle.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;
+
+namespace {
+
+bool isSimple(const FormData* formData)
+{
+    for (const auto& element : formData->elements()) {
+        if (element.m_type != FormDataElement::data)
+            return false;
+    }
+    return true;
+}
+
+} // namespace
+
+class FetchFormDataConsumerHandle::Context : public ThreadSafeRefCounted<Context> {
+    WTF_MAKE_NONCOPYABLE(Context);
+public:
+    virtual ~Context() {}
+    virtual PassOwnPtr<FetchDataConsumerHandle::Reader> obtainReader(Client*) = 0;
+
+protected:
+    explicit Context() {}
+};
+
+class FetchFormDataConsumerHandle::SimpleContext final : public Context {
+    class ReaderImpl;
+public:
+    static PassRefPtr<SimpleContext> create(const String& body) { return adoptRef(new SimpleContext(body)); }
+    static PassRefPtr<SimpleContext> create(const void* data, size_t size) { return adoptRef(new SimpleContext(data, size)); }
+    static PassRefPtr<SimpleContext> create(PassRefPtr<FormData> body) { return adoptRef(new SimpleContext(body)); }
+
+    PassOwnPtr<Reader> obtainReader(Client* client) override
+    {
+        // For memory barrier.
+        Mutex m;
+        MutexLocker locker(m);
+        return ReaderImpl::create(this, client);
+    }
+
+    PassRefPtr<FormData> drainFormData()
+    {
+        ASSERT(!m_formData || m_formData->isSafeToSendToAnotherThread());
+        return m_formData.release();
+    }
+
+    Result read(void* data, size_t size, Flags flags, size_t* readSize)
+    {
+        *readSize = 0;
+        if (size == 0 && m_formData)
+            return WebDataConsumerHandle::Ok;
+
+        flatten();
+        RELEASE_ASSERT(m_flattenFormDataOffset <= m_flattenFormData.size());
+
+        *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;
+        RELEASE_ASSERT(m_flattenFormDataOffset <= m_flattenFormData.size());
+
+        return WebDataConsumerHandle::Ok;
+    }
+
+    Result beginRead(const void** buffer, Flags flags, size_t* available)
+    {
+        *buffer = nullptr;
+        *available = 0;
+
+        flatten();
+        RELEASE_ASSERT(m_flattenFormDataOffset <= m_flattenFormData.size());
+
+        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)
+    {
+        RELEASE_ASSERT(m_flattenFormDataOffset <= m_flattenFormData.size());
+        RELEASE_ASSERT(read <= m_flattenFormData.size() - m_flattenFormDataOffset);
+        m_flattenFormDataOffset += read;
+
+        return WebDataConsumerHandle::Ok;
+    }
+
+private:
+    class ReaderImpl final : public FetchDataConsumerHandle::Reader {
+        WTF_MAKE_NONCOPYABLE(ReaderImpl);
+    public:
+        static PassOwnPtr<ReaderImpl> create(PassRefPtr<SimpleContext> context, Client* client) { return adoptPtr(new ReaderImpl(context, client)); }
+        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();
+        }
+

[hiroshige, 2015/08/12 06:44:48]

IIUC drainAsBlobDataHandle() here is omitted (thus it returns null for
SimpleContext), just because it is currently not implemented/needed and we can
implement it if needed (i.e. not because we intentionally disabled for some
reasons).
If so, leaving a comment would be helpful.

[yhirano, 2015/08/12 07:43:42]

Hm, yes, but I don't think it is worth noting, is it?
If we have a critical reason against implementing, it would be worth noting.

[hiroshige, 2015/08/13 06:44:31]

optional: I think turning something implicit into explicit is always helpful for
external readers.

[hiroshige, 2015/08/13 07:03:50]

And the DrainAsBlobDataHandle unit test asserts drainAsBlobDataHandle() to fail,
so it would be a signal that we explicitly disallow drainAsBlobDataHandle() for
FormData.

[yhirano, 2015/08/13 15:17:56]

If stating the reason for doing the default action is needed, I think there
should not be the default action, i.e. draining functions should be pure
virtual.

[hiroshige, 2015/08/13 16:14:37]

Hmm. Anyway it is not a strong objection so please go ahead.

+    private:
+        ReaderImpl(PassRefPtr<SimpleContext> context, Client* client) : m_context(context), m_notifier(client) {}
+
+        RefPtr<SimpleContext> m_context;
+        NotifyOnReaderCreationHelper m_notifier;
+    };
+
+    explicit SimpleContext(const String& body)
+        : m_formData(FormData::create(UTF8Encoding().encode(body, WTF::EntitiesForUnencodables)))
+        , m_flattenFormDataOffset(0) {}
+    explicit SimpleContext(const void* data, size_t size) : m_formData(FormData::create(data, size)) , m_flattenFormDataOffset(0) {}
+    explicit SimpleContext(PassRefPtr<FormData> body) : m_formData(body->deepCopy()) , m_flattenFormDataOffset(0) {}
+
+    void flatten()
+    {
+        if (!m_formData) {
+            // It is already drained or flatten.
+            return;
+        }
+        ASSERT(m_formData->isSafeToSendToAnotherThread());
+        m_formData->flatten(m_flattenFormData);
+        m_formData = nullptr;
+    }
+
+    // either one of |m_formData| and |m_flattenFormData| is usable at a time.
+    RefPtr<FormData> m_formData;
+    Vector<char> m_flattenFormData;
+    size_t m_flattenFormDataOffset;
+};
+
+class FetchFormDataConsumerHandle::ComplexContext final : public Context {
+    class ReaderImpl;
+public:
+    static PassRefPtr<ComplexContext> create(ExecutionContext* executionContext,
+        PassRefPtr<FormData> formData,
+        FetchBlobDataConsumerHandle::LoaderFactory* factory)
+    {
+        return adoptRef(new ComplexContext(executionContext, formData, factory));
+    }
+
+    PassOwnPtr<FetchFormDataConsumerHandle::Reader> obtainReader(Client* client) override
+    {
+        // For memory barrier.
+        Mutex m;
+        MutexLocker locker(m);
+        return ReaderImpl::create(this, client);
+    }
+
+private:
+    class ReaderImpl final : public FetchDataConsumerHandle::Reader {
+        WTF_MAKE_NONCOPYABLE(ReaderImpl);
+    public:
+        static PassOwnPtr<ReaderImpl> create(PassRefPtr<ComplexContext> context, Client* client) { return adoptPtr(new ReaderImpl(context, client)); }
+        Result read(void* data, size_t size, Flags flags, size_t* readSize) override
+        {
+            Result r = m_reader->read(data, size, flags, readSize);
+            if (!(size == 0 && (r == Ok || r == ShouldWait))) {
+                m_context->drainFormData();
+            }
+            return r;
+        }
+        Result beginRead(const void** buffer, Flags flags, size_t* available) override
+        {
+            m_context->drainFormData();
+            return m_reader->beginRead(buffer, flags, available);
+        }
+        Result endRead(size_t read) override
+        {
+            return m_reader->endRead(read);
+        }
+        PassRefPtr<BlobDataHandle> drainAsBlobDataHandle(BlobSizePolicy policy) override
+        {
+            RefPtr<BlobDataHandle> handle = m_reader->drainAsBlobDataHandle();

[hiroshige, 2015/08/17 10:08:17]

Please pass |policy| to m_reader->drainAsBlobDataHandle().

[yhirano, 2015/08/18 02:21:22]

Done.

+            if (handle) {
+                m_context->drainFormData();
+            }
+            return handle.release();
+        }
+        PassRefPtr<FormData> drainAsFormData() override
+        {
+            RefPtr<FormData> formData = m_context->drainFormData();
+            if (formData) {
+                // Read from the internal reader in order to make as read.
+                const void* p;
+                size_t available;
+                if (Ok == m_reader->beginRead(&p, FlagNone, &available)) {

[hiroshige, 2015/08/12 06:44:48]

IIUC this is to make drainAsBlobDataHandle() to return nullptr after
drainAsFormData().

How about implementing drainAsBlobDataHandle() as:
    RefPtr<BlobDataHandle> handle = m_reader->drainAsBlobDataHandle();
    if (handle) {
        if (m_context->drainFormData())
            return handle.release();
    }
    return nullptr;
and remove L213-L220?
By doing so,
- we don't start ThreadableLoader by calling beginRead() here unnecessarily, and
- drainAs.*() is controlled by primarily m_context->drainFormData(), and I think
this is clearer (i.e. I'd like to avoid to depend on side effects of beginRead()
here).

[yhirano, 2015/08/12 07:43:42]

That depends on how strong we believe that the underlying handle returns a valid
handle. For example, your code fails when the underlying handle has a blob with
invalid size. Your point about ThreadableLoader is true but about clearness I'm
not sure.

By the way, we can introduce state in ReaderImpl and dispose the underlying
handle and reader. What do you think about it?

[hiroshige, 2015/08/13 06:44:31]

Sounds good.

[hiroshige, 2015/08/17 10:08:17]

Another way to avoid starting ThreadableLoader is calling
m_reader->drainAsBlobDataHandle(AllowBlobWithInvalidSize) here.

I make the issue related this comment thread (including my previous comments) as
optional.
(Leaving a comment stating this code block is to make drainAsBlobDataHandle() to
return nullptr would be helpful)

[yhirano, 2015/08/18 02:21:22]

Done.

+                    m_reader->endRead(0);
+                }
+            }
+            return formData.release();
+        }
+    private:
+        ReaderImpl(PassRefPtr<ComplexContext> context, Client* client) : m_context(context), m_reader(m_context->m_handle->obtainReader(client)) {}
+
+        RefPtr<ComplexContext> m_context;
+        OwnPtr<FetchDataConsumerHandle::Reader> m_reader;
+    };
+
+    explicit ComplexContext(ExecutionContext* executionContext, PassRefPtr<FormData> body, FetchBlobDataConsumerHandle::LoaderFactory* factory)
+    {
+        OwnPtr<BlobData> blobData = BlobData::create();
+        for (const auto& element : body->elements()) {
+            switch (element.m_type) {
+            case FormDataElement::data:
+                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;
+            }
+        }
+        // Here we handle body->boundary() as a C-style string. See
+        // FormDataBuilder::generateUniqueBoundaryString.
+        blobData->setContentType(AtomicString("multipart/form-data; boundary=", AtomicString::ConstructFromLiteral) + body->boundary().data());
+        auto size = blobData->length();
+        if (factory) {
+            // For testing
+            m_handle = FetchBlobDataConsumerHandle::create(executionContext, BlobDataHandle::create(blobData.release(), size), factory);
+        } else {
+            m_handle = FetchBlobDataConsumerHandle::create(executionContext, BlobDataHandle::create(blobData.release(), size));
+        }
+        // It is important to initialize |m_formData| here, because even
+        // read-only operations may make the form data unsharable with implicit
+        // ref-counting.
+        m_formData = body->deepCopy();
+    }
+    PassRefPtr<FormData> drainFormData()
+    {
+        ASSERT(!m_formData || m_formData->isSafeToSendToAnotherThread());
+        return m_formData.release();
+    }
+
+    RefPtr<FormData> m_formData;
+    OwnPtr<FetchDataConsumerHandle> m_handle;
+};
+
+PassOwnPtr<FetchDataConsumerHandle> FetchFormDataConsumerHandle::create(const String& body)
+{
+    return adoptPtr(new FetchFormDataConsumerHandle(body));
+}
+PassOwnPtr<FetchDataConsumerHandle> FetchFormDataConsumerHandle::create(PassRefPtr<DOMArrayBuffer> body)
+{
+    return adoptPtr(new FetchFormDataConsumerHandle(body->data(), body->byteLength()));
+}
+PassOwnPtr<FetchDataConsumerHandle> FetchFormDataConsumerHandle::create(PassRefPtr<DOMArrayBufferView> body)
+{
+    return adoptPtr(new FetchFormDataConsumerHandle(body->baseAddress(), body->byteLength()));
+}
+PassOwnPtr<FetchDataConsumerHandle> FetchFormDataConsumerHandle::create(const void* data, size_t size)
+{
+    return adoptPtr(new FetchFormDataConsumerHandle(data, size));
+}
+PassOwnPtr<FetchDataConsumerHandle> FetchFormDataConsumerHandle::create(ExecutionContext* executionContext, PassRefPtr<FormData> body)
+{
+    return adoptPtr(new FetchFormDataConsumerHandle(executionContext, body));
+}
+PassOwnPtr<FetchDataConsumerHandle> FetchFormDataConsumerHandle::createForTest(
+    ExecutionContext* executionContext,
+    PassRefPtr<FormData> body,
+    FetchBlobDataConsumerHandle::LoaderFactory* loaderFactory)
+{
+    return adoptPtr(new FetchFormDataConsumerHandle(executionContext, body, loaderFactory));
+}
+
+FetchFormDataConsumerHandle::FetchFormDataConsumerHandle(const String& body) : m_context(SimpleContext::create(body)) {}
+FetchFormDataConsumerHandle::FetchFormDataConsumerHandle(const void* data, size_t size) : m_context(SimpleContext::create(data, size)) {}
+FetchFormDataConsumerHandle::FetchFormDataConsumerHandle(ExecutionContext* executionContext,
+    PassRefPtr<FormData> body,
+    FetchBlobDataConsumerHandle::LoaderFactory* loaderFactory)
+{
+    if (isSimple(body.get())) {
+        m_context = SimpleContext::create(body);
+    } else {
+        m_context = ComplexContext::create(executionContext, body, loaderFactory);
+    }
+}
+FetchFormDataConsumerHandle::~FetchFormDataConsumerHandle() {}
+
+FetchDataConsumerHandle::Reader* FetchFormDataConsumerHandle::obtainReaderInternal(Client* client)
+{
+    return m_context->obtainReader(client).leakPtr();
+}
+
+} // namespace blink