Make Manifest/Permission Features Compose with Feature

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>
-SimpleFeature* CreateFeature() {
-  return new FeatureClass();
+Feature* CreateFeature(Feature* feature) {
+  return new FeatureClass(feature);
 }
 
 struct Static {
   Static()
       : manifest_features(
             LoadProvider("manifest",
                          &CreateFeature<ManifestFeature>,
                          IDR_EXTENSION_MANIFEST_FEATURES)),
         permission_features(
             LoadProvider("permissions",
@@ skipping 47 matching lines @@
     return true;
 }
 
 base::LazyInstance<Static> g_static = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 SimpleFeatureProvider::SimpleFeatureProvider(const DictionaryValue& root,
                                              FeatureFactory factory)
     : factory_(factory ? factory :
-               static_cast<FeatureFactory>(&CreateFeature<SimpleFeature>)) {
+               static_cast<FeatureFactory>(&CreateFeature<ManifestFeature>)) {
   for (DictionaryValue::Iterator iter(root); iter.HasNext(); iter.Advance()) {
     if (iter.value().GetType() == Value::TYPE_DICTIONARY) {
-      linked_ptr<SimpleFeature> feature((*factory_)());
+      scoped_ptr<SimpleFeature> simple_feature(new SimpleFeature());
 
       if (!ParseFeature(static_cast<const DictionaryValue*>(&iter.value()),
                         iter.key(),
-                        feature.get()))
+                        simple_feature.get()))
         continue;
 
+      linked_ptr<Feature> feature((*factory_)(simple_feature.release()));
       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_)());
+        scoped_ptr<SimpleFeature> feature(new SimpleFeature());
         if (!ParseFeature(static_cast<const DictionaryValue*>(*list_iter),
                           iter.key(),
                           feature.get()))
           continue;
 
-        features->push_back(feature.release());
+        features->push_back((*factory_)(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.";
     }
@@ skipping 24 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