Lazy load chrome.* APIs

chrome/renderer/extensions/module_system.h

Index: chrome/renderer/extensions/module_system.h
diff --git a/chrome/renderer/extensions/module_system.h b/chrome/renderer/extensions/module_system.h
index 4f790842aec9f0a5095e355b90c10a2d991a837b..f45368d47022f5a273ccc14fbd299426786cc145 100644
--- a/chrome/renderer/extensions/module_system.h
+++ b/chrome/renderer/extensions/module_system.h
@@ -8,7 +8,7 @@
 #include "base/compiler_specific.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
-#include "chrome/renderer/extensions/native_handler.h"
+#include "chrome/renderer/extensions/object_backed_native_handler.h"
 #include "v8/include/v8.h"
 
 #include <map>
@@ -33,7 +33,7 @@ namespace extensions {
 // Note that a ModuleSystem must be used only in conjunction with a single
 // v8::Context.
 // TODO(koz): Rename this to JavaScriptModuleSystem.
-class ModuleSystem : public NativeHandler {
+class ModuleSystem : public ObjectBackedNativeHandler {
  public:
   class SourceMap {
    public:
@@ -71,7 +71,7 @@ class ModuleSystem : public NativeHandler {
 
   // Require the specified module. This is the equivalent of calling
   // require('module_name') from the loaded JS files.
-  void Require(const std::string& module_name);
+  v8::Handle<v8::Value> Require(const std::string& module_name);
   v8::Handle<v8::Value> Require(const v8::Arguments& args);
   v8::Handle<v8::Value> RequireForJs(const v8::Arguments& args);
   v8::Handle<v8::Value> RequireForJsInner(v8::Handle<v8::String> module_name);

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

hm these two methods (RequireForJs/RequireForJsInner) should be private.

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

Done.

@@ -81,11 +81,19 @@ class ModuleSystem : public NativeHandler {
   void CallModuleMethod(const std::string& module_name,
                         const std::string& method_name);
 
+  // Call |value| with arguments |argv| and return the result.
+  // TODO(cduvall): Make a v8::Function
+  v8::Handle<v8::Value> CallModuleMethod(v8::Local<v8::Value> value,
+                                         int argc,
+                                         v8::Handle<v8::Value> argv[]);
+
   // Register |native_handler| as a potential target for requireNative(), so
   // calls to requireNative(|name|) from JS will return a new object created by
   // |native_handler|.
   void RegisterNativeHandler(const std::string& name,
                              scoped_ptr<NativeHandler> native_handler);
+  // Check if a native handler has been registered for this |name|.
+  bool HasNativeHandler(const std::string& name);
 
   // Causes requireNative(|name|) to look for its module in |source_map_|
   // instead of using a registered native handler. This can be used in unit
@@ -98,6 +106,24 @@ class ModuleSystem : public NativeHandler {
   // Retrieves the lazily defined field specified by |property|.
   static v8::Handle<v8::Value> LazyFieldGetter(v8::Local<v8::String> property,
                                                const v8::AccessorInfo& info);
+  // Retrieves the lazily defined field specified by |property| on a native
+  // object.
+  static v8::Handle<v8::Value> NativeLazyFieldGetter(
+      v8::Local<v8::String> property,
+      const v8::AccessorInfo& info);
+
+  typedef v8::Handle<v8::Object> (ModuleSystem::*GetModuleFunc)(
+      v8::Handle<v8::Object>);
+  // Base implementation of a LazyFieldGetter that can be customized by passing
+  // in a |get_module| function.
+  static v8::Handle<v8::Value> BaseLazyFieldGetter(

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

Should be private.

Also the "base" confused me, it sounds like a modifier like ((base lazy field)
getter) which doesn't mean anything.

Perhaps LazyFieldGetterInner or something would be better.

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

Done.

+      v8::Local<v8::String> property,
+      const v8::AccessorInfo& info,
+      GetModuleFunc get_module);
+  // Gets a module. Same as calling |require|.
+  v8::Handle<v8::Object> GetModule(v8::Handle<v8::Object> parameters);
+  // Gets a native module. Same as calling |requireNative|.
+  v8::Handle<v8::Object> GetNativeModule(v8::Handle<v8::Object> parameters);

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

should all be private

I also don't think these are the same as require? They're specifically getters
designed to collaborate with lazy fields (more specifically
BaseLazyFieldGetter).

Looking at the implementation, they just seem to pull out kModuleName from
parameters. In that case, could BaseLazyFieldGetter pull out the module name
from parameters itself, then pass just the name to its get_module callback? That
would let you use Require or GetNativeFromString (TBH I'd call those
RequireNative/RequireNativeFromString but I don't want to go renaming koz's
stuff arbitrarily) without needing these extra slightly-confusing methods at
all.

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

Done.

 
   // Make |object|.|field| lazily evaluate to the result of
   // require(|module_name|)[|module_field|].
@@ -106,6 +132,13 @@ class ModuleSystem : public NativeHandler {
                     const std::string& module_name,
                     const std::string& module_field);
 
+  // Make |object|.|field| lazily evaluate to the result of
+  // requireNative(|module_name|)[|module_field|].
+  void SetNativeLazyField(v8::Handle<v8::Object> object,
+                          const std::string& field,
+                          const std::string& module_name,
+                          const std::string& module_field);
+
   void set_exception_handler(scoped_ptr<ExceptionHandler> handler) {
     exception_handler_ = handler.Pass();
   }
@@ -124,6 +157,13 @@ class ModuleSystem : public NativeHandler {
   v8::Handle<v8::Value> RunString(v8::Handle<v8::String> code,
                                   v8::Handle<v8::String> name);
 
+  // Sets a lazy field using the specified |getter|.
+  void SetLazyField(v8::Handle<v8::Object> object,
+                    const std::string& field,
+                    const std::string& module_name,
+                    const std::string& module_field,
+                    v8::AccessorGetter getter);
+
   // Return the named source file stored in the source map.
   // |args[0]| - the name of a source file in source_map_.
   v8::Handle<v8::Value> GetSource(v8::Handle<v8::String> source_name);
@@ -131,6 +171,7 @@ class ModuleSystem : public NativeHandler {
   // Return an object that contains the native methods defined by the named
   // NativeHandler.
   // |args[0]| - the name of a native handler object.
+  v8::Handle<v8::Value> GetNativeFromString(const std::string& native_name);
   v8::Handle<v8::Value> GetNative(const v8::Arguments& args);
 
   // Wraps |source| in a (function(require, requireNative, exports) {...}).