Initial Implementation of Iframe Attribute for Feature Policy (Part 3)

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 13 matching lines @@
 // feature; see the specification for details).
 //
 // Policies can be defined in the HTTP header stream, with the |Feature-Policy|
 // HTTP header, or can be set by the |allow| attributes on the iframe element
 // which embeds the document.
 //
 // See https://wicg.github.io/FeaturePolicy/
 //
 // Key concepts:
 //
-// Features
-// --------
-// Features which can be controlled by policy are defined by instances of the
-// FeaturePolicy::Feature struct. The features are referenced by the
-// |WebFeaturePolicyFeature| enum, declared in |WebFeaturePolicy.h|.
-//
 // Whitelists
 // ----------
 // Whitelists are collections of origins, although two special terms can be used
 // when declaring them:
 //   "self" refers to the orgin of the frame which is declaring the policy.
 //   "*" refers to all origins; any origin will match a whitelist which contains
 //     it.
 //
 // Declarations
 // ------------
@@ skipping 33 matching lines @@
 // determined by the feature's default policy. (Again, see the comments in
 // FeaturePolicy::DefaultPolicy for details)
 
 // This struct holds feature policy whitelist data that needs to be replicated
 // between a RenderFrame and any of its associated RenderFrameProxies. A list of
 // these form a ParsedFeaturePolicyHeader.
 // NOTE: These types are used for replication frame state between processes.
 // They exist only because we can't transfer WebVectors directly over IPC.
 struct CONTENT_EXPORT ParsedFeaturePolicyDeclaration {
   ParsedFeaturePolicyDeclaration();
-  ParsedFeaturePolicyDeclaration(std::string feature_name,
+  ParsedFeaturePolicyDeclaration(blink::WebFeaturePolicyFeature feature,
                                  bool matches_all_origins,
                                  std::vector<url::Origin> origins);
   ParsedFeaturePolicyDeclaration(const ParsedFeaturePolicyDeclaration& rhs);
   ~ParsedFeaturePolicyDeclaration();
 
-  std::string feature_name;
+  blink::WebFeaturePolicyFeature feature;
   bool matches_all_origins;
   std::vector<url::Origin> origins;
 };
 
 using ParsedFeaturePolicyHeader = std::vector<ParsedFeaturePolicyDeclaration>;
 
 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
@@ skipping 31 matching lines @@
     // Equivalent to ["self"]. If this default policy is in effect for a frame,
     // then the feature will be enabled for that frame, and any same-origin
     // child frames, but not for any cross-origin child frames.
     EnableForSelf,
 
     // Equivalent to ["*"]. If in effect for a frame, then the feature is
     // enabled for that frame and all of its children.
     EnableForAll
   };
 
-  // The FeaturePolicy::Feature struct is used to define all features under
-  // control of Feature Policy. There should only be one instance of this struct
-  // for any given feature (declared below).
-  struct Feature {
-    // The name of the feature, as it should appear in a policy string
-    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*>;
+  using FeatureList = std::map<blink::WebFeaturePolicyFeature, FeatureDefault>;
 
   ~FeaturePolicy() override;
 
   static std::unique_ptr<FeaturePolicy> CreateFromParentPolicy(
       const FeaturePolicy* parent_policy,
       const ParsedFeaturePolicyHeader& container_policy,
       const url::Origin& origin);
 
   static std::unique_ptr<FeaturePolicy> CreateFromPolicyWithOrigin(
       const FeaturePolicy& policy,
@@ skipping 44 matching lines @@
   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_