[Fetch API] Implement Request.formData and Response.formData.

third_party/WebKit/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 "modules/fetch/FetchDataLoader.h"
 
+#include "core/fetch/MultipartImageResourceParser.h"

[horo, 2016/08/30 05:12:55]

I think we should rename MultipartImageResourceParser to
MultipartResourceParser.

Reviewers:+yhirano@
WDYT?

[yhirano, 2016/08/30 05:51:14]

MultipartImageResourceParser is not a generic multipart parser. It is a specific
parser for multipart/x-mixed-replace images.

[horo, 2016/08/30 06:24:36]

Then, are you saying that we shouldn't use it to parse "multipart/form-data"?

+#include "core/fileapi/Blob.h"
 #include "core/html/parser/TextResourceDecoder.h"

[horo, 2016/08/30 05:12:56]

Include FormData.h here.

[e_hakkinen, 2016/08/30 07:59:08]

Done.

 #include "modules/fetch/BytesConsumer.h"
+#include "platform/HTTPNames.h"
+#include "platform/network/ParsedContentType.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/WTFString.h"
 #include "wtf/typed_arrays/ArrayBufferBuilder.h"
 #include <memory>
 
 namespace blink {
 
 namespace {
 
@@ skipping 135 matching lines @@
         BytesConsumer::Client::trace(visitor);
     }
 
 private:
     Member<BytesConsumer> m_consumer;
     Member<FetchDataLoader::Client> m_client;
 
     std::unique_ptr<ArrayBufferBuilder> m_rawData;
 };
 
+class FetchDataLoaderAsFormData final : public FetchDataLoader, public BytesConsumer::Client, private MultipartImageResourceParser::Client {
+    USING_GARBAGE_COLLECTED_MIXIN(FetchDataLoaderAsFormData);
+public:
+    explicit FetchDataLoaderAsFormData(const String& multipartBoundary)
+        : m_multipartBoundary(multipartBoundary)
+    {
+    }
+
+    void start(BytesConsumer* consumer, FetchDataLoader::Client* client) override
+    {
+        DCHECK(!m_client);
+        DCHECK(!m_multipartParser);
+        DCHECK(!m_consumer);
+
+        CString multipartBoundaryCString = m_multipartBoundary.utf8();
+        Vector<char> multipartBoundaryVector;
+        multipartBoundaryVector.append(multipartBoundaryCString.data(), multipartBoundaryCString.length());
+
+        m_client = client;
+        m_formData = FormData::create();
+        m_multipartParser = new MultipartImageResourceParser(ResourceResponse(), multipartBoundaryVector, this);
+        m_consumer = consumer;
+        m_consumer->setClient(this);
+        onStateChange();
+    }
+
+    void onStateChange() override
+    {
+        while (true) {
+            const char* buffer;
+            size_t available;
+            switch (m_consumer->beginRead(&buffer, &available)) {
+            case BytesConsumer::Result::Ok:
+                if (available > 0)
+                    m_multipartParser->appendData(buffer, available);
+                m_consumer->endRead(available);
+                break;
+            case BytesConsumer::Result::ShouldWait:
+                return;
+            case BytesConsumer::Result::Done:
+                m_multipartParser->finish();
+                m_currentEntry.finishIfInitialized(m_formData);
+                m_client->didFetchDataLoadedFormData(m_formData);
+                return;
+            case BytesConsumer::Result::Error:
+                m_client->didFetchDataLoadFailed();
+                return;
+            }
+        }
+    }
+
+    void cancel() override
+    {
+        m_consumer->cancel();
+        m_multipartParser->cancel();
+    }
+
+    DEFINE_INLINE_TRACE()
+    {
+        visitor->trace(m_consumer);
+        visitor->trace(m_client);
+        visitor->trace(m_formData);
+        visitor->trace(m_multipartParser);
+        FetchDataLoader::trace(visitor);
+        BytesConsumer::Client::trace(visitor);
+        MultipartImageResourceParser::Client::trace(visitor);
+    }
+
+private:
+    void onePartInMultipartReceived(const ResourceResponse& response) override
+    {
+        m_currentEntry.finishIfInitialized(m_formData);
+        if (!m_currentEntry.initialize(response))
+            m_client->didFetchDataLoadFailed();
+    }
+
+    void multipartDataReceived(const char* bytes, size_t size) override
+    {
+        m_currentEntry.appendBytes(bytes, size);
+    }
+
+    class Entry {
+    public:
+        bool initialize(const ResourceResponse& response)
+        {
+            ParsedContentType disposition(response.httpHeaderField(HTTPNames::Content_Disposition));
+            String dispositionType = disposition.mimeType();
+            m_filename = disposition.parameterValueForName("filename");
+            m_name = disposition.parameterValueForName("name");
+            if (dispositionType != "form-data" || m_name.isNull())
+                return false;
+            if (!m_filename.isNull()) {
+                m_blobData = BlobData::create();
+                m_blobData->setContentType(response.httpHeaderField(HTTPNames::Content_Type));
+                m_stringBuilder.reset();
+            } else {
+                m_blobData.reset();
+                if (!m_decoder)
+                    m_decoder = TextResourceDecoder::createAlwaysUseUTF8ForText();
+                m_stringBuilder.reset(new StringBuilder);
+            }
+            return true;
+        }
+
+        void appendBytes(const char* bytes, size_t size)
+        {
+            if (m_blobData)
+                m_blobData->appendBytes(bytes, size);
+            if (m_stringBuilder)
+                m_stringBuilder->append(m_decoder->decode(bytes, size));
+        }
+
+        void finishIfInitialized(FormData* formData)
+        {
+            if (m_blobData) {
+                auto size = m_blobData->length();

[horo, 2016/08/30 05:12:56]

ASSERT(!m_stringBuilder);

[e_hakkinen, 2016/08/30 07:59:08]

ASSERT is deprecated and does not thus pass presubmit checks. Therefore, I used
DCHECK instead of ASSERT. Done.

+                formData->append(m_name, Blob::create(BlobDataHandle::create(std::move(m_blobData), size)), m_filename);
+            }
+            if (m_stringBuilder) {
+                m_stringBuilder->append(m_decoder->flush());

[horo, 2016/08/30 05:12:56]

ASSERT(!m_blobData));

[e_hakkinen, 2016/08/30 07:59:08]

Done.

+                formData->append(m_name, m_stringBuilder->toString());
+            }
+        }
+
+    private:
+        std::unique_ptr<BlobData> m_blobData;
+        std::unique_ptr<TextResourceDecoder> m_decoder;
+        String m_filename;
+        String m_name;
+        std::unique_ptr<StringBuilder> m_stringBuilder;
+    };
+
+    Member<BytesConsumer> m_consumer;
+    Member<FetchDataLoader::Client> m_client;
+    Member<FormData> m_formData;
+    Member<MultipartImageResourceParser> m_multipartParser;
+
+    Entry m_currentEntry;
+    String m_multipartBoundary;
+};
+
 class FetchDataLoaderAsString final : public FetchDataLoader, public BytesConsumer::Client {
     USING_GARBAGE_COLLECTED_MIXIN(FetchDataLoaderAsString);
 public:
     void start(BytesConsumer* consumer, FetchDataLoader::Client* client) override
     {
         DCHECK(!m_client);
         DCHECK(!m_decoder);
         DCHECK(!m_consumer);
         m_client = client;
         m_decoder = TextResourceDecoder::createAlwaysUseUTF8ForText();
@@ skipping 124 matching lines @@
 FetchDataLoader* FetchDataLoader::createLoaderAsBlobHandle(const String& mimeType)
 {
     return new FetchDataLoaderAsBlobHandle(mimeType);
 }
 
 FetchDataLoader* FetchDataLoader::createLoaderAsArrayBuffer()
 {
     return new FetchDataLoaderAsArrayBuffer();
 }
 
+FetchDataLoader* FetchDataLoader::createLoaderAsFormData(const String& multipartBoundary)
+{
+    return new FetchDataLoaderAsFormData(multipartBoundary);
+}
+
 FetchDataLoader* FetchDataLoader::createLoaderAsString()
 {
     return new FetchDataLoaderAsString();
 }
 
 FetchDataLoader* FetchDataLoader::createLoaderAsStream(Stream* outStream)
 {
     return new FetchDataLoaderAsStream(outStream);
 }
 
 } // namespace blink