Replace string by enum in WebParsedFeaturePolicyDeclaration#feature

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"
 
 namespace content {
 
-namespace {
-
-// Given a string name, return the matching feature struct, or nullptr if it is
-// not the name of a policy-controlled feature.
-blink::WebFeaturePolicyFeature FeatureForName(
-    const std::string& feature_name,
-    const FeaturePolicy::FeatureList& features) {
-  for (const auto& feature_mapping : features) {
-    if (feature_name == feature_mapping.second->feature_name)
-      return feature_mapping.first;
-  }
-  return blink::WebFeaturePolicyFeature::NotFound;
-}
-
 // Definitions of all features controlled by Feature Policy should appear here.
 const FeaturePolicy::Feature kDocumentCookie{

[iclelland, 2017/03/06 13:55:59]

Removing the namespace declaration moves all of these symbols into the content::
namespace -- was that intentional?

     "cookie", FeaturePolicy::FeatureDefault::EnableForAll};
 const FeaturePolicy::Feature kDocumentDomain{
     "domain", FeaturePolicy::FeatureDefault::EnableForAll};
 const FeaturePolicy::Feature kDocumentWrite{
     "docwrite", FeaturePolicy::FeatureDefault::EnableForAll};
 const FeaturePolicy::Feature kFullscreenFeature{
     "fullscreen", FeaturePolicy::FeatureDefault::EnableForSelf};
 const FeaturePolicy::Feature kGeolocationFeature{
     "geolocation", FeaturePolicy::FeatureDefault::EnableForSelf};
 const FeaturePolicy::Feature kMidiFeature{
@@ skipping 20 matching lines @@
     const ParsedFeaturePolicyDeclaration& parsed_declaration) {
   std::unique_ptr<FeaturePolicy::Whitelist> result =
       base::WrapUnique(new FeaturePolicy::Whitelist());
   if (parsed_declaration.matches_all_origins)
     result->AddAll();
   for (const auto& origin : parsed_declaration.origins)
     result->Add(origin);
   return result;
 }
 
-}  // namespace
-
 ParsedFeaturePolicyDeclaration::ParsedFeaturePolicyDeclaration()
     : matches_all_origins(false) {}
 
 ParsedFeaturePolicyDeclaration::ParsedFeaturePolicyDeclaration(
-    std::string feature_name,
+    blink::WebFeaturePolicyFeature feature,
     bool matches_all_origins,
     std::vector<url::Origin> origins)
-    : feature_name(feature_name),
+    : feature(feature),
       matches_all_origins(matches_all_origins),
       origins(origins) {}
 
 ParsedFeaturePolicyDeclaration::ParsedFeaturePolicyDeclaration(
     const ParsedFeaturePolicyDeclaration& rhs) = default;
 
 ParsedFeaturePolicyDeclaration::~ParsedFeaturePolicyDeclaration() {}
 
 FeaturePolicy::Whitelist::Whitelist() : matches_all_origins_(false) {}
 
@@ skipping 76 matching lines @@
     return (&origin_ == &origin) || origin_.IsSameOriginWith(origin);
   }
   return false;
 }
 
 void FeaturePolicy::SetHeaderPolicy(
     const ParsedFeaturePolicyHeader& parsed_header) {
   DCHECK(whitelists_.empty());
   for (const ParsedFeaturePolicyDeclaration& parsed_declaration :
        parsed_header) {
-    blink::WebFeaturePolicyFeature feature =
-        FeatureForName(parsed_declaration.feature_name, feature_list_);
+    blink::WebFeaturePolicyFeature feature = parsed_declaration.feature;
     if (feature == blink::WebFeaturePolicyFeature::NotFound)
       continue;
     whitelists_[feature] = WhitelistFromDeclaration(parsed_declaration);
   }
 }
 
 FeaturePolicy::FeaturePolicy(url::Origin origin,
                              const FeatureList& feature_list)
     : origin_(origin), feature_list_(feature_list) {}
 
@@ skipping 25 matching lines @@
 
 void FeaturePolicy::AddContainerPolicy(
     const ParsedFeaturePolicyHeader& container_policy,
     const FeaturePolicy* parent_policy) {
   DCHECK(parent_policy);
   for (const ParsedFeaturePolicyDeclaration& parsed_declaration :
        container_policy) {
     // If a feature is enabled in the parent frame, and the parent chooses to
     // delegate it to the child frame, using the iframe attribute, then the
     // feature should be enabled in the child frame.
-    blink::WebFeaturePolicyFeature feature =
-        FeatureForName(parsed_declaration.feature_name, feature_list_);
+    blink::WebFeaturePolicyFeature feature = parsed_declaration.feature;
     if (feature == blink::WebFeaturePolicyFeature::NotFound)
       continue;
     if (WhitelistFromDeclaration(parsed_declaration)->Contains(origin_) &&
         parent_policy->IsFeatureEnabled(feature)) {
       inherited_policies_[feature] = true;
     } else {
       inherited_policies_[feature] = false;
     }
   }
 }
@@ skipping 13 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