Lazily load API schemas from resource files and convert all APIs to features

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/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/values.h"
 #include "chrome/common/extensions/api/generated_schemas.h"
 #include "chrome/common/extensions/extension.h"
@@ skipping 258 matching lines @@
 void ExtensionAPI::InitDefaultConfiguration() {
   RegisterDependencyProvider(
       "api", BaseFeatureProvider::GetByName("api"));
   RegisterDependencyProvider(
       "manifest", BaseFeatureProvider::GetByName("manifest"));
   RegisterDependencyProvider(
       "permission", BaseFeatureProvider::GetByName("permission"));
 
   // Schemas to be loaded from resources.
   CHECK(unloaded_schemas_.empty());
-  RegisterSchema("app", ReadFromResource(
-      IDR_EXTENSION_API_JSON_APP));
-  RegisterSchema("browserAction", ReadFromResource(
-      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("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("fileBrowserHandler", ReadFromResource(
-      IDR_EXTENSION_API_JSON_FILEBROWSERHANDLER));
-  RegisterSchema("fileBrowserPrivate", ReadFromResource(
-      IDR_EXTENSION_API_JSON_FILEBROWSERPRIVATE));
-  RegisterSchema("input.ime", ReadFromResource(
-      IDR_EXTENSION_API_JSON_INPUT_IME));
-  RegisterSchema("inputMethodPrivate", ReadFromResource(
-      IDR_EXTENSION_API_JSON_INPUTMETHODPRIVATE));
-  RegisterSchema("pageAction", ReadFromResource(
-      IDR_EXTENSION_API_JSON_PAGEACTION));
-  RegisterSchema("pageActions", ReadFromResource(
-      IDR_EXTENSION_API_JSON_PAGEACTIONS));
-  RegisterSchema("privacy", ReadFromResource(
-      IDR_EXTENSION_API_JSON_PRIVACY));
-  RegisterSchema("proxy", ReadFromResource(
-      IDR_EXTENSION_API_JSON_PROXY));
-  RegisterSchema("scriptBadge", ReadFromResource(
-      IDR_EXTENSION_API_JSON_SCRIPTBADGE));
-  RegisterSchema("streamsPrivate", ReadFromResource(
-      IDR_EXTENSION_API_JSON_STREAMSPRIVATE));
-  RegisterSchema("ttsEngine", ReadFromResource(
-      IDR_EXTENSION_API_JSON_TTSENGINE));
-  RegisterSchema("tts", ReadFromResource(
-      IDR_EXTENSION_API_JSON_TTS));
-  RegisterSchema("types", ReadFromResource(
-      IDR_EXTENSION_API_JSON_TYPES));
-  RegisterSchema("webRequestInternal", ReadFromResource(
-      IDR_EXTENSION_API_JSON_WEBREQUESTINTERNAL));
-  RegisterSchema("webstore", ReadFromResource(
-      IDR_EXTENSION_API_JSON_WEBSTORE));
-  RegisterSchema("webstorePrivate", ReadFromResource(
-      IDR_EXTENSION_API_JSON_WEBSTOREPRIVATE));
+  RegisterSchema("app", IDR_EXTENSION_API_JSON_APP);
+  RegisterSchema("browserAction", IDR_EXTENSION_API_JSON_BROWSERACTION);
+  RegisterSchema("browsingData", IDR_EXTENSION_API_JSON_BROWSINGDATA);
+  RegisterSchema("commands", IDR_EXTENSION_API_JSON_COMMANDS);
+  RegisterSchema("declarativeContent",
+      IDR_EXTENSION_API_JSON_DECLARATIVE_CONTENT);
+  RegisterSchema("declarativeWebRequest",
+      IDR_EXTENSION_API_JSON_DECLARATIVE_WEBREQUEST);
+  RegisterSchema("experimental.input.virtualKeyboard",
+      IDR_EXTENSION_API_JSON_EXPERIMENTAL_INPUT_VIRTUALKEYBOARD);
+  RegisterSchema("experimental.processes",
+      IDR_EXTENSION_API_JSON_EXPERIMENTAL_PROCESSES);
+  RegisterSchema("experimental.rlz", IDR_EXTENSION_API_JSON_EXPERIMENTAL_RLZ);
+  RegisterSchema("runtime", IDR_EXTENSION_API_JSON_RUNTIME);
+  RegisterSchema("fileBrowserHandler",
+      IDR_EXTENSION_API_JSON_FILEBROWSERHANDLER);
+  RegisterSchema("fileBrowserPrivate",
+      IDR_EXTENSION_API_JSON_FILEBROWSERPRIVATE);
+  RegisterSchema("input.ime", IDR_EXTENSION_API_JSON_INPUT_IME);
+  RegisterSchema("inputMethodPrivate",
+      IDR_EXTENSION_API_JSON_INPUTMETHODPRIVATE);
+  RegisterSchema("pageAction", IDR_EXTENSION_API_JSON_PAGEACTION);
+  RegisterSchema("pageActions", IDR_EXTENSION_API_JSON_PAGEACTIONS);
+  RegisterSchema("privacy", IDR_EXTENSION_API_JSON_PRIVACY);
+  RegisterSchema("proxy", IDR_EXTENSION_API_JSON_PROXY);
+  RegisterSchema("scriptBadge", IDR_EXTENSION_API_JSON_SCRIPTBADGE);
+  RegisterSchema("streamsPrivate", IDR_EXTENSION_API_JSON_STREAMSPRIVATE);
+  RegisterSchema("ttsEngine", IDR_EXTENSION_API_JSON_TTSENGINE);
+  RegisterSchema("tts", IDR_EXTENSION_API_JSON_TTS);
+  RegisterSchema("types", IDR_EXTENSION_API_JSON_TYPES);
+  RegisterSchema("webRequestInternal",
+      IDR_EXTENSION_API_JSON_WEBREQUESTINTERNAL);
+  RegisterSchema("webstore", IDR_EXTENSION_API_JSON_WEBSTORE);
+  RegisterSchema("webstorePrivate", IDR_EXTENSION_API_JSON_WEBSTOREPRIVATE);
 
   // Schemas to be loaded via JSON generated from IDL files.
-  GeneratedSchemas::Get(&unloaded_schemas_);
+  std::vector<std::string> names;
+  GeneratedSchemas::GetNames(&names);
+  for (size_t i = 0; i < names.size(); ++i)
+    RegisterGeneratedSchema(names[i]);
 }
 
-void ExtensionAPI::RegisterSchema(const std::string& name,
-                                  const base::StringPiece& source) {
-  unloaded_schemas_[name] = source;
+void ExtensionAPI::RegisterSchema(const std::string& name, int resource_id) {

[not at google - send to devlin, 2013/05/10 02:46:45]

RegisterSchemaResource?

[cduvall, 2013/05/10 03:31:07]

Done.

+  unloaded_schemas_[name] = base::Bind(&ReadFromResource, resource_id);
+}
+
+void ExtensionAPI::RegisterGeneratedSchema(const std::string& name) {
+  unloaded_schemas_[name] = base::Bind(&GeneratedSchemas::Get, name);

[not at google - send to devlin, 2013/05/10 02:46:45]

There should be some kind of optimisation possible here where we don't load the
generated schemas into unloaded_schemas_, but instead know to fall back to it if
things are missing from unloaded_schemas.

It might be something to try with that memory issue? Though I doubt this is it.
Perhaps in a follow up?

[cduvall, 2013/05/10 03:31:07]

So I tried to optimize by adding the IsGenerated() function to GeneratedSchemas.
Unfortunately, this didn't help the memory increase. I found when I comment out
line GetNames() in ExtensionAPI::GetAllAPINames (in the most recent patch set),
the memory usage goes back down. So it looks like something with storing the API
names is causing the increase.

 }
 
 void ExtensionAPI::RegisterDependencyProvider(const std::string& name,
                                               FeatureProvider* provider) {
   dependency_providers_[name] = provider;
 }
 
 bool ExtensionAPI::IsAnyFeatureAvailableToContext(const std::string& api_name,
                                                   Feature::Context context,
                                                   const GURL& url) {
@@ skipping 89 matching lines @@
 const DictionaryValue* ExtensionAPI::GetSchema(const std::string& full_name) {
   std::string child_name;
   std::string api_name = GetAPINameFromFullName(full_name, &child_name);
 
   const DictionaryValue* result = NULL;
   SchemaMap::iterator maybe_schema = schemas_.find(api_name);
   if (maybe_schema != schemas_.end()) {
     result = maybe_schema->second.get();
   } else {
     // Might not have loaded yet; or might just not exist.
-    std::map<std::string, base::StringPiece>::iterator maybe_schema_resource =
+   UnloadedSchemaMap ::iterator maybe_schema_resource =

[not at google - send to devlin, 2013/05/10 02:46:45]

extra space?

[cduvall, 2013/05/10 03:31:07]

Done.

         unloaded_schemas_.find(api_name);
     if (maybe_schema_resource == unloaded_schemas_.end())
       return NULL;
 
-    LoadSchema(maybe_schema_resource->first, maybe_schema_resource->second);
+    LoadSchema(maybe_schema_resource->first,
+               maybe_schema_resource->second.Run());
     maybe_schema = schemas_.find(api_name);
     CHECK(schemas_.end() != maybe_schema);
     result = maybe_schema->second.get();
   }
 
   if (!child_name.empty())
     result = GetSchemaChild(result, child_name);
 
   return result;
 }
@@ skipping 128 matching lines @@
       PermissionsData::GetOptionalPermissions(extension)->
           HasAnyAccessToAPI(name);
 }
 
 bool ExtensionAPI::IsPrivilegedAPI(const std::string& name) {
   return completely_unprivileged_apis_.count(name) ||
       partially_unprivileged_apis_.count(name);
 }
 
 }  // namespace extensions