Implement a module system for the extension bindings JS.

chrome/renderer/resources/require.js

 // 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.
 
 // This file should define a function that returns a require() method that can
 // be used to load JS modules.
 //
 // A module works the same as modules in node.js - JS script that populates
 // an exports object, which is what require()ers get returned. The JS in a
 // module will be run at most once as the exports result is cached.
@@ skipping 15 matching lines @@
 
 function ModuleLoader() {
   this.cache_ = {};
 };
 
 ModuleLoader.prototype.run = function(id) {
   var source = bootstrap.GetSource(id);
   if (!source) {
     return null;
   }
   var wrappedSource = wrap(source);

[Aaron Boodman, 2012/03/01 07:24:26]

Unless v8 does something fancy internally, it seems like this will end up making
a copy of the big string that you went to such trouble to avoid allocating in
the first place.

If you just required the modules to be wrapped in the source, it would avoid
this problem, and you could make the interface between require.js and
ModuleSystem a bit simpler by just having Run(id), not GetSource(id) and
Run(id).

Alternately, there could be some build-time magic to do the wrapping. Or, we
could just say screw it and allocate the strings once and cache them across the
process thereafter.

[Aaron Boodman, 2012/03/01 07:30:32]

I feel pretty strongly that the right answer here is to wrap the code within the
source of each module. That would simplify things.

[koz (OOO until 15th September), 2012/03/02 01:13:58]

As discussed, I've reimplemented with "new Function(...)" on the JS side.

-  var f = bootstrap.Run(wrappedSource);
+  var f = bootstrap.Run(wrappedSource, id);
   var exports = {};
   f(require, requireNative, exports);
   return exports;
 };
 
 ModuleLoader.prototype.load = function(id) {
   var exports = this.cache_[id];
   if (exports) {
     return exports;
   }
   exports = this.run(id);
   this.cache_[id] = exports;
   return exports;
 };
 
 var moduleLoader = new ModuleLoader();
 
 function requireNative(nativeName) {
-  return bootstrap.GetNative(nativeName);
+  var result = bootstrap.GetNative(nativeName);
+  if (!result) {
+    throw "No such native object: '" + nativeName + "'";
+  }
+  return result;
 }
 
 function require(moduleId) {
   return moduleLoader.load(moduleId);
 }
 
 return require;
 });