Lazy load chrome.* APIs

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>
 
@@ skipping 337 matching lines @@
       IDR_EXTENSION_API_JSON_BROWSERACTION));
   RegisterSchema("browsingData", ReadFromResource(
       IDR_EXTENSION_API_JSON_BROWSINGDATA));
   RegisterSchema("commands", ReadFromResource(
       IDR_EXTENSION_API_JSON_COMMANDS));
   RegisterSchema("declarativeContent", ReadFromResource(
       IDR_EXTENSION_API_JSON_DECLARATIVE_CONTENT));
   RegisterSchema("declarativeWebRequest", ReadFromResource(
       IDR_EXTENSION_API_JSON_DECLARATIVE_WEBREQUEST));
   RegisterSchema("devtools", ReadFromResource(
       IDR_EXTENSION_API_JSON_DEVTOOLS));

[not at google - send to devlin, 2013/02/15 22:26:17]

Good news! https://codereview.chromium.org/12281003/ fixes the devtools test
failures without touching webkit.

And if that patch gets delayed, removing this reference to the devtools API will
also fix it.

[cduvall, 2013/02/19 23:58:49]

Yay!

   RegisterSchema("experimental.input.virtualKeyboard", ReadFromResource(
       IDR_EXTENSION_API_JSON_EXPERIMENTAL_INPUT_VIRTUALKEYBOARD));
   RegisterSchema("experimental.processes", ReadFromResource(
       IDR_EXTENSION_API_JSON_EXPERIMENTAL_PROCESSES));
   RegisterSchema("experimental.rlz", ReadFromResource(
       IDR_EXTENSION_API_JSON_EXPERIMENTAL_RLZ));
   RegisterSchema("runtime", ReadFromResource(
       IDR_EXTENSION_API_JSON_RUNTIME));
   RegisterSchema("experimental.speechInput", ReadFromResource(
       IDR_EXTENSION_API_JSON_EXPERIMENTAL_SPEECHINPUT));
@@ skipping 169 matching lines @@
     if (!IsFeatureAllowedForExtension(*i, extension)) {
       apis->erase(i++);
     } else {
       ++i;
     }
   }
 }
 
 }  // namespace
 
-scoped_ptr<std::set<std::string> > ExtensionAPI::GetAPIsForContext(
+std::set<std::string> ExtensionAPI::GetAPIsForContext(
     Feature::Context context, const Extension* extension, const GURL& url) {
   // We're forced to load all schemas now because we need to know the metadata
   // 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;
 
@@ skipping 37 matching lines @@
     case Feature::WEB_PAGE_CONTEXT:
       if (url.is_valid()) {
         // Availablility is determined by the url.
         GetAPIsMatchingURL(url, &temp_result);
       }
       break;
   }
 
   // Filter out all non-API features and remove the feature type part of the
   // name.
-  scoped_ptr<std::set<std::string> > result(new std::set<std::string>());
+  std::set<std::string> result;
   for (std::set<std::string>::iterator iter = temp_result.begin();
        iter != temp_result.end(); ++iter) {
     std::string feature_type;
     std::string feature_name;
     SplitDependencyName(*iter, &feature_type, &feature_name);
     if (feature_type == "api")
-      result->insert(feature_name);
+      result.insert(feature_name);
   }
 
-  return result.Pass();
+  return result;
+}
+
+std::set<std::string> ExtensionAPI::GetAllAPINames() {
+  std::set<std::string> result;
+  for (SchemaMap::iterator i = schemas_.begin(); i != schemas_.end(); ++i)
+    result.insert(i->first);
+  for (UnloadedSchemaMap::iterator i = unloaded_schemas_.begin();
+       i != unloaded_schemas_.end(); ++i) {
+    result.insert(i->first);
+  }
+  return result;
 }
 
 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);
@@ skipping 152 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