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 74 matching lines @@
       stack_trace.assign(*stack_value, stack_value.length());
     else
       stack_trace = "<could not convert stack trace to string>";
   }
 
   LOG(ERROR) << "[" << resource_name << "(" << message->GetLineNumber() << ")] "
              << error_message
              << "{" << stack_trace << "}";
 }
 
-void ModuleSystem::Require(const std::string& module_name) {
+v8::Handle<v8::Value> ModuleSystem::Require(const std::string& module_name) {
   v8::HandleScope handle_scope;
-  RequireForJsInner(v8::String::New(module_name.c_str()));
+  return handle_scope.Close(
+      RequireForJsInner(v8::String::New(module_name.c_str())));
 }
 
 v8::Handle<v8::Value> ModuleSystem::RequireForJs(const v8::Arguments& args) {
   v8::HandleScope handle_scope;
   v8::Handle<v8::String> module_name = args[0]->ToString();
   return handle_scope.Close(RequireForJsInner(module_name));
 }
 
 v8::Handle<v8::Value> ModuleSystem::RequireForJsInner(
     v8::Handle<v8::String> module_name) {
@@ skipping 42 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);
+  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));
 }
 
 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