Implement ComplexFeature to support permission features with multiple rules.

chrome/common/extensions/features/simple_feature_provider.cc

Index: chrome/common/extensions/features/simple_feature_provider.cc
diff --git a/chrome/common/extensions/features/simple_feature_provider.cc b/chrome/common/extensions/features/simple_feature_provider.cc
deleted file mode 100644
index 4edcfe11c19544ae346e296bf3014334dd142e34..0000000000000000000000000000000000000000
--- a/chrome/common/extensions/features/simple_feature_provider.cc
+++ /dev/null
@@ -1,124 +0,0 @@
-// 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() {
-  return new FeatureClass();
-}
-
-struct Static {
-  Static()
-      : manifest_features(
-            LoadProvider("manifest",
-                         &CreateFeature<ManifestFeature>,
-                         IDR_EXTENSION_MANIFEST_FEATURES)),
-        permission_features(
-            LoadProvider("permissions",
-                         &CreateFeature<PermissionFeature>,
-                         IDR_EXTENSION_PERMISSION_FEATURES)) {
-  }
-
-  scoped_ptr<SimpleFeatureProvider> manifest_features;
-  scoped_ptr<SimpleFeatureProvider> permission_features;
-
- private:
-  scoped_ptr<SimpleFeatureProvider> LoadProvider(
-      const std::string& debug_string,
-      SimpleFeatureProvider::FeatureFactory factory,
-      int resource_id) {
-    std::string manifest_features =
-        ResourceBundle::GetSharedInstance().GetRawDataResource(
-            resource_id).as_string();
-    int error_code = 0;
-    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));
-  }
-};
-
-base::LazyInstance<Static> g_static = LAZY_INSTANCE_INITIALIZER;
-
-}  // namespace
-
-SimpleFeatureProvider::SimpleFeatureProvider(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;
-    }
-
-    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();
-}
-
-// 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) {
-  FeatureMap::iterator iter = features_.find(name);
-  if (iter != features_.end())
-    return iter->second.get();
-  else
-    return NULL;
-}
-
-}  // namespace