Replicate feature policy headers to remote frames

third_party/WebKit/Source/platform/feature_policy/FeaturePolicy.cpp

 // Copyright 2016 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/feature_policy/FeaturePolicy.h"
 
 #include "platform/json/JSONValues.h"
 #include "platform/network/HTTPParsers.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SecurityOrigin.h"
@@ skipping 11 matching lines @@
     FeaturePolicy::FeatureList& features) {
   for (const FeaturePolicy::Feature* feature : features) {
     if (featureName == feature->featureName)
       return feature;
   }
   return nullptr;
 }
 
 // Converts a list of JSON feature policy items into a mapping of features to
 // whitelists. For future compatibility, unrecognized features are simply
-// ignored, as are unparseable origins. Any errors in the input will cause an
-// error message appended to |messages|.
+// ignored, as are unparseable origins. If |messages| is not null, then any
+// errors in the input will cause an error message to be appended to it.
 HashMap<const FeaturePolicy::Feature*,
         std::unique_ptr<FeaturePolicy::Whitelist>>
 parseFeaturePolicyFromJson(std::unique_ptr<JSONArray> policyItems,
                            RefPtr<SecurityOrigin> origin,
                            FeaturePolicy::FeatureList& features,
-                           Vector<String>& messages) {
+                           Vector<String>* messages) {
   HashMap<const FeaturePolicy::Feature*,
           std::unique_ptr<FeaturePolicy::Whitelist>>
       whitelists;
 
   for (size_t i = 0; i < policyItems->size(); ++i) {
     JSONObject* item = JSONObject::cast(policyItems->at(i));
     if (!item) {
-      messages.append("Policy is not an object");
+      if (messages)
+        messages->append("Policy is not an object");
       continue;  // Array element is not an object; skip
     }
 
     for (size_t j = 0; j < item->size(); ++j) {
       JSONObject::Entry entry = item->at(j);
       String featureName = entry.first;
       JSONArray* targets = JSONArray::cast(entry.second);
       if (!targets) {
-        messages.append("Whitelist is not an array of strings.");
+        if (messages)
+          messages->append("Whitelist is not an array of strings.");
         continue;
       }
 
       const FeaturePolicy::Feature* feature =
           featureForName(featureName, features);
       if (!feature)
         continue;  // Feature is not recognized; skip
 
       std::unique_ptr<FeaturePolicy::Whitelist> whitelist(
           new FeaturePolicy::Whitelist);
       String targetString;
       for (size_t j = 0; j < targets->size(); ++j) {
         if (targets->at(j)->asString(&targetString)) {
           if (equalIgnoringCase(targetString, "self")) {
             whitelist->add(origin);
           } else if (targetString == "*") {
             whitelist->addAll();
           } else {
             KURL originUrl = KURL(KURL(), targetString);
             if (originUrl.isValid()) {
               whitelist->add(SecurityOrigin::create(originUrl));
             }
           }
         } else {
-          messages.append("Whitelist is not an array of strings.");
+          if (messages)
+            messages->append("Whitelist is not an array of strings.");
         }
       }
       whitelists.set(feature, std::move(whitelist));
     }
   }
   return whitelists;
 }
 
 }  // namespace
 
@@ skipping 94 matching lines @@
 
 // static
 std::unique_ptr<FeaturePolicy> FeaturePolicy::createFromParentPolicy(
     const FeaturePolicy* parent,
     RefPtr<SecurityOrigin> currentOrigin) {
   return createFromParentPolicy(parent, std::move(currentOrigin),
                                 getDefaultFeatureList());
 }
 
 void FeaturePolicy::setHeaderPolicy(const String& policy,
-                                    Vector<String>& messages) {
+                                    Vector<String>* messages) {
   DCHECK(m_headerWhitelists.isEmpty());
   std::unique_ptr<JSONArray> policyJSON = parseJSONHeader(policy);
   if (!policyJSON) {
-    messages.append("Unable to parse header");
+    if (messages)
+      messages->append("Unable to parse header");
     return;
   }
   m_headerWhitelists = parseFeaturePolicyFromJson(
       std::move(policyJSON), m_origin, m_features, messages);
 }
 
 bool FeaturePolicy::isFeatureEnabledForOrigin(
     const FeaturePolicy::Feature& feature,
     const SecurityOrigin& origin) const {
   DCHECK(m_inheritedFeatures.contains(&feature));
@@ skipping 40 matching lines @@
     sb.append("  ");
     sb.append(whitelist.key->featureName);
     sb.append(": ");
     sb.append(whitelist.value->toString());
     sb.append("\n");
   }
   return sb.toString();
 }
 
 }  // namespace blink