The Tor Browser: accessible/tests/mochitest/jsat/jsatcommon.js@97036ab72558 (annotated)

accessible/tests/mochitest/jsat/jsatcommon.js@97036ab72558 (annotated)

accessible/tests/mochitest/jsat/jsatcommon.js

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 // A common module to run tests on the AccessFu module
 'use strict';
 /*global isDeeply, getMainChromeWindow, SimpleTest, SpecialPowers, Logger,
   AccessFu, Utils, addMessageListener, currentTabDocument, currentBrowser*/
 /**
   * A global variable holding an array of test functions.
   */
 var gTestFuncs = [];
 /**
   * A global Iterator for the array of test functions.
   */
 var gIterator;
 Components.utils.import('resource://gre/modules/Services.jsm');
 Components.utils.import("resource://gre/modules/accessibility/Utils.jsm");
 Components.utils.import("resource://gre/modules/accessibility/EventManager.jsm");
 Components.utils.import("resource://gre/modules/accessibility/Gestures.jsm");
 const dwellThreshold = GestureSettings.dwellThreshold;
 const swipeMaxDuration = GestureSettings.swipeMaxDuration;
 const maxConsecutiveGestureDelay = GestureSettings.maxConsecutiveGestureDelay;
 // https://bugzilla.mozilla.org/show_bug.cgi?id=1001945 - sometimes
 // SimpleTest.executeSoon timeout is bigger than the timer settings in
 // GestureSettings that causes intermittents.
 GestureSettings.dwellThreshold = dwellThreshold * 10;
 GestureSettings.swipeMaxDuration = swipeMaxDuration * 10;
 GestureSettings.maxConsecutiveGestureDelay = maxConsecutiveGestureDelay * 10;
 var AccessFuTest = {
   addFunc: function AccessFuTest_addFunc(aFunc) {
     if (aFunc) {
       gTestFuncs.push(aFunc);
     }
   },
   _registerListener: function AccessFuTest__registerListener(aWaitForMessage, aListenerFunc) {
     var listener = {
       observe: function observe(aMessage) {
         // Ignore unexpected messages.
         if (!(aMessage instanceof Components.interfaces.nsIConsoleMessage)) {
           return;
         }
         if (aMessage.message.indexOf(aWaitForMessage) < 0) {
           return;
         }
         aListenerFunc.apply(listener);
       }
     };
     Services.console.registerListener(listener);
     return listener;
   },
   on_log: function AccessFuTest_on_log(aWaitForMessage, aListenerFunc) {
     return this._registerListener(aWaitForMessage, aListenerFunc);
   },
   off_log: function AccessFuTest_off_log(aListener) {
     Services.console.unregisterListener(aListener);
   },
   once_log: function AccessFuTest_once_log(aWaitForMessage, aListenerFunc) {
     return this._registerListener(aWaitForMessage,
       function listenAndUnregister() {
         Services.console.unregisterListener(this);
         aListenerFunc();
       });
   },
   _addObserver: function AccessFuTest__addObserver(aWaitForData, aListener) {
     var listener = function listener(aSubject, aTopic, aData) {
       var data = JSON.parse(aData)[1];
       // Ignore non-relevant outputs.
       if (!data) {
         return;
       }
       isDeeply(data.details.actions, aWaitForData, "Data is correct");
       aListener.apply(listener);
     };
     Services.obs.addObserver(listener, 'accessfu-output', false);
     return listener;
   },
   on: function AccessFuTest_on(aWaitForData, aListener) {
     return this._addObserver(aWaitForData, aListener);
   },
   off: function AccessFuTest_off(aListener) {
     Services.obs.removeObserver(aListener, 'accessfu-output');
   },
   once: function AccessFuTest_once(aWaitForData, aListener) {
     return this._addObserver(aWaitForData, function observerAndRemove() {
       Services.obs.removeObserver(this, 'accessfu-output');
       aListener();
     });
   },
   _waitForExplicitFinish: false,
   waitForExplicitFinish: function AccessFuTest_waitForExplicitFinish() {
     this._waitForExplicitFinish = true;
   },
   finish: function AccessFuTest_finish() {
     // Disable the console service logging.
     Logger.test = false;
     Logger.logLevel = Logger.INFO;
     // Reset Gesture Settings.
     GestureSettings.dwellThreshold = dwellThreshold;
     GestureSettings.swipeMaxDuration = swipeMaxDuration;
     GestureSettings.maxConsecutiveGestureDelay = maxConsecutiveGestureDelay;
     // Finish through idle callback to let AccessFu._disable complete.
     SimpleTest.executeSoon(function () {
       AccessFu.detach();
       SimpleTest.finish();
     });
   },
   nextTest: function AccessFuTest_nextTest() {
     var testFunc;
     try {
       // Get the next test function from the iterator. If none left,
       // StopIteration exception is thrown.
       testFunc = gIterator.next()[1];
     } catch (ex) {
       // StopIteration exception.
       this.finish();
       return;
     }
     testFunc();
   },
   runTests: function AccessFuTest_runTests() {
     if (gTestFuncs.length === 0) {
       ok(false, "No tests specified!");
       SimpleTest.finish();
       return;
     }
     // Create an Iterator for gTestFuncs array.
     gIterator = Iterator(gTestFuncs); // jshint ignore:line
     // Start AccessFu and put it in stand-by.
     Components.utils.import("resource://gre/modules/accessibility/AccessFu.jsm");
     AccessFu.attach(getMainChromeWindow(window));
     AccessFu.readyCallback = function readyCallback() {
       // Enable logging to the console service.
       Logger.test = true;
       Logger.logLevel = Logger.DEBUG;
     };
     SpecialPowers.pushPrefEnv({
       'set': [['accessibility.accessfu.notify_output', 1],
               ['dom.mozSettings.enabled', true]]
     }, function () {
       if (AccessFuTest._waitForExplicitFinish) {
         // Run all test functions asynchronously.
         AccessFuTest.nextTest();
       } else {
         // Run all test functions synchronously.
         [testFunc() for (testFunc of gTestFuncs)]; // jshint ignore:line
         AccessFuTest.finish();
       }
     });
   }
 };
 function AccessFuContentTest(aFuncResultPairs) {
   this.queue = aFuncResultPairs;
 }
 AccessFuContentTest.prototype = {
   currentPair: null,
   start: function(aFinishedCallback) {
     Logger.logLevel = Logger.DEBUG;
     this.finishedCallback = aFinishedCallback;
     var self = this;
     // Get top content message manager, and set it up.
     this.mms = [Utils.getMessageManager(currentBrowser())];
     this.setupMessageManager(this.mms[0], function () {
       // Get child message managers and set them up
       var frames = currentTabDocument().querySelectorAll('iframe');
       if (frames.length === 0) {
         self.pump();
         return;
       }
       var toSetup = 0;
       for (var i = 0; i < frames.length; i++ ) {
         var mm = Utils.getMessageManager(frames[i]);
         if (mm) {
           toSetup++;
           self.mms.push(mm);
           self.setupMessageManager(mm, function () {
             if (--toSetup === 0) {
               // All message managers are loaded and ready to go.
               self.pump();
             }
           });
         }
       }
     });
   },
   finish: function() {
     Logger.logLevel = Logger.INFO;
     for (var mm of this.mms) {
         mm.sendAsyncMessage('AccessFu:Stop');
       }
     if (this.finishedCallback) {
       this.finishedCallback();
     }
   },
   setupMessageManager:  function (aMessageManager, aCallback) {
     function contentScript() {
       addMessageListener('AccessFuTest:Focus', function (aMessage) {
         var elem = content.document.querySelector(aMessage.json.selector);
         if (elem) {
           if (aMessage.json.blur) {
             elem.blur();
           } else {
             elem.focus();
           }
         }
       });
     }
     aMessageManager.addMessageListener('AccessFu:Present', this);
     aMessageManager.addMessageListener('AccessFu:CursorCleared', this);
     aMessageManager.addMessageListener('AccessFu:Ready', function () {
       aMessageManager.addMessageListener('AccessFu:ContentStarted', aCallback);
       aMessageManager.sendAsyncMessage('AccessFu:Start',
         { buildApp: 'browser',
           androidSdkVersion: Utils.AndroidSdkVersion,
           logLevel: 'DEBUG' });
     });
     aMessageManager.loadFrameScript(
       'chrome://global/content/accessibility/content-script.js', false);
     aMessageManager.loadFrameScript(
       'data:,(' + contentScript.toString() + ')();', false);
   },
   pump: function() {
     this.currentPair = this.queue.shift();
     if (this.currentPair) {
       if (this.currentPair[0] instanceof Function) {
         this.currentPair[0](this.mms[0]);
       } else if (this.currentPair[0]) {
         this.mms[0].sendAsyncMessage(this.currentPair[0].name,
          this.currentPair[0].json);
       }
       if (!this.currentPair[1]) {
        this.pump();
      }
     } else {
       this.finish();
     }
   },
   receiveMessage: function(aMessage) {
     if (!this.currentPair) {
       return;
     }
     var expected = this.currentPair[1] || {};
     // |expected| can simply be a name of a message, no more further testing.
     if (aMessage.name === expected) {
       ok(true, 'Received ' + expected);
       this.pump();
       return;
     }
     var speech = this.extractUtterance(aMessage.json);
     var android = this.extractAndroid(aMessage.json, expected.android);
     if ((speech && expected.speak) || (android && expected.android)) {
       if (expected.speak) {
         (SimpleTest[expected.speak_checkFunc] || is)(speech, expected.speak,
           '"' + speech + '" spoken');
       }
       if (expected.android) {
         var checkFunc = SimpleTest[expected.android_checkFunc] || ok;
         checkFunc.apply(SimpleTest,
           this.lazyCompare(android, expected.android));
       }
       this.pump();
     }
   },
   lazyCompare: function lazyCompare(aReceived, aExpected) {
     var matches = true;
     var delta = [];
     for (var attr in aExpected) {
       var expected = aExpected[attr];
       var received = aReceived !== undefined ? aReceived[attr] : null;
       if (typeof expected === 'object') {
         var [childMatches, childDelta] = this.lazyCompare(received, expected);
         if (!childMatches) {
           delta.push(attr + ' [ ' + childDelta + ' ]');
           matches = false;
         }
       } else {
         if (received !== expected) {
           delta.push(
             attr + ' [ expected ' + expected + ' got ' + received + ' ]');
           matches = false;
         }
       }
     }
     return [matches, delta.join(' ')];
   },
   extractUtterance: function(aData) {
     if (!aData) {
       return null;
     }
     for (var output of aData) {
       if (output && output.type === 'Speech') {
         for (var action of output.details.actions) {
           if (action && action.method == 'speak') {
             return action.data;
           }
         }
       }
     }
     return null;
   },
   extractAndroid: function(aData, aExpectedEvents) {
     for (var output of aData) {
       if (output && output.type === 'Android') {
         for (var i in output.details) {
           // Only extract if event types match expected event types.
           var exp = aExpectedEvents ? aExpectedEvents[i] : null;
           if (!exp || (output.details[i].eventType !== exp.eventType)) {
             return null;
           }
         }
         return output.details;
       }
     }
     return null;
   }
 };
 // Common content messages
 var ContentMessages = {
   simpleMoveFirst: {
     name: 'AccessFu:MoveCursor',
     json: {
       action: 'moveFirst',
       rule: 'Simple',
       inputType: 'gesture',
       origin: 'top'
     }
   },
   simpleMoveLast: {
     name: 'AccessFu:MoveCursor',
     json: {
       action: 'moveLast',
       rule: 'Simple',
       inputType: 'gesture',
       origin: 'top'
     }
   },
   simpleMoveNext: {
     name: 'AccessFu:MoveCursor',
     json: {
       action: 'moveNext',
       rule: 'Simple',
       inputType: 'gesture',
       origin: 'top'
     }
   },
   simpleMovePrevious: {
     name: 'AccessFu:MoveCursor',
     json: {
       action: 'movePrevious',
       rule: 'Simple',
       inputType: 'gesture',
       origin: 'top'
     }
   },
   clearCursor: {
     name: 'AccessFu:ClearCursor',
     json: {
       origin: 'top'
     }
   },
   adjustRangeUp: {
     name: 'AccessFu:AdjustRange',
     json: {
       origin: 'top',
       direction: 'backward'
     }
   },
   adjustRangeDown: {
     name: 'AccessFu:AdjustRange',
     json: {
       origin: 'top',
       direction: 'forward'
     }
   },
   focusSelector: function focusSelector(aSelector, aBlur) {
     return {
       name: 'AccessFuTest:Focus',
       json: {
         selector: aSelector,
         blur: aBlur
       }
     };
   },
   activateCurrent: function activateCurrent(aOffset) {
     return {
       name: 'AccessFu:Activate',
       json: {
         origin: 'top',
         offset: aOffset
       }
     };
   },
   moveNextBy: function moveNextBy(aGranularity) {
     return {
       name: 'AccessFu:MoveByGranularity',
       json: {
         direction: 'Next',
         granularity: this._granularityMap[aGranularity]
       }
     };
   },
   movePreviousBy: function movePreviousBy(aGranularity) {
     return {
       name: 'AccessFu:MoveByGranularity',
       json: {
         direction: 'Previous',
         granularity: this._granularityMap[aGranularity]
       }
     };
   },
   moveCaretNextBy: function moveCaretNextBy(aGranularity) {
     return {
       name: 'AccessFu:MoveCaret',
       json: {
         direction: 'Next',
         granularity: this._granularityMap[aGranularity]
       }
     };
   },
   moveCaretPreviousBy: function moveCaretPreviousBy(aGranularity) {
     return {
       name: 'AccessFu:MoveCaret',
       json: {
         direction: 'Previous',
         granularity: this._granularityMap[aGranularity]
       }
     };
   },
   _granularityMap: {
     'character': 1, // MOVEMENT_GRANULARITY_CHARACTER
     'word': 2, // MOVEMENT_GRANULARITY_WORD
     'paragraph': 8 // MOVEMENT_GRANULARITY_PARAGRAPH
   }
 };
 var AndroidEvent = {
   VIEW_CLICKED: 0x01,
   VIEW_LONG_CLICKED: 0x02,
   VIEW_SELECTED: 0x04,
   VIEW_FOCUSED: 0x08,
   VIEW_TEXT_CHANGED: 0x10,
   WINDOW_STATE_CHANGED: 0x20,
   VIEW_HOVER_ENTER: 0x80,
   VIEW_HOVER_EXIT: 0x100,
   VIEW_SCROLLED: 0x1000,
   VIEW_TEXT_SELECTION_CHANGED: 0x2000,
   ANNOUNCEMENT: 0x4000,
   VIEW_ACCESSIBILITY_FOCUSED: 0x8000,
   VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY: 0x20000
 };