Move parsing of referrer policy header values to SecurityPolicy

third_party/WebKit/Source/platform/weborigin/SecurityPolicy.cpp

 /*
  * Copyright (C) 2011 Google 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 28 matching lines @@
 #include "wtf/Threading.h"
 #include "wtf/text/StringHash.h"
 #include <memory>
 
 namespace blink {
 
 using OriginAccessWhiteList = Vector<OriginAccessEntry>;
 using OriginAccessMap = HashMap<String, std::unique_ptr<OriginAccessWhiteList>>;
 using OriginSet = HashSet<String>;
 
-enum ReferrerPolicyLegacyKeywordsSupport {
-  SupportReferrerPolicyLegacyKeywords,
-  DoNotSupportReferrerPolicyLegacyKeywords,
-};
-
 static OriginAccessMap& originAccessMap() {
   DEFINE_STATIC_LOCAL(OriginAccessMap, originAccessMap, ());
   return originAccessMap;
 }
 
 static OriginSet& trustworthyOriginSet() {
   DEFINE_STATIC_LOCAL(OriginSet, trustworthyOriginSet, ());
   return trustworthyOriginSet;
 }
 
-static bool referrerPolicyFromStringImpl(
-    const String& policy,
-    ReferrerPolicyLegacyKeywordsSupport legacyKeywordsSupport,
-    ReferrerPolicy* result) {
-  DCHECK(!policy.isNull());
-  bool supportLegacyKeywords =
-      (legacyKeywordsSupport == SupportReferrerPolicyLegacyKeywords);
-
-  if (equalIgnoringASCIICase(policy, "no-referrer") ||
-      (supportLegacyKeywords && equalIgnoringASCIICase(policy, "never"))) {
-    *result = ReferrerPolicyNever;
-    return true;
-  }
-  if (equalIgnoringASCIICase(policy, "unsafe-url") ||
-      (supportLegacyKeywords && equalIgnoringASCIICase(policy, "always"))) {
-    *result = ReferrerPolicyAlways;
-    return true;
-  }
-  if (equalIgnoringASCIICase(policy, "origin")) {
-    *result = ReferrerPolicyOrigin;
-    return true;
-  }
-  if (equalIgnoringASCIICase(policy, "origin-when-cross-origin") ||
-      (supportLegacyKeywords &&
-       equalIgnoringASCIICase(policy, "origin-when-crossorigin"))) {
-    *result = ReferrerPolicyOriginWhenCrossOrigin;
-    return true;
-  }
-  if (equalIgnoringASCIICase(policy, "no-referrer-when-downgrade") ||
-      (supportLegacyKeywords && equalIgnoringASCIICase(policy, "default"))) {
-    *result = ReferrerPolicyNoReferrerWhenDowngrade;
-    return true;
-  }
-  return false;
-}
-
 void SecurityPolicy::init() {
   originAccessMap();
   trustworthyOriginSet();
 }
 
 bool SecurityPolicy::shouldHideReferrer(const KURL& url, const KURL& referrer) {
   bool referrerIsSecureURL = referrer.protocolIs("https");
   bool schemeIsAllowed =
       SchemeRegistry::shouldTreatURLSchemeAsAllowedForReferrer(
           referrer.protocol());
@@ skipping 180 matching lines @@
 
   if (list->isEmpty())
     map.remove(it);
 }
 
 void SecurityPolicy::resetOriginAccessWhitelists() {
   ASSERT(isMainThread());
   originAccessMap().clear();
 }
 
-bool SecurityPolicy::referrerPolicyFromString(const String& policy,
-                                              ReferrerPolicy* result) {
-  return referrerPolicyFromStringImpl(
-      policy, DoNotSupportReferrerPolicyLegacyKeywords, result);
+bool SecurityPolicy::referrerPolicyFromString(
+    const String& policy,
+    ReferrerPolicyLegacyKeywordsSupport legacyKeywordsSupport,
+    ReferrerPolicy* result) {
+  DCHECK(!policy.isNull());
+  bool supportLegacyKeywords =
+      (legacyKeywordsSupport == SupportReferrerPolicyLegacyKeywords);
+
+  if (equalIgnoringASCIICase(policy, "no-referrer") ||
+      (supportLegacyKeywords && equalIgnoringASCIICase(policy, "never"))) {
+    *result = ReferrerPolicyNever;
+    return true;
+  }
+  if (equalIgnoringASCIICase(policy, "unsafe-url") ||
+      (supportLegacyKeywords && equalIgnoringASCIICase(policy, "always"))) {
+    *result = ReferrerPolicyAlways;
+    return true;
+  }
+  if (equalIgnoringASCIICase(policy, "origin")) {
+    *result = ReferrerPolicyOrigin;
+    return true;
+  }
+  if (equalIgnoringASCIICase(policy, "origin-when-cross-origin") ||
+      (supportLegacyKeywords &&
+       equalIgnoringASCIICase(policy, "origin-when-crossorigin"))) {
+    *result = ReferrerPolicyOriginWhenCrossOrigin;
+    return true;
+  }
+  if (equalIgnoringASCIICase(policy, "no-referrer-when-downgrade") ||
+      (supportLegacyKeywords && equalIgnoringASCIICase(policy, "default"))) {
+    *result = ReferrerPolicyNoReferrerWhenDowngrade;
+    return true;
+  }
+  return false;
 }
 
-bool SecurityPolicy::referrerPolicyFromStringWithLegacyKeywords(
-    const String& policy,
+bool SecurityPolicy::referrerPolicyFromHeaderValue(
+    const String& headerValue,
+    ReferrerPolicyLegacyKeywordsSupport legacyKeywordsSupport,
     ReferrerPolicy* result) {
-  return referrerPolicyFromStringImpl(
-      policy, SupportReferrerPolicyLegacyKeywords, result);
+  ReferrerPolicy referrerPolicy = ReferrerPolicyDefault;
+
+  Vector<String> tokens;
+  headerValue.split(',', true, tokens);
+  for (const auto& token : tokens) {
+    ReferrerPolicy currentResult;
+    if (SecurityPolicy::referrerPolicyFromString(token, legacyKeywordsSupport,
+                                                 &currentResult)) {
+      referrerPolicy = currentResult;
+    }
+  }
+
+  if (referrerPolicy == ReferrerPolicyDefault)
+    return false;
+
+  *result = referrerPolicy;
+  return true;
 }
 
 }  // namespace blink