Replicate feature policy container 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 24 matching lines @@
     std::vector<url::Origin> origins)
     : feature(feature),
       matches_all_origins(matches_all_origins),
       origins(origins) {}
 
 ParsedFeaturePolicyDeclaration::ParsedFeaturePolicyDeclaration(
     const ParsedFeaturePolicyDeclaration& rhs) = default;
 
 ParsedFeaturePolicyDeclaration::~ParsedFeaturePolicyDeclaration() {}
 
+bool operator==(const ParsedFeaturePolicyDeclaration& lhs,
+                const ParsedFeaturePolicyDeclaration& rhs) {
+  return std::tie(lhs.feature, lhs.matches_all_origins, lhs.origins) ==
+         std::tie(rhs.feature, rhs.matches_all_origins, rhs.origins);

[lunalu1, 2017/04/05 22:30:03]

If lhs.origins = [a.com, b.com, c.com], rhs.origins = [c.com, b.com, a.com], and
the rest are the same, do you think == will return true? Or should it return
false in this case?

[alexmos, 2017/04/11 01:17:49]

+1, just bumping this up to ensure we don't forget this.  I'm also curious what
happens if you declare a duplicate policy, as in ["b.com", "b.com"] - should
that be considered equal to ["b.com"]?

It probably doesn't matter much in places like CommitPendingFramePolicy, but I
do wonder if there are reasons to think about the whitelist as a vector rather
than a set.

[iclelland, 2017/04/11 17:41:43]

I think that the reason may have just been that vectors round-trip better over
IPC and between WTF/WebKit/Content. I don't think it matters here (yet) as this
is only used to tell when the policy might have changed, and there isn't much
cost if we get that wrong and trigger an update for an essentially unchanged
policy.

I'll add a TODO and file a crbug to make something more robust -- either check
here for equivalence, or what's probably more efficient, normalize when we parse
the policy in the first place -- I'd hate to have to make this an O(n^2)
comparison when we could just maintain the whitelists in a sorted state.

+}
+
 FeaturePolicy::Whitelist::Whitelist() : matches_all_origins_(false) {}
 
 FeaturePolicy::Whitelist::Whitelist(const Whitelist& rhs) = default;
 
 FeaturePolicy::Whitelist::~Whitelist() = default;
 
 void FeaturePolicy::Whitelist::Add(const url::Origin& origin) {
   origins_.push_back(origin);
 }
 
@@ skipping 50 matching lines @@
     const url::Origin& origin) const {
   DCHECK(base::ContainsKey(feature_list_, feature));
   const FeaturePolicy::FeatureDefault default_policy =
       feature_list_.at(feature);
   DCHECK(base::ContainsKey(inherited_policies_, feature));
   if (!inherited_policies_.at(feature))
     return false;
   auto whitelist = whitelists_.find(feature);
   if (whitelist != whitelists_.end())
     return whitelist->second->Contains(origin);
-  if (default_policy == FeaturePolicy::FeatureDefault::EnableForAll) {
+  if (default_policy == FeaturePolicy::FeatureDefault::EnableForAll)
     return true;
-  }
   if (default_policy == FeaturePolicy::FeatureDefault::EnableForSelf) {
     // TODO(iclelland): Remove the pointer equality check once it is possible to
     // compare opaque origins successfully against themselves.
     // https://crbug.com/690520
     return (&origin_ == &origin) || origin_.IsSameOriginWith(origin);
   }
   return false;
 }
 
 void FeaturePolicy::SetHeaderPolicy(
@@ skipping 94 matching lines @@
                            {blink::WebFeaturePolicyFeature::SyncScript,
                             FeaturePolicy::FeatureDefault::EnableForAll},
                            {blink::WebFeaturePolicyFeature::SyncXHR,
                             FeaturePolicy::FeatureDefault::EnableForAll},
                            {blink::WebFeaturePolicyFeature::WebRTC,
                             FeaturePolicy::FeatureDefault::EnableForAll}}));
   return default_feature_list;
 }
 
 }  // namespace content