The Tor Browser: dom/browser-element/mochitest/browserElementTestHelpers.js@b8a032363ba2 (annotated)

dom/browser-element/mochitest/browserElementTestHelpers.js@b8a032363ba2 (annotated)

dom/browser-element/mochitest/browserElementTestHelpers.js

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

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