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

third_party/WebKit/Source/modules/fetch/Body.cpp

 // Copyright 2014 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/Body.h"
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8ArrayBuffer.h"
 #include "bindings/core/v8/V8ThrowException.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMTypedArray.h"
+#include "core/dom/URLSearchParams.h"
 #include "core/fileapi/Blob.h"
 #include "core/frame/UseCounter.h"
+#include "core/html/FormData.h"
 #include "modules/fetch/BodyStreamBuffer.h"
 #include "modules/fetch/FetchDataLoader.h"
+#include "platform/network/ParsedContentType.h"
 #include "public/platform/WebDataConsumerHandle.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefPtr.h"
 #include <memory>
 
 namespace blink {
 
 namespace {
 
 class BodyConsumerBase : public GarbageCollectedFinalized<BodyConsumerBase>,
@@ skipping 38 matching lines @@
 
  public:
   explicit BodyArrayBufferConsumer(ScriptPromiseResolver* resolver)
       : BodyConsumerBase(resolver) {}
 
   void didFetchDataLoadedArrayBuffer(DOMArrayBuffer* arrayBuffer) override {
     resolver()->resolve(arrayBuffer);
   }
 };
 
+class BodyFormDataConsumer final : public BodyConsumerBase {
+  WTF_MAKE_NONCOPYABLE(BodyFormDataConsumer);
+
+ public:
+  explicit BodyFormDataConsumer(ScriptPromiseResolver* resolver)
+      : BodyConsumerBase(resolver) {}
+
+  void didFetchDataLoadedFormData(FormData* formData) override {
+    resolver()->resolve(formData);
+  }
+
+  void didFetchDataLoadedString(const String& string) override {
+    FormData* formData = FormData::create();
+    for (const auto& pair : URLSearchParams::create(string)->params())
+      formData->append(pair.first, pair.second);
+    didFetchDataLoadedFormData(formData);
+  }
+};
+
 class BodyTextConsumer final : public BodyConsumerBase {
   WTF_MAKE_NONCOPYABLE(BodyTextConsumer);
 
  public:
   explicit BodyTextConsumer(ScriptPromiseResolver* resolver)
       : BodyConsumerBase(resolver) {}
 
   void didFetchDataLoadedString(const String& string) override {
     resolver()->resolve(string);
   }
@@ skipping 66 matching lines @@
         new BodyBlobConsumer(resolver));
   } else {
     std::unique_ptr<BlobData> blobData = BlobData::create();
     blobData->setContentType(mimeType());
     resolver->resolve(
         Blob::create(BlobDataHandle::create(std::move(blobData), 0)));
   }
   return promise;
 }
 
+ScriptPromise Body::formData(ScriptState* scriptState) {
+  ScriptPromise promise = rejectInvalidConsumption(scriptState);
+  if (!promise.isEmpty())
+    return promise;
+
+  // See above comment.
+  if (!scriptState->getExecutionContext())
+    return ScriptPromise();
+
+  ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
+  const ParsedContentType parsedTypeWithParameters(contentType());
+  const String parsedType = parsedTypeWithParameters.mimeType().lower();
+  promise = resolver->promise();
+  if (parsedType == "multipart/form-data") {
+    const String boundary =
+        parsedTypeWithParameters.parameterValueForName("boundary");
+    if (bodyBuffer() && !boundary.isEmpty()) {
+      bodyBuffer()->startLoading(
+          FetchDataLoader::createLoaderAsFormData(boundary),
+          new BodyFormDataConsumer(resolver));
+      return promise;
+    }
+  } else if (parsedType == "application/x-www-form-urlencoded") {
+    if (bodyBuffer()) {
+      bodyBuffer()->startLoading(FetchDataLoader::createLoaderAsString(),
+                                 new BodyFormDataConsumer(resolver));
+    } else {
+      resolver->resolve(FormData::create());
+    }
+    return promise;
+  } else {
+    if (bodyBuffer())
+      bodyBuffer()->closeAndLockAndDisturb();
+  }
+
+  resolver->reject(V8ThrowException::createTypeError(scriptState->isolate(),
+                                                     "Invalid MIME type"));
+  return promise;
+}
+
 ScriptPromise Body::json(ScriptState* scriptState) {
   ScriptPromise promise = rejectInvalidConsumption(scriptState);
   if (!promise.isEmpty())
     return promise;
 
   // See above comment.
   if (!scriptState->getExecutionContext())
     return ScriptPromise();
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
@@ skipping 59 matching lines @@
 
 ScriptPromise Body::rejectInvalidConsumption(ScriptState* scriptState) {
   if (isBodyLocked() || bodyUsed())
     return ScriptPromise::reject(
         scriptState, V8ThrowException::createTypeError(scriptState->isolate(),
                                                        "Already read"));
   return ScriptPromise();
 }
 
 }  // namespace blink