Add m-esr52 at 52.6.0

1 files changed, 956 insertions, 0 deletions

diff --git a/accessible/jsat/Gestures.jsm b/accessible/jsat/Gestures.jsm
new file mode 100644
index 000000000..cc431614c
--- /dev/null
+++ b/accessible/jsat/Gestures.jsm
@@ -0,0 +1,956 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* global Components, GestureSettings, XPCOMUtils, Utils, Promise, Logger */
+/* exported GestureSettings, GestureTracker */
+
+/******************************************************************************
+  All gestures have the following pathways when being resolved(v)/rejected(x):
+               Tap -> DoubleTap        (x)
+                   -> Dwell            (x)
+                   -> Swipe            (x)
+
+         DoubleTap -> TripleTap        (x)
+                   -> TapHold          (x)
+
+         TripleTap -> DoubleTapHold    (x)
+
+             Dwell -> DwellEnd         (v)
+
+             Swipe -> Explore          (x)
+
+           TapHold -> TapHoldEnd       (v)
+
+     DoubleTapHold -> DoubleTapHoldEnd (v)
+
+          DwellEnd -> Explore          (x)
+
+        TapHoldEnd -> Explore          (x)
+
+  DoubleTapHoldEnd -> Explore          (x)
+
+        ExploreEnd -> Explore          (x)
+
+           Explore -> ExploreEnd       (v)
+******************************************************************************/
+
+'use strict';
+
+const Cu = Components.utils;
+
+this.EXPORTED_SYMBOLS = ['GestureSettings', 'GestureTracker']; // jshint ignore:line
+
+Cu.import('resource://gre/modules/XPCOMUtils.jsm');
+
+XPCOMUtils.defineLazyModuleGetter(this, 'Utils', // jshint ignore:line
+  'resource://gre/modules/accessibility/Utils.jsm');
+XPCOMUtils.defineLazyModuleGetter(this, 'Logger', // jshint ignore:line
+  'resource://gre/modules/accessibility/Utils.jsm');
+XPCOMUtils.defineLazyModuleGetter(this, 'setTimeout', // jshint ignore:line
+  'resource://gre/modules/Timer.jsm');
+XPCOMUtils.defineLazyModuleGetter(this, 'clearTimeout', // jshint ignore:line
+  'resource://gre/modules/Timer.jsm');
+XPCOMUtils.defineLazyModuleGetter(this, 'Promise', // jshint ignore:line
+  'resource://gre/modules/Promise.jsm');
+
+// Default maximum duration of swipe
+const SWIPE_MAX_DURATION = 200;
+// Default maximum amount of time allowed for a gesture to be considered a
+// multitouch
+const MAX_MULTITOUCH = 125;
+// Default maximum consecutive pointer event timeout
+const MAX_CONSECUTIVE_GESTURE_DELAY = 200;
+// Default delay before tap turns into dwell
+const DWELL_THRESHOLD = 250;
+// Minimal swipe distance in inches
+const SWIPE_MIN_DISTANCE = 0.4;
+// Maximum distance the pointer could move during a tap in inches
+const TAP_MAX_RADIUS = 0.2;
+// Directness coefficient. It is based on the maximum 15 degree angle between
+// consequent pointer move lines.
+const DIRECTNESS_COEFF = 1.44;
+// Amount in inches from the edges of the screen for it to be an edge swipe
+const EDGE = 0.1;
+// Multiply timeouts by this constant, x2 works great too for slower users.
+const TIMEOUT_MULTIPLIER = 1;
+// A single pointer down/up sequence periodically precedes the tripple swipe
+// gesture on Android. This delay acounts for that.
+const IS_ANDROID = Utils.MozBuildApp === 'mobile/android' &&
+  Utils.AndroidSdkVersion >= 14;
+
+/**
+ * A point object containing distance travelled data.
+ * @param {Object} aPoint A point object that looks like: {
+ *   x: x coordinate in pixels,
+ *   y: y coordinate in pixels
+ * }
+ */
+function Point(aPoint) {
+  this.startX = this.x = aPoint.x;
+  this.startY = this.y = aPoint.y;
+  this.distanceTraveled = 0;
+  this.totalDistanceTraveled = 0;
+}
+
+Point.prototype = {
+  /**
+   * Update the current point coordiates.
+   * @param  {Object} aPoint A new point coordinates.
+   */
+  update: function Point_update(aPoint) {
+    let lastX = this.x;
+    let lastY = this.y;
+    this.x = aPoint.x;
+    this.y = aPoint.y;
+    this.distanceTraveled = this.getDistanceToCoord(lastX, lastY);
+    this.totalDistanceTraveled += this.distanceTraveled;
+  },
+
+  reset: function Point_reset() {
+    this.distanceTraveled = 0;
+    this.totalDistanceTraveled = 0;
+  },
+
+  /**
+   * Get distance between the current point coordinates and the given ones.
+   * @param  {Number} aX A pixel value for the x coordinate.
+   * @param  {Number} aY A pixel value for the y coordinate.
+   * @return {Number} A distance between point's current and the given
+   * coordinates.
+   */
+  getDistanceToCoord: function Point_getDistanceToCoord(aX, aY) {
+    return Math.hypot(this.x - aX, this.y - aY);
+  },
+
+  /**
+   * Get the direct distance travelled by the point so far.
+   */
+  get directDistanceTraveled() {
+    return this.getDistanceToCoord(this.startX, this.startY);
+  }
+};
+
+/**
+ * An externally accessible collection of settings used in gesture resolition.
+ * @type {Object}
+ */
+this.GestureSettings = { // jshint ignore:line
+  /**
+   * Maximum duration of swipe
+   * @type {Number}
+   */
+  swipeMaxDuration: SWIPE_MAX_DURATION * TIMEOUT_MULTIPLIER,
+
+  /**
+   * Maximum amount of time allowed for a gesture to be considered a multitouch.
+   * @type {Number}
+   */
+  maxMultitouch: MAX_MULTITOUCH * TIMEOUT_MULTIPLIER,
+
+  /**
+   * Maximum consecutive pointer event timeout.
+   * @type {Number}
+   */
+  maxConsecutiveGestureDelay:
+    MAX_CONSECUTIVE_GESTURE_DELAY * TIMEOUT_MULTIPLIER,
+
+  /**
+   * A maximum time we wait for a next pointer down event to consider a sequence
+   * a multi-action gesture.
+   * @type {Number}
+   */
+  maxGestureResolveTimeout:
+    MAX_CONSECUTIVE_GESTURE_DELAY * TIMEOUT_MULTIPLIER,
+
+  /**
+   * Delay before tap turns into dwell
+   * @type {Number}
+   */
+  dwellThreshold: DWELL_THRESHOLD * TIMEOUT_MULTIPLIER,
+
+  /**
+   * Minimum distance that needs to be travelled for the pointer move to be
+   * fired.
+   * @type {Number}
+   */
+  travelThreshold: 0.025
+};
+
+/**
+ * An interface that handles the pointer events and calculates the appropriate
+ * gestures.
+ * @type {Object}
+ */
+this.GestureTracker = { // jshint ignore:line
+  /**
+   * Reset GestureTracker to its initial state.
+   * @return {[type]} [description]
+   */
+  reset: function GestureTracker_reset() {
+    if (this.current) {
+      this.current.clearTimer();
+    }
+    delete this.current;
+  },
+
+  /**
+   * Create a new gesture object and attach resolution handler to it as well as
+   * handle the incoming pointer event.
+   * @param  {Object} aDetail A new pointer event detail.
+   * @param  {Number} aTimeStamp A new pointer event timeStamp.
+   * @param  {Function} aGesture A gesture constructor (default: Tap).
+   */
+  _init: function GestureTracker__init(aDetail, aTimeStamp, aGesture) {
+    // Only create a new gesture on |pointerdown| event.
+    if (aDetail.type !== 'pointerdown') {
+      return;
+    }
+    let GestureConstructor = aGesture || (IS_ANDROID ? DoubleTap : Tap);
+    this._create(GestureConstructor);
+    this._update(aDetail, aTimeStamp);
+  },
+
+  /**
+   * Handle the incoming pointer event with the existing gesture object(if
+   * present) or with the newly created one.
+   * @param  {Object} aDetail A new pointer event detail.
+   * @param  {Number} aTimeStamp A new pointer event timeStamp.
+   */
+  handle: function GestureTracker_handle(aDetail, aTimeStamp) {
+    Logger.gesture(() => {
+      return ['Pointer event', Utils.dpi, 'at:', aTimeStamp, JSON.stringify(aDetail)];
+    });
+    this[this.current ? '_update' : '_init'](aDetail, aTimeStamp);
+  },
+
+  /**
+   * Create a new gesture object and attach resolution handler to it.
+   * @param  {Function} aGesture A gesture constructor.
+   * @param  {Number} aTimeStamp An original pointer event timeStamp.
+   * @param  {Array} aPoints All changed points associated with the new pointer
+   * event.
+   * @param {?String} aLastEvent Last pointer event type.
+   */
+  _create: function GestureTracker__create(aGesture, aTimeStamp, aPoints, aLastEvent) {
+    this.current = new aGesture(aTimeStamp, aPoints, aLastEvent); /* A constructor name should start with an uppercase letter. */ // jshint ignore:line
+    this.current.then(this._onFulfill.bind(this));
+  },
+
+  /**
+   * Handle the incoming pointer event with the existing gesture object.
+   * @param  {Object} aDetail A new pointer event detail.
+   * @param  {Number} aTimeStamp A new pointer event timeStamp.
+   */
+  _update: function GestureTracker_update(aDetail, aTimeStamp) {
+    this.current[aDetail.type](aDetail.points, aTimeStamp);
+  },
+
+  /**
+   * A resolution handler function for the current gesture promise.
+   * @param  {Object} aResult A resolution payload with the relevant gesture id
+   * and an optional new gesture contructor.
+   */
+  _onFulfill: function GestureTracker__onFulfill(aResult) {
+    let {id, gestureType} = aResult;
+    let current = this.current;
+    // Do nothing if there's no existing gesture or there's already a newer
+    // gesture.
+    if (!current || current.id !== id) {
+      return;
+    }
+    // Only create a gesture if we got a constructor.
+    if (gestureType) {
+      this._create(gestureType, current.startTime, current.points,
+        current.lastEvent);
+    } else {
+      this.current.clearTimer();
+      delete this.current;
+    }
+  }
+};
+
+/**
+ * Compile a mozAccessFuGesture detail structure.
+ * @param  {String} aType A gesture type.
+ * @param  {Object} aPoints Gesture's points.
+ * @param  {String} xKey A default key for the x coordinate. Default is
+ * 'startX'.
+ * @param  {String} yKey A default key for the y coordinate. Default is
+ * 'startY'.
+ * @return {Object} a mozAccessFuGesture detail structure.
+ */
+function compileDetail(aType, aPoints, keyMap = {x: 'startX', y: 'startY'}) {
+  let touches = [];
+  let maxDeltaX = 0;
+  let maxDeltaY = 0;
+  for (let identifier in aPoints) {
+    let point = aPoints[identifier];
+    let touch = {};
+    for (let key in keyMap) {
+      touch[key] = point[keyMap[key]];
+    }
+    touches.push(touch);
+    let deltaX = point.x - point.startX;
+    let deltaY = point.y - point.startY;
+    // Determine the maximum x and y travel intervals.
+    if (Math.abs(maxDeltaX) < Math.abs(deltaX)) {
+      maxDeltaX = deltaX;
+    }
+    if (Math.abs(maxDeltaY) < Math.abs(deltaY)) {
+      maxDeltaY = deltaY;
+    }
+    // Since the gesture is resolving, reset the points' distance information
+    // since they are passed to the next potential gesture.
+    point.reset();
+  }
+  return {
+    type: aType,
+    touches: touches,
+    deltaX: maxDeltaX,
+    deltaY: maxDeltaY
+  };
+}
+
+/**
+ * A general gesture object.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * Default is an empty object.
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function Gesture(aTimeStamp, aPoints = {}, aLastEvent = undefined) {
+  this.startTime = Date.now();
+  Logger.gesture('Creating', this.id, 'gesture.');
+  this.points = aPoints;
+  this.lastEvent = aLastEvent;
+  this._deferred = Promise.defer();
+  // Call this._handleResolve or this._handleReject when the promise is
+  // fulfilled with either resolve or reject.
+  this.promise = this._deferred.promise.then(this._handleResolve.bind(this),
+    this._handleReject.bind(this));
+  this.startTimer(aTimeStamp);
+}
+
+Gesture.prototype = {
+  /**
+   * Get the gesture timeout delay.
+   * @return {Number}
+   */
+  _getDelay: function Gesture__getDelay() {
+    // If nothing happens withing the
+    // GestureSettings.maxConsecutiveGestureDelay, we should not wait for any
+    // more pointer events and consider them the part of the same gesture -
+    // reject this gesture promise.
+    return GestureSettings.maxConsecutiveGestureDelay;
+  },
+
+  /**
+   * Clear the existing timer.
+   */
+  clearTimer: function Gesture_clearTimer() {
+    Logger.gesture('clearTimeout', this.type);
+    clearTimeout(this._timer);
+    delete this._timer;
+  },
+
+  /**
+   * Start the timer for gesture timeout.
+   * @param {Number} aTimeStamp An original pointer event's timeStamp that
+   * started the gesture resolution sequence.
+   */
+  startTimer: function Gesture_startTimer(aTimeStamp) {
+    Logger.gesture('startTimer', this.type);
+    this.clearTimer();
+    let delay = this._getDelay(aTimeStamp);
+    let handler = () => {
+      Logger.gesture('timer handler');
+      this.clearTimer();
+      if (!this._inProgress) {
+        this._deferred.reject();
+      } else if (this._rejectToOnWait) {
+        this._deferred.reject(this._rejectToOnWait);
+      }
+    };
+    if (delay <= 0) {
+      handler();
+    } else {
+      this._timer = setTimeout(handler, delay);
+    }
+  },
+
+  /**
+   * Add a gesture promise resolution callback.
+   * @param  {Function} aCallback
+   */
+  then: function Gesture_then(aCallback) {
+    this.promise.then(aCallback);
+  },
+
+  /**
+   * Update gesture's points. Test the points set with the optional gesture test
+   * function.
+   * @param  {Array} aPoints An array with the changed points from the new
+   * pointer event.
+   * @param {String} aType Pointer event type.
+   * @param  {Boolean} aCanCreate A flag that enables including the new points.
+   * Default is false.
+   * @param  {Boolean} aNeedComplete A flag that indicates that the gesture is
+   * completing. Default is false.
+   * @return {Boolean} Indicates whether the gesture can be complete (it is
+   * set to true iff the aNeedComplete is true and there was a change to at
+   * least one point that belongs to the gesture).
+   */
+  _update: function Gesture__update(aPoints, aType, aCanCreate = false, aNeedComplete = false) {
+    let complete;
+    let lastEvent;
+    for (let point of aPoints) {
+      let identifier = point.identifier;
+      let gesturePoint = this.points[identifier];
+      if (gesturePoint) {
+        if (aType === 'pointerdown' && aCanCreate) {
+          // scratch the previous pointer with that id.
+          this.points[identifier] = new Point(point);
+        } else {
+          gesturePoint.update(point);
+        }
+        if (aNeedComplete) {
+          // Since the gesture is completing and at least one of the gesture
+          // points is updated, set the return value to true.
+          complete = true;
+        }
+        lastEvent = lastEvent || aType;
+      } else if (aCanCreate) {
+        // Only create a new point if aCanCreate is true.
+        this.points[identifier] =
+          new Point(point);
+        lastEvent = lastEvent || aType;
+      }
+    }
+    this.lastEvent = lastEvent || this.lastEvent;
+    // If test function is defined test the points.
+    if (this.test) {
+      this.test(complete);
+    }
+    return complete;
+  },
+
+  /**
+   * Emit a mozAccessFuGesture (when the gesture is resolved).
+   * @param  {Object} aDetail a compiled mozAccessFuGesture detail structure.
+   */
+  _emit: function Gesture__emit(aDetail) {
+    let evt = new Utils.win.CustomEvent('mozAccessFuGesture', {
+      bubbles: true,
+      cancelable: true,
+      detail: aDetail
+    });
+    Utils.win.dispatchEvent(evt);
+  },
+
+  /**
+   * Handle the pointer down event.
+   * @param  {Array} aPoints A new pointer down points.
+   * @param  {Number} aTimeStamp A new pointer down timeStamp.
+   */
+  pointerdown: function Gesture_pointerdown(aPoints, aTimeStamp) {
+    this._inProgress = true;
+    this._update(aPoints, 'pointerdown',
+      aTimeStamp - this.startTime < GestureSettings.maxMultitouch);
+  },
+
+  /**
+   * Handle the pointer move event.
+   * @param  {Array} aPoints A new pointer move points.
+   */
+  pointermove: function Gesture_pointermove(aPoints) {
+    this._update(aPoints, 'pointermove');
+  },
+
+  /**
+   * Handle the pointer up event.
+   * @param  {Array} aPoints A new pointer up points.
+   */
+  pointerup: function Gesture_pointerup(aPoints) {
+    let complete = this._update(aPoints, 'pointerup', false, true);
+    if (complete) {
+      this._deferred.resolve();
+    }
+  },
+
+  /**
+   * A subsequent gesture constructor to resolve the current one to. E.g.
+   * tap->doubletap, dwell->dwellend, etc.
+   * @type {Function}
+   */
+  resolveTo: null,
+
+  /**
+   * A unique id for the gesture. Composed of the type + timeStamp.
+   */
+  get id() {
+    delete this._id;
+    this._id = this.type + this.startTime;
+    return this._id;
+  },
+
+  /**
+   * A gesture promise resolve callback. Compile and emit the gesture.
+   * @return {Object} Returns a structure to the gesture handler that looks like
+   * this: {
+   *   id: current gesture id,
+   *   gestureType: an optional subsequent gesture constructor.
+   * }
+   */
+  _handleResolve: function Gesture__handleResolve() {
+    if (this.isComplete) {
+      return;
+    }
+    Logger.gesture('Resolving', this.id, 'gesture.');
+    this.isComplete = true;
+    this.clearTimer();
+    let detail = this.compile();
+    if (detail) {
+      this._emit(detail);
+    }
+    return {
+      id: this.id,
+      gestureType: this.resolveTo
+    };
+  },
+
+  /**
+   * A gesture promise reject callback.
+   * @return {Object} Returns a structure to the gesture handler that looks like
+   * this: {
+   *   id: current gesture id,
+   *   gestureType: an optional subsequent gesture constructor.
+   * }
+   */
+  _handleReject: function Gesture__handleReject(aRejectTo) {
+    if (this.isComplete) {
+      return;
+    }
+    Logger.gesture('Rejecting', this.id, 'gesture.');
+    this.isComplete = true;
+    this.clearTimer();
+    return {
+      id: this.id,
+      gestureType: aRejectTo
+    };
+  },
+
+  /**
+   * A default compilation function used to build the mozAccessFuGesture event
+   * detail. The detail always includes the type and the touches associated
+   * with the gesture.
+   * @return {Object} Gesture event detail.
+   */
+  compile: function Gesture_compile() {
+    return compileDetail(this.type, this.points);
+  }
+};
+
+/**
+ * A mixin for an explore related object.
+ */
+function ExploreGesture() {
+  this.compile = () => {
+    // Unlike most of other gestures explore based gestures compile using the
+    // current point position and not the start one.
+    return compileDetail(this.type, this.points, {x: 'x', y: 'y'});
+  };
+}
+
+/**
+ * Check the in progress gesture for completion.
+ */
+function checkProgressGesture(aGesture) {
+  aGesture._inProgress = true;
+  if (aGesture.lastEvent === 'pointerup') {
+    if (aGesture.test) {
+      aGesture.test(true);
+    }
+    aGesture._deferred.resolve();
+  }
+}
+
+/**
+ * A common travel gesture. When the travel gesture is created, all subsequent
+ * pointer events' points are tested for their total distance traveled. If that
+ * distance exceeds the _threshold distance, the gesture will be rejected to a
+ * _travelTo gesture.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ * @param {Function} aTravelTo A contructor for the gesture to reject to when
+ * travelling (default: Explore).
+ * @param {Number} aThreshold Travel threshold (default:
+ * GestureSettings.travelThreshold).
+ */
+function TravelGesture(aTimeStamp, aPoints, aLastEvent, aTravelTo = Explore, aThreshold = GestureSettings.travelThreshold) {
+  Gesture.call(this, aTimeStamp, aPoints, aLastEvent);
+  this._travelTo = aTravelTo;
+  this._threshold = aThreshold;
+}
+
+TravelGesture.prototype = Object.create(Gesture.prototype);
+
+/**
+ * Test the gesture points for travel. The gesture will be rejected to
+ * this._travelTo gesture iff at least one point crosses this._threshold.
+ */
+TravelGesture.prototype.test = function TravelGesture_test() {
+  if (!this._travelTo) {
+    return;
+  }
+  for (let identifier in this.points) {
+    let point = this.points[identifier];
+    if (point.totalDistanceTraveled / Utils.dpi > this._threshold) {
+      this._deferred.reject(this._travelTo);
+      return;
+    }
+  }
+};
+
+/**
+ * DwellEnd gesture.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function DwellEnd(aTimeStamp, aPoints, aLastEvent) {
+  this._inProgress = true;
+  // If the pointer travels, reject to Explore.
+  TravelGesture.call(this, aTimeStamp, aPoints, aLastEvent);
+  checkProgressGesture(this);
+}
+
+DwellEnd.prototype = Object.create(TravelGesture.prototype);
+DwellEnd.prototype.type = 'dwellend';
+
+/**
+ * TapHoldEnd gesture. This gesture can be represented as the following diagram:
+ * pointerdown-pointerup-pointerdown-*wait*-pointerup.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function TapHoldEnd(aTimeStamp, aPoints, aLastEvent) {
+  this._inProgress = true;
+  // If the pointer travels, reject to Explore.
+  TravelGesture.call(this, aTimeStamp, aPoints, aLastEvent);
+  checkProgressGesture(this);
+}
+
+TapHoldEnd.prototype = Object.create(TravelGesture.prototype);
+TapHoldEnd.prototype.type = 'tapholdend';
+
+/**
+ * DoubleTapHoldEnd gesture. This gesture can be represented as the following
+ * diagram:
+ * pointerdown-pointerup-pointerdown-pointerup-pointerdown-*wait*-pointerup.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function DoubleTapHoldEnd(aTimeStamp, aPoints, aLastEvent) {
+  this._inProgress = true;
+  // If the pointer travels, reject to Explore.
+  TravelGesture.call(this, aTimeStamp, aPoints, aLastEvent);
+  checkProgressGesture(this);
+}
+
+DoubleTapHoldEnd.prototype = Object.create(TravelGesture.prototype);
+DoubleTapHoldEnd.prototype.type = 'doubletapholdend';
+
+/**
+ * A common tap gesture object.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ * @param {Function} aRejectToOnWait A constructor for the next gesture to
+ * reject to in case no pointermove or pointerup happens within the
+ * GestureSettings.dwellThreshold.
+ * @param {Function} aTravelTo An optional constuctor for the next gesture to
+ * reject to in case the the TravelGesture test fails.
+ * @param {Function} aRejectToOnPointerDown A constructor for the gesture to
+ * reject to if a finger comes down immediately after the tap.
+ */
+function TapGesture(aTimeStamp, aPoints, aLastEvent, aRejectToOnWait, aTravelTo, aRejectToOnPointerDown) {
+  this._rejectToOnWait = aRejectToOnWait;
+  this._rejectToOnPointerDown = aRejectToOnPointerDown;
+  // If the pointer travels, reject to aTravelTo.
+  TravelGesture.call(this, aTimeStamp, aPoints, aLastEvent, aTravelTo,
+    TAP_MAX_RADIUS);
+}
+
+TapGesture.prototype = Object.create(TravelGesture.prototype);
+TapGesture.prototype._getDelay = function TapGesture__getDelay() {
+  // If, for TapGesture, no pointermove or pointerup happens within the
+  // GestureSettings.dwellThreshold, reject.
+  // Note: the original pointer event's timeStamp is irrelevant here.
+  return GestureSettings.dwellThreshold;
+};
+
+TapGesture.prototype.pointerup = function TapGesture_pointerup(aPoints) {
+    if (this._rejectToOnPointerDown) {
+      let complete = this._update(aPoints, 'pointerup', false, true);
+      if (complete) {
+        this.clearTimer();
+        if (GestureSettings.maxGestureResolveTimeout) {
+          this._pointerUpTimer = setTimeout(() => {
+            clearTimeout(this._pointerUpTimer);
+            delete this._pointerUpTimer;
+            this._deferred.resolve();
+          }, GestureSettings.maxGestureResolveTimeout);
+        } else {
+          this._deferred.resolve();
+        }
+      }
+    } else {
+      TravelGesture.prototype.pointerup.call(this, aPoints);
+    }
+};
+
+TapGesture.prototype.pointerdown = function TapGesture_pointerdown(aPoints, aTimeStamp) {
+  if (this._pointerUpTimer) {
+    clearTimeout(this._pointerUpTimer);
+    delete this._pointerUpTimer;
+    this._deferred.reject(this._rejectToOnPointerDown);
+  } else {
+    TravelGesture.prototype.pointerdown.call(this, aPoints, aTimeStamp);
+  }
+};
+
+
+/**
+ * Tap gesture.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function Tap(aTimeStamp, aPoints, aLastEvent) {
+  // If the pointer travels, reject to Swipe.
+  TapGesture.call(this, aTimeStamp, aPoints, aLastEvent, Dwell, Swipe, DoubleTap);
+}
+
+Tap.prototype = Object.create(TapGesture.prototype);
+Tap.prototype.type = 'tap';
+
+
+/**
+ * Double Tap gesture.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function DoubleTap(aTimeStamp, aPoints, aLastEvent) {
+  this._inProgress = true;
+  TapGesture.call(this, aTimeStamp, aPoints, aLastEvent, TapHold, null, TripleTap);
+}
+
+DoubleTap.prototype = Object.create(TapGesture.prototype);
+DoubleTap.prototype.type = 'doubletap';
+
+/**
+ * Triple Tap gesture.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function TripleTap(aTimeStamp, aPoints, aLastEvent) {
+  this._inProgress = true;
+  TapGesture.call(this, aTimeStamp, aPoints, aLastEvent, DoubleTapHold, null, null);
+}
+
+TripleTap.prototype = Object.create(TapGesture.prototype);
+TripleTap.prototype.type = 'tripletap';
+
+/**
+ * Common base object for gestures that are created as resolved.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function ResolvedGesture(aTimeStamp, aPoints, aLastEvent) {
+  Gesture.call(this, aTimeStamp, aPoints, aLastEvent);
+  // Resolve the guesture right away.
+  this._deferred.resolve();
+}
+
+ResolvedGesture.prototype = Object.create(Gesture.prototype);
+
+/**
+ * Dwell gesture
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function Dwell(aTimeStamp, aPoints, aLastEvent) {
+  ResolvedGesture.call(this, aTimeStamp, aPoints, aLastEvent);
+}
+
+Dwell.prototype = Object.create(ResolvedGesture.prototype);
+Dwell.prototype.type = 'dwell';
+Dwell.prototype.resolveTo = DwellEnd;
+
+/**
+ * TapHold gesture
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function TapHold(aTimeStamp, aPoints, aLastEvent) {
+  ResolvedGesture.call(this, aTimeStamp, aPoints, aLastEvent);
+}
+
+TapHold.prototype = Object.create(ResolvedGesture.prototype);
+TapHold.prototype.type = 'taphold';
+TapHold.prototype.resolveTo = TapHoldEnd;
+
+/**
+ * DoubleTapHold gesture
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function DoubleTapHold(aTimeStamp, aPoints, aLastEvent) {
+  ResolvedGesture.call(this, aTimeStamp, aPoints, aLastEvent);
+}
+
+DoubleTapHold.prototype = Object.create(ResolvedGesture.prototype);
+DoubleTapHold.prototype.type = 'doubletaphold';
+DoubleTapHold.prototype.resolveTo = DoubleTapHoldEnd;
+
+/**
+ * Explore gesture
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function Explore(aTimeStamp, aPoints, aLastEvent) {
+  ExploreGesture.call(this);
+  ResolvedGesture.call(this, aTimeStamp, aPoints, aLastEvent);
+}
+
+Explore.prototype = Object.create(ResolvedGesture.prototype);
+Explore.prototype.type = 'explore';
+Explore.prototype.resolveTo = ExploreEnd;
+
+/**
+ * ExploreEnd gesture.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function ExploreEnd(aTimeStamp, aPoints, aLastEvent) {
+  this._inProgress = true;
+  ExploreGesture.call(this);
+  // If the pointer travels, reject to Explore.
+  TravelGesture.call(this, aTimeStamp, aPoints, aLastEvent);
+  checkProgressGesture(this);
+}
+
+ExploreEnd.prototype = Object.create(TravelGesture.prototype);
+ExploreEnd.prototype.type = 'exploreend';
+
+/**
+ * Swipe gesture.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function Swipe(aTimeStamp, aPoints, aLastEvent) {
+  this._inProgress = true;
+  this._rejectToOnWait = Explore;
+  Gesture.call(this, aTimeStamp, aPoints, aLastEvent);
+  checkProgressGesture(this);
+}
+
+Swipe.prototype = Object.create(Gesture.prototype);
+Swipe.prototype.type = 'swipe';
+Swipe.prototype._getDelay = function Swipe__getDelay(aTimeStamp) {
+  // Swipe should be completed within the GestureSettings.swipeMaxDuration from
+  // the initial pointer down event.
+  return GestureSettings.swipeMaxDuration - this.startTime + aTimeStamp;
+};
+
+/**
+ * Determine wither the gesture was Swipe or Explore.
+ * @param  {Booler} aComplete A flag that indicates whether the gesture is and
+ * will be complete after the test.
+ */
+Swipe.prototype.test = function Swipe_test(aComplete) {
+  if (!aComplete) {
+    // No need to test if the gesture is not completing or can't be complete.
+    return;
+  }
+  let reject = true;
+  // If at least one point travelled for more than SWIPE_MIN_DISTANCE and it was
+  // direct enough, consider it a Swipe.
+  for (let identifier in this.points) {
+    let point = this.points[identifier];
+    let directDistance = point.directDistanceTraveled;
+    if (directDistance / Utils.dpi >= SWIPE_MIN_DISTANCE ||
+      directDistance * DIRECTNESS_COEFF >= point.totalDistanceTraveled) {
+      reject = false;
+    }
+  }
+  if (reject) {
+    this._deferred.reject(Explore);
+  }
+};
+
+/**
+ * Compile a swipe related mozAccessFuGesture event detail.
+ * @return {Object} A mozAccessFuGesture detail object.
+ */
+Swipe.prototype.compile = function Swipe_compile() {
+  let type = this.type;
+  let detail = compileDetail(type, this.points,
+    {x1: 'startX', y1: 'startY', x2: 'x', y2: 'y'});
+  let deltaX = detail.deltaX;
+  let deltaY = detail.deltaY;
+  let edge = EDGE * Utils.dpi;
+  if (Math.abs(deltaX) > Math.abs(deltaY)) {
+    // Horizontal swipe.
+    let startPoints = detail.touches.map(touch => touch.x1);
+    if (deltaX > 0) {
+      detail.type = type + 'right';
+      detail.edge = Math.min.apply(null, startPoints) <= edge;
+    } else {
+      detail.type = type + 'left';
+      detail.edge =
+        Utils.win.screen.width - Math.max.apply(null, startPoints) <= edge;
+    }
+  } else {
+    // Vertical swipe.
+    let startPoints = detail.touches.map(touch => touch.y1);
+    if (deltaY > 0) {
+      detail.type = type + 'down';
+      detail.edge = Math.min.apply(null, startPoints) <= edge;
+    } else {
+      detail.type = type + 'up';
+      detail.edge =
+        Utils.win.screen.height - Math.max.apply(null, startPoints) <= edge;
+    }
+  }
+  return detail;
+};