Replicate feature policy container policies.

content/common/feature_policy/feature_policy.cc

Index: content/common/feature_policy/feature_policy.cc
diff --git a/content/common/feature_policy/feature_policy.cc b/content/common/feature_policy/feature_policy.cc
index 9494574587d983312b0292d6019f3fd970d01713..96a92cbc6920ca1fd7c21c4beec5f426f42a8b4e 100644
--- a/content/common/feature_policy/feature_policy.cc
+++ b/content/common/feature_policy/feature_policy.cc
@@ -42,6 +42,12 @@ ParsedFeaturePolicyDeclaration::ParsedFeaturePolicyDeclaration(
 
 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;
@@ -112,9 +118,8 @@ bool FeaturePolicy::IsFeatureEnabledForOrigin(
   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.