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();
+    if (feature->contexts()->empty()) {
+      LOG(ERROR) << "API feature '" << schema_namespace << "' includes no "
+                 << "contexts and will never be available.";

[not at google - send to devlin, 2012/04/10 02:04:27]

Why not CHECK?

[Aaron Boodman, 2012/04/11 21:51:54]

Done.

+    }
+
     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 157 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) {

[not at google - send to devlin, 2012/04/10 23:55:41]

Urk, it seems like "IsPrivileged" is a bit of a strange thing to expose, since
we're dealing with multiple types of Contexts and it's not clear from the name
what exactly that means anymore.

But probably not something to look at now.  And I'm too tired to think abou it.

   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 68 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 iter =
+             feature->dependencies()->begin();
+         iter != feature->dependencies()->end(); ++iter) {

[not at google - send to devlin, 2012/04/10 23:55:41]

nit: I think this would fit on 1 line. Certainly if you called it "it" instead
of "iter".

[Aaron Boodman, 2012/04/11 21:51:54]

Done.

+      out->insert(*iter);
+    }
+    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 (features_.find(*i) != features_.end()) {

[not at google - send to devlin, 2012/04/10 23:55:41]

This pattern is being used a lot. How about adding an IsControlledByFeatures()
method, then we also wouldn't need the comment that follows every check like
this.

[Aaron Boodman, 2012/04/11 21:51:54]

I like it. Done.

+      // This API is controlled by the feature system. Nothing to do here.
+      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);
   }
 }
@@ skipping 12 matching lines @@
   }
 }
 
 void ExtensionAPI::LoadAllSchemas() {
   while (unloaded_schemas_.size()) {
     LoadSchema(unloaded_schemas_.begin()->second);
   }
 }
 
 }  // namespace extensions