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/complex_feature.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 17 matching lines @@
     std::string error_message;
     Value* value = base::JSONReader::ReadAndReturnError(
         manifest_features, base::JSON_PARSE_RFC,
         &error_code, &error_message);
     CHECK(value) << "Could not load features: " << debug_string << " "
                  << error_message;
     CHECK(value->IsType(Value::TYPE_DICTIONARY)) << debug_string;
     scoped_ptr<DictionaryValue> dictionary_value(
         static_cast<DictionaryValue*>(value));
     return scoped_ptr<SimpleFeatureProvider>(
-        new SimpleFeatureProvider(dictionary_value.get(), factory));
+        new SimpleFeatureProvider(*dictionary_value, factory));
   }
 };
 
+bool ParseFeature(const DictionaryValue* value,
+                  const std::string& name,
+                  SimpleFeature* feature) {
+    feature->set_name(name);
+    feature->Parse(value);
+
+    if (feature->extension_types()->empty()) {
+      LOG(ERROR) << name << ": Simple features must specify at least one "
+                 << "value for extension_types.";
+      return false;
+    }
+
+    if (!feature->GetContexts()->empty()) {
+      LOG(ERROR) << name << ": Simple features do not support contexts.";
+      return false;
+    }
+
+    return true;
+}
+
 base::LazyInstance<Static> g_static = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
-SimpleFeatureProvider::SimpleFeatureProvider(DictionaryValue* root,
+SimpleFeatureProvider::SimpleFeatureProvider(const DictionaryValue& root,
                                              FeatureFactory factory)
     : factory_(factory ? factory :
-               static_cast<FeatureFactory>(&CreateFeature<Feature>)) {
-  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.";
-      continue;
+               static_cast<FeatureFactory>(&CreateFeature<SimpleFeature>)) {
+  for (DictionaryValue::Iterator iter(root); iter.HasNext(); iter.Advance()) {
+    if (iter.value().GetType() == Value::TYPE_DICTIONARY) {
+      linked_ptr<SimpleFeature> feature((*factory_)());
+
+      if (!ParseFeature(static_cast<const DictionaryValue*>(&iter.value()),
+                        iter.key(),
+                        feature.get()))
+        continue;
+
+      features_[iter.key()] = feature;
+    } else if (iter.value().GetType() == Value::TYPE_LIST) {
+      // This is a complex feature.
+      const ListValue* list = static_cast<const ListValue*>(&iter.value());
+      CHECK_GT(list->GetSize(), 0UL);
+
+      scoped_ptr<ComplexFeature::FeatureList> features(
+          new ComplexFeature::FeatureList());
+
+      // Parse and add all SimpleFeatures from the list.
+      for (ListValue::const_iterator list_iter = list->begin();
+           list_iter != list->end(); ++list_iter) {
+        if ((*list_iter)->GetType() != Value::TYPE_DICTIONARY) {
+          LOG(ERROR) << iter.key() << ": Feature rules must be dictionaries.";
+          continue;
+        }
+
+        scoped_ptr<SimpleFeature> feature((*factory_)());
+        if (!ParseFeature(static_cast<const DictionaryValue*>(*list_iter),
+                          iter.key(),
+                          feature.get()))
+          continue;
+
+        features->push_back(feature.release());
+      }
+
+      linked_ptr<ComplexFeature> feature(new ComplexFeature(features.Pass()));
+      feature->set_name(iter.key());
+
+      features_[iter.key()] = feature;
+    } else {
+      LOG(ERROR) << iter.key() << ": Feature description must be dictionary or"
+                 << " list of dictionaries.";
     }
-
-    linked_ptr<Feature> 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 "
-                 << "value for extension_types.";
-      continue;
-    }
-
-    if (!feature->contexts()->empty()) {
-      LOG(ERROR) << iter.key() << ": Simple features do not support contexts.";
-      continue;
-    }
-
-    features_[iter.key()] = feature;
   }
 }
 
 SimpleFeatureProvider::~SimpleFeatureProvider() {
 }
 
 // static
 SimpleFeatureProvider* SimpleFeatureProvider::GetManifestFeatures() {
   return g_static.Get().manifest_features.get();
 }
@@ skipping 14 matching lines @@
 
 Feature* SimpleFeatureProvider::GetFeature(const std::string& name) {
   FeatureMap::iterator iter = features_.find(name);
   if (iter != features_.end())
     return iter->second.get();
   else
     return NULL;
 }
 
 }  // namespace