[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>, public FetchDataLoader::Client {
@@ skipping 33 matching lines @@
     WTF_MAKE_NONCOPYABLE(BodyArrayBufferConsumer);
 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 62 matching lines @@
         bodyBuffer()->startLoading(FetchDataLoader::createLoaderAsBlobHandle(mimeType()), 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);
+    ParsedContentType parsedTypeWithParameters(contentType());

[yhirano, 2016/09/07 06:00:16]

The spec[1] uses body's "MIME type", why don't you use Body::mimeType?


1: https://fetch.spec.whatwg.org/#concept-body-consume-body

[e_hakkinen, 2016/09/08 00:06:29]

Because the return value of Body::mimeType does not contain parameters like
boundary if the response comes from content. So using Body::mimeType would work
for Responses created by Response constructor but not for Responses created by
fetches. 

[yhirano, 2016/09/12 02:20:49]

Then I think the existing Body::mimeType should be fixed.
Note that ResourceRequest::mimeType and 'content-type' header may diverge
because of the mime sniffer. I'm trying to disable it for Fetch API[1]. When
it's done we can use the 'content-type' header for Body::mimeType (possibly in a
separate CL?).

1: https://codereview.chromium.org/2323623002/

+    String parsedType = parsedTypeWithParameters.mimeType().lower();
+    promise = resolver->promise();
+    if (parsedType == "multipart/form-data") {
+        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;
+    }
+
+    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();
 
@@ skipping 59 matching lines @@
 Body::Body(ExecutionContext* context) : ActiveScriptWrappable(this) , ContextLifecycleObserver(context) {}
 
 ScriptPromise Body::rejectInvalidConsumption(ScriptState* scriptState)
 {
     if (isBodyLocked() || bodyUsed())
         return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Already read"));
     return ScriptPromise();
 }
 
 } // namespace blink