[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/fileapi/Blob.h"
+#include "core/html/FormData.h"
 #include "core/html/parser/TextResourceDecoder.h"
 #include "modules/fetch/BytesConsumer.h"
+#include "modules/fetch/MultipartParser.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 142 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, public MultipartParser::Client {

[yhirano, 2016/09/21 09:02:57]

Please add unittests.

[e_hakkinen, 2016/09/22 22:27:15]

Done.

+    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 MultipartParser(std::move(multipartBoundaryVector), this);
+        m_consumer = consumer;
+        m_consumer->setClient(this);
+        onStateChange();
+    }
+
+    void onStateChange() override
+    {
+        while (!m_multipartParser->isCancelled()) {
+            const char* buffer;
+            size_t available;
+            switch (m_consumer->beginRead(&buffer, &available)) {
+            case BytesConsumer::Result::Ok:
+                if (available > 0) {
+                    if (!m_multipartParser->appendData(buffer, available))
+                        failed();

[yhirano, 2016/09/21 09:02:57]

BytesConsumer::cancel cannot be called in a two-phase read. You need to call
endRead beforehand (this applies all |failed| calls in MultipartParser::Client
functions).

[e_hakkinen, 2016/09/22 22:27:15]

Done.

+                }
+                if (m_consumer->endRead(available) != BytesConsumer::Result::Ok) {

[yhirano, 2016/09/21 09:02:57]

I recently changed BytesConsumer::endRead so that it can return Result::Done.
Please handle the case. You can see other loaders. Sorry for the inconvenience.

[e_hakkinen, 2016/09/22 22:27:16]

Done.

+                    m_client->didFetchDataLoadFailed();

[yhirano, 2016/09/21 09:02:57]

failed()?

[e_hakkinen, 2016/09/22 22:27:16]

Yeah, but there is not really need for failed() to exist when it cannot be
called between beginRead and endRead.

+                    return;
+                }
+                break;
+            case BytesConsumer::Result::ShouldWait:
+                return;
+            case BytesConsumer::Result::Done:
+                if (m_multipartParser->finish()) {
+                    m_client->didFetchDataLoadedFormData(m_formData);
+                } else {
+                    m_client->didFetchDataLoadFailed();
+                }
+                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);
+        MultipartParser::Client::trace(visitor);
+    }
+
+private:
+    void failed()
+    {
+        m_client->didFetchDataLoadFailed();
+        // The client does not like to be notified multiple times thus stop
+        // parsing so that no more errors will be reached.
+        cancel();
+    }
+
+    void partHeaderFieldsInMultipartReceived(const ResourceResponse& response) override
+    {
+        if (!m_currentEntry.initialize(response))
+            failed();
+    }
+
+    void partDataInMultipartReceived(const char* bytes, size_t size) override
+    {
+        if (!m_currentEntry.appendBytes(bytes, size))
+            failed();
+    }
+
+    void partDataInMultipartFullyReceived() override
+    {
+        if (!m_currentEntry.finish(m_formData))
+            failed();
+    }
+
+    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");
+            m_blobData.reset();
+            m_stringBuilder.reset();
+            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));
+            } else {
+                if (!m_decoder)
+                    m_decoder = TextResourceDecoder::createAlwaysUseUTF8ForText();
+                m_stringBuilder.reset(new StringBuilder);
+            }
+            return true;
+        }
+
+        bool 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));
+                if (m_decoder->sawError())
+                    return false;
+            }
+            return true;
+        }
+
+        bool finish(FormData* formData)
+        {
+            if (m_blobData) {
+                DCHECK(!m_stringBuilder);
+                auto size = m_blobData->length();
+                formData->append(m_name, Blob::create(BlobDataHandle::create(std::move(m_blobData), size)), m_filename);
+            }
+            if (m_stringBuilder) {
+                DCHECK(!m_blobData);
+                m_stringBuilder->append(m_decoder->flush());
+                if (m_decoder->sawError())
+                    return false;
+                formData->append(m_name, m_stringBuilder->toString());
+            }
+            return true;
+        }
+
+    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<MultipartParser> 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 131 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