Convert tabs, windows, and extension APIs to feature system.

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/extension_api_feature.h"
 #include "chrome/common/extensions/api/generated_schemas.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_permission_set.h"
 #include "chrome/common/extensions/simple_feature_provider.h"
 #include "googleurl/src/gurl.h"
 #include "grit/common_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 
 using base::DictionaryValue;
 using base::ListValue;
@@ skipping 159 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();
+    ExtensionAPIFeature* feature = new ExtensionAPIFeature();
     feature->set_name(schema_namespace);
     feature->Parse(schema);
 
-    FeatureMap* schema_features = new FeatureMap();
+    CHECK(!feature->contexts()->empty())
+        << "API feature '" << schema_namespace << "' includes no "
+        << "contexts and will never be available.";
+
     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));
-        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);
-      }
-    }
+                       make_linked_ptr(feature))).second);
   }
 }
 
 ExtensionAPI::ExtensionAPI() {
   RegisterDependencyProvider("api", this);
 
   // TODO(aa): Can remove this when all JSON files are converted.
   RegisterDependencyProvider("", this);
 }
 
@@ skipping 153 matching lines @@
 
 bool ExtensionAPI::IsAvailable(const std::string& full_name,
                                const Extension* extension,
                                Feature::Context context) {
   std::set<std::string> dependency_names;
   dependency_names.insert(full_name);
   ResolveDependencies(&dependency_names);
 
   for (std::set<std::string>::iterator iter = dependency_names.begin();
        iter != dependency_names.end(); ++iter) {
-    Feature* feature = GetFeatureDependency(full_name);
+    Feature* feature = GetFeatureDependency(*iter);
     CHECK(feature) << *iter;
 
     Feature::Availability availability =
         feature->IsAvailableToContext(extension, context);
     if (availability != Feature::IS_AVAILABLE)
       return false;
   }
 
   return true;
 }
 
 bool ExtensionAPI::IsPrivileged(const std::string& full_name) {
   std::string child_name;
   std::string api_name = GetAPINameFromFullName(full_name, &child_name);
 
   // First try to use the feature system.
-  Feature* feature(GetFeature(full_name));
+  Feature* feature = GetFeature(full_name);
   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) {
-        if (*context != Feature::BLESSED_EXTENSION_CONTEXT)
-          return false;
+      if (dependency->contexts()->size() == 1u) {
+        Feature::Context context =
+            *(dependency->contexts()->begin());
+        if (context == Feature::BLESSED_EXTENSION_CONTEXT)
+          return true;
       }
     }
-    return true;
+    return false;
   }
 
   // If this API hasn't been converted yet, fall back to the old system.
   if (completely_unprivileged_apis_.count(api_name))
     return false;
 
   const DictionaryValue* schema = GetSchema(api_name);
   if (partially_unprivileged_apis_.count(api_name))
     return IsChildNamePrivileged(schema, child_name);
 
@@ skipping 43 matching lines @@
   // about every API -- and the metadata is stored in the schemas themselves.
   // This is a shame.
   // TODO(aa/kalman): store metadata in a separate file and don't load all
   // schemas.
   LoadAllSchemas();
 
   std::set<std::string> temp_result;
 
   // First handle all the APIs that have been converted to the feature system.
   if (extension) {
-    for (APIFeatureMap::iterator iter = features_.begin();
-         iter != features_.end(); ++iter) {
+    for (FeatureMap::iterator iter = features_.begin(); iter != features_.end();
+         ++iter) {
       if (IsAvailable(iter->first, extension, context))
         temp_result.insert(iter->first);
     }
   }
 
   // Second, fall back to the old way.
   // TODO(aa): Remove this when all APIs have been converted.
   switch (context) {
     case Feature::UNSPECIFIED_CONTEXT:
       break;
@@ skipping 39 matching lines @@
   return result.Pass();
 }
 
 Feature* ExtensionAPI::GetFeature(const std::string& full_name) {
   // Ensure it's loaded.
   GetSchema(full_name);
 
   std::string child_name;
   std::string api_namespace = GetAPINameFromFullName(full_name, &child_name);
 
-  APIFeatureMap::iterator feature_map = features_.find(api_namespace);
-  if (feature_map == features_.end())
+  FeatureMap::iterator parent = features_.find(api_namespace);
+  if (parent == features_.end())
     return NULL;
 
-  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();
+  Feature* child = parent->second->GetChild(child_name);
+  if (child) {
+    return child;
   } else {
-    FeatureMap::iterator parent_feature = feature_map->second->find("");
-    CHECK(parent_feature != feature_map->second->end());
-    result = parent_feature->second.get();
+    // TODO(aa): This is lame. We should generate a feature with the correct
+    // name on the fly. In order to do that, change the return type of this
+    // method to linked_ptr.
+    return parent->second.get();
   }
-
-  if (result->contexts()->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;
   std::string feature_name;
   SplitDependencyName(full_name, &feature_type, &feature_name);
 
   FeatureProviderMap::iterator provider =
       dependency_providers_.find(feature_type);
   CHECK(provider != dependency_providers_.end()) << full_name;
@@ skipping 31 matching lines @@
   }
 
   *child_name = "";
   return "";
 }
 
 void ExtensionAPI::GetAllowedAPIs(
     const Extension* extension, std::set<std::string>* out) {
   for (SchemaMap::const_iterator i = schemas_.begin(); i != schemas_.end();
       ++i) {
-    if (features_.find(i->first) != features_.end()) {
-      // This API is controlled by the feature system. Nothing to do here.
+    if (IsControlledByFeatureSystem(i->first))
       continue;
-    }
 
     if (extension->required_permission_set()->HasAnyAccessToAPI(i->first) ||
         extension->optional_permission_set()->HasAnyAccessToAPI(i->first)) {
       out->insert(i->first);
     }
   }
 }
 
 void ExtensionAPI::ResolveDependencies(std::set<std::string>* out) {
   std::set<std::string> missing_dependencies;
@@ skipping 13 matching lines @@
     const std::set<std::string>& excluding,
     std::set<std::string>* out) {
   std::string feature_type;
   std::string feature_name;
   SplitDependencyName(api_name, &feature_type, &feature_name);
 
   // Only API features can have dependencies for now.
   if (feature_type != "api")
     return;
 
+  // If this API is controlled by the feature system, use it to get dependencies
+  // to avoid loading the schema.
+  ExtensionAPIFeature* feature =
+      static_cast<ExtensionAPIFeature*>(GetFeature(api_name));
+  if (feature) {
+    for (std::set<std::string>::iterator it = feature->dependencies()->begin();
+         it != feature->dependencies()->end(); ++it) {
+      out->insert(*it);
+    }
+    return;
+  }
+
+  // Otherwise, fall back to the old system.
   const DictionaryValue* schema = GetSchema(feature_name);
   CHECK(schema) << "Schema for " << feature_name << " not found";
 
   ListValue* dependencies = NULL;
   if (!schema->GetList("dependencies", &dependencies))
     return;
 
   for (size_t i = 0; i < dependencies->GetSize(); ++i) {
     std::string dependency_name;
     if (dependencies->GetString(i, &dependency_name) &&
         !excluding.count(dependency_name)) {
       out->insert(dependency_name);
     }
   }
 }
 
 void ExtensionAPI::RemovePrivilegedAPIs(std::set<std::string>* apis) {
   std::set<std::string> privileged_apis;
   for (std::set<std::string>::iterator i = apis->begin(); i != apis->end();
       ++i) {
+    if (IsControlledByFeatureSystem(*i))
+      continue;
+
     if (!completely_unprivileged_apis_.count(*i) &&
         !partially_unprivileged_apis_.count(*i)) {
       privileged_apis.insert(*i);
     }
   }
   for (std::set<std::string>::iterator i = privileged_apis.begin();
       i != privileged_apis.end(); ++i) {
     apis->erase(*i);
   }
 }
 
 void ExtensionAPI::GetAPIsMatchingURL(const GURL& url,
                                       std::set<std::string>* out) {
   for (std::map<std::string, URLPatternSet>::const_iterator i =
       url_matching_apis_.begin(); i != url_matching_apis_.end(); ++i) {
-    if (features_.find(i->first) != features_.end()) {
-      // This API is controlled by the feature system. Nothing to do.
+    if (IsControlledByFeatureSystem(i->first))
       continue;
-    }
 
     if (i->second.MatchesURL(url))
       out->insert(i->first);
   }
 }
 
 void ExtensionAPI::LoadAllSchemas() {
   while (unloaded_schemas_.size()) {
     LoadSchema(unloaded_schemas_.begin()->second);
   }
 }
 
+bool ExtensionAPI::IsControlledByFeatureSystem(
+    const std::string& api_name) const {
+  return features_.find(api_name) != features_.end();
+}
+
 }  // namespace extensions