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..edf7703b3d1f9383c1a9b39034ed273fc704a915 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,62 @@ function deepCopy(value) {
   return nativeDeepCopy(value);
 }
 
+/**
+ * Wrap an asynchronous API call in a promise.

[not at google - send to devlin, 2014/08/19 19:23:38]

Explain how the call happens. I presume that |arg| manipulating is so that you
could do something like:

promise(chrome.storage.get, 'a').then(function(result) {
  console.log('got ' + result);
});

so... explain that. You might also want to DCHECK (logging.DCHECK) that the
first argument is indeed a function.

[Sam McNally, 2014/08/20 01:27:18]

Done.

+ */
+function promise(func) {
+  var args = $Array.slice(arguments, 1);
+  return new Promise(function(resolve, reject) {
+    args.push(function() {
+      if (chrome.runtime.lastError) {
+        reject(new Error(chrome.runtime.lastError));
+        return;
+      }
+      if (arguments.length <= 1)
+        resolve(arguments[0]);
+      else
+        resolve($Array.slice(arguments));

[not at google - send to devlin, 2014/08/19 19:23:38]

This doesn't seem right; so if there are multiple results, they're put in an
array? Should you be calling $Function.apply(resolve, null, arguments)?

[Sam McNally, 2014/08/20 01:27:18]

Promises only support one argument.

[not at google - send to devlin, 2014/08/20 01:47:22]

Yikes. THE MORE YOU KNOW.

+    });
+    $Function.apply(func, null, args);
+  });
+}
+
+/**
+ * Asynchronously require a module from the background page, loading the
+ * background page if necessary.

[not at google - send to devlin, 2014/08/19 19:23:38]

You might actually want to explain why you need this method at all. Why would
you want to require from the background page rather than the current page? Seems
very specialised.

[Sam McNally, 2014/08/20 01:27:18]

Done and moved it into serial_custom_bindings.

+ */
+function requireAsyncFromBackgroundPage(moduleName) {
+  return promise(chrome.runtime.getBackgroundPage).then(function(bgPage) {
+    return context.GetModuleSystem(bgPage).requireAsync(moduleName);
+  }).catch(function() {
+    return requireAsync(moduleName);
+  });
+}
+
+/**
+ * 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) {

[not at google - send to devlin, 2014/08/19 19:23:38]

I'm having a hard time grasping what this method does, and I think it's the
name, it's very generic. Maybe it would help if you called it
createPromiseProxy? Even the "proxy" part is hard to parse. Maybe toPromiseAPI?

[Sam McNally, 2014/08/20 01:27:18]

Fair enough. Removed it and inlined the uses.

+  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;
+}
+
 exports.forEach = forEach;
 exports.loadTypeSchema = loadTypeSchema;
 exports.lookup = lookup;
 exports.expose = expose;
 exports.deepCopy = deepCopy;
+exports.promise = promise;
+exports.requireAsyncFromBackgroundPage = requireAsyncFromBackgroundPage;
+exports.createAsyncProxy = createAsyncProxy;