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

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

accessible/tests/mochitest/jsat/dom_helper.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.

 'use strict';
 /* global getMainChromeWindow, AccessFuTest, GestureSettings, GestureTracker,
    SimpleTest, getBoundsForDOMElm, Point, Utils */
 /* exported loadJSON, eventMap */
 const Ci = Components.interfaces;
 const Cu = Components.utils;
 Cu.import('resource://gre/modules/accessibility/Utils.jsm');
 Cu.import('resource://gre/modules/Geometry.jsm');
 Cu.import("resource://gre/modules/accessibility/Gestures.jsm");
 var win = getMainChromeWindow(window);
 /**
  * Convert inch based point coordinates into pixels.
  * @param  {Array} aPoints Array of coordinates in inches.
  * @return {Array} Array of coordinates in pixels.
  */
 function convertPointCoordinates(aPoints) {
   var dpi = Utils.dpi;
   return aPoints.map(function convert(aPoint) {
     return {
       x: aPoint.x * dpi,
       y: aPoint.y * dpi,
       identifier: aPoint.identifier
     };
   });
 }
 /**
  * For a given list of points calculate their coordinates in relation to the
  * document body.
  * @param  {Array} aTouchPoints An array of objects of the following format: {
  *   base: {String}, // Id of an element to server as a base for the touch.
  *   x: {Number},    // An optional x offset from the base element's geometric
  *                   // centre.
  *   y: {Number}     // An optional y offset from the base element's geometric
  *                   // centre.
  * }
  * @return {JSON} An array of {x, y} coordinations.
  */
 function calculateTouchListCoordinates(aTouchPoints) {
   var coords = [];
   for (var i = 0, target = aTouchPoints[i]; i < aTouchPoints.length; ++i) {
     var bounds = getBoundsForDOMElm(target.base);
     var parentBounds = getBoundsForDOMElm('root');
     var point = new Point(target.x || 0, target.y || 0);
     point.scale(Utils.dpi);
     point.add(bounds[0], bounds[1]);
     point.add(bounds[2] / 2, bounds[3] / 2);
     point.subtract(parentBounds[0], parentBounds[0]);
     coords.push({
       x: point.x,
       y: point.y
     });
   }
   return coords;
 }
 /**
  * Send a touch event with specified touchPoints.
  * @param  {Array} aTouchPoints An array of points to be associated with
  * touches.
  * @param  {String} aName A name of the touch event.
  */
 function sendTouchEvent(aTouchPoints, aName) {
   var touchList = sendTouchEvent.touchList;
   if (aName === 'touchend') {
     sendTouchEvent.touchList = null;
   } else {
     var coords = calculateTouchListCoordinates(aTouchPoints);
     var touches = [];
     for (var i = 0; i < coords.length; ++i) {
       var {x, y} = coords[i];
       var node = document.elementFromPoint(x, y);
       var touch = document.createTouch(window, node, aName === 'touchstart' ?
 : touchList.item(i).identifier, x, y, x, y);
       touches.push(touch);
     }
     touchList = document.createTouchList(touches);
     sendTouchEvent.touchList = touchList;
   }
   var evt = document.createEvent('TouchEvent');
   evt.initTouchEvent(aName, true, true, window, 0, false, false, false, false,
     touchList, touchList, touchList);
   document.dispatchEvent(evt);
 }
 sendTouchEvent.touchList = null;
 /**
  * A map of event names to the functions that actually send them.
  * @type {Object}
  */
 var eventMap = {
   touchstart: sendTouchEvent,
   touchend: sendTouchEvent,
   touchmove: sendTouchEvent
 };
 var originalDwellThreshold = GestureSettings.dwellThreshold;
 var originalSwipeMaxDuration = GestureSettings.swipeMaxDuration;
 /**
  * Attach a listener for the mozAccessFuGesture event that tests its
  * type.
  * @param  {Array} aExpectedGestures A stack of expected event types.
  * Note: the listener is removed once the stack reaches 0.
  */
 function testMozAccessFuGesture(aExpectedGestures) {
   var types = typeof aExpectedGestures === "string" ?
     [aExpectedGestures] : aExpectedGestures;
   function handleGesture(aEvent) {
     if (aEvent.detail.type !== types[0]) {
       // The is not the event of interest.
       return;
     }
     ok(true, 'Received correct mozAccessFuGesture: ' + types.shift() + '.');
     if (types.length === 0) {
       win.removeEventListener('mozAccessFuGesture', handleGesture);
       if (AccessFuTest.sequenceCleanup) {
         AccessFuTest.sequenceCleanup();
       }
       AccessFuTest.nextTest();
     }
   }
   win.addEventListener('mozAccessFuGesture', handleGesture);
 }
 /**
  * Reset the thresholds and max delays that affect gesture rejection.
  * @param {Number} aTimeStamp Gesture time stamp.
  * @param {Boolean} aRemoveDwellThreshold An optional flag to reset dwell
  * threshold.
  * @param {Boolean} aRemoveSwipeMaxDuration An optional flag to reset swipe max
  * duration.
  */
 function setTimers(aTimeStamp, aRemoveDwellThreshold, aRemoveSwipeMaxDuration) {
   if (!aRemoveDwellThreshold && !aRemoveSwipeMaxDuration) {
     return;
   }
   if (aRemoveDwellThreshold) {
     GestureSettings.dwellThreshold = 0;
   }
   if (aRemoveSwipeMaxDuration) {
     GestureSettings.swipeMaxDuration = 0;
   }
   GestureTracker.current.clearTimer();
   GestureTracker.current.startTimer(aTimeStamp);
 }
 function resetTimers() {
   GestureSettings.dwellThreshold = originalDwellThreshold;
   GestureSettings.swipeMaxDuration = originalSwipeMaxDuration;
 }
 /**
  * An extention to AccessFuTest that adds an ability to test a sequence of
  * pointer events and their expected mozAccessFuGesture events.
  * @param {Object} aSequence An object that has a list of pointer events to be
  * generated and the expected mozAccessFuGesture events.
  */
 AccessFuTest.addSequence = function AccessFuTest_addSequence(aSequence) {
   AccessFuTest.addFunc(function testSequence() {
     testMozAccessFuGesture(aSequence.expectedGestures);
     var events = aSequence.events;
     function fireEvent(aEvent) {
       var event = {
         points: convertPointCoordinates(aEvent.points),
         type: aEvent.type
       };
       var timeStamp = Date.now();
       resetTimers();
       GestureTracker.handle(event, timeStamp);
       setTimers(timeStamp, aEvent.removeDwellThreshold,
         aEvent.removeSwipeMaxDuration);
       processEvents();
     }
     function processEvents() {
       if (events.length === 0) {
         return;
       }
       var event = events.shift();
       SimpleTest.executeSoon(function() {
         fireEvent(event);
       });
     }
     processEvents();
   });
 };
 /**
  * A helper function that loads JSON files.
  * @param {String} aPath A path to a JSON file.
  * @param {Function} aCallback A callback to be called on success.
  */
 function loadJSON(aPath, aCallback) {
   var request = new XMLHttpRequest();
   request.open('GET', aPath, true);
   request.responseType = 'json';
   request.onload = function onload() {
     aCallback(request.response);
   };
   request.send();
 }