Make content::FeaturePolicy implement WebFeaturePolicy, and use it in blink code

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 79 matching lines @@
 
 void FeaturePolicy::Whitelist::Add(const url::Origin& origin) {
   origins_.push_back(origin);
 }
 
 void FeaturePolicy::Whitelist::AddAll() {
   matches_all_origins_ = true;
 }
 
 bool FeaturePolicy::Whitelist::Contains(const url::Origin& origin) const {
+  // This does not handle the case where origin is an opaque origin, which is
+  // also supposed to exist in the whitelist. (The identical opaque origins
+  // should match in that case)
+  // TODO(iclelland): Fix that, possibly by having another flag for
+  // 'matches_self', which will explicitly match the policy's origin.
+  // https://crbug.com/690520
   if (matches_all_origins_)
     return true;
   for (const auto& targetOrigin : origins_) {
     if (targetOrigin.IsSameOriginWith(origin))
       return true;
   }
   return false;
 }
 
 // static
@@ skipping 13 matching lines @@
     return false;
   auto whitelist = whitelists_.find(feature);
   if (whitelist != whitelists_.end())
     return whitelist->second->Contains(origin);
   if (feature_definition->default_policy ==
       FeaturePolicy::FeatureDefault::EnableForAll) {
     return true;
   }
   if (feature_definition->default_policy ==
       FeaturePolicy::FeatureDefault::EnableForSelf) {
-    return origin_.IsSameOriginWith(origin);
+    // TODO(iclelland): Remove the pointer equality check once it is possible to
+    // compare opaque origins successfully against themselves.
+    // https://crbug.com/690520

[raymes, 2017/02/13 04:45:22]

I put a question on the bug about this. I'm wondering if we can avoid needing to
handle unique origins?

[iclelland, 2017/02/23 20:04:12]

I don't know if we can -- they are going to need *some* kind of a policy, even
if it's the default one.

If we can, then I'll have to update the test framework to ensure that a dummy
page always has a valid origin; the fullscreen tests were failing for a while
because of this. Sandboxed frames are going to be the real issue, here, I think:
Not so much data or file urls. (Although I'm sure there are uses for each of
those as well, that's a policy rather than a technical issue, once we allow it
in sandbox.)

+    return (&origin_ == &origin) || origin_.IsSameOriginWith(origin);
   }
   return false;
 }
 
 bool FeaturePolicy::IsFeatureEnabled(
     blink::WebFeaturePolicyFeature feature) const {
   return IsFeatureEnabledForOrigin(feature, origin_);
 }
 
 void FeaturePolicy::SetHeaderPolicy(
@@ skipping 51 matching lines @@
         {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