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

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

+// Copyright 2016 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/MultipartParser.h"
+
+#include "platform/HTTPNames.h"
+#include "public/platform/Platform.h"
+
+#include <algorithm>
+#include <utility>
+
+namespace blink {
+
+namespace {
+
+constexpr char kCloseDelimiterSuffix[] = "--\r\n";
+constexpr size_t kCloseDelimiterSuffixSize = WTF_ARRAY_LENGTH(kCloseDelimiterSuffix) - 1u;
+constexpr size_t kDashBoundaryOffset = 2u; // The length of "--".
+constexpr char kDelimiterSuffix[] = "\r\n";
+constexpr size_t kDelimiterSuffixSize = WTF_ARRAY_LENGTH(kDelimiterSuffix) - 1u;
+
+} // namespace
+
+MultipartParser::Buffer::Buffer() = default;
+
+MultipartParser::Buffer::Buffer(const char* first, const char* last)
+    : Buffer(first, static_cast<size_t>(last - first), static_cast<size_t>(last - first)) {}
+
+MultipartParser::Buffer::Buffer(const char* data, size_t size, size_t capacity)
+    : m_capacity(capacity), m_data(data), m_size(size) {}
+
+bool MultipartParser::Buffer::appendIfExpected(char value)
+{
+    DCHECK_LT(m_size, m_capacity);
+    if (value != m_data[m_size])
+        return false;
+    ++m_size;
+    return true;
+}
+
+bool MultipartParser::Buffer::appendIfExpected(const char* first, const char* last)
+{
+    while (first < last) {
+        if (!appendIfExpected(*first++))
+            return false;
+    }
+    return true;
+}
+
+void MultipartParser::Buffer::clear()
+{
+    m_size = 0u;
+}
+
+MultipartParser::MultipartParser(Vector<char> boundary, Client* client)
+    : m_client(client)
+    , m_delimiter(std::move(boundary))
+    , m_state(ParsingPreamble)
+{
+    // The delimiter consists of "\r\n" and a dash boundary which consists of
+    // "--" and a boundary.
+    m_delimiter.prepend("\r\n--", 4u);
+    m_bufferedBytes = delimiterBuffer(kDashBoundaryOffset);
+}
+
+bool MultipartParser::appendData(const char* bytes, size_t size)
+{
+    DCHECK_NE(Finished, m_state);
+    DCHECK_NE(Cancelled, m_state);
+
+    const char* bytesEnd = bytes + size;
+
+    while (bytes < bytesEnd) {
+        switch (m_state) {
+        case ParsingPreamble: {
+            // Parse either a preamble and a delimiter or a dash boundary.
+            Buffer unusedPreambleData;
+            if (parseDataAndDelimiter(&bytes, bytesEnd, &unusedPreambleData))
+                m_state = ParsingDelimiterSuffix;
+            break;
+        }
+
+        case ParsingDelimiterSuffix:
+            // Parse transport padding and "\r\n" after a delimiter.
+            // This can happen after either a preamble or part octets.
+            if (m_bufferedBytes.empty()) {
+                m_bufferedBytes = delimiterSuffixBuffer();
+                parseTransportPadding(&bytes, bytesEnd);
+            }
+            while (m_state == ParsingDelimiterSuffix && bytes < bytesEnd) {
+                if (!m_bufferedBytes.appendIfExpected(*bytes++)) {
+                    m_state = Failed;

[yhirano, 2016/09/20 09:49:53]

If bytes == bytesEnd this function returns true. I guess that's not you want.

[e_hakkinen, 2016/09/20 21:59:29]

True. Fixed.

+                } else if (m_bufferedBytes.size() == kDelimiterSuffixSize) {

[yhirano, 2016/09/20 09:49:53]

How about having isComplete method rather than comparing pattern's length
manually?

[e_hakkinen, 2016/09/20 21:59:29]

Done.

+                    m_bufferedBytes.clear();
+                    m_state = ParsingPartHeaderFields;
+                }
+            }
+            break;
+
+        case ParsingPartHeaderFields: {
+            // Parse part header fields (which ends with "\r\n") and an empty
+            // line (which also ends with "\r\n").
+            // This can happen after a delimiter and a delimiter suffix which
+            // can happen after either a preamble or part octets.
+            WebURLResponse response;
+            if (parseHeaderFields(&bytes, bytesEnd, &response)) {
+                m_bufferedBytes = delimiterBuffer();
+                m_state = ParsingPartOctets;
+                m_client->partHeaderFieldsInMultipartReceived(response.toResourceResponse());
+            }
+            break;
+        }
+
+        case ParsingPartOctets: {
+            // Parse either a non-empty part octets and a delimiter or an empty
+            // part octets and a dash boundary.
+            // This can happen only after part header fields.
+            Buffer octetsData;
+            if (parseDataAndDelimiter(&bytes, bytesEnd, &octetsData))
+                m_state = ParsingDelimiterOrCloseDelimiterSuffix;
+            if (!octetsData.empty())
+                m_client->partDataInMultipartReceived(octetsData.data(), octetsData.size());
+            if (m_state == ParsingDelimiterOrCloseDelimiterSuffix)
+                m_client->partDataInMultipartFullyReceived();
+            break;
+        }
+
+        case ParsingDelimiterOrCloseDelimiterSuffix:
+            // Determine whether this is a delimiter suffix or a close
+            // delimiter suffix.
+            // This can happen only after part octets.
+            m_state = *bytes == '-' ? ParsingCloseDelimiterSuffix : ParsingDelimiterSuffix;
+            break;
+
+        case ParsingCloseDelimiterSuffix:
+            // Parse "--", transport padding and "\r\n" after a delimiter
+            // (a delimiter and "--" constitute a close delimiter).
+            // This can happen only after part octets.
+            if (m_bufferedBytes.empty())
+                m_bufferedBytes = closeDelimiterSuffixBuffer();
+            while (m_state == ParsingCloseDelimiterSuffix && bytes < bytesEnd) {
+                if (m_bufferedBytes.size() == 2u && parseTransportPadding(&bytes, bytesEnd))

[yhirano, 2016/09/20 09:49:53]

What do you think about the following pattern?

while (...) {
  if (m_bufferedBytes.size() == 2u)
    parseTransportPadding(&bytes, bytesEnd);
  if (bytes == bytesEnd)
    break;
  ...
}

That way you don't have to return a boolean from parseTransportPadding.

[e_hakkinen, 2016/09/20 21:59:29]

I am equally fine with that. Done.

+                    continue;
+                if (!m_bufferedBytes.appendIfExpected(*bytes++)) {
+                    m_state = Failed;
+                } else if (m_bufferedBytes.size() == kCloseDelimiterSuffixSize) {
+                    m_bufferedBytes.clear();
+                    m_state = ParsingEpilogue;
+                }
+            }
+            break;
+
+        case ParsingEpilogue:
+            // Parse an epilogue (by ignoring it).
+            // This can happen only after a delimiter and a close delimiter
+            // suffix which can happen only after part octets.
+            return true;
+
+        case Cancelled:
+        case Finished:
+            // The client changed the state.
+            return true;
+
+        case Failed:
+            // Keep failing.
+            return false;
+        }
+    }
+
+    DCHECK_EQ(bytesEnd, bytes);
+
+    return true;
+}
+
+void MultipartParser::cancel()
+{
+    m_state = Cancelled;
+}
+
+bool MultipartParser::finish()
+{
+    DCHECK_NE(Cancelled, m_state);
+
+    State initialState = m_state;
+
+    if (m_state == ParsingPartOctets && !m_bufferedBytes.empty()) {
+        // The end of append bytes looked like a delimiter but was not a full
+        // one, after all. Treat the those bytes as part of part octets.
+        m_client->partDataInMultipartReceived(m_bufferedBytes.data(), m_bufferedBytes.size());
+        m_bufferedBytes.clear();
+    }
+    m_state = Finished;
+
+    switch (initialState) {
+    case ParsingCloseDelimiterSuffix:
+        // Require a full close delimiter consisting of a delimiter and "--"
+        // but ignore missing or partial "\r\n" after that.
+        return m_bufferedBytes.size() >= 2u;
+    case ParsingEpilogue:
+    case Finished:
+        return true;
+    default:
+        return false;
+    }
+}
+
+MultipartParser::Buffer MultipartParser::closeDelimiterSuffixBuffer(size_t size) const
+{
+    return Buffer(kCloseDelimiterSuffix, size, kCloseDelimiterSuffixSize);
+}
+
+MultipartParser::Buffer MultipartParser::delimiterBuffer(size_t size) const
+{
+    return Buffer(m_delimiter.data(), size, m_delimiter.size());
+}
+
+MultipartParser::Buffer MultipartParser::delimiterSuffixBuffer(size_t size) const
+{
+    return Buffer(kDelimiterSuffix, size, kDelimiterSuffixSize);
+}
+
+bool MultipartParser::parseDataAndDelimiter(const char** bytesPointer, const char* bytesEnd, Buffer* data)
+{
+    bool hasInitiallyBufferedBytes = !m_bufferedBytes.empty();
+    const char* bytesBegin = *bytesPointer;
+
+    // Continue parsing a partial delimiter in the beginning of bytes.
+    while (*bytesPointer < bytesEnd && m_bufferedBytes.appendIfExpected(*(*bytesPointer))) {
+        // The partial delimiter continued.
+        ++(*bytesPointer);
+        if (m_bufferedBytes.size() == m_delimiter.size()) {
+            // The partial delimiter turned out to be a complete one.
+            // Therefore, the buffered bytes are delimiter bytes.
+            m_bufferedBytes.clear();

[yhirano, 2016/09/20 09:49:53]

Can you move this statement (and the similar ones) out of this function so that
the caller can calculate the region currently held by |*data| from
|*bytesPointer| and |m_bufferedBytes| uniformally? That way we can remove |data|
parameter.

[e_hakkinen, 2016/09/20 21:59:29]

Done.

+            *data = Buffer();
+            return true; // A delimiter is parsed.
+        }
+    }
+
+    if (*bytesPointer == bytesEnd) {
+        // More bytes are needed. All bytes are buffered for now.
+        *data = Buffer();
+        return false;
+    }
+
+    if (!m_bufferedBytes.empty()) {
+        // The partial delimiter did not turn out to be a complete one.
+        // Therefore, the buffered bytes are data bytes.
+        if (hasInitiallyBufferedBytes) {
+            // Not all buffered bytes are in the range [bytesBegin, bytesEnd[
+            // thus the buffered bytes must be returned separately.
+            *data = std::move(m_bufferedBytes);
+            m_bufferedBytes = delimiterBuffer();
+            return false;
+        }
+        // The fact the some bytes are now buffered can be ignored as they are
+        // also in the range [bytesBegin, bytesEnd[. There is no need to reset

[yhirano, 2016/09/20 09:49:53]

]

[e_hakkinen, 2016/09/20 21:59:29]

*bytesEnd does not belong to the range.

+        // |*bytesPointer| to |bytesBegin| as (partial) delimiters cannot
+        // overlap.
+    }
+
+    // Search for a complete delimiter within the remaining bytes.
+    const char* delimiterBegin = std::search(*bytesPointer, bytesEnd, m_delimiter.begin(), m_delimiter.end());
+    if (delimiterBegin != bytesEnd) {
+        // A complete delimiter was found. The bytes before that are data
+        // bytes.
+        const char* delimiterEnd = delimiterBegin + m_delimiter.size();
+        *bytesPointer = delimiterEnd;
+        *data = Buffer(bytesBegin, delimiterBegin);
+        m_bufferedBytes.clear();
+        return true; // A delimiter is parsed.
+    }
+
+    // Search for a partial delimiter in the end of the remaining bytes.
+    size_t remainingBytesSize = static_cast<size_t>(bytesEnd - *bytesPointer);
+    delimiterBegin = bytesEnd - std::min(m_delimiter.size() - 1u, remainingBytesSize);
+    for (;;) {
+        m_bufferedBytes = delimiterBuffer();
+        if (m_bufferedBytes.appendIfExpected(delimiterBegin, bytesEnd))
+            break;
+        DCHECK_LT(delimiterBegin, bytesEnd);
+        ++delimiterBegin;
+    }
+
+    // A partial delimiter (consisting of zero or more bytes) was found and
+    // the bytes are buffered for now. The bytes before the partial delimiter
+    // are definitely data bytes and can thus be returned.
+    *bytesPointer = bytesEnd;
+    *data = Buffer(bytesBegin, delimiterBegin);
+    return false;
+}
+
+bool MultipartParser::parseHeaderFields(const char** bytesPointer, const char* bytesEnd, WebURLResponse* response)
+{
+    // Combine the current bytes with buffered header bytes if needed.
+    const char* headerBytes = *bytesPointer;
+    size_t headerSize = static_cast<size_t>(bytesEnd - *bytesPointer);
+    if (!m_bufferedHeaderBytes.isEmpty()) {
+        m_bufferedHeaderBytes.append(headerBytes, headerSize);
+        headerBytes = m_bufferedHeaderBytes.data();
+        headerSize = m_bufferedHeaderBytes.size();
+    }
+
+    size_t end = 0u;
+    if (!Platform::current()->parseMultipartHeadersFromBody(headerBytes, headerSize, response, &end)) {
+        // Store the current header bytes for the next call unless that has
+        // already been done.
+        if (m_bufferedHeaderBytes.isEmpty())
+            m_bufferedHeaderBytes.append(headerBytes, headerSize);
+        *bytesPointer = bytesEnd;
+        return false;
+    }
+    m_bufferedHeaderBytes.clear();
+    *bytesPointer = bytesEnd - (headerSize - end);
+
+    const AtomicString& encoding = response->toResourceResponse().httpHeaderFields().get(HTTPNames::Content_Transfer_Encoding);
+    if (!encoding.isNull()) {

[yhirano, 2016/09/20 09:49:53]

Why do you need this condition?

[e_hakkinen, 2016/09/20 21:59:29]

It is needed in order to handle the common case in which there are no
Content-Transfer-Encoding header fields.

+        if (!(equalIgnoringCase(encoding, "binary")
+              || equalIgnoringCase(encoding, "7bit")
+              || equalIgnoringCase(encoding, "8bit"))) {
+            // Decoding is not implemented.
+            m_state = Failed;
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool MultipartParser::parseTransportPadding(const char** bytesPointer, const char* bytesEnd) const
+{
+    const char* bytesBegin = *bytesPointer;
+    while (*bytesPointer < bytesEnd && (*(*bytesPointer) == '\t' || *(*bytesPointer) == ' '))
+        ++(*bytesPointer);
+    return *bytesPointer > bytesBegin;
+}
+
+DEFINE_TRACE(MultipartParser)
+{
+    visitor->trace(m_client);
+}
+
+} // namespace blink