ParsedContentType refactoring

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 18 matching lines @@
  * 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 {
 
-class DummyParsedContentType final {
-  STACK_ALLOCATED();
+using SubstringRange = ParsedContentType::SubstringRange;
 
- public:
-  void setContentType(const SubstringRange&) const {}
-  void setContentTypeParameter(const SubstringRange&,
-                               const SubstringRange&) const {}
-};
+namespace {
 
-static void skipSpaces(const String& input, unsigned& startIndex) {
+void skipSpaces(const String& input, unsigned& startIndex) {
   while (startIndex < input.length() && input[startIndex] == ' ')
     ++startIndex;
 }
 
-static SubstringRange parseParameterPart(const String& input,
-                                         unsigned& startIndex) {
+SubstringRange parseParameterPart(const String& input, unsigned& startIndex) {
   unsigned inputLength = input.length();
   unsigned tokenStart = startIndex;
   unsigned& tokenEnd = startIndex;
 
   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 (quoted)
     return SubstringRange();
   return SubstringRange(tokenStart, tokenEnd - tokenStart);
 }
 
-static String substringForRange(const String& string,
-                                const SubstringRange& range) {
+String substringForRange(const String& string, const SubstringRange& range) {
   return string.substring(range.first, range.second);
 }
 
+}  // namespace
+
+ParsedContentType::ParsedContentType(const String& contentType) {
+  parse(contentType.stripWhiteSpace());

[tyoshino-do-not-use, 2017/02/20 14:48:46]

How about saving the result of parse() in a member indicating validness of the
ParsedContentType like GURL?

The users would call ParsedContentType(contentType).isValid() instead of
ParsedContentType::isValid(contentType). It wouldn't break
MIMEHeader::parseHeader() since retrieveKeyValuePairs() strips \r and \n.

[tyoshino-do-not-use, 2017/02/20 14:50:31]

Sorry. I forgot to insert break in the last paragraph and explain regarding what
concern I wrote the last sentence. I meant that skipping parse() in case
contentType contains \r or \n doesn't break MIMEHeader::parseHeader().

[yhirano, 2017/02/21 04:40:30]

Done.

+}
+
+String ParsedContentType::charset() const {
+  return parameterValueForName("charset");
+}
+
+String ParsedContentType::parameterValueForName(const String& name) const {
+  return m_parameters.get(name);
+}
+
+size_t ParsedContentType::parameterCount() const {
+  return m_parameters.size();
+}
+
+bool ParsedContentType::isValid(const String& contentType) {
+  if (contentType.contains('\r') || contentType.contains('\n'))
+    return false;
+
+  return ParsedContentType().parse(contentType.stripWhiteSpace());
+}
+
 // From http://tools.ietf.org/html/rfc2045#section-5.1:
 //
 // content := "Content-Type" ":" type "/" subtype
 //            *(";" parameter)
 //            ; Matching of media type and subtype
 //            ; is ALWAYS case-insensitive.
 //
 // type := discrete-type / composite-type
 //
 // discrete-type := "text" / "image" / "audio" / "video" /
@@ skipping 26 matching lines @@
 //
 // token := 1*<any (US-ASCII) CHAR except SPACE, CTLs,
 //             or tspecials>
 //
 // tspecials :=  "(" / ")" / "<" / ">" / "@" /
 //               "," / ";" / ":" / "\" / <">
 //               "/" / "[" / "]" / "?" / "="
 //               ; Must be in quoted-string,
 //               ; to use within parameter values
 
-template <class ReceiverType>
-bool parseContentType(const String& contentType, ReceiverType& receiver) {
+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 << "'";
     return false;
   }
 
   // There should not be any quoted strings until we reach the parameters.
   size_t semiColonIndex = contentType.find(';', index);
   if (semiColonIndex == kNotFound) {
-    receiver.setContentType(SubstringRange(index, contentTypeLength - index));
+    m_mimeType =
+        substringForRange(contentType,
+                          SubstringRange(index, contentTypeLength - index))
+            .stripWhiteSpace();
     return true;
   }
 
-  receiver.setContentType(SubstringRange(index, semiColonIndex - index));
+  m_mimeType = substringForRange(contentType,
+                                 SubstringRange(index, semiColonIndex - index))
+                   .stripWhiteSpace();
   index = semiColonIndex + 1;
-  while (true) {
+  do {
     skipSpaces(contentType, index);
     SubstringRange keyRange = parseParameterPart(contentType, index);
     if (!keyRange.second || index >= contentTypeLength) {
       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
@@ skipping 13 matching lines @@
     }
 
     // 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;
     }
 
-    receiver.setContentTypeParameter(keyRange, valueRange);
-
-    if (index >= contentTypeLength)
-      return true;
-  }
+    m_parameters.set(substringForRange(contentType, keyRange),
+                     substringForRange(contentType, valueRange));
+  } while (index < contentTypeLength);
 
   return true;
 }
 
-bool isValidContentType(const String& contentType) {
-  if (contentType.contains('\r') || contentType.contains('\n'))
-    return false;
-
-  DummyParsedContentType parsedContentType = DummyParsedContentType();
-  return parseContentType<DummyParsedContentType>(contentType,
-                                                  parsedContentType);
-}
-
-ParsedContentType::ParsedContentType(const String& contentType)
-    : m_contentType(contentType.stripWhiteSpace()) {
-  parseContentType<ParsedContentType>(m_contentType, *this);
-}
-
-String ParsedContentType::charset() const {
-  return parameterValueForName("charset");
-}
-
-String ParsedContentType::parameterValueForName(const String& name) const {
-  return m_parameters.get(name);
-}
-
-size_t ParsedContentType::parameterCount() const {
-  return m_parameters.size();
-}
-
-void ParsedContentType::setContentType(const SubstringRange& contentRange) {
-  m_mimeType = substringForRange(m_contentType, contentRange).stripWhiteSpace();
-}
-
-void ParsedContentType::setContentTypeParameter(const SubstringRange& key,
-                                                const SubstringRange& value) {
-  m_parameters.set(substringForRange(m_contentType, key),
-                   substringForRange(m_contentType, value));
-}
-
 }  // namespace blink