Lazy load chrome.* APIs

chrome/renderer/extensions/module_system.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/module_system.h"
 
 #include "base/bind.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebScopedMicrotaskSuppression.h"
 
 namespace {
 
+const char* kArgument = "argument";
 const char* kModuleSystem = "module_system";
 const char* kModuleName = "module_name";
 const char* kModuleField = "module_field";
 const char* kModulesField = "modules";
 
 } // namespace
 
 namespace extensions {
 
 ModuleSystem::ModuleSystem(v8::Handle<v8::Context> context,
@@ skipping 139 matching lines @@
                                     const std::string& method_name) {
   v8::HandleScope handle_scope;
   v8::Local<v8::Value> module =
       v8::Local<v8::Value>::New(
           RequireForJsInner(v8::String::New(module_name.c_str())));
   if (module.IsEmpty() || !module->IsObject())
     return;
   v8::Local<v8::Value> value =
       v8::Handle<v8::Object>::Cast(module)->Get(
           v8::String::New(method_name.c_str()));
+  CallModuleMethod(value, 0, NULL);
+}
+
+v8::Handle<v8::Value> ModuleSystem::CallModuleMethod(
+    v8::Local<v8::Value> value,
+    int argc,
+    v8::Handle<v8::Value> argv[]) {
   if (value.IsEmpty() || !value->IsFunction())
-    return;
+    return v8::Handle<v8::Value>();
   v8::Handle<v8::Function> func =
       v8::Handle<v8::Function>::Cast(value);
   // TODO(jeremya/koz): refer to context_ here, not the current context.
   v8::Handle<v8::Object> global(v8::Context::GetCurrent()->Global());
+  v8::Handle<v8::Value> ret;
   {
     WebKit::WebScopedMicrotaskSuppression suppression;
     v8::TryCatch try_catch;
     try_catch.SetCaptureMessage(true);
-    func->Call(global, 0, NULL);
+    ret = func->Call(global, argc, argv);
     if (try_catch.HasCaught())
       HandleException(try_catch);
   }
+  return ret;
+}
+
+bool ModuleSystem::HasNativeHandler(const std::string& name) {
+  return native_handler_map_.find(name) != native_handler_map_.end();
 }
 
 void ModuleSystem::RegisterNativeHandler(const std::string& name,
     scoped_ptr<NativeHandler> native_handler) {
   native_handler_map_[name] =
       linked_ptr<NativeHandler>(native_handler.release());
 }
 
 void ModuleSystem::OverrideNativeHandler(const std::string& name) {
   overridden_native_handlers_.insert(name);
@@ skipping 26 matching lines @@
     NativesEnabledScope scope(module_system);
     module = v8::Handle<v8::Object>::Cast(module_system->RequireForJsInner(
         parameters->Get(v8::String::New(kModuleName))->ToString()));
   }
   if (module.IsEmpty())
     return handle_scope.Close(v8::Handle<v8::Value>());
 
   v8::Handle<v8::String> field =
       parameters->Get(v8::String::New(kModuleField))->ToString();
 
-  return handle_scope.Close(module->Get(field));
+  v8::Local<v8::Value> value = module->Get(field);

[not at google - send to devlin, 2012/12/13 22:26:40]

Something to add a TODO about - it seems like we could save a bit here by
actually setting the property on the lazy object, thus never calling into this
LazyFieldGetter again for that property. The laziness here comes from
RequireForJs not requiring something twice, but we can do a little bit better.

+  if (!parameters->Has(v8::String::New(kArgument)))
+    return handle_scope.Close(module->Get(field));
+  v8::Handle<v8::Value> argv[] = {parameters->Get(v8::String::New(kArgument))};
+
+  NativesEnabledScope scope(module_system);
+  return handle_scope.Close(module_system->CallModuleMethod(value, 1, argv));

[not at google - send to devlin, 2012/12/13 22:26:40]

Yeah, all this stuff - can it go in schema_binding_generator?

 }
 
 void ModuleSystem::SetLazyField(v8::Handle<v8::Object> object,
                                 const std::string& field,
                                 const std::string& module_name,
                                 const std::string& module_field) {
+  SetLazyField(object, field, module_name, module_field, "");
+}
+
+void ModuleSystem::SetLazyField(v8::Handle<v8::Object> object,
+                                const std::string& field,
+                                const std::string& module_name,
+                                const std::string& module_field,
+                                const std::string& arg) {
   v8::HandleScope handle_scope;
   v8::Handle<v8::Object> parameters = v8::Object::New();
   parameters->Set(v8::String::New(kModuleName),
                   v8::String::New(module_name.c_str()));
   parameters->Set(v8::String::New(kModuleField),
                   v8::String::New(module_field.c_str()));
+  if (arg.size()) {
+    parameters->Set(v8::String::New(kArgument),
+                    v8::String::New(arg.c_str()));
+  }
 
   object->SetAccessor(v8::String::New(field.c_str()),
                       &ModuleSystem::LazyFieldGetter,
                       NULL,
                       parameters);
 }
 
 v8::Handle<v8::Value> ModuleSystem::RunString(v8::Handle<v8::String> code,
                                               v8::Handle<v8::String> name) {
   v8::HandleScope handle_scope;
@@ skipping 43 matching lines @@
   v8::Handle<v8::String> right = v8::String::New("\n})");
   return handle_scope.Close(
       v8::String::Concat(left, v8::String::Concat(source, right)));
 }
 
 v8::Handle<v8::Value> ModuleSystem::ThrowException(const std::string& message) {
   return v8::ThrowException(v8::String::New(message.c_str()));
 }
 
 }  // extensions