Lazy load chrome.* APIs

chrome/renderer/extensions/module_system.h

 // 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.
 
 #ifndef CHROME_RENDERER_EXTENSIONS_MODULE_SYSTEM_H_
 #define CHROME_RENDERER_EXTENSIONS_MODULE_SYSTEM_H_
 
 #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>
 #include <set>
 #include <string>
 
 namespace extensions {
 
 // A module system for JS similar to node.js' require() function.
 // Each module has three variables in the global scope:
 //   - exports, an object returned to dependencies who require() this
 //     module.
 //   - require, a function that takes a module name as an argument and returns
 //     that module's exports object.
 //   - requireNative, a function that takes the name of a registered
 //     NativeHandler and returns an object that contains the functions the
 //     NativeHandler defines.
 //
 // Each module in a ModuleSystem is executed at most once and its exports
 // object cached.
 //
 // 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:
     virtual ~SourceMap() {}
     virtual v8::Handle<v8::Value> GetSource(const std::string& name) = 0;
     virtual bool Contains(const std::string& name) = 0;
   };
 
   class ExceptionHandler {
    public:
@@ skipping 17 matching lines @@
   virtual ~ModuleSystem();
 
   // Returns true if the current context has a ModuleSystem installed in it.
   static bool IsPresentInCurrentContext();
 
   // Dumps the debug info from |try_catch| to LOG(ERROR).
   static void DumpException(const v8::TryCatch& try_catch);
 
   // 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.

 
   // Calls the specified method exported by the specified module. This is
   // equivalent to calling require('module_name').method_name() from JS.
   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
   // tests to mock out native modules.
   void OverrideNativeHandler(const std::string& name);
 
   // Executes |code| in the current context with |name| as the filename.
   void RunString(const std::string& code, const std::string& name);
 
   // 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|].
   void SetLazyField(v8::Handle<v8::Object> object,
                     const std::string& field,
                     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();
   }
 
  private:
   typedef std::map<std::string, linked_ptr<NativeHandler> > NativeHandlerMap;
 
   // Called when an exception is thrown but not caught.
   void HandleException(const v8::TryCatch& try_catch);
 
   // Ensure that require_ has been evaluated from require.js.
   void EnsureRequireLoaded();
 
   // Run |code| in the current context with the name |name| used for stack
   // traces.
   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);
 
   // 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) {...}).
   v8::Handle<v8::String> WrapSource(v8::Handle<v8::String> source);
 
   // Throws an exception in the calling JS context.
   v8::Handle<v8::Value> ThrowException(const std::string& message);
 
   // The context that this ModuleSystem is for.
   v8::Persistent<v8::Context> context_;
@@ skipping 13 matching lines @@
   scoped_ptr<ExceptionHandler> exception_handler_;
 
   std::set<std::string> overridden_native_handlers_;
 
   DISALLOW_COPY_AND_ASSIGN(ModuleSystem);
 };
 
 }  // extensions
 
 #endif  // CHROME_RENDERER_EXTENSIONS_MODULE_SYSTEM_H_