Feature policy: Add basic algorithm for supporting frame policies.

content/common/feature_policy/feature_policy.cc

 // Copyright 2017 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 "content/common/feature_policy/feature_policy.h"
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 
@@ skipping 91 matching lines @@
   for (const auto& targetOrigin : origins_) {
     if (targetOrigin.IsSameOriginWith(origin))
       return true;
   }
   return false;
 }
 
 // static
 std::unique_ptr<FeaturePolicy> FeaturePolicy::CreateFromParentPolicy(
     const FeaturePolicy* parent_policy,
+    const ParsedFeaturePolicyHeader* frame_policy,
     const url::Origin& origin) {
-  return CreateFromParentPolicy(parent_policy, origin, GetDefaultFeatureList());
+  return CreateFromParentPolicy(parent_policy, frame_policy, origin,
+                                GetDefaultFeatureList());
 }
 
 bool FeaturePolicy::IsFeatureEnabledForOrigin(
     blink::WebFeaturePolicyFeature feature,
     const url::Origin& origin) const {
   DCHECK(base::ContainsKey(feature_list_, feature));
   const FeaturePolicy::Feature* feature_definition = feature_list_.at(feature);
   DCHECK(base::ContainsKey(inherited_policies_, feature));
   if (!inherited_policies_.at(feature))
     return false;
@@ skipping 34 matching lines @@
     : origin_(origin), feature_list_(feature_list) {}
 
 FeaturePolicy::FeaturePolicy(url::Origin origin)
     : origin_(origin), feature_list_(GetDefaultFeatureList()) {}
 
 FeaturePolicy::~FeaturePolicy() {}
 
 // static
 std::unique_ptr<FeaturePolicy> FeaturePolicy::CreateFromParentPolicy(
     const FeaturePolicy* parent_policy,
+    const ParsedFeaturePolicyHeader* frame_policy,
     const url::Origin& origin,
     const FeaturePolicy::FeatureList& features) {
   std::unique_ptr<FeaturePolicy> new_policy =
       base::WrapUnique(new FeaturePolicy(origin, features));
   for (const auto& feature : features) {
     if (!parent_policy ||
         parent_policy->IsFeatureEnabledForOrigin(feature.first, origin)) {
       new_policy->inherited_policies_[feature.first] = true;
     } else {
       new_policy->inherited_policies_[feature.first] = false;
     }
+    if (frame_policy) {

[raymes, 2017/02/20 02:20:17]

nit: we should be consistent with brackets around single-line if's.
Unfortunately the style guide says nothing, but at least within files we should
try to be consistent :)

[iclelland, 2017/02/21 19:51:05]

Done.

+      new_policy->AddFramePolicy(parent_policy, frame_policy);
+    }
   }
   return new_policy;
 }
 
+void FeaturePolicy::AddFramePolicy(
+    const FeaturePolicy* parent_policy,
+    const ParsedFeaturePolicyHeader* frame_policy) {
+  DCHECK(parent_policy);
+  DCHECK(frame_policy);
+  for (const ParsedFeaturePolicyDeclaration& parsed_declaration :
+       *frame_policy) {
+    blink::WebFeaturePolicyFeature feature =
+        FeatureForName(parsed_declaration.feature_name, feature_list_);
+    if (feature == blink::WebFeaturePolicyFeature::NotFound)
+      continue;
+    if (WhitelistFromDeclaration(parsed_declaration)->Contains(origin_) &&

[raymes, 2017/02/20 02:20:17]

nit: I know it will be specc'd but maybe a comment explaining the reasoning here
would help. e.g.
// If a feature is enabled in the parent frame and the parent chooses to
delegate it to a child frame
// using the iframe attribute, then the feature should be enabled in the child
frame.

[iclelland, 2017/02/21 19:51:05]

Done. (And in blink-side implementation as well)

+        parent_policy->IsFeatureEnabled(feature)) {
+      inherited_policies_[feature] = true;
+    } else {
+      inherited_policies_[feature] = false;
+    }
+  }
+}
+
 // static
 const FeaturePolicy::FeatureList& FeaturePolicy::GetDefaultFeatureList() {
   CR_DEFINE_STATIC_LOCAL(
       FeatureList, default_feature_list,
       ({{blink::WebFeaturePolicyFeature::DocumentCookie, &kDocumentCookie},
         {blink::WebFeaturePolicyFeature::DocumentDomain, &kDocumentDomain},
         {blink::WebFeaturePolicyFeature::DocumentWrite, &kDocumentWrite},
         {blink::WebFeaturePolicyFeature::Fullscreen, &kFullscreenFeature},
         {blink::WebFeaturePolicyFeature::Geolocation, &kGeolocationFeature},
         {blink::WebFeaturePolicyFeature::MidiFeature, &kMidiFeature},
         {blink::WebFeaturePolicyFeature::Notifications, &kNotificationsFeature},
         {blink::WebFeaturePolicyFeature::Payment, &kPaymentFeature},
         {blink::WebFeaturePolicyFeature::Push, &kPushFeature},
         {blink::WebFeaturePolicyFeature::SyncScript, &kSyncScript},
         {blink::WebFeaturePolicyFeature::SyncXHR, &kSyncXHR},
         {blink::WebFeaturePolicyFeature::Usermedia, &kUsermedia},
         {blink::WebFeaturePolicyFeature::Vibrate, &kVibrateFeature},
         {blink::WebFeaturePolicyFeature::WebRTC, &kWebRTC}}));
   return default_feature_list;
 }
 
 }  // namespace content