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) {
+  // This method returns true only when the arguments are actually identical,
+  // including the order of elements in the origins vector.
+  // TODO(iclelland): Consider making this return true when comparing equal-
+  // but-not-identical whitelists, or eliminate those comparisons by maintaining
+  // the whiteslists in a normalized form.
+  // https://crbug.com/710324
+  return std::tie(lhs.feature, lhs.matches_all_origins, lhs.origins) ==
+         std::tie(rhs.feature, rhs.matches_all_origins, rhs.origins);
+}
+
 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::kSyncScript,
                             FeaturePolicy::FeatureDefault::EnableForAll},
                            {blink::WebFeaturePolicyFeature::kSyncXHR,
                             FeaturePolicy::FeatureDefault::EnableForAll},
                            {blink::WebFeaturePolicyFeature::kWebRTC,
                             FeaturePolicy::FeatureDefault::EnableForAll}}));
   return default_feature_list;
 }
 
 }  // namespace content