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);
 }
 
+/**
+ * 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;