Make ParsedContentType more conformant to the spec

third_party/WebKit/Source/platform/network/ParsedContentType.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 13 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/network/ParsedContentType.h"
 
-#include "wtf/text/CString.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
-using SubstringRange = ParsedContentType::SubstringRange;
+using Mode = ParsedContentType::Mode;
 
 namespace {
 
-void skipSpaces(const String& input, unsigned& startIndex) {
-  while (startIndex < input.length() && input[startIndex] == ' ')
-    ++startIndex;
+bool isTokenCharacter(Mode mode, UChar c) {
+  if (c >= 128)
+    return false;
+  if (c < 0x20)
+    return false;
+
+  switch (c) {
+    case ' ':
+    case ';':
+    case '"':
+      return false;
+    case '(':
+    case ')':
+    case '<':
+    case '>':
+    case '@':
+    case ',':
+    case ':':
+    case '\\':
+    case '/':
+    case '[':
+    case ']':
+    case '?':
+    case '=':
+      return mode == Mode::Relaxed;
+    default:
+      return true;
+  }
 }
 
-SubstringRange parseParameterPart(const String& input, unsigned& startIndex) {
-  unsigned inputLength = input.length();
-  unsigned tokenStart = startIndex;
-  unsigned& tokenEnd = startIndex;
+bool consume(char c, const String& input, unsigned& index) {
+  DCHECK_NE(c, ' ');
+  while (index < input.length() && input[index] == ' ')
+    ++index;
 
-  if (tokenEnd >= inputLength)
-    return SubstringRange();
-
-  bool quoted = input[tokenStart] == '\"';
-  bool escape = false;
-
-  while (tokenEnd < inputLength) {
-    UChar c = input[tokenEnd];
-    if (quoted && tokenStart != tokenEnd && c == '\"' && !escape)
-      return SubstringRange(tokenStart + 1, tokenEnd++ - tokenStart - 1);
-    if (!quoted && (c == ';' || c == '='))
-      return SubstringRange(tokenStart, tokenEnd - tokenStart);
-    escape = !escape && c == '\\';
-    ++tokenEnd;
+  if (index < input.length() && input[index] == c) {
+    ++index;
+    return true;
   }
-
-  if (quoted)
-    return SubstringRange();
-  return SubstringRange(tokenStart, tokenEnd - tokenStart);
+  return false;
 }
 
-String substringForRange(const String& string, const SubstringRange& range) {
-  return string.substring(range.first, range.second);
+bool consumeToken(Mode mode,
+                  const String& input,
+                  unsigned& index,
+                  String& output) {
+  DCHECK(output.isNull());
+
+  while (index < input.length() && input[index] == ' ')
+    ++index;
+
+  auto start = index;
+  while (index < input.length() && isTokenCharacter(mode, input[index]))
+    ++index;
+
+  if (start == index)
+    return false;
+
+  output = input.substring(start, index - start);

[kinuko, 2017/02/21 11:43:02]

nit: output could be StringView if we want to save allocation in some cases

[yhirano, 2017/02/22 05:17:03]

Done.

+  return true;
+}
+
+bool consumeQuotedString(const String& input, unsigned& index, String& output) {
+  StringBuilder builder;
+  DCHECK_EQ('"', input[index]);
+  ++index;
+  while (index < input.length()) {
+    if (input[index] == '\\') {
+      ++index;
+      if (index == input.length())
+        return false;
+      builder.append(input[index]);
+      ++index;
+      continue;
+    }
+    if (input[index] == '"') {
+      output = builder.toString();
+      ++index;
+      return true;
+    }
+    builder.append(input[index]);
+    ++index;
+  }
+  return false;
+}
+
+bool consumeTokenOrQuotedString(Mode mode,
+                                const String& input,
+                                unsigned& index,
+                                String& output) {
+  while (index < input.length() && input[index] == ' ')
+    ++index;
+  if (input.length() == index)
+    return false;
+  if (input[index] == '"')
+    return consumeQuotedString(input, index, output);
+  return consumeToken(mode, input, index, output);
+}
+
+bool isEnd(const String& input, unsigned index) {

[kinuko, 2017/02/21 11:43:02]

Any reason this doesn't take unsigned& index?

[yhirano, 2017/02/22 05:17:03]

consume* eat the input and hence update the index. isEnd sounds like not
modifying the input so I'm not using a reference here.

+  while (index < input.length()) {
+    if (input[index] != ' ')
+      return false;
+    ++index;
+  }
+  return true;
 }
 
 }  // namespace
 
-ParsedContentType::ParsedContentType(const String& contentType) {
-  if (contentType.contains('\r') || contentType.contains('\n'))
-    m_isValid = false;
-  else
-    m_isValid = parse(contentType.stripWhiteSpace());
+ParsedContentType::ParsedContentType(const String& contentType, Mode mode)
+    : m_mode(mode) {
+  m_isValid = parse(contentType);
 }
 
 String ParsedContentType::charset() const {
   return parameterValueForName("charset");
 }
 
 String ParsedContentType::parameterValueForName(const String& name) const {
   return m_parameters.get(name);
 }
 
@@ skipping 42 matching lines @@
 //             or tspecials>
 //
 // tspecials :=  "(" / ")" / "<" / ">" / "@" /
 //               "," / ";" / ":" / "\" / <">
 //               "/" / "[" / "]" / "?" / "="
 //               ; Must be in quoted-string,
 //               ; to use within parameter values
 
 bool ParsedContentType::parse(const String& contentType) {
   unsigned index = 0;
-  unsigned contentTypeLength = contentType.length();
-  skipSpaces(contentType, index);
-  if (index >= contentTypeLength) {
-    DVLOG(1) << "Invalid Content-Type string '" << contentType << "'";
+
+  String type, subtype;
+  if (!consumeToken(Mode::Normal, contentType, index, type)) {
+    DVLOG(1) << "Failed to find `type' in '" << contentType << "'";
+    return false;
+  }
+  if (!consume('/', contentType, index)) {
+    DVLOG(1) << "Failed to find '/' in '" << contentType << "'";
+    return false;
+  }
+  if (!consumeToken(Mode::Normal, contentType, index, subtype)) {
+    DVLOG(1) << "Failed to find `type' in '" << contentType << "'";
     return false;
   }
 
-  // There should not be any quoted strings until we reach the parameters.
-  size_t semiColonIndex = contentType.find(';', index);
-  if (semiColonIndex == kNotFound) {
-    m_mimeType =
-        substringForRange(contentType,
-                          SubstringRange(index, contentTypeLength - index))
-            .stripWhiteSpace();
-    return true;
-  }
+  m_mimeType = type + '/' + subtype;
 
-  m_mimeType = substringForRange(contentType,
-                                 SubstringRange(index, semiColonIndex - index))
-                   .stripWhiteSpace();
-  index = semiColonIndex + 1;
-  do {
-    skipSpaces(contentType, index);
-    SubstringRange keyRange = parseParameterPart(contentType, index);
-    if (!keyRange.second || index >= contentTypeLength) {
+  KeyValuePairs map;
+  while (!isEnd(contentType, index)) {
+    if (!consume(';', contentType, index)) {
+      DVLOG(1) << "Failed to find ';'";
+      return false;
+    }
+
+    String key, value;
+    if (!consumeToken(Mode::Normal, contentType, index, key)) {
       DVLOG(1) << "Invalid Content-Type parameter name. (at " << index << ")";
       return false;
     }
-
-    // Should we tolerate spaces here?
-    if (contentType[index++] != '=' || index >= contentTypeLength) {
-      DVLOG(1) << "Invalid Content-Type malformed parameter (at " << index
-               << ").";
+    if (!consume('=', contentType, index)) {
+      DVLOG(1) << "Failed to find '='";
       return false;
     }
-
-    // Should we tolerate spaces here?
-    SubstringRange valueRange = parseParameterPart(contentType, index);
-
-    if (!valueRange.second) {
+    if (!consumeTokenOrQuotedString(m_mode, contentType, index, value)) {
       DVLOG(1) << "Invalid Content-Type, invalid parameter value (at " << index
-               << ", for '"
-               << substringForRange(contentType, keyRange).stripWhiteSpace()
-               << "').";
+               << ", for '" << key << "').";
       return false;
     }
-
-    // Should we tolerate spaces here?
-    if (index < contentTypeLength && contentType[index++] != ';') {
-      DVLOG(1) << "Invalid Content-Type, invalid character at the end of "
-                  "key/value parameter (at "
-               << index << ").";
-      return false;
-    }
-
-    m_parameters.set(substringForRange(contentType, keyRange),
-                     substringForRange(contentType, valueRange));
-  } while (index < contentTypeLength);
-
+    map.set(key, value);
+  }
+  m_parameters = std::move(map);
   return true;
 }
 
 }  // namespace blink