TEST ONLY: Duplicate FP rather than modifying in place

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 68 matching lines @@
       matches_all_origins(matches_all_origins),
       origins(origins) {}
 
 ParsedFeaturePolicyDeclaration::ParsedFeaturePolicyDeclaration(
     const ParsedFeaturePolicyDeclaration& rhs) = default;
 
 ParsedFeaturePolicyDeclaration::~ParsedFeaturePolicyDeclaration() {}
 
 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);
 }
 
 void FeaturePolicy::Whitelist::AddAll() {
   matches_all_origins_ = true;
 }
 
@@ skipping 15 matching lines @@
 
 // static
 std::unique_ptr<FeaturePolicy> FeaturePolicy::CreateFromParentPolicy(
     const FeaturePolicy* parent_policy,
     const ParsedFeaturePolicyHeader& container_policy,
     const url::Origin& origin) {
   return CreateFromParentPolicy(parent_policy, container_policy, origin,
                                 GetDefaultFeatureList());
 }
 
-void FeaturePolicy::ResetOrigin(const url::Origin& origin) {
-  origin_ = url::Origin(origin);
+// static
+std::unique_ptr<FeaturePolicy> FeaturePolicy::CreateFromPolicyWithOrigin(
+    const FeaturePolicy& policy,
+    const url::Origin& origin) {
+  std::unique_ptr<FeaturePolicy> new_policy =
+      base::WrapUnique(new FeaturePolicy(origin, policy.feature_list_));
+  new_policy->inherited_policies_ = policy.inherited_policies_;
+  for (const auto& feature : policy.whitelists_) {
+    new_policy->whitelists_[feature.first] =
+        base::WrapUnique(new Whitelist(*feature.second));
+  }
+  return new_policy;
 }
 
 bool FeaturePolicy::IsFeatureEnabled(
     blink::WebFeaturePolicyFeature feature) const {
   return IsFeatureEnabledForOrigin(feature, origin_);
 }
 
 bool FeaturePolicy::IsFeatureEnabledForOrigin(
     blink::WebFeaturePolicyFeature feature,
     const url::Origin& origin) const {
@@ skipping 99 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