Add support for asynchronously loading modules from the background page.

extensions/renderer/resources/utils.js

 // Copyright 2014 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.
 
 var createClassWrapper = requireNative('utils').createClassWrapper;
 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
  * |self| as the target.
  * @param {Object} obj The object to iterate over.
  * @param {function} f The function to call in each iteration.
  * @param {Object} self The object to use as |this| in each function call.
  */
 function forEach(obj, f, self) {
   for (var key in obj) {
@@ skipping 106 matching lines @@
 }
 
 /**
  * Returns a deep copy of |value|. The copy will have no references to nested
  * values of |value|.
  */
 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;