[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/File.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 {
+  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_consumer);
+    DCHECK(!m_formData);
+    DCHECK(!m_multipartParser);
+
+    const CString multipartBoundaryCString = m_multipartBoundary.utf8();

[yhirano, 2017/01/11 08:54:03]

Is this variable needed? Isn't it enough to run
|multipartBoundaryVector.append(multipartBoundary.utf8().data(),
multipartBoundary.utf8().length())|?

[e_hakkinen, 2017/05/02 23:38:56]

|Utf8()| is not a getter but a conversion function thus calling it twice would
result in the conversion to be done twice. So I think that it does make sense to
cache the conversion result.

+    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 (true) {
+      const char* buffer;
+      size_t available;
+      auto result = m_consumer->beginRead(&buffer, &available);
+      if (result == BytesConsumer::Result::ShouldWait)
+        return;
+      if (result == BytesConsumer::Result::Ok) {
+        const bool bufferAppended =
+            m_multipartParser->appendData(buffer, available);
+        const bool multipartReceiveFailed = m_multipartParser->isCancelled();
+        result = m_consumer->endRead(available);
+        if (!bufferAppended || multipartReceiveFailed)
+          result = BytesConsumer::Result::Error;
+      }
+      switch (result) {
+        case BytesConsumer::Result::Ok:
+          break;
+        case BytesConsumer::Result::ShouldWait:
+          NOTREACHED();
+          return;
+        case BytesConsumer::Result::Done:
+          if (m_multipartParser->finish()) {
+            DCHECK(!m_multipartParser->isCancelled());
+            m_client->didFetchDataLoadedFormData(m_formData);
+            return;
+          }
+        // Fall throught.

[yhirano, 2017/01/11 08:54:03]

Can you write m_client->didFetchDataLoadFailed() here explicitly?

[e_hakkinen, 2017/05/02 23:38:56]

Done.

+        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 partHeaderFieldsInMultipartReceived(
+      const HTTPHeaderMap& headerFields) override {
+    if (!m_currentEntry.initialize(headerFields))
+      m_multipartParser->cancel();

[yhirano, 2017/01/11 08:54:03]

Shouldn't be this cancel() (i.e., this->cancel())? Ditto below.

[e_hakkinen, 2017/05/02 23:38:56]

No, it should not. This member function is called while |OnStateChange()| does a
two-phase read during which |consumer_->Cancel()| (called by |Cancel()|) must
not be called. Ditto below.

+  }
+
+  void partDataInMultipartReceived(const char* bytes, size_t size) override {
+    if (!m_currentEntry.appendBytes(bytes, size))
+      m_multipartParser->cancel();
+  }
+
+  void partDataInMultipartFullyReceived() override {
+    if (!m_currentEntry.finish(m_formData))
+      m_multipartParser->cancel();
+  }
+
+  class Entry {
+   public:
+    bool initialize(const HTTPHeaderMap& headerFields) {
+      const ParsedContentType disposition(
+          headerFields.get(HTTPNames::Content_Disposition));
+      const 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();
+        const AtomicString& contentType =
+            headerFields.get(HTTPNames::Content_Type);
+        m_blobData->setContentType(contentType.isNull() ? "text/plain"
+                                                        : contentType);
+      } 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);
+        const auto size = m_blobData->length();
+        File* file =
+            File::create(m_filename, invalidFileTime(),
+                         BlobDataHandle::create(std::move(m_blobData), size));
+        formData->append(m_name, file, 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);
@@ skipping 128 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