Implement ComplexFeature to support permission features with multiple rules.

chrome/common/extensions/api/extension_api.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/api/extension_api.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/common/extensions/api/generated_schemas.h"
 #include "chrome/common/extensions/extension.h"
-#include "chrome/common/extensions/features/simple_feature_provider.h"
+#include "chrome/common/extensions/features/base_feature_provider.h"
+#include "chrome/common/extensions/features/simple_feature.h"
 #include "chrome/common/extensions/permissions/permission_set.h"
 #include "googleurl/src/gurl.h"
 #include "grit/common_resources.h"
 #include "grit/extensions_api_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 
 using base::DictionaryValue;
 using base::ListValue;
 using base::Value;
 
@@ skipping 247 matching lines @@
     }
 
     // Populate feature maps.
     // TODO(aa): Consider not storing features that can never run on the current
     // machine (e.g., because of platform restrictions).
     bool uses_feature_system = false;
     schema->GetBoolean("uses_feature_system", &uses_feature_system);
     if (!uses_feature_system)
       continue;
 
-    Feature* feature = new Feature();
+    SimpleFeature* feature = new SimpleFeature();
     feature->set_name(schema_namespace);
     feature->Parse(schema);
 
     FeatureMap* schema_features = new FeatureMap();
     CHECK(features_.insert(
         std::make_pair(schema_namespace,
                        make_linked_ptr(schema_features))).second);
     CHECK(schema_features->insert(
         std::make_pair("", make_linked_ptr(feature))).second);
 
     for (size_t i = 0; i < arraysize(kChildKinds); ++i) {
       ListValue* child_list = NULL;
       schema->GetList(kChildKinds[i], &child_list);
       if (!child_list)
         continue;
 
       for (size_t j = 0; j < child_list->GetSize(); ++j) {
         DictionaryValue* child = NULL;
         CHECK(child_list->GetDictionary(j, &child));
 
-        scoped_ptr<Feature> child_feature(new Feature(*feature));
+        scoped_ptr<SimpleFeature> child_feature(new SimpleFeature(*feature));
         child_feature->Parse(child);
         if (child_feature->Equals(*feature))
           continue;  // no need to store no-op features
 
         std::string child_name;
         CHECK(child->GetString("name", &child_name));
         child_feature->set_name(schema_namespace + "." + child_name);
         CHECK(schema_features->insert(
             std::make_pair(child_name,
                            make_linked_ptr(child_feature.release()))).second);
       }
     }
   }
 }
 
 ExtensionAPI::ExtensionAPI() {
   RegisterDependencyProvider("api", this);
 
   // TODO(aa): Can remove this when all JSON files are converted.
   RegisterDependencyProvider("", this);
 }
 
 ExtensionAPI::~ExtensionAPI() {
 }
 
 void ExtensionAPI::InitDefaultConfiguration() {
   RegisterDependencyProvider(
-      "manifest", SimpleFeatureProvider::GetManifestFeatures());
+      "manifest", BaseFeatureProvider::GetManifestFeatures());
   RegisterDependencyProvider(
-      "permission", SimpleFeatureProvider::GetPermissionFeatures());
+      "permission", BaseFeatureProvider::GetPermissionFeatures());
 
   // Schemas to be loaded from resources.
   CHECK(unloaded_schemas_.empty());
   RegisterSchema("app", ReadFromResource(
       IDR_EXTENSION_API_JSON_APP));
   RegisterSchema("bookmarks", ReadFromResource(
       IDR_EXTENSION_API_JSON_BOOKMARKS));
   RegisterSchema("bookmarkManagerPrivate", ReadFromResource(
       IDR_EXTENSION_API_JSON_BOOKMARKMANAGERPRIVATE));
   RegisterSchema("browserAction", ReadFromResource(
@@ skipping 167 matching lines @@
   if (feature) {
     // An API is 'privileged' if it or any of its dependencies can only be run
     // in a blessed context.
     std::set<std::string> resolved_dependencies;
     resolved_dependencies.insert(full_name);
     ResolveDependencies(&resolved_dependencies);
     for (std::set<std::string>::iterator iter = resolved_dependencies.begin();
          iter != resolved_dependencies.end(); ++iter) {
       Feature* dependency = GetFeatureDependency(*iter);
       for (std::set<Feature::Context>::iterator context =
-               dependency->contexts()->begin();
-           context != dependency->contexts()->end(); ++context) {
+               dependency->GetContexts()->begin();
+           context != dependency->GetContexts()->end(); ++context) {
         if (*context != Feature::BLESSED_EXTENSION_CONTEXT)
           return false;
       }
     }
     return true;
   }
 
   // If this API hasn't been converted yet, fall back to the old system.
   if (completely_unprivileged_apis_.count(api_name))
     return false;
@@ skipping 167 matching lines @@
   Feature* result = NULL;
   FeatureMap::iterator child_feature = feature_map->second->find(child_name);
   if (child_feature != feature_map->second->end()) {
     result = child_feature->second.get();
   } else {
     FeatureMap::iterator parent_feature = feature_map->second->find("");
     CHECK(parent_feature != feature_map->second->end());
     result = parent_feature->second.get();
   }
 
-  if (result->contexts()->empty()) {
+  if (result->GetContexts()->empty()) {
     LOG(ERROR) << "API feature '" << full_name
                << "' must specify at least one context.";
     return NULL;
   }
 
   return result;
 }
 
 Feature* ExtensionAPI::GetFeatureDependency(const std::string& full_name) {
   std::string feature_type;
@@ skipping 128 matching lines @@
 
 void ExtensionAPI::LoadAllSchemas() {
   while (unloaded_schemas_.size()) {
     std::map<std::string, base::StringPiece>::iterator it =
         unloaded_schemas_.begin();
     LoadSchema(it->first, it->second);
   }
 }
 
 }  // namespace extensions