The Tor Browser: docshell/test/chrome/docshell_helpers.js@b8a032363ba2 (annotated)

docshell/test/chrome/docshell_helpers.js@b8a032363ba2 (annotated)

docshell/test/chrome/docshell_helpers.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: -rwxr-xr-x

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

 /**
  * Import common SimpleTest methods so that they're usable in this window.
  */
 var imports = [ "SimpleTest", "is", "isnot", "ise", "ok", "onerror", "todo",
   "todo_is", "todo_isnot" ];
 for each (var name in imports) {
   window[name] = window.opener.wrappedJSObject[name];
 }
 /**
  * Define global constants and variables.
  */
 const NAV_NONE = 0;
 const NAV_BACK = 1;
 const NAV_FORWARD = 2;
 const NAV_URI = 3;
 const NAV_RELOAD = 4;
 var gExpectedEvents;          // an array of events which are expected to
                               // be triggered by this navigation
 var gUnexpectedEvents;        // an array of event names which are NOT expected
                               // to be triggered by this navigation
 var gFinalEvent;              // true if the last expected event has fired
 var gUrisNotInBFCache = [];   // an array of uri's which shouldn't be stored
                               // in the bfcache
 var gNavType = NAV_NONE;      // defines the most recent navigation type
                               // executed by doPageNavigation
 var gOrigMaxTotalViewers =    // original value of max_total_viewers,
   undefined;                  // to be restored at end of test
 var gExtractedPath = null;    //used to cache file path for extracting files from a .jar file
 /**
  * The doPageNavigation() function performs page navigations asynchronously,
  * listens for specified events, and compares actual events with a list of
  * expected events.  When all expected events have occurred, an optional
  * callback can be notified. The parameter passed to this function is an
  * object with the following properties:
  *
  *                uri: if !undefined, the browser will navigate to this uri
  *
  *               back: if true, the browser will execute goBack()
  *
  *            forward: if true, the browser will execute goForward()
  *
  *             reload: if true, the browser will execute reload()
  *
  *  eventsToListenFor: an array containing one or more of the following event
  *                     types to listen for:  "pageshow", "pagehide", "onload",
  *                     "onunload".  If this property is undefined, only a
  *                     single "pageshow" events will be listened for.  If this
  *                     property is explicitly empty, [], then no events will
  *                     be listened for.
  *
  *     expectedEvents: an array of one or more expectedEvent objects,
  *                     corresponding to the events which are expected to be
  *                     fired for this navigation.  Each object has the
  *                     following properties:
  *
  *                          type: one of the event type strings
  *                          title (optional): the title of the window the
  *                              event belongs to
  *                          persisted (optional): the event's expected
  *                              .persisted attribute
  *
  *                     This function will verify that events with the
  *                     specified properties are fired in the same order as
  *                     specified in the array.  If .title or .persisted
  *                     properties for an expectedEvent are undefined, those
  *                     properties will not be verified for that particular
  *                     event.
  *
  *                     This property is ignored if eventsToListenFor is
  *                     undefined or [].
  *
  *     preventBFCache: if true, an unload handler will be added to the loaded
  *                     page to prevent it from being bfcached.  This property
  *                     has no effect when eventsToListenFor is [].
  *
  *      onNavComplete: a callback which is notified after all expected events
  *                     have occurred, or after a timeout has elapsed.  This
  *                     callback is not notified if eventsToListenFor is [].
  *
  * There must be an expectedEvent object for each event of the types in
  * eventsToListenFor which is triggered by this navigation.  For example, if
  * eventsToListenFor = [ "pagehide", "pageshow" ], then expectedEvents
  * must contain an object for each pagehide and pageshow event which occurs as
  * a result of this navigation.
  */
 function doPageNavigation(params) {
   // Parse the parameters.
   let back = params.back ? params.back : false;
   let forward = params.forward ? params.forward : false;
   let reload = params.reload ? params.reload : false;
   let uri = params.uri ? params.uri : false;
   let eventsToListenFor = typeof(params.eventsToListenFor) != "undefined" ?
     params.eventsToListenFor : ["pageshow"];
   gExpectedEvents = typeof(params.eventsToListenFor) == "undefined" ||
     eventsToListenFor.length == 0 ? undefined : params.expectedEvents;
   gUnexpectedEvents = typeof(params.eventsToListenFor) == "undefined" ||
     eventsToListenFor.length == 0 ? undefined : params.unexpectedEvents;
   let preventBFCache = (typeof[params.preventBFCache] == "undefined") ?
     false : params.preventBFCache;
   let waitOnly = (typeof(params.waitForEventsOnly) == "boolean"
     && params.waitForEventsOnly);
   // Do some sanity checking on arguments.
   if (back && forward)
     throw "Can't specify both back and forward";
   if (back && uri)
     throw "Can't specify both back and a uri";
   if (forward && uri)
     throw "Can't specify both forward and a uri";
   if (reload && (forward || back || uri))
     throw "Can't specify reload and another navigation type";
   if (!back && !forward && !uri && !reload && !waitOnly)
     throw "Must specify back or foward or reload or uri";
   if (params.onNavComplete && eventsToListenFor.length == 0)
     throw "Can't use onNavComplete when eventsToListenFor == []";
   if (params.preventBFCache && eventsToListenFor.length == 0)
     throw "Can't use preventBFCache when eventsToListenFor == []";
   if (params.preventBFCache && waitOnly)
     throw "Can't prevent bfcaching when only waiting for events";
   if (waitOnly && typeof(params.onNavComplete) == "undefined")
     throw "Must specify onNavComplete when specifying waitForEventsOnly";
   if (waitOnly && (back || forward || reload || uri))
     throw "Can't specify a navigation type when using waitForEventsOnly";
   for each (let anEventType in eventsToListenFor) {
     let eventFound = false;
     if ( (anEventType == "pageshow") && (!gExpectedEvents) )
       eventFound = true;
     for each (let anExpectedEvent in gExpectedEvents) {
       if (anExpectedEvent.type == anEventType)
         eventFound = true;
     }
     for each (let anExpectedEventType in gUnexpectedEvents) {
       if (anExpectedEventType == anEventType)
         eventFound = true;
     }
     if (!eventFound)
       throw "Event type " + anEventType + " is specified in " +
         "eventsToListenFor, but not in expectedEvents";
   }
   // If the test explicitly sets .eventsToListenFor to [], don't wait for any
   // events.
   gFinalEvent = eventsToListenFor.length == 0 ? true : false;
   // Add an event listener for each type of event in the .eventsToListenFor
   // property of the input parameters.
   for each (let eventType in eventsToListenFor) {
     dump("TEST: registering a listener for " + eventType + " events\n");
     TestWindow.getBrowser().addEventListener(eventType, pageEventListener,
       true);
   }
   // Perform the specified navigation.
   if (back) {
     gNavType = NAV_BACK;
     TestWindow.getBrowser().goBack();
   }
   else if (forward) {
     gNavType = NAV_FORWARD;
     TestWindow.getBrowser().goForward();
   }
   else if (uri) {
     gNavType = NAV_URI;
     TestWindow.getBrowser().loadURI(uri);
   }
   else if (reload) {
     gNavType = NAV_RELOAD;
     TestWindow.getBrowser().reload();
   }
   else if (waitOnly) {
     gNavType = NAV_NONE;
   }
   else {
     throw "No valid navigation type passed to doPageNavigation!";
   }
   // If we're listening for events and there is an .onNavComplete callback,
   // wait for all events to occur, and then call doPageNavigation_complete().
   if (eventsToListenFor.length > 0 && params.onNavComplete)
   {
     waitForTrue(
       function() { return gFinalEvent; },
       function() {
         doPageNavigation_complete(eventsToListenFor, params.onNavComplete,
           preventBFCache);
       } );
   }
 }
 /**
  * Finish doPageNavigation(), by removing event listeners, adding an unload
  * handler if appropriate, and calling the onNavComplete callback.  This
  * function is called after all the expected events for this navigation have
  * occurred.
  */
 function doPageNavigation_complete(eventsToListenFor, onNavComplete,
   preventBFCache) {
   // Unregister our event listeners.
   dump("TEST: removing event listeners\n");
   for each (let eventType in eventsToListenFor) {
     TestWindow.getBrowser().removeEventListener(eventType, pageEventListener,
       true);
   }
   // If the .preventBFCache property was set, add an empty unload handler to
   // prevent the page from being bfcached.
   let uri = TestWindow.getBrowser().currentURI.spec;
   if (preventBFCache) {
     TestWindow.getWindow().addEventListener("unload", function() {
         dump("TEST: Called dummy unload function to prevent page from " +
           "being bfcached.\n");
       }, true);
     // Save the current uri in an array of uri's which shouldn't be
     // stored in the bfcache, for later verification.
     if (!(uri in gUrisNotInBFCache)) {
       gUrisNotInBFCache.push(uri);
     }
   } else if (gNavType == NAV_URI) {
     // If we're navigating to a uri and .preventBFCache was not
     // specified, splice it out of gUrisNotInBFCache if it's there.
     gUrisNotInBFCache.forEach(
       function(element, index, array) {
         if (element == uri) {
           array.splice(index, 1);
         }
       }, this);
   }
   // Notify the callback now that we're done.
   onNavComplete.call();
 }
 /**
  * Allows a test to wait for page navigation events, and notify a
  * callback when they've all been received.  This works exactly the
  * same as doPageNavigation(), except that no navigation is initiated.
  */
 function waitForPageEvents(params) {
   params.waitForEventsOnly = true;
   doPageNavigation(params);
 }
 /**
  * The event listener which listens for expectedEvents.
  */
 function pageEventListener(event) {
   try {
     dump("TEST: eventListener received a " + event.type + " event for page " +
       event.originalTarget.title + ", persisted=" + event.persisted + "\n");
   } catch(e) {
     // Ignore any exception.
   }
   // If this page shouldn't be in the bfcache because it was previously
   // loaded with .preventBFCache, make sure that its pageshow event
   // has .persisted = false, even if the test doesn't explicitly test
   // for .persisted.
   if ( (event.type == "pageshow") &&
     (gNavType == NAV_BACK || gNavType == NAV_FORWARD) ) {
     let uri = TestWindow.getBrowser().currentURI.spec;
     if (uri in gUrisNotInBFCache) {
       ok(!event.persisted, "pageshow event has .persisted = false, even " +
        "though it was loaded with .preventBFCache previously\n");
     }
   }
   if (typeof(gUnexpectedEvents) != "undefined") {
     is(gUnexpectedEvents.indexOf(event.type), -1,
        "Should not get unexpected event " + event.type);
   }
   // If no expected events were specified, mark the final event as having been
   // triggered when a pageshow event is fired; this will allow
   // doPageNavigation() to return.
   if ((typeof(gExpectedEvents) == "undefined") && event.type == "pageshow")
   {
     setTimeout(function() { gFinalEvent = true; }, 0);
     return;
   }
   // If there are explicitly no expected events, but we receive one, it's an
   // error.
   if (gExpectedEvents.length == 0) {
     ok(false, "Unexpected event (" + event.type + ") occurred");
     return;
   }
   // Grab the next expected event, and compare its attributes against the
   // actual event.
   let expected = gExpectedEvents.shift();
   is(event.type, expected.type,
     "A " + expected.type + " event was expected, but a " +
     event.type + " event occurred");
   if (typeof(expected.title) != "undefined") {
     ok(event.originalTarget instanceof HTMLDocument,
        "originalTarget for last " + event.type +
        " event not an HTMLDocument");
     is(event.originalTarget.title, expected.title,
       "A " + event.type + " event was expected for page " +
       expected.title + ", but was fired for page " +
       event.originalTarget.title);
   }
   if (typeof(expected.persisted) != "undefined") {
     is(event.persisted, expected.persisted,
       "The persisted property of the " + event.type + " event on page " +
       event.originalTarget.location + " had an unexpected value");
   }
   if ("visibilityState" in expected) {
     is(event.originalTarget.visibilityState, expected.visibilityState,
        "The visibilityState property of the document on page " +
        event.originalTarget.location + " had an unexpected value");
   }
   if ("hidden" in expected) {
     is(event.originalTarget.hidden, expected.hidden,
        "The hidden property of the document on page " +
        event.originalTarget.location + " had an unexpected value");
   }
   // If we're out of expected events, let doPageNavigation() return.
   if (gExpectedEvents.length == 0)
     setTimeout(function() { gFinalEvent = true; }, 0);
 }
 /**
  * End a test.
  */
 function finish() {
   // Work around bug 467960.
   var history = TestWindow.getBrowser().webNavigation.sessionHistory;
   history.PurgeHistory(history.count);
   // If the test changed the value of max_total_viewers via a call to
   // enableBFCache(), then restore it now.
   if (typeof(gOrigMaxTotalViewers) != "undefined") {
     var prefs = Components.classes["@mozilla.org/preferences-service;1"]
                 .getService(Components.interfaces.nsIPrefBranch);
     prefs.setIntPref("browser.sessionhistory.max_total_viewers",
       gOrigMaxTotalViewers);
   }
   // Close the test window and signal the framework that the test is done.
   let opener = window.opener;
   let SimpleTest = opener.wrappedJSObject.SimpleTest;
   // Wait for the window to be closed before finishing the test
   let ww = Components.classes["@mozilla.org/embedcomp/window-watcher;1"]
 	             .getService(Components.interfaces.nsIWindowWatcher);
   ww.registerNotification(function(subject, topic, data) {
     if (topic == "domwindowclosed") {
       ww.unregisterNotification(arguments.callee);
       SimpleTest.waitForFocus(function() {
         SimpleTest.finish();
       }, opener);
     }
   });
   window.close();
 }
 /**
  * Helper function which waits until another function returns true, or until a
  * timeout occurs, and then notifies a callback.
  *
  * Parameters:
  *
  *    fn: a function which is evaluated repeatedly, and when it turns true,
  *        the onWaitComplete callback is notified.
  *
  *    onWaitComplete:  a callback which will be notified when fn() returns
  *        true, or when a timeout occurs.
  *
  *    timeout: a timeout, in seconds or ms, after which waitForTrue() will
  *        fail an assertion and then return, even if the fn function never
  *        returns true.  If timeout is undefined, waitForTrue() will never
  *        time out.
  */
 function waitForTrue(fn, onWaitComplete, timeout) {
   var start = new Date().valueOf();
   if (typeof(timeout) != "undefined") {
     // If timeoutWait is less than 500, assume it represents seconds, and
     // convert to ms.
     if (timeout < 500)
       timeout *= 1000;
   }
   // Loop until the test function returns true, or until a timeout occurs,
   // if a timeout is defined.
   var intervalid;
   intervalid =
     setInterval(
       function() {
         var timeoutHit = false;
         if (typeof(timeout) != "undefined") {
           timeoutHit = new Date().valueOf() - start >=
             timeout ? true : false;
           if (timeoutHit) {
             ok(false, "Timed out waiting for condition");
           }
         }
         if (timeoutHit || fn.call()) {
           // Stop calling the test function and notify the callback.
           clearInterval(intervalid);
           onWaitComplete.call();
         }
       }, 20);
 }
 /**
  * Enable or disable the bfcache.
  *
  * Parameters:
  *
  *   enable: if true, set max_total_viewers to -1 (the default); if false, set
  *           to 0 (disabled), if a number, set it to that specific number
  */
 function enableBFCache(enable) {
   var prefs = Components.classes["@mozilla.org/preferences-service;1"]
               .getService(Components.interfaces.nsIPrefBranch);
   // If this is the first time the test called enableBFCache(),
   // store the original value of max_total_viewers, so it can
   // be restored at the end of the test.
   if (typeof(gOrigMaxTotalViewers) == "undefined") {
     gOrigMaxTotalViewers =
       prefs.getIntPref("browser.sessionhistory.max_total_viewers");
   }
   if (typeof(enable) == "boolean") {
     if (enable)
       prefs.setIntPref("browser.sessionhistory.max_total_viewers", -1);
     else
       prefs.setIntPref("browser.sessionhistory.max_total_viewers", 0);
   }
   else if (typeof(enable) == "number") {
     prefs.setIntPref("browser.sessionhistory.max_total_viewers", enable);
   }
 }
 /*
  * get http root for local tests.  Use a single extractJarToTmp instead of
  * extracting for each test.
  * Returns a file://path if we have a .jar file
  */
 function getHttpRoot() {
   var location = window.location.href;
   location = getRootDirectory(location);
   var jar = getJar(location);
   if (jar != null) {
     if (gExtractedPath == null) {
       var resolved = extractJarToTmp(jar);
       gExtractedPath = resolved.path;
     }
   } else {
     return null;
   }
   return "file://" + gExtractedPath + '/';
 }
 /**
  * Returns the full HTTP url for a file in the mochitest docshell test
  * directory.
  */
 function getHttpUrl(filename) {
   var root = getHttpRoot();
   if (root == null) {
     root = "http://mochi.test:8888/chrome/docshell/test/chrome/";
   }
   return root + filename;
 }
 /**
  * A convenience object with methods that return the current test window,
  * browser, and document.
  */
 var TestWindow = {};
 TestWindow.getWindow = function () {
   return document.getElementById("content").contentWindow;
 }
 TestWindow.getBrowser = function () {
   return document.getElementById("content");
 }
 TestWindow.getDocument = function () {
   return document.getElementById("content").contentDocument;
 }