Implement ComplexFeature to support permission features with multiple rules.

chrome/common/extensions/features/simple_feature_provider.cc

 // Copyright (c) 2012 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 "chrome/common/extensions/features/simple_feature_provider.h"
 
 #include "base/json/json_reader.h"
 #include "base/lazy_instance.h"
 #include "chrome/common/extensions/features/manifest_feature.h"
 #include "chrome/common/extensions/features/permission_feature.h"
 #include "grit/common_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 
 namespace extensions {
 
 namespace {
 
 template<class FeatureClass>
-Feature* CreateFeature() {
+SimpleFeature* CreateFeature() {
   return new FeatureClass();
 }
 
 struct Static {
   Static()
       : manifest_features(
             LoadProvider("manifest",
                          &CreateFeature<ManifestFeature>,
                          IDR_EXTENSION_MANIFEST_FEATURES)),
         permission_features(
@@ skipping 28 matching lines @@
   }
 };
 
 base::LazyInstance<Static> g_static = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 SimpleFeatureProvider::SimpleFeatureProvider(DictionaryValue* root,
                                              FeatureFactory factory)
     : factory_(factory ? factory :
-               static_cast<FeatureFactory>(&CreateFeature<Feature>)) {
+               static_cast<FeatureFactory>(&CreateFeature<SimpleFeature>)) {
   for (DictionaryValue::Iterator iter(*root); iter.HasNext(); iter.Advance()) {
     if (iter.value().GetType() != Value::TYPE_DICTIONARY) {
-      LOG(ERROR) << iter.key() << ": Feature description must be dictionary.";
+      if (iter.value().GetType() != Value::TYPE_LIST)
+        LOG(ERROR) << iter.key() << ": Feature description must be dictionary.";
+      else
+        DVLOG(2) << iter.key() << ": Feature is a complex feature.";

[not at google - send to devlin, 2012/12/12 17:42:41]

I would hope this, by design, can never happen and would indicate a bug in our
C++ code rather than the feature files.

[justinlin, 2012/12/14 12:26:26]

Updated.

       continue;
     }
 
-    linked_ptr<Feature> feature((*factory_)());
+    linked_ptr<SimpleFeature> feature((*factory_)());
     feature->set_name(iter.key());
     feature->Parse(static_cast<const DictionaryValue*>(&iter.value()));
 
     if (feature->extension_types()->empty()) {
-      LOG(ERROR) << iter.key() << ": Simple features must specify atleast one "
+      LOG(ERROR) << iter.key() << ": Simple features must specify at least one "
                  << "value for extension_types.";
       continue;
     }
 
     if (!feature->contexts()->empty()) {
       LOG(ERROR) << iter.key() << ": Simple features do not support contexts.";
       continue;

[not at google - send to devlin, 2012/12/12 17:42:41]

ah I see, this validation is here. It would be nice not to have to repeat it.

[justinlin, 2012/12/14 12:26:26]

Done.

     }
 
     features_[iter.key()] = feature;
   }
 }
 
 SimpleFeatureProvider::~SimpleFeatureProvider() {
 }
 
 // static
 SimpleFeatureProvider* SimpleFeatureProvider::GetManifestFeatures() {
   return g_static.Get().manifest_features.get();
 }
 
 // static
 SimpleFeatureProvider* SimpleFeatureProvider::GetPermissionFeatures() {
   return g_static.Get().permission_features.get();
 }
 
 std::set<std::string> SimpleFeatureProvider::GetAllFeatureNames() const {
   std::set<std::string> result;
   for (FeatureMap::const_iterator iter = features_.begin();
        iter != features_.end(); ++iter) {
     result.insert(iter->first);
   }
   return result;
 }
 
-Feature* SimpleFeatureProvider::GetFeature(const std::string& name) {
+SimpleFeature* SimpleFeatureProvider::GetFeature(const std::string& name) {
   FeatureMap::iterator iter = features_.find(name);
   if (iter != features_.end())
     return iter->second.get();
   else
     return NULL;
 }
 
 }  // namespace