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

chrome/renderer/extensions/dispatcher.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/renderer/extensions/dispatcher.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/json/json_reader.h"
@@ skipping 704 matching lines @@
 }
 
 void Dispatcher::RegisterSchemaGeneratedBindings(
     ModuleSystem* module_system,
     ChromeV8Context* context) {
   std::set<std::string> apis =
       ExtensionAPI::GetSharedInstance()->GetAllAPINames();
   for (std::set<std::string>::iterator it = apis.begin();
        it != apis.end(); ++it) {
     const std::string& api_name = *it;
-    if (!context->IsAnyFeatureAvailableToContext(api_name))
-      continue;
+    // TODO(cduvall): Reenable once all APIs are converted to features.
+    // if (!context->IsAnyFeatureAvailableToContext(api_name))
+    //   continue;
 
     Feature* feature =
         BaseFeatureProvider::GetByName("api")->GetFeature(api_name);
     if (feature && feature->IsInternal())
       continue;
 
     std::vector<std::string> split;
     base::SplitString(api_name, '.', &split);
 
     v8::Handle<v8::Object> bind_object =
         GetOrCreateChrome(context->v8_context());
 
     // Check if this API has an ancestor. If the API's ancestor is available and
     // the API is not available, don't install the bindings for this API. If
     // the API is available and its ancestor is not, delete the ancestor and
     // install the bindings for the API. This is to prevent loading the ancestor
     // API schema if it will not be needed.
     //
     // For example:
     //  If app is available and app.window is not, just install app.
     //  If app.window is available and app is not, delete app and install
     //  app.window on a new object so app does not have to be loaded.
     std::string ancestor_name;
     bool only_ancestor_available = false;
     for (size_t i = 0; i < split.size() - 1; ++i) {
       ancestor_name += (i ? ".": "") + split[i];
-      if (!ancestor_name.empty() &&
+      // Only check if the ancestor is "app" for now, because this is the only
+      // API that actually has children. If this checks every ancestor, the
+      // API schemas will need to be loaded to check availability. This can go
+      // back to checking all APIs once all the APIs have been converted to the
+      // feature system.
+      if (ancestor_name == "app" && !ancestor_name.empty() &&

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

maybe you should comment out the second of these conditions since it doesn't
make since given the first.

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

Done.

           context->GetAvailability(ancestor_name).is_available() &&
           !context->GetAvailability(api_name).is_available()) {
         only_ancestor_available = true;
         break;
       }
       bind_object = GetOrCreateObject(bind_object, split[i]);
     }
     if (only_ancestor_available)
       continue;
 
@@ skipping 282 matching lines @@
        BackgroundInfo::HasLazyBackgroundPage(extension));
   module_system->RegisterNativeHandler("process",
       scoped_ptr<NativeHandler>(new ProcessInfoNativeHandler(
           this, v8_context, context->GetExtensionID(),
           context->GetContextTypeDescription(),
           ChromeRenderProcessObserver::is_incognito_process(),
           manifest_version, send_request_disabled)));
 
   GetOrCreateChrome(v8_context);
 
-  // Loading JavaScript is expensive, so only run the full API bindings
-  // generation mechanisms in extension pages (NOT all web pages).
-  switch (context_type) {
-    case Feature::UNSPECIFIED_CONTEXT:
-    case Feature::WEB_PAGE_CONTEXT:
-      // TODO(kalman): see comment below about ExtensionAPI.
-      InstallBindings(module_system.get(), v8_context, "app");
-      InstallBindings(module_system.get(), v8_context, "webstore");
-      break;
-    case Feature::BLESSED_EXTENSION_CONTEXT:
-    case Feature::UNBLESSED_EXTENSION_CONTEXT:
-    case Feature::CONTENT_SCRIPT_CONTEXT:
-      if (extension && !extension->is_platform_app())
-        module_system->Require("miscellaneous_bindings");
-      module_system->Require("json");  // see paranoid comment in json.js
+  if (extension && !extension->is_platform_app())

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

Maybe this _is_ a bit premature if there's still a 500kb increase. I expect
that'd correlate with some perf degradation. Perhaps try that thing in
extension_api after all?

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

Tried the extension api thing, commented there.

+    module_system->Require("miscellaneous_bindings");
+  if (context_type != Feature::WEB_PAGE_CONTEXT)
+    module_system->Require("json");  // see paranoid comment in json.js
 
-      // TODO(kalman): move this code back out of the switch and execute it
-      // regardless of |context_type|. ExtensionAPI knows how to return the
-      // correct APIs, however, until it doesn't have a 2MB overhead we can't
-      // load it in every process.
-      RegisterSchemaGeneratedBindings(module_system.get(), context);
-      break;
-  }
+  RegisterSchemaGeneratedBindings(module_system.get(), context);
 
   bool is_within_platform_app = IsWithinPlatformApp(frame);
   // Inject custom JS into the platform app context.
   if (is_within_platform_app)
     module_system->Require("platformApp");
 
   // Only platform apps support the <webview> tag, because the "webView" and
   // "denyWebView" modules will affect the performance of DOM modifications
   // (http://crbug.com/196453).
   if (context_type == Feature::BLESSED_EXTENSION_CONTEXT &&
@@ skipping 362 matching lines @@
     std::string error_msg = base::StringPrintf(kMessage, function_name.c_str());
     v8::ThrowException(
         v8::Exception::Error(v8::String::New(error_msg.c_str())));
     return false;
   }
 
   return true;
 }
 
 }  // namespace extensions