Lazy load chrome.* APIs

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/memory/scoped_ptr.h"
 #include "base/string_piece.h"
@@ skipping 18 matching lines @@
 #include "chrome/renderer/extensions/extension_custom_bindings.h"
 #include "chrome/renderer/extensions/extension_groups.h"
 #include "chrome/renderer/extensions/extension_helper.h"
 #include "chrome/renderer/extensions/file_browser_handler_custom_bindings.h"
 #include "chrome/renderer/extensions/file_browser_private_custom_bindings.h"
 #include "chrome/renderer/extensions/file_system_natives.h"
 #include "chrome/renderer/extensions/i18n_custom_bindings.h"
 #include "chrome/renderer/extensions/media_galleries_custom_bindings.h"
 #include "chrome/renderer/extensions/miscellaneous_bindings.h"
 #include "chrome/renderer/extensions/module_system.h"
-#include "chrome/renderer/extensions/native_handler.h"
+#include "chrome/renderer/extensions/object_backed_native_handler.h"
 #include "chrome/renderer/extensions/page_actions_custom_bindings.h"
 #include "chrome/renderer/extensions/page_capture_custom_bindings.h"
 #include "chrome/renderer/extensions/request_sender.h"
 #include "chrome/renderer/extensions/runtime_custom_bindings.h"
+#include "chrome/renderer/extensions/schema_generated_native_handler.h"
 #include "chrome/renderer/extensions/send_request_natives.h"
 #include "chrome/renderer/extensions/set_icon_natives.h"
 #include "chrome/renderer/extensions/sync_file_system_custom_bindings.h"
 #include "chrome/renderer/extensions/tab_finder.h"
 #include "chrome/renderer/extensions/tabs_custom_bindings.h"
 #include "chrome/renderer/extensions/tts_custom_bindings.h"
 #include "chrome/renderer/extensions/user_script_slave.h"
 #include "chrome/renderer/extensions/web_request_custom_bindings.h"
 #include "chrome/renderer/extensions/webstore_bindings.h"
 #include "chrome/renderer/resource_bundle_source_map.h"
@@ skipping 26 matching lines @@
 namespace extensions {
 
 namespace {
 
 static const int64 kInitialExtensionIdleHandlerDelayMs = 5*1000;
 static const int64 kMaxExtensionIdleHandlerDelayMs = 5*60*1000;
 static const char kEventDispatchFunction[] = "Event.dispatchEvent";
 static const char kOnUnloadEvent[] = "runtime.onSuspend";
 static const char kOnSuspendCanceledEvent[] = "runtime.onSuspendCanceled";
 
-class ChromeHiddenNativeHandler : public NativeHandler {
+static v8::Handle<v8::Object> GetOrCreateChrome(
+    v8::Handle<v8::Context> context) {
+  v8::Handle<v8::String> chrome_string(v8::String::New("chrome"));
+  v8::Handle<v8::Object> global(context->Global());
+  v8::Handle<v8::Value> chrome(global->Get(chrome_string));
+  if (chrome.IsEmpty() || chrome->IsUndefined()) {
+    v8::Handle<v8::Object> chrome_object(v8::Object::New());
+    global->Set(chrome_string, chrome_object);
+    return chrome_object;
+  }
+  CHECK(chrome->IsObject());
+  return chrome->ToObject();
+}
+
+class SchemaRegistryNativeHandler : public ObjectBackedNativeHandler {
+ public:
+  SchemaRegistryNativeHandler(V8SchemaRegistry* registry)
+      : registry_(registry)  {
+    RouteFunction("GetSchema",
+        base::Bind(&SchemaRegistryNativeHandler::GetSchema,
+                   base::Unretained(this)));
+  }
+
+ private:
+  v8::Handle<v8::Value> GetSchema(const v8::Arguments& args) {
+    return registry_->GetSchema(*v8::String::AsciiValue(args[0]));
+  }
+
+  V8SchemaRegistry* registry_;
+};
+
+class ChromeHiddenNativeHandler : public ObjectBackedNativeHandler {
  public:
   ChromeHiddenNativeHandler() {
     RouteFunction("GetChromeHidden",
         base::Bind(&ChromeHiddenNativeHandler::GetChromeHidden,
                    base::Unretained(this)));
   }
 
   v8::Handle<v8::Value> GetChromeHidden(const v8::Arguments& args) {
     return ChromeV8Context::GetOrCreateChromeHidden(v8::Context::GetCurrent());
   }
 };
 
-class PrintNativeHandler : public NativeHandler {
+class ChromeNativeHandler : public ObjectBackedNativeHandler {
+ public:
+  ChromeNativeHandler() {
+    RouteFunction("GetChrome",
+        base::Bind(&ChromeNativeHandler::GetChrome, base::Unretained(this)));
+  }
+
+  v8::Handle<v8::Value> GetChrome(const v8::Arguments& args) {
+    return GetOrCreateChrome(v8::Context::GetCurrent());
+  }
+};
+
+class PrintNativeHandler : public ObjectBackedNativeHandler {
  public:
   PrintNativeHandler() {
     RouteFunction("Print",
         base::Bind(&PrintNativeHandler::Print,
                    base::Unretained(this)));
   }
 
   v8::Handle<v8::Value> Print(const v8::Arguments& args) {
     if (args.Length() < 1)
       return v8::Undefined();
@@ skipping 113 matching lines @@
   }
 
  private:
   std::string extension_id_;
   std::string context_type_;
   bool is_incognito_context_;
   int manifest_version_;
   bool send_request_disabled_;
 };
 
-class LoggingNativeHandler : public NativeHandler {
+class LoggingNativeHandler : public ObjectBackedNativeHandler {
  public:
   LoggingNativeHandler() {
     RouteFunction("DCHECK",
         base::Bind(&LoggingNativeHandler::Dcheck,
                    base::Unretained(this)));
   }
 
   v8::Handle<v8::Value> Dcheck(const v8::Arguments& args) {
     CHECK_LE(args.Length(), 2);
     bool check_value = args[0]->BooleanValue();
@@ skipping 42 matching lines @@
 }
 
 void InstallWebstoreBindings(ModuleSystem* module_system,
                              v8::Handle<v8::Object> chrome,
                              v8::Handle<v8::Object> chrome_hidden) {
   module_system->SetLazyField(chrome, "webstore", "webstore", "chromeWebstore");
   module_system->SetLazyField(chrome_hidden, "webstore", "webstore",
                               "chromeHiddenWebstore");
 }
 
-static v8::Handle<v8::Object> GetOrCreateChrome(
-    v8::Handle<v8::Context> context) {
-  v8::Handle<v8::String> chrome_string(v8::String::New("chrome"));
-  v8::Handle<v8::Object> global(context->Global());
-  v8::Handle<v8::Value> chrome(global->Get(chrome_string));
-  if (chrome.IsEmpty() || chrome->IsUndefined()) {
-    v8::Handle<v8::Object> chrome_object(v8::Object::New());
-    global->Set(chrome_string, chrome_object);
-    return chrome_object;
-  }
-  CHECK(chrome->IsObject());
-  return chrome->ToObject();
-}
-
 }  // namespace
 
 Dispatcher::Dispatcher()
     : is_webkit_initialized_(false),
       webrequest_adblock_(false),
       webrequest_adblock_plus_(false),
       webrequest_other_(false),
       source_map_(&ResourceBundle::GetSharedInstance()) {
   const CommandLine& command_line = *(CommandLine::ForCurrentProcess());
   is_extension_process_ =
@@ skipping 221 matching lines @@
 }  // namespace
 
 bool Dispatcher::AllowScriptExtension(WebFrame* frame,
                                       const std::string& v8_extension_name,
                                       int extension_group,
                                       int world_id) {
   g_hack_extension_group = extension_group;
   return true;
 }
 
+void Dispatcher::SetUpChainedField(v8::Handle<v8::Object> object,
+                                   const std::string& field,
+                                   const std::string& module_name,
+                                   const std::string& module_field,
+                                   ModuleSystem* module_system,
+                                   LazyFieldSetter setter) {
+  size_t prev = -1, next = field.find_first_of(".");
+  std::vector<std::string> parts;
+  // TODO(cduvall): Clean up.
+  while (next != std::string::npos) {
+    parts.push_back(field.substr(prev + 1, next - prev - 1));
+    prev = next;
+    next = field.find_first_of(".", prev + 1);
+  }
+  parts.push_back(field.substr(prev + 1));
+
+  v8::Handle<v8::Object> current = object;
+  for (size_t i = 0; i < parts.size() - 1; i++) {
+    v8::Handle<v8::String> key = v8::String::New(parts[i].c_str());
+    if (current->Has(key)) {
+      current = v8::Handle<v8::Object>::Cast(current->Get(key));
+    } else {
+      v8::Handle<v8::Object> new_object = v8::Object::New();
+      current->Set(key, new_object);
+      current = new_object;
+    }
+  }
+
+  (module_system->*setter)(current, parts.back(), module_name, module_field);
+}
+
+void Dispatcher::RegisterSchemaGeneratedBindings(
+    ModuleSystem* module_system,
+    ChromeV8Context* context,
+    v8::Handle<v8::Context> v8_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 (lazy_bindings_map_.find(api_name) != lazy_bindings_map_.end()) {
+      InstallBindings(module_system, v8_context, api_name);
+    // If there isn't already a custom binding for this API, we need to make
+    // sure one exists to load the schema. Otherwise the custom binding will
+    // need to do it itself. Either way, register it on the chrome object to be
+    // loaded lazily.
+    } else if (!source_map_.Contains(api_name)) {
+      module_system->RegisterNativeHandler(
+          api_name,
+          scoped_ptr<NativeHandler>(new SchemaGeneratedNativeHandler(
+              module_system,
+              v8_schema_registry(),
+              api_name,
+              "bindings")));
+      SetUpChainedField(GetOrCreateChrome(v8_context),
+                        api_name,
+                        api_name,
+                        "bindings",
+                        module_system,
+                        &ModuleSystem::SetNativeLazyField);
+    } else {
+      // TODO(cduvall): Handle apitest.
+      SetUpChainedField(GetOrCreateChrome(v8_context),
+                        api_name,
+                        api_name,
+                        "bindings",
+                        module_system,
+                        &ModuleSystem::SetLazyField);
+    }
+  }

[not at google - send to devlin, 2013/01/25 00:44:31]

I feel like this should look more like

const std::string& api_name = *it;

std::vector<std::string> split;
base::SplitString(api_name, '.', &split);

v8::Handle<v8::Object> bind_object = GetOrCreateChrome(v8_context);
for (size_t i = 0; i < split.size() - 1; ++i)
  bind_object = GetOrCreateObject(bind_object, split[i]);

if (lazy_bindings_map_.find(api_name) != lazy_bindings_map_.end()) {
  InstallBindings(module_system, v8_context, api_name);
} else if (source_map_.Contains(api_name)) {
  // There is a custom binding for |api_name|. When an API is needed run that;
  // custom bindings will be responsible for generating all bindings.
  module_system->SetLazyField(bind_object,
                              split[split.size() - 1],
                              api_name,
                              "bindings");
} else {
  // There is no custom binding to generate bindings, so use
  // SchemaGeneratingNativeHandler to generate it for us.
  module_system->RegisterNativeHandler(
      api_name,
      scoped_ptr<NativeHandler>(new SchemaGeneratingNativeHandler(
          module_system,
          v8_schema_registry(),
          api_name,
          "bindings"));
  module_system->SetNativeLazyField(bind_object,
                                    split[split.size() - 1],
                                    api_name,
                                    "bindings");
}

Writing GetOrCreateObject is much easier than writing SetUpChainedField, and
besides I find SetUpChainedField a bit too abstract/indirect.

[cduvall, 2013/02/12 02:13:47]

Done.

+  module_system->SetLazyField(GetOrCreateChrome(v8_context),
+                              "Event",
+                              "event_bindings",

[not at google - send to devlin, 2013/01/25 00:44:31]

would it work to make schema_binding_generator require() Event if it wants to
use it? I.e. if it finds itself wanting to generate an event. This wouldn't need
to be lazy then, since those bindings are lazy.

[cduvall, 2013/02/12 02:13:47]

Done.

+                              "bindings");
+  module_system->SetLazyField(GetOrCreateChrome(v8_context),

[not at google - send to devlin, 2013/01/25 00:44:31]

Maybe we should fix that test thing before submitting this change.

+                              "test",
+                              "apitest",
+                              "bindings");
+}
+
 void Dispatcher::RegisterNativeHandlers(ModuleSystem* module_system,
                                         ChromeV8Context* context) {
   module_system->RegisterNativeHandler("event_bindings",
       scoped_ptr<NativeHandler>(EventBindings::Get(this)));
   module_system->RegisterNativeHandler("miscellaneous_bindings",
       scoped_ptr<NativeHandler>(MiscellaneousBindings::Get(this)));
   module_system->RegisterNativeHandler("apiDefinitions",
       scoped_ptr<NativeHandler>(new ApiDefinitionsNatives(this)));
   module_system->RegisterNativeHandler("sendRequest",
       scoped_ptr<NativeHandler>(
@@ skipping 106 matching lines @@
                              IDR_SYSTEM_INDICATOR_CUSTOM_BINDINGS_JS);
   source_map_.RegisterSource("tabCapture", IDR_TAB_CAPTURE_CUSTOM_BINDINGS_JS);
   source_map_.RegisterSource("tabs", IDR_TABS_CUSTOM_BINDINGS_JS);
   source_map_.RegisterSource("tts", IDR_TTS_CUSTOM_BINDINGS_JS);
   source_map_.RegisterSource("ttsEngine", IDR_TTS_ENGINE_CUSTOM_BINDINGS_JS);
   source_map_.RegisterSource("types", IDR_TYPES_CUSTOM_BINDINGS_JS);
   source_map_.RegisterSource("webRequest", IDR_WEB_REQUEST_CUSTOM_BINDINGS_JS);
   source_map_.RegisterSource("webRequestInternal",
                              IDR_WEB_REQUEST_INTERNAL_CUSTOM_BINDINGS_JS);
   source_map_.RegisterSource("webstore", IDR_WEBSTORE_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("schema_binding_generator",
+                             IDR_SCHEMA_BINDING_GENERATOR_JS);
 
   // Platform app sources that are not API-specific..
   source_map_.RegisterSource("tagWatcher", IDR_TAG_WATCHER_JS);
   source_map_.RegisterSource("webview", IDR_WEB_VIEW_JS);
   source_map_.RegisterSource("denyWebview", IDR_WEB_VIEW_DENY_JS);
   source_map_.RegisterSource("platformApp", IDR_PLATFORM_APP_JS);
   source_map_.RegisterSource("injectAppTitlebar", IDR_INJECT_APP_TITLEBAR_JS);
 }
 
 void Dispatcher::PopulateLazyBindingsMap() {
@@ skipping 56 matching lines @@
       new ChromeV8Context(v8_context, frame, extension, context_type);
   v8_context_set_.Add(context);
 
   scoped_ptr<ModuleSystem> module_system(new ModuleSystem(v8_context,
                                                           &source_map_));
   // Enable natives in startup.
   ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system.get());
 
   RegisterNativeHandlers(module_system.get(), context);
 
+  module_system->RegisterNativeHandler("chrome",
+      scoped_ptr<NativeHandler>(new ChromeNativeHandler()));
   module_system->RegisterNativeHandler("chrome_hidden",
       scoped_ptr<NativeHandler>(new ChromeHiddenNativeHandler()));
   module_system->RegisterNativeHandler("print",
       scoped_ptr<NativeHandler>(new PrintNativeHandler()));
   module_system->RegisterNativeHandler("lazy_background_page",
       scoped_ptr<NativeHandler>(new LazyBackgroundPageNativeHandler(this)));
   module_system->RegisterNativeHandler("logging",
       scoped_ptr<NativeHandler>(new LoggingNativeHandler()));
+  module_system->RegisterNativeHandler("schema_registry",
+      scoped_ptr<NativeHandler>(
+          new SchemaRegistryNativeHandler(v8_schema_registry())));
 
   int manifest_version = extension ? extension->manifest_version() : 1;
   bool send_request_disabled =
       (extension && extension->location() == Extension::LOAD &&
        extension->has_lazy_background_page());
   module_system->RegisterNativeHandler("process",
       scoped_ptr<NativeHandler>(new ProcessInfoNativeHandler(
           this, 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: {
-      module_system->Require("miscellaneous_bindings");
-      module_system->Require("schema_generated_bindings");
-      module_system->Require("apitest");
+      if (extension && !extension->is_platform_app())
+        module_system->Require("miscellaneous_bindings");
+      RegisterSchemaGeneratedBindings(module_system.get(),
+                                      context,
+                                      v8_context);
 
       // 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.
-      const std::set<std::string>& apis = context->GetAvailableExtensionAPIs();
-      for (std::set<std::string>::const_iterator i = apis.begin();
-           i != apis.end(); ++i) {
-        InstallBindings(module_system.get(), v8_context, *i);
-      }
-
       break;
     }
   }
 
   // Inject custom JS into the platform app context.
   if (IsWithinPlatformApp(frame))
     module_system->Require("platformApp");
 
   if (context_type == Feature::BLESSED_EXTENSION_CONTEXT) {
     bool has_permission = extension->HasAPIPermission(APIPermission::kWebView);
@@ skipping 317 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