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

content/common/feature_policy/feature_policy.h

 // 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.
 
 #ifndef CONTENT_COMMON_FEATURE_POLICY_FEATURE_POLICY_H_
 #define CONTENT_COMMON_FEATURE_POLICY_FEATURE_POLICY_H_
 
 #include <map>
 #include <memory>
 #include <string>
@@ skipping 85 matching lines @@
   ParsedFeaturePolicyDeclaration(const ParsedFeaturePolicyDeclaration& rhs);
   ~ParsedFeaturePolicyDeclaration();
 
   std::string feature_name;
   bool matches_all_origins;
   std::vector<url::Origin> origins;
 };
 
 using ParsedFeaturePolicyHeader = std::vector<ParsedFeaturePolicyDeclaration>;
 
-class CONTENT_EXPORT FeaturePolicy {
+class CONTENT_EXPORT FeaturePolicy : public blink::WebFeaturePolicy {
  public:
   // Represents a collection of origins which make up a whitelist in a feature
   // policy. This collection may be set to match every origin (corresponding to
   // the "*" syntax in the policy string, in which case the Contains() method
   // will always return true.
   class Whitelist final {
    public:
     Whitelist();
+    Whitelist(const Whitelist& rhs);
     ~Whitelist();
 
     // Adds a single origin to the whitelist.
     void Add(const url::Origin& origin);
 
     // Adds all origins to the whitelist.
     void AddAll();
 
     // Returns true if the given origin has been added to the whitelist.
     bool Contains(const url::Origin& origin) const;
@@ skipping 30 matching lines @@
     const char* const feature_name;
 
     // Controls whether the feature should be available in the platform by
     // default, in the absence of any declared policy.
     FeatureDefault default_policy;
   };
 
   using FeatureList =
       std::map<blink::WebFeaturePolicyFeature, const FeaturePolicy::Feature*>;
 
-  ~FeaturePolicy();
+  ~FeaturePolicy() override;
 
   static std::unique_ptr<FeaturePolicy> CreateFromParentPolicy(
       const FeaturePolicy* parent_policy,
-      const ParsedFeaturePolicyHeader* container_policy,
+      const ParsedFeaturePolicyHeader& container_policy,
       const url::Origin& origin);
 
-  // Returns whether or not the given feature is enabled by this policy.
+  static std::unique_ptr<FeaturePolicy> CreateFromPolicyWithOrigin(
+      const FeaturePolicy& policy,
+      const url::Origin& origin);
+
+  // WebFeaturePolicy implementation
+  bool IsFeatureEnabled(blink::WebFeaturePolicyFeature feature) const override;
+
+  // Returns whether or not the given feature is enabled by this policy for a
+  // specific origin.
   bool IsFeatureEnabledForOrigin(blink::WebFeaturePolicyFeature feature,
                                  const url::Origin& origin) const;
 
-  // Returns whether or not the given feature is enabled for the origin of the
-  // document that owns the policy.
-  bool IsFeatureEnabled(blink::WebFeaturePolicyFeature feature) const;
-
   // Sets the declared policy from the parsed Feature-Policy HTTP header.
   // Unrecognized features will be ignored.
   void SetHeaderPolicy(const ParsedFeaturePolicyHeader& parsed_header);
 
  private:
   friend class FeaturePolicyTest;
 
   explicit FeaturePolicy(url::Origin origin);
   FeaturePolicy(url::Origin origin, const FeatureList& feature_list);
   static std::unique_ptr<FeaturePolicy> CreateFromParentPolicy(
       const FeaturePolicy* parent_policy,
-      const ParsedFeaturePolicyHeader* container_policy,
+      const ParsedFeaturePolicyHeader& container_policy,
       const url::Origin& origin,
       const FeatureList& features);
 
   // Updates the inherited policy with the declarations from the iframe allow*
   // attributes.
-  void AddContainerPolicy(const ParsedFeaturePolicyHeader* container_policy,
+  void AddContainerPolicy(const ParsedFeaturePolicyHeader& container_policy,
                           const FeaturePolicy* parent_policy);
 
   // Returns the list of features which can be controlled by Feature Policy.
   static const FeatureList& GetDefaultFeatureList();
 
   url::Origin origin_;
 
   // Map of feature names to declared whitelists. Any feature which is missing
   // from this map should use the inherited policy.
   std::map<blink::WebFeaturePolicyFeature, std::unique_ptr<Whitelist>>
       whitelists_;
 
   // Records whether or not each feature was enabled for this frame by its
   // parent frame.
   // TODO(iclelland): Generate, instead of this map, a set of bool flags, one
   // for each feature, as all features are supposed to be represented here.
   std::map<blink::WebFeaturePolicyFeature, bool> inherited_policies_;
 
   const FeatureList& feature_list_;
 
   DISALLOW_COPY_AND_ASSIGN(FeaturePolicy);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_FEATURE_POLICY_FEATURE_POLICY_H_