Share link header parsing code between blink and content.

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

Index: third_party/WebKit/Source/platform/network/LinkHeader.cpp
diff --git a/third_party/WebKit/Source/platform/network/LinkHeader.cpp b/third_party/WebKit/Source/platform/network/LinkHeader.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..35d4739c05e682709854c2e215f2c4b71e976713
--- /dev/null
+++ b/third_party/WebKit/Source/platform/network/LinkHeader.cpp
@@ -0,0 +1,88 @@
+// 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 "platform/network/LinkHeader.h"
+
+#include "components/link_header_util/link_header_util.h"
+#include "platform/ParsingUtilities.h"
+
+namespace blink {
+
+// Verify that the parameter is a link-extension which according to spec doesn't have to have a value.
+static bool isExtensionParameter(LinkHeader::LinkParameterName name)
+{
+    return name >= LinkHeader::LinkParameterUnknown;
+}
+
+static LinkHeader::LinkParameterName parameterNameFromString(const String& name)

[esprehn, 2016/04/27 08:10:17]

We could also take a base::StringPiece and use whatever base would use to do the
comparison below.

[Marijn Kruisselbrink, 2016/05/11 00:36:56]

Good point. Changed it to base::StringPiece and
base::EqualsCaseInsensitiveASCII.

+{
+    if (equalIgnoringCase(name, "rel"))

[esprehn, 2016/04/27 08:10:17]

This is unicode aware, the other code uses ASCII compares, I think you want the
same here?

+        return LinkHeader::LinkParameterRel;
+    if (equalIgnoringCase(name, "anchor"))
+        return LinkHeader::LinkParameterAnchor;
+    if (equalIgnoringCase(name, "crossorigin"))
+        return LinkHeader::LinkParameterCrossOrigin;
+    if (equalIgnoringCase(name, "title"))
+        return LinkHeader::LinkParameterTitle;
+    if (equalIgnoringCase(name, "media"))
+        return LinkHeader::LinkParameterMedia;
+    if (equalIgnoringCase(name, "type"))
+        return LinkHeader::LinkParameterType;
+    if (equalIgnoringCase(name, "rev"))
+        return LinkHeader::LinkParameterRev;
+    if (equalIgnoringCase(name, "hreflang"))
+        return LinkHeader::LinkParameterHreflang;
+    if (equalIgnoringCase(name, "as"))
+        return LinkHeader::LinkParameterAs;
+    return LinkHeader::LinkParameterUnknown;
+}
+
+void LinkHeader::setValue(LinkParameterName name, const String& value)
+{
+    if (name == LinkParameterRel && !m_rel)
+        m_rel = value.lower();
+    else if (name == LinkParameterAnchor)
+        m_isValid = false;
+    else if (name == LinkParameterCrossOrigin)
+        m_crossOrigin = value;
+    else if (name == LinkParameterAs)
+        m_as = value.lower();
+    else if (name == LinkParameterType)
+        m_mimeType = value.lower();
+    else if (name == LinkParameterMedia)
+        m_media = value.lower();
+}
+
+template <typename Iterator>

[esprehn, 2016/04/27 08:10:17]

why do we need the template?

[Marijn Kruisselbrink, 2016/05/11 00:36:56]

Without a template the header file would need to include <string> to be able to
explicitly use std::string::const_iterator. It seemed preferred to not leak
std::string implementation details passed the implementation. But I agree it's a
bit weird to use a template when only one type can ever be used as template
parameter.

+LinkHeader::LinkHeader(Iterator begin, Iterator end)
+    : m_isValid(true)
+{
+    std::string url;
+    std::unordered_map<std::string, base::Optional<std::string>> params;
+    m_isValid = link_header_util::ParseLinkHeaderValue(begin, end, &url, &params);
+    if (!m_isValid)
+        return;
+
+    m_url = String(&url[0], url.length());

[esprehn, 2016/04/27 08:10:17]

It's always latin1?

[Marijn Kruisselbrink, 2016/05/11 00:36:56]

LinkHeaderSet bellow DCHECKs to make sure it's always 8 bit (and in the latest
PS I made the LinkHeader constructor private with LinkHeaderSet as friend), and
beyond that it's pretty much guaranteed that headers are always latin1 (or at
least sequences of octets), yes. Certainly by the way content passes headers to
blink, and all the other places where headers are created as blink strings that
I looked at verify that they're latin1.

+    for (const auto& param : params) {
+        LinkParameterName name = parameterNameFromString(String(&param.first[0], param.first.length()));
+        if (!isExtensionParameter(name) && !param.second)
+            m_isValid = false;
+        std::string value = param.second.value_or("");
+        setValue(name, String(&value[0], value.length()));
+    }
+}
+
+LinkHeaderSet::LinkHeaderSet(const String& header)
+{
+    if (header.isNull())
+        return;
+
+    DCHECK(header.is8Bit()) << "Headers should always be 8 bit";
+    std::string headerString(reinterpret_cast<const char*>(header.characters8()), header.length());
+    for (const auto& value : link_header_util::SplitLinkHeader(headerString))
+        m_headerSet.append(LinkHeader(value.first, value.second));
+}
+
+} // namespace blink