Add <link rel=preconnect> crossorigin attribute (take 2)

Source/core/loader/LinkHeader.cpp

 // Copyright 2015 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 "config.h"
 #include "core/loader/LinkHeader.h"
 
 #include "platform/ParsingUtilities.h"
 
 namespace blink {
@@ skipping 22 matching lines @@
 {
     return chr == ';' || chr == ',';
 }
 
 template <typename CharType>
 static bool isValidParameterValueChar(CharType chr)
 {
     return !isWhitespace(chr) && !isValidParameterValueEnd(chr);
 }
 
+static bool isExtensionParameter(LinkHeader::LinkParameterName name)
+{
+    return name > LinkHeader::LinkParameterAnchor;
+}
+
 // Before:
 //
 // <cat.jpg>; rel=preload
 // ^                     ^
 // position              end
 //
 // After (if successful: otherwise the method returns false)
 //
 // <cat.jpg>; rel=preload
 //          ^            ^
@@ skipping 56 matching lines @@
     return true;
 }
 
 static LinkHeader::LinkParameterName paramterNameFromString(String name)
 {
     // FIXME: Add support for more header parameters as neccessary.
     if (equalIgnoringCase(name, "rel"))
         return LinkHeader::LinkParameterRel;
     else if (equalIgnoringCase(name, "anchor"))
         return LinkHeader::LinkParameterAnchor;
+    else if (equalIgnoringCase(name, "crossorigin"))
+        return LinkHeader::LinkParameterCrossOrigin;
     return LinkHeader::LinkParameterUnknown;
 }
 
 // Before:
 //
 // <cat.jpg>; rel=preload
 //            ^          ^
 //            position   end
 //
 // After (if successful: otherwise the method returns false)
 //
 // <cat.jpg>; rel=preload
 //                ^      ^
 //            position  end
 template <typename CharType>
 static bool parseParameterName(CharType*& position, CharType* end, LinkHeader::LinkParameterName& name)
 {
     CharType* nameStart = position;
     skipWhile<CharType, isValidParameterNameChar>(position, end);
     CharType* nameEnd = position;
     skipWhile<CharType, isWhitespace>(position, end);
-    if (!skipExactly<CharType>(position, end, '='))
-        return false;
+    bool hasEqual = skipExactly<CharType>(position, end, '=');
     skipWhile<CharType, isWhitespace>(position, end);
     name = paramterNameFromString(String(nameStart, nameEnd - nameStart));
-    return true;
+    return hasEqual || isExtensionParameter(name);
 }
 
 // Before:
 //
 // <cat.jpg>; rel="preload"; type="image/jpeg";
 //                ^                            ^
 //            position                        end
 //
 // After (if the parameter starts with a quote, otherwise the method returns false)
 //
@@ skipping 38 matching lines @@
 {
     CharType* valueStart = position;
     CharType* valueEnd = position;
     bool completeQuotes;
     bool hasQuotes = skipQuotesIfNeeded(position, end, completeQuotes);
     if (!hasQuotes) {
         skipWhile<CharType, isValidParameterValueChar>(position, end);
     }
     valueEnd = position;
     skipWhile<CharType, isWhitespace>(position, end);
-    if ((!completeQuotes && valueStart == valueEnd) || (position != end && !isValidParameterValueEnd(*position)))
+    if ((!completeQuotes && valueStart == valueEnd) || (position != end && !isValidParameterValueEnd(*position))) {
+        value = String("");
         return false;
+    }
     if (hasQuotes)
         ++valueStart;
     if (completeQuotes)
         --valueEnd;
     value = String(valueStart, valueEnd - valueStart);
     return !hasQuotes || completeQuotes;
 }
 
 void LinkHeader::setValue(LinkParameterName name, String value)
 {
     // FIXME: Add support for more header parameters as neccessary.
     if (name == LinkParameterRel && !m_rel)
         m_rel = value.lower();
     else if (name == LinkParameterAnchor)
         m_isValid = false;
+    else if (name == LinkParameterCrossOrigin)
+        m_crossOrigin = crossOriginAttributeValue(value);
 }
 
 template <typename CharType>
 static void findNextHeader(CharType*& position, CharType* end)
 {
     skipUntil<CharType>(position, end, ',');
     skipExactly<CharType>(position, end, ',');
 }
 
 template <typename CharType>
 LinkHeader::LinkHeader(CharType*& position, CharType* end)
-    : m_isValid(true)
+    : m_crossOrigin(CrossOriginAttributeNotSet)
+    , m_isValid(true)
 {
     if (!parseURL(position, end, m_url)) {
         m_isValid = false;
         findNextHeader(position, end);
         return;
     }
 
     while (m_isValid && position < end) {
         if (!parseParameterDelimiter(position, end, m_isValid)) {
             findNextHeader(position, end);
             return;
         }
 
         LinkParameterName parameterName;
         if (!parseParameterName(position, end, parameterName)) {
             findNextHeader(position, end);
             m_isValid = false;
             return;
         }
 
         String parameterValue;
-        if (!parseParameterValue(position, end, parameterValue)) {
+        if (!parseParameterValue(position, end, parameterValue) && !isExtensionParameter(parameterName)) {
             findNextHeader(position, end);
             m_isValid = false;
             return;
         }
 
         setValue(parameterName, parameterValue);
     }
 }
 
 LinkHeaderSet::LinkHeaderSet(const String& header)
@@ skipping 10 matching lines @@
 template <typename CharType>
 void LinkHeaderSet::init(CharType* headerValue, unsigned len)
 {
     CharType* position = headerValue;
     CharType* end = headerValue + len;
     while (position < end)
         m_headerSet.append(LinkHeader(position, end));
 }
 
 }