michael@0: /* Any copyright is dedicated to the public domain.
michael@0:    http://creativecommons.org/publicdomain/zero/1.0/ */
michael@0: 
michael@0: // Helpers for managing the browser frame preferences.
michael@0: "use strict";
michael@0: 
michael@0: function _getPath() {
michael@0:   return window.location.pathname
michael@0:                .substring(0, window.location.pathname.lastIndexOf('/'))
michael@0:                .replace("/priority", "");
michael@0: }
michael@0: 
michael@0: const browserElementTestHelpers = {
michael@0:   _getBoolPref: function(pref) {
michael@0:     try {
michael@0:       return SpecialPowers.getBoolPref(pref);
michael@0:     }
michael@0:     catch (e) {
michael@0:       return undefined;
michael@0:     }
michael@0:   },
michael@0: 
michael@0:   _setPref: function(pref, value) {
michael@0:     this.lockTestReady();
michael@0:     if (value !== undefined && value !== null) {
michael@0:       SpecialPowers.pushPrefEnv({'set': [[pref, value]]}, this.unlockTestReady.bind(this));
michael@0:     } else {
michael@0:       SpecialPowers.pushPrefEnv({'clear': [[pref]]}, this.unlockTestReady.bind(this));
michael@0:     }
michael@0:   },
michael@0: 
michael@0:   _setPrefs: function() {
michael@0:     this.lockTestReady();
michael@0:     SpecialPowers.pushPrefEnv({'set': Array.slice(arguments)}, this.unlockTestReady.bind(this));
michael@0:   },
michael@0: 
michael@0:   _testReadyLockCount: 0,
michael@0:   _firedTestReady: false,
michael@0:   lockTestReady: function() {
michael@0:     this._testReadyLockCount++;
michael@0:   },
michael@0: 
michael@0:   unlockTestReady: function() {
michael@0:     this._testReadyLockCount--;
michael@0:     if (this._testReadyLockCount == 0 && !this._firedTestReady) {
michael@0:       this._firedTestReady = true;
michael@0:       dispatchEvent(new Event("testready"));
michael@0:     }
michael@0:   },
michael@0: 
michael@0:   enableProcessPriorityManager: function() {
michael@0:     this._setPrefs(
michael@0:       ['dom.ipc.processPriorityManager.testMode', true],
michael@0:       ['dom.ipc.processPriorityManager.enabled', true],
michael@0:       ['dom.ipc.processPriorityManager.backgroundLRUPoolLevels', 2]
michael@0:     );
michael@0:   },
michael@0: 
michael@0:   setEnabledPref: function(value) {
michael@0:     this._setPref('dom.mozBrowserFramesEnabled', value);
michael@0:   },
michael@0: 
michael@0:   getOOPByDefaultPref: function() {
michael@0:     return this._getBoolPref("dom.ipc.browser_frames.oop_by_default");
michael@0:   },
michael@0: 
michael@0:   addPermission: function() {
michael@0:     SpecialPowers.addPermission("browser", true, document);
michael@0:     this.tempPermissions.push(location.href)
michael@0:   },
michael@0: 
michael@0:   'tempPermissions': [],
michael@0:   addPermissionForUrl: function(url) {
michael@0:     SpecialPowers.addPermission("browser", true, url);
michael@0:     this.tempPermissions.push(url);
michael@0:   },
michael@0: 
michael@0:   _observers: [],
michael@0: 
michael@0:   // This function is a wrapper which lets you register an observer to one of
michael@0:   // the process priority manager's test-only topics.  observerFn should be a
michael@0:   // function which takes (subject, topic, data).
michael@0:   //
michael@0:   // We'll clean up any observers you add at the end of the test.
michael@0:   addProcessPriorityObserver: function(processPriorityTopic, observerFn) {
michael@0:     var topic = "process-priority-manager:TEST-ONLY:" + processPriorityTopic;
michael@0: 
michael@0:     // SpecialPowers appears to require that the observer be an object, not a
michael@0:     // function.
michael@0:     var observer = {
michael@0:       observe: observerFn
michael@0:     };
michael@0: 
michael@0:     SpecialPowers.addObserver(observer, topic, /* weak = */ false);
michael@0:     this._observers.push([observer, topic]);
michael@0:   },
michael@0: 
michael@0:   cleanUp: function() {
michael@0:     for (var i = 0; i < this.tempPermissions.length; i++) {
michael@0:       SpecialPowers.removePermission("browser", this.tempPermissions[i]);
michael@0:     }
michael@0: 
michael@0:     for (var i = 0; i < this._observers.length; i++) {
michael@0:       SpecialPowers.removeObserver(this._observers[i][0],
michael@0:                                    this._observers[i][1]);
michael@0:     }
michael@0:   },
michael@0: 
michael@0:   // Some basically-empty pages from different domains you can load.
michael@0:   'emptyPage1': 'http://example.com' + _getPath() + '/file_empty.html',
michael@0:   'emptyPage2': 'http://example.org' + _getPath() + '/file_empty.html',
michael@0:   'emptyPage3': 'http://test1.example.org' + _getPath() + '/file_empty.html',
michael@0:   'focusPage': 'http://example.org' + _getPath() + '/file_focus.html',
michael@0: };
michael@0: 
michael@0: // Returns a promise which is resolved when a subprocess is created.  The
michael@0: // argument to resolve() is the childID of the subprocess.
michael@0: function expectProcessCreated() {
michael@0:   var deferred = Promise.defer();
michael@0: 
michael@0:   var observed = false;
michael@0:   browserElementTestHelpers.addProcessPriorityObserver(
michael@0:     "process-created",
michael@0:     function(subject, topic, data) {
michael@0:       // Don't run this observer twice, so we don't ok(true) twice.  (It's fine
michael@0:       // to resolve a promise twice; the second resolve() call does nothing.)
michael@0:       if (observed) {
michael@0:         return;
michael@0:       }
michael@0:       observed = true;
michael@0: 
michael@0:       var childID = parseInt(data);
michael@0:       ok(true, 'Got new process, id=' + childID);
michael@0:       deferred.resolve(childID);
michael@0:     }
michael@0:   );
michael@0: 
michael@0:   return deferred.promise;
michael@0: }
michael@0: 
michael@0: // Just like expectProcessCreated(), except we'll call ok(false) if a second
michael@0: // process is created.
michael@0: function expectOnlyOneProcessCreated() {
michael@0:   var p = expectProcessCreated();
michael@0:   p.then(function() {
michael@0:     expectProcessCreated().then(function(childID) {
michael@0:       ok(false, 'Got unexpected process creation, childID=' + childID);
michael@0:     });
michael@0:   });
michael@0:   return p;
michael@0: }
michael@0: 
michael@0: // Returns a promise which is resolved or rejected the next time the process
michael@0: // childID changes its priority.  We resolve if the (priority, CPU priority)
michael@0: // tuple matches (expectedPriority, expectedCPUPriority) and we reject
michael@0: // otherwise.
michael@0: //
michael@0: // expectedCPUPriority is an optional argument; if it's not specified, we
michael@0: // resolve if priority matches expectedPriority.
michael@0: 
michael@0: function expectPriorityChange(childID, expectedPriority,
michael@0:                               /* optional */ expectedCPUPriority) {
michael@0:   var deferred = Promise.defer();
michael@0: 
michael@0:   var observed = false;
michael@0:   browserElementTestHelpers.addProcessPriorityObserver(
michael@0:     'process-priority-set',
michael@0:     function(subject, topic, data) {
michael@0:       if (observed) {
michael@0:         return;
michael@0:       }
michael@0: 
michael@0:       var [id, priority, cpuPriority] = data.split(":");
michael@0:       if (id != childID) {
michael@0:         return;
michael@0:       }
michael@0: 
michael@0:       // Make sure we run the is() calls in this observer only once, otherwise
michael@0:       // we'll expect /every/ priority change to match expectedPriority.
michael@0:       observed = true;
michael@0: 
michael@0:       is(priority, expectedPriority,
michael@0:          'Expected priority of childID ' + childID +
michael@0:          ' to change to ' + expectedPriority);
michael@0: 
michael@0:       if (expectedCPUPriority) {
michael@0:         is(cpuPriority, expectedCPUPriority,
michael@0:            'Expected CPU priority of childID ' + childID +
michael@0:            ' to change to ' + expectedCPUPriority);
michael@0:       }
michael@0: 
michael@0:       if (priority == expectedPriority &&
michael@0:           (!expectedCPUPriority || expectedCPUPriority == cpuPriority)) {
michael@0:         deferred.resolve();
michael@0:       } else {
michael@0:         deferred.reject();
michael@0:       }
michael@0:     }
michael@0:   );
michael@0: 
michael@0:   return deferred.promise;
michael@0: }
michael@0: 
michael@0: // Returns a promise which is resolved or rejected the next time the background
michael@0: // process childID changes its priority.  We resolve if the backgroundLRU
michael@0: // matches expectedBackgroundLRU and we reject otherwise.
michael@0: 
michael@0: function expectPriorityWithBackgroundLRUSet(childID, expectedBackgroundLRU) {
michael@0:   var deferred = Promise.defer();
michael@0: 
michael@0:   browserElementTestHelpers.addProcessPriorityObserver(
michael@0:     'process-priority-with-background-LRU-set',
michael@0:     function(subject, topic, data) {
michael@0: 
michael@0:       var [id, priority, cpuPriority, backgroundLRU] = data.split(":");
michael@0:       if (id != childID) {
michael@0:         return;
michael@0:       }
michael@0: 
michael@0:       is(backgroundLRU, expectedBackgroundLRU,
michael@0:          'Expected backgroundLRU ' + backgroundLRU + ' of childID ' + childID +
michael@0:          ' to change to ' + expectedBackgroundLRU);
michael@0: 
michael@0:       if (backgroundLRU == expectedBackgroundLRU) {
michael@0:         deferred.resolve();
michael@0:       } else {
michael@0:         deferred.reject();
michael@0:       }
michael@0:     }
michael@0:   );
michael@0: 
michael@0:   return deferred.promise;
michael@0: }
michael@0: 
michael@0: // Returns a promise which is resolved the first time the given iframe fires
michael@0: // the mozbrowser##eventName event.
michael@0: function expectMozbrowserEvent(iframe, eventName) {
michael@0:   var deferred = Promise.defer();
michael@0:   iframe.addEventListener('mozbrowser' + eventName, function handler(e) {
michael@0:     iframe.removeEventListener('mozbrowser' + eventName, handler);
michael@0:     deferred.resolve(e);
michael@0:   });
michael@0:   return deferred.promise;
michael@0: }
michael@0: 
michael@0: // Set some prefs:
michael@0: //
michael@0: //  * browser.pagethumbnails.capturing_disabled: true
michael@0: //
michael@0: //    Disable tab view; it seriously messes us up.
michael@0: //
michael@0: //  * dom.ipc.browser_frames.oop_by_default
michael@0: //
michael@0: //    Enable or disable OOP-by-default depending on the test's filename.  You
michael@0: //    can still force OOP on or off with <iframe mozbrowser remote=true/false>,
michael@0: //    at least until bug 756376 lands.
michael@0: //
michael@0: //  * dom.ipc.tabs.disabled: false
michael@0: //
michael@0: //    Allow us to create OOP frames.  Even if they're not the default, some
michael@0: //    "in-process" tests create OOP frames.
michael@0: //
michael@0: //  * network.disable.ipc.security: true
michael@0: //
michael@0: //    Disable the networking security checks; our test harness just tests
michael@0: //    browser elements without sticking them in apps, and the security checks
michael@0: //    dislike that.
michael@0: //
michael@0: //    Unfortunately setting network.disable.ipc.security to false before the
michael@0: //    child process(es) created by this test have shut down can cause us to
michael@0: //    assert and kill the child process.  That doesn't cause the tests to fail,
michael@0: //    but it's still scary looking.  So we just set the pref to true and never
michael@0: //    pop that value.  We'll rely on the tests which test IPC security to set
michael@0: //    it to false.
michael@0: //
michael@0: //  * security.mixed_content.block_active_content: false
michael@0: //
michael@0: //    Disable mixed active content blocking, so that tests can confirm that mixed
michael@0: //    content results in a broken security state.
michael@0: 
michael@0: (function() {
michael@0:   var oop = location.pathname.indexOf('_inproc_') == -1;
michael@0: 
michael@0:   browserElementTestHelpers.lockTestReady();
michael@0:   SpecialPowers.setBoolPref("network.disable.ipc.security", true);
michael@0:   SpecialPowers.pushPrefEnv({set: [["browser.pagethumbnails.capturing_disabled", true],
michael@0:                                    ["dom.ipc.browser_frames.oop_by_default", oop],
michael@0:                                    ["dom.ipc.tabs.disabled", false],
michael@0:                                    ["security.mixed_content.block_active_content", false]]},
michael@0:                             browserElementTestHelpers.unlockTestReady.bind(browserElementTestHelpers));
michael@0: })();
michael@0: 
michael@0: addEventListener('unload', function() {
michael@0:   browserElementTestHelpers.cleanUp();
michael@0: });
michael@0: 
michael@0: // Wait for the load event before unlocking the test-ready event.
michael@0: browserElementTestHelpers.lockTestReady();
michael@0: addEventListener('load', function() {
michael@0:   SimpleTest.executeSoon(browserElementTestHelpers.unlockTestReady.bind(browserElementTestHelpers));
michael@0: });
michael@0: 
michael@0: //////////////////////////////////
michael@0: // promise.js from the addon SDK with some modifications to the module
michael@0: // boilerplate.
michael@0: //////////////////////////////////
michael@0: 
michael@0: ;(function(id, factory) { // Module boilerplate :(
michael@0:     var globals = this;
michael@0:     factory(function require(id) {
michael@0:       return globals[id];
michael@0:     }, (globals[id] = {}), { uri: document.location.href + '#' + id, id: id });
michael@0: }).call(this, 'Promise', function Promise(require, exports, module) {
michael@0: 
michael@0: 'use strict';
michael@0: 
michael@0: module.metadata = {
michael@0:   "stability": "unstable"
michael@0: };
michael@0: 
michael@0: /**
michael@0:  * Internal utility: Wraps given `value` into simplified promise, successfully
michael@0:  * fulfilled to a given `value`. Note the result is not a complete promise
michael@0:  * implementation, as its method `then` does not returns anything.
michael@0:  */
michael@0: function fulfilled(value) {
michael@0:   return { then: function then(fulfill) { fulfill(value); } };
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * Internal utility: Wraps given input into simplified promise, pre-rejected
michael@0:  * with a given `reason`. Note the result is not a complete promise
michael@0:  * implementation, as its method `then` does not returns anything.
michael@0:  */
michael@0: function rejected(reason) {
michael@0:   return { then: function then(fulfill, reject) { reject(reason); } };
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * Internal utility: Returns `true` if given `value` is a promise. Value is
michael@0:  * assumed to be a promise if it implements method `then`.
michael@0:  */
michael@0: function isPromise(value) {
michael@0:   return value && typeof(value.then) === 'function';
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * Creates deferred object containing fresh promise & methods to either resolve
michael@0:  * or reject it. The result is an object with the following properties:
michael@0:  * - `promise` Eventual value representation implementing CommonJS [Promises/A]
michael@0:  *   (http://wiki.commonjs.org/wiki/Promises/A) API.
michael@0:  * - `resolve` Single shot function that resolves enclosed `promise` with a
michael@0:  *   given `value`.
michael@0:  * - `reject` Single shot function that rejects enclosed `promise` with a given
michael@0:  *   `reason`.
michael@0:  *
michael@0:  * An optional `prototype` argument is used as a prototype of the returned
michael@0:  * `promise` allowing one to implement additional API. If prototype is not
michael@0:  * passed then it falls back to `Object.prototype`.
michael@0:  *
michael@0:  *  ## Example
michael@0:  *
michael@0:  *  function fetchURI(uri, type) {
michael@0:  *    var deferred = defer();
michael@0:  *    var request = new XMLHttpRequest();
michael@0:  *    request.open("GET", uri, true);
michael@0:  *    request.responseType = type;
michael@0:  *    request.onload = function onload() {
michael@0:  *      deferred.resolve(request.response);
michael@0:  *    }
michael@0:  *    request.onerror = function(event) {
michael@0:  *     deferred.reject(event);
michael@0:  *    }
michael@0:  *    request.send();
michael@0:  *
michael@0:  *    return deferred.promise;
michael@0:  *  }
michael@0:  */
michael@0: function defer(prototype) {
michael@0:   // Define FIFO queue of observer pairs. Once promise is resolved & all queued
michael@0:   // observers are forwarded to `result` and variable is set to `null`.
michael@0:   var observers = [];
michael@0: 
michael@0:   // Promise `result`, which will be assigned a resolution value once promise
michael@0:   // is resolved. Note that result will always be assigned promise (or alike)
michael@0:   // object to take care of propagation through promise chains. If result is
michael@0:   // `null` promise is not resolved yet.
michael@0:   var result = null;
michael@0: 
michael@0:   prototype = (prototype || prototype === null) ? prototype : Object.prototype;
michael@0: 
michael@0:   // Create an object implementing promise API.
michael@0:   var promise = Object.create(prototype, {
michael@0:     then: { value: function then(onFulfill, onError) {
michael@0:       var deferred = defer(prototype);
michael@0: 
michael@0:       function resolve(value) {
michael@0:         // If `onFulfill` handler is provided resolve `deferred.promise` with
michael@0:         // result of invoking it with a resolution value. If handler is not
michael@0:         // provided propagate value through.
michael@0:         try {
michael@0:           deferred.resolve(onFulfill ? onFulfill(value) : value);
michael@0:         }
michael@0:         // `onFulfill` may throw exception in which case resulting promise
michael@0:         // is rejected with thrown exception.
michael@0:         catch(error) {
michael@0:           if (exports._reportErrors && typeof(console) === 'object')
michael@0:             console.error(error);
michael@0:           // Note: Following is equivalent of `deferred.reject(error)`,
michael@0:           // we use this shortcut to reduce a stack.
michael@0:           deferred.resolve(rejected(error));
michael@0:         }
michael@0:       }
michael@0: 
michael@0:       function reject(reason) {
michael@0:         try {
michael@0:           if (onError) deferred.resolve(onError(reason));
michael@0:           else deferred.resolve(rejected(reason));
michael@0:         }
michael@0:         catch(error) {
michael@0:           if (exports._reportErrors && typeof(console) === 'object')
michael@0:             console.error(error)
michael@0:           deferred.resolve(rejected(error));
michael@0:         }
michael@0:       }
michael@0: 
michael@0:       // If enclosed promise (`this.promise`) observers queue is still alive
michael@0:       // enqueue a new observer pair into it. Note that this does not
michael@0:       // necessary means that promise is pending, it may already be resolved,
michael@0:       // but we still have to queue observers to guarantee an order of
michael@0:       // propagation.
michael@0:       if (observers) {
michael@0:         observers.push({ resolve: resolve, reject: reject });
michael@0:       }
michael@0:       // Otherwise just forward observer pair right to a `result` promise.
michael@0:       else {
michael@0:         result.then(resolve, reject);
michael@0:       }
michael@0: 
michael@0:       return deferred.promise;
michael@0:     }}
michael@0:   })
michael@0: 
michael@0:   var deferred = {
michael@0:     promise: promise,
michael@0:     /**
michael@0:      * Resolves associated `promise` to a given `value`, unless it's already
michael@0:      * resolved or rejected. Note that resolved promise is not necessary a
michael@0:      * successfully fulfilled. Promise may be resolved with a promise `value`
michael@0:      * in which case `value` promise's fulfillment / rejection will propagate
michael@0:      * up to a promise resolved with `value`.
michael@0:      */
michael@0:     resolve: function resolve(value) {
michael@0:       if (!result) {
michael@0:         // Store resolution `value` in a `result` as a promise, so that all
michael@0:         // the subsequent handlers can be simply forwarded to it. Since
michael@0:         // `result` will be a promise all the value / error propagation will
michael@0:         // be uniformly taken care of.
michael@0:         result = isPromise(value) ? value : fulfilled(value);
michael@0: 
michael@0:         // Forward already registered observers to a `result` promise in the
michael@0:         // order they were registered. Note that we intentionally dequeue
michael@0:         // observer at a time until queue is exhausted. This makes sure that
michael@0:         // handlers registered as side effect of observer forwarding are
michael@0:         // queued instead of being invoked immediately, guaranteeing FIFO
michael@0:         // order.
michael@0:         while (observers.length) {
michael@0:           var observer = observers.shift();
michael@0:           result.then(observer.resolve, observer.reject);
michael@0:         }
michael@0: 
michael@0:         // Once `observers` queue is exhausted we `null`-ify it, so that
michael@0:         // new handlers are forwarded straight to the `result`.
michael@0:         observers = null;
michael@0:       }
michael@0:     },
michael@0:     /**
michael@0:      * Rejects associated `promise` with a given `reason`, unless it's already
michael@0:      * resolved / rejected. This is just a (better performing) convenience
michael@0:      * shortcut for `deferred.resolve(reject(reason))`.
michael@0:      */
michael@0:     reject: function reject(reason) {
michael@0:       // Note that if promise is resolved that does not necessary means that it
michael@0:       // is successfully fulfilled. Resolution value may be a promise in which
michael@0:       // case its result propagates. In other words if promise `a` is resolved
michael@0:       // with promise `b`, `a` is either fulfilled or rejected depending
michael@0:       // on weather `b` is fulfilled or rejected. Here `deferred.promise` is
michael@0:       // resolved with a promise pre-rejected with a given `reason`, there for
michael@0:       // `deferred.promise` is rejected with a given `reason`. This may feel
michael@0:       // little awkward first, but doing it this way greatly simplifies
michael@0:       // propagation through promise chains.
michael@0:       deferred.resolve(rejected(reason));
michael@0:     }
michael@0:   };
michael@0: 
michael@0:   return deferred;
michael@0: }
michael@0: exports.defer = defer;
michael@0: 
michael@0: /**
michael@0:  * Returns a promise resolved to a given `value`. Optionally a second
michael@0:  * `prototype` argument may be provided to be used as a prototype for the
michael@0:  * returned promise.
michael@0:  */
michael@0: function resolve(value, prototype) {
michael@0:   var deferred = defer(prototype);
michael@0:   deferred.resolve(value);
michael@0:   return deferred.promise;
michael@0: }
michael@0: exports.resolve = resolve;
michael@0: 
michael@0: /**
michael@0:  * Returns a promise rejected with a given `reason`. Optionally a second
michael@0:  * `prototype` argument may be provided to be used as a prototype for the
michael@0:  * returned promise.
michael@0:  */
michael@0: function reject(reason, prototype) {
michael@0:   var deferred = defer(prototype);
michael@0:   deferred.reject(reason);
michael@0:   return deferred.promise;
michael@0: }
michael@0: exports.reject = reject;
michael@0: 
michael@0: var promised = (function() {
michael@0:   // Note: Define shortcuts and utility functions here in order to avoid
michael@0:   // slower property accesses and unnecessary closure creations on each
michael@0:   // call of this popular function.
michael@0: 
michael@0:   var call = Function.call;
michael@0:   var concat = Array.prototype.concat;
michael@0: 
michael@0:   // Utility function that does following:
michael@0:   // execute([ f, self, args...]) => f.apply(self, args)
michael@0:   function execute(args) { return call.apply(call, args) }
michael@0: 
michael@0:   // Utility function that takes promise of `a` array and maybe promise `b`
michael@0:   // as arguments and returns promise for `a.concat(b)`.
michael@0:   function promisedConcat(promises, unknown) {
michael@0:     return promises.then(function(values) {
michael@0:       return resolve(unknown).then(function(value) {
michael@0:         return values.concat([ value ])
michael@0:       });
michael@0:     });
michael@0:   }
michael@0: 
michael@0:   return function promised(f, prototype) {
michael@0:     /**
michael@0:     Returns a wrapped `f`, which when called returns a promise that resolves to
michael@0:     `f(...)` passing all the given arguments to it, which by the way may be
michael@0:     promises. Optionally second `prototype` argument may be provided to be used
michael@0:     a prototype for a returned promise.
michael@0: 
michael@0:     ## Example
michael@0: 
michael@0:     var promise = promised(Array)(1, promise(2), promise(3))
michael@0:     promise.then(console.log) // => [ 1, 2, 3 ]
michael@0:     **/
michael@0: 
michael@0:     return function promised() {
michael@0:       // create array of [ f, this, args... ]
michael@0:       return concat.apply([ f, this ], arguments).
michael@0:         // reduce it via `promisedConcat` to get promised array of fulfillments
michael@0:         reduce(promisedConcat, resolve([], prototype)).
michael@0:         // finally map that to promise of `f.apply(this, args...)`
michael@0:         then(execute);
michael@0:     }
michael@0:   }
michael@0: })();
michael@0: exports.promised = promised;
michael@0: 
michael@0: var all = promised(Array);
michael@0: exports.all = all;
michael@0: 
michael@0: });