Better header value parsing for Server-Timing.

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

 /*
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2011 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ skipping 20 matching lines @@
  */
 
 #include "platform/network/HTTPParsers.h"
 
 #include "net/http/http_content_disposition.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "platform/HTTPNames.h"
 #include "platform/json/JSONParser.h"
 #include "platform/loader/fetch/ResourceResponse.h"
+#include "platform/network/HeaderFieldTokenizer.h"
 #include "platform/weborigin/Suborigin.h"
 #include "platform/wtf/DateMath.h"
 #include "platform/wtf/MathExtras.h"
 #include "platform/wtf/text/CString.h"
 #include "platform/wtf/text/CharacterNames.h"
 #include "platform/wtf/text/ParsingUtilities.h"
 #include "platform/wtf/text/StringBuilder.h"
 #include "platform/wtf/text/StringUTF8Adaptor.h"
 #include "platform/wtf/text/WTFString.h"
 #include "public/platform/WebString.h"
@@ skipping 806 matching lines @@
 
 bool ParseContentRangeHeaderFor206(const String& content_range,
                                    int64_t* first_byte_position,
                                    int64_t* last_byte_position,
                                    int64_t* instance_length) {
   return net::HttpUtil::ParseContentRangeHeaderFor206(
       StringUTF8Adaptor(content_range).AsStringPiece(), first_byte_position,
       last_byte_position, instance_length);
 }
 
-template <typename CharType>
-inline bool IsNotServerTimingHeaderDelimiter(CharType c) {
-  return c != '=' && c != ';' && c != ',';
-}
-
-const LChar* ParseServerTimingToken(const LChar* begin,
-                                    const LChar* end,
-                                    String& result) {
-  const LChar* position = begin;
-  skipWhile<LChar, IsNotServerTimingHeaderDelimiter>(position, end);
-  result = String(begin, position - begin).StripWhiteSpace();
-  return position;
-}
-
-String CheckDoubleQuotedString(const String& value) {
-  if (value.length() < 2 || value[0] != '"' ||
-      value[value.length() - 1] != '"') {
-    return value;
-  }
-
-  StringBuilder out;
-  unsigned pos = 1;                   // Begin after the opening DQUOTE.
-  unsigned len = value.length() - 1;  // End before the closing DQUOTE.
-
-  // Skip past backslashes, but include everything else.
-  while (pos < len) {
-    if (value[pos] == '\\')
-      pos++;
-    if (pos < len)
-      out.Append(value[pos++]);
-  }
-
-  return out.ToString();
-}
-
 std::unique_ptr<ServerTimingHeaderVector> ParseServerTimingHeader(
     const String& headerValue) {
   std::unique_ptr<ServerTimingHeaderVector> headers =
       WTF::MakeUnique<ServerTimingHeaderVector>();
 
   if (!headerValue.IsNull()) {
     DCHECK(headerValue.Is8Bit());
 
-    const LChar* position = headerValue.Characters8();
-    const LChar* end = position + headerValue.length();
-    while (position < end) {
-      String metric, value, description = "";
-      position = ParseServerTimingToken(position, end, metric);
-      if (position != end && *position == '=') {
-        position = ParseServerTimingToken(position + 1, end, value);
+    HeaderFieldTokenizer tokenizer(headerValue);
+    while (!tokenizer.IsConsumed()) {
+      StringView metric;
+      if (!tokenizer.ConsumeToken(Mode::kNormal, metric)) {
+        break;
       }
-      if (position != end && *position == ';') {
-        position = ParseServerTimingToken(position + 1, end, description);
+
+      double duration = 0.0;
+      String description = "";
+      if (tokenizer.Consume('=')) {
+        StringView durationOutput;
+        if (tokenizer.ConsumeToken(Mode::kNormal, durationOutput)) {
+          duration = durationOutput.ToString().ToDouble();
+        }
       }
-      position++;
+      if (tokenizer.Consume(';')) {
+        tokenizer.ConsumeTokenOrQuotedString(Mode::kNormal, description);
+      }
 
       headers->push_back(WTF::MakeUnique<ServerTimingHeader>(
-          metric, value.ToDouble(), CheckDoubleQuotedString(description)));
+          metric.ToString(), duration, description));
+
+      if (!tokenizer.Consume(',')) {
+        break;
+      }
     }
   }
   return headers;
 }
 
 }  // namespace blink