Add support for asynchronously loading modules from the background page.

extensions/renderer/resources/utils.js

Index: extensions/renderer/resources/utils.js
diff --git a/extensions/renderer/resources/utils.js b/extensions/renderer/resources/utils.js
index 803a3518d753b271bf740dd982d51d8af86c4720..afcde50cd24999643b7f1648e53f0cbea1d4cae3 100644
--- a/extensions/renderer/resources/utils.js
+++ b/extensions/renderer/resources/utils.js
@@ -7,6 +7,7 @@ var nativeDeepCopy = requireNative('utils').deepCopy;
 var schemaRegistry = requireNative('schema_registry');
 var CHECK = requireNative('logging').CHECK;
 var WARNING = requireNative('logging').WARNING;
+var context = requireNative('v8_context');
 
 /**
  * An object forEach. Calls |f| with each (key, value) pair of |obj|, using
@@ -133,8 +134,45 @@ function deepCopy(value) {
   return nativeDeepCopy(value);
 }
 
+/**
+ * Create an async proxy for the resolved value of |targetPromise|. The returned
+ * object will contain a function for each name in |functionNames|. Calling this
+ * function will result in a call to the corresponding function on the resolved
+ * value of |targetPromise| and returns a promise to the result of that call.
+ */
+function createAsyncProxy(targetPromise, functionNames) {
+  var functionProxies = {};
+  $Array.forEach(functionNames, function(name) {
+    functionProxies[name] = function() {
+      var args = arguments;
+      return targetPromise.then(function(target) {
+        return $Function.apply(target[name], target, args);
+      });
+    };
+  });
+  return functionProxies;
+}
+
+/**
+ * Asynchronously require a module from the background page, loading the
+ * background page if necessary.
+ */
+function requireAsyncFromBackgroundPage(moduleName) {
+  return new Promise(function(resolve, reject) {
+    chrome.runtime.getBackgroundPage(resolve);

[not at google - send to devlin, 2014/08/18 21:22:11]

Promise is neat, but strictly speaking you need to watch out for
chrome.runtime.lastError here and reject the Promise if it's set. It looks like
it can indeed fail:

https://code.google.com/p/chromium/codesearch#chromium/src/extensions/browser...

I think it would help this problem - and just compose better in general - if
there were a utils.promise function which promise-fies an API call? I did
something similar here:

https://github.com/kalman/chrome-extensions/blob/master/snippets/promise.js

but it would be simpler than that. Once you have that function you could do (at
the call site, not in here):

promise(chrome.runtime.getBackgroundPage).then(
  function(bg) {
    return context.GetModuleSystem(bg || window).requireAsync('serial');
  },
  function(err) {
    ???
  }
);

of course it would be nice to support this as a first-class citizen in the
bindings, but that shouldn't block this work :)

This also seems similar to what createAsyncProxy is doing, but that's a little
harder to use (in this context, anyway). You could implement createAsyncProxy in
terms of promise pretty easily.

[Sam McNally, 2014/08/19 01:44:56]

Done. I'd prefer to keep requireAsyncFromBackgroundPage here so we can have a
drop-in replacement for requireAsync.

The async proxy is to skip one side of the promise glue. Instead of something
like
function doSomething() {
  return fooPromise.then(function(foo) {
    return foo.doSomething();
  });
}
we can just refer to "fooProxy.doSomething".

+  }).then(function(backgroundPage) {
+    if (!backgroundPage)
+      backgroundPage = window;
+    return context.GetModuleSystem(backgroundPage).requireAsync(moduleName);
+  }).catch(function(e) {
+    return requireAsync(moduleName);
+  });
+}
+
 exports.forEach = forEach;
 exports.loadTypeSchema = loadTypeSchema;
 exports.lookup = lookup;
 exports.expose = expose;
 exports.deepCopy = deepCopy;
+exports.createAsyncProxy = createAsyncProxy;
+exports.requireAsyncFromBackgroundPage = requireAsyncFromBackgroundPage;