Add m-esr52 at 52.6.0

1 files changed, 419 insertions, 0 deletions

diff --git a/accessible/jsat/Traversal.jsm b/accessible/jsat/Traversal.jsm
new file mode 100644
index 000000000..5b3bbdf89
--- /dev/null
+++ b/accessible/jsat/Traversal.jsm
@@ -0,0 +1,419 @@
+/* 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 PrefCache, Roles, Prefilters, States, Filters, Utils,
+   TraversalRules, Components, XPCOMUtils */
+/* exported TraversalRules, TraversalHelper */
+
+'use strict';
+
+const Ci = Components.interfaces;
+const Cu = Components.utils;
+
+this.EXPORTED_SYMBOLS = ['TraversalRules', 'TraversalHelper']; // jshint ignore:line
+
+Cu.import('resource://gre/modules/accessibility/Utils.jsm');
+Cu.import('resource://gre/modules/XPCOMUtils.jsm');
+XPCOMUtils.defineLazyModuleGetter(this, 'Roles',  // jshint ignore:line
+  'resource://gre/modules/accessibility/Constants.jsm');
+XPCOMUtils.defineLazyModuleGetter(this, 'Filters',  // jshint ignore:line
+  'resource://gre/modules/accessibility/Constants.jsm');
+XPCOMUtils.defineLazyModuleGetter(this, 'States',  // jshint ignore:line
+  'resource://gre/modules/accessibility/Constants.jsm');
+XPCOMUtils.defineLazyModuleGetter(this, 'Prefilters',  // jshint ignore:line
+  'resource://gre/modules/accessibility/Constants.jsm');
+
+var gSkipEmptyImages = new PrefCache('accessibility.accessfu.skip_empty_images');
+
+function BaseTraversalRule(aRoles, aMatchFunc, aPreFilter, aContainerRule) {
+  this._explicitMatchRoles = new Set(aRoles);
+  this._matchRoles = aRoles;
+  if (aRoles.length) {
+    if (aRoles.indexOf(Roles.LABEL) < 0) {
+      this._matchRoles.push(Roles.LABEL);
+    }
+    if (aRoles.indexOf(Roles.INTERNAL_FRAME) < 0) {
+      // Used for traversing in to child OOP frames.
+      this._matchRoles.push(Roles.INTERNAL_FRAME);
+    }
+  }
+  this._matchFunc = aMatchFunc || function() { return Filters.MATCH; };
+  this.preFilter = aPreFilter || gSimplePreFilter;
+  this.containerRule = aContainerRule;
+}
+
+BaseTraversalRule.prototype = {
+    getMatchRoles: function BaseTraversalRule_getmatchRoles(aRoles) {
+      aRoles.value = this._matchRoles;
+      return aRoles.value.length;
+    },
+
+    match: function BaseTraversalRule_match(aAccessible)
+    {
+      let role = aAccessible.role;
+      if (role == Roles.INTERNAL_FRAME) {
+        return (Utils.getMessageManager(aAccessible.DOMNode)) ?
+          Filters.MATCH  | Filters.IGNORE_SUBTREE : Filters.IGNORE;
+      }
+
+      let matchResult =
+        (this._explicitMatchRoles.has(role) || !this._explicitMatchRoles.size) ?
+        this._matchFunc(aAccessible) : Filters.IGNORE;
+
+      // If we are on a label that nests a checkbox/radio we should land on it.
+      // It is a bigger touch target, and it reduces clutter.
+      if (role == Roles.LABEL && !(matchResult & Filters.IGNORE_SUBTREE)) {
+        let control = Utils.getEmbeddedControl(aAccessible);
+        if (control && this._explicitMatchRoles.has(control.role)) {
+          matchResult = this._matchFunc(control) | Filters.IGNORE_SUBTREE;
+        }
+      }
+
+      return matchResult;
+    },
+
+    QueryInterface: XPCOMUtils.generateQI([Ci.nsIAccessibleTraversalRule])
+};
+
+var gSimpleTraversalRoles =
+  [Roles.MENUITEM,
+   Roles.LINK,
+   Roles.PAGETAB,
+   Roles.GRAPHIC,
+   Roles.STATICTEXT,
+   Roles.TEXT_LEAF,
+   Roles.PUSHBUTTON,
+   Roles.CHECKBUTTON,
+   Roles.RADIOBUTTON,
+   Roles.COMBOBOX,
+   Roles.PROGRESSBAR,
+   Roles.BUTTONDROPDOWN,
+   Roles.BUTTONMENU,
+   Roles.CHECK_MENU_ITEM,
+   Roles.PASSWORD_TEXT,
+   Roles.RADIO_MENU_ITEM,
+   Roles.TOGGLE_BUTTON,
+   Roles.ENTRY,
+   Roles.KEY,
+   Roles.HEADER,
+   Roles.HEADING,
+   Roles.SLIDER,
+   Roles.SPINBUTTON,
+   Roles.OPTION,
+   Roles.LISTITEM,
+   Roles.GRID_CELL,
+   Roles.COLUMNHEADER,
+   Roles.ROWHEADER,
+   Roles.STATUSBAR,
+   Roles.SWITCH,
+   Roles.MATHML_MATH];
+
+var gSimpleMatchFunc = function gSimpleMatchFunc(aAccessible) {
+  // An object is simple, if it either has a single child lineage,
+  // or has a flat subtree.
+  function isSingleLineage(acc) {
+    for (let child = acc; child; child = child.firstChild) {
+      if (Utils.visibleChildCount(child) > 1) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  function isFlatSubtree(acc) {
+    for (let child = acc.firstChild; child; child = child.nextSibling) {
+      // text leafs inherit the actionCount of any ancestor that has a click
+      // listener.
+      if ([Roles.TEXT_LEAF, Roles.STATICTEXT].indexOf(child.role) >= 0) {
+        continue;
+      }
+      if (Utils.visibleChildCount(child) > 0 || child.actionCount > 0) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  switch (aAccessible.role) {
+  case Roles.COMBOBOX:
+    // We don't want to ignore the subtree because this is often
+    // where the list box hangs out.
+    return Filters.MATCH;
+  case Roles.TEXT_LEAF:
+    {
+      // Nameless text leaves are boring, skip them.
+      let name = aAccessible.name;
+      return (name && name.trim()) ? Filters.MATCH : Filters.IGNORE;
+    }
+  case Roles.STATICTEXT:
+    // Ignore prefix static text in list items. They are typically bullets or numbers.
+    return Utils.isListItemDecorator(aAccessible) ?
+      Filters.IGNORE : Filters.MATCH;
+  case Roles.GRAPHIC:
+    return TraversalRules._shouldSkipImage(aAccessible);
+  case Roles.HEADER:
+  case Roles.HEADING:
+  case Roles.COLUMNHEADER:
+  case Roles.ROWHEADER:
+  case Roles.STATUSBAR:
+    if ((aAccessible.childCount > 0 || aAccessible.name) &&
+        (isSingleLineage(aAccessible) || isFlatSubtree(aAccessible))) {
+      return Filters.MATCH | Filters.IGNORE_SUBTREE;
+    }
+    return Filters.IGNORE;
+  case Roles.GRID_CELL:
+    return isSingleLineage(aAccessible) || isFlatSubtree(aAccessible) ?
+      Filters.MATCH | Filters.IGNORE_SUBTREE : Filters.IGNORE;
+  case Roles.LISTITEM:
+    {
+      let item = aAccessible.childCount === 2 &&
+        aAccessible.firstChild.role === Roles.STATICTEXT ?
+        aAccessible.lastChild : aAccessible;
+        return isSingleLineage(item) || isFlatSubtree(item) ?
+          Filters.MATCH | Filters.IGNORE_SUBTREE : Filters.IGNORE;
+    }
+  default:
+    // Ignore the subtree, if there is one. So that we don't land on
+    // the same content that was already presented by its parent.
+    return Filters.MATCH |
+      Filters.IGNORE_SUBTREE;
+  }
+};
+
+var gSimplePreFilter = Prefilters.DEFUNCT |
+  Prefilters.INVISIBLE |
+  Prefilters.ARIA_HIDDEN |
+  Prefilters.TRANSPARENT;
+
+this.TraversalRules = { // jshint ignore:line
+  Simple: new BaseTraversalRule(gSimpleTraversalRoles, gSimpleMatchFunc),
+
+  SimpleOnScreen: new BaseTraversalRule(
+    gSimpleTraversalRoles, gSimpleMatchFunc,
+    Prefilters.DEFUNCT | Prefilters.INVISIBLE | Prefilters.ARIA_HIDDEN |
+    Prefilters.TRANSPARENT | Prefilters.OFFSCREEN),
+
+  Anchor: new BaseTraversalRule(
+    [Roles.LINK],
+    function Anchor_match(aAccessible)
+    {
+      // We want to ignore links, only focus named anchors.
+      if (Utils.getState(aAccessible).contains(States.LINKED)) {
+        return Filters.IGNORE;
+      } else {
+        return Filters.MATCH;
+      }
+    }),
+
+  Button: new BaseTraversalRule(
+    [Roles.PUSHBUTTON,
+     Roles.SPINBUTTON,
+     Roles.TOGGLE_BUTTON,
+     Roles.BUTTONDROPDOWN,
+     Roles.BUTTONDROPDOWNGRID]),
+
+  Combobox: new BaseTraversalRule(
+    [Roles.COMBOBOX,
+     Roles.LISTBOX]),
+
+  Landmark: new BaseTraversalRule(
+    [],
+    function Landmark_match(aAccessible) {
+      return Utils.getLandmarkName(aAccessible) ? Filters.MATCH :
+        Filters.IGNORE;
+    }, null, true),
+
+  /* A rule for Android's section navigation, lands on landmarks, regions, and
+     on headings to aid navigation of traditionally structured documents */
+  Section: new BaseTraversalRule(
+    [],
+    function Section_match(aAccessible) {
+      if (aAccessible.role === Roles.HEADING) {
+        return Filters.MATCH;
+      }
+
+      let matchedRole = Utils.matchRoles(aAccessible, [
+        'banner',
+        'complementary',
+        'contentinfo',
+        'main',
+        'navigation',
+        'search',
+        'region'
+        ]);
+
+      return matchedRole ? Filters.MATCH : Filters.IGNORE;
+    }, null, true),
+
+  Entry: new BaseTraversalRule(
+    [Roles.ENTRY,
+     Roles.PASSWORD_TEXT]),
+
+  FormElement: new BaseTraversalRule(
+    [Roles.PUSHBUTTON,
+     Roles.SPINBUTTON,
+     Roles.TOGGLE_BUTTON,
+     Roles.BUTTONDROPDOWN,
+     Roles.BUTTONDROPDOWNGRID,
+     Roles.COMBOBOX,
+     Roles.LISTBOX,
+     Roles.ENTRY,
+     Roles.PASSWORD_TEXT,
+     Roles.PAGETAB,
+     Roles.RADIOBUTTON,
+     Roles.RADIO_MENU_ITEM,
+     Roles.SLIDER,
+     Roles.CHECKBUTTON,
+     Roles.CHECK_MENU_ITEM,
+     Roles.SWITCH]),
+
+  Graphic: new BaseTraversalRule(
+    [Roles.GRAPHIC],
+    function Graphic_match(aAccessible) {
+      return TraversalRules._shouldSkipImage(aAccessible);
+    }),
+
+  Heading: new BaseTraversalRule(
+    [Roles.HEADING],
+    function Heading_match(aAccessible) {
+      return aAccessible.childCount > 0 ? Filters.MATCH : Filters.IGNORE;
+    }),
+
+  ListItem: new BaseTraversalRule(
+    [Roles.LISTITEM,
+     Roles.TERM]),
+
+  Link: new BaseTraversalRule(
+    [Roles.LINK],
+    function Link_match(aAccessible)
+    {
+      // We want to ignore anchors, only focus real links.
+      if (Utils.getState(aAccessible).contains(States.LINKED)) {
+        return Filters.MATCH;
+      } else {
+        return Filters.IGNORE;
+      }
+    }),
+
+  /* For TalkBack's "Control" granularity. Form conrols and links */
+  Control: new BaseTraversalRule(
+    [Roles.PUSHBUTTON,
+     Roles.SPINBUTTON,
+     Roles.TOGGLE_BUTTON,
+     Roles.BUTTONDROPDOWN,
+     Roles.BUTTONDROPDOWNGRID,
+     Roles.COMBOBOX,
+     Roles.LISTBOX,
+     Roles.ENTRY,
+     Roles.PASSWORD_TEXT,
+     Roles.PAGETAB,
+     Roles.RADIOBUTTON,
+     Roles.RADIO_MENU_ITEM,
+     Roles.SLIDER,
+     Roles.CHECKBUTTON,
+     Roles.CHECK_MENU_ITEM,
+     Roles.SWITCH,
+     Roles.LINK,
+     Roles.MENUITEM],
+    function Control_match(aAccessible)
+    {
+      // We want to ignore anchors, only focus real links.
+      if (aAccessible.role == Roles.LINK &&
+          !Utils.getState(aAccessible).contains(States.LINKED)) {
+        return Filters.IGNORE;
+      }
+      return Filters.MATCH;
+    }),
+
+  List: new BaseTraversalRule(
+    [Roles.LIST,
+     Roles.DEFINITION_LIST],
+    null, null, true),
+
+  PageTab: new BaseTraversalRule(
+    [Roles.PAGETAB]),
+
+  Paragraph: new BaseTraversalRule(
+    [Roles.PARAGRAPH,
+     Roles.SECTION],
+    function Paragraph_match(aAccessible) {
+      for (let child = aAccessible.firstChild; child; child = child.nextSibling) {
+        if (child.role === Roles.TEXT_LEAF) {
+          return Filters.MATCH | Filters.IGNORE_SUBTREE;
+        }
+      }
+
+      return Filters.IGNORE;
+    }),
+
+  RadioButton: new BaseTraversalRule(
+    [Roles.RADIOBUTTON,
+     Roles.RADIO_MENU_ITEM]),
+
+  Separator: new BaseTraversalRule(
+    [Roles.SEPARATOR]),
+
+  Table: new BaseTraversalRule(
+    [Roles.TABLE]),
+
+  Checkbox: new BaseTraversalRule(
+    [Roles.CHECKBUTTON,
+     Roles.CHECK_MENU_ITEM,
+     Roles.SWITCH /* A type of checkbox that represents on/off values */]),
+
+  _shouldSkipImage: function _shouldSkipImage(aAccessible) {
+    if (gSkipEmptyImages.value && aAccessible.name === '') {
+      return Filters.IGNORE;
+    }
+    return Filters.MATCH;
+  }
+};
+
+this.TraversalHelper = {
+  _helperPivotCache: null,
+
+  get helperPivotCache() {
+    delete this.helperPivotCache;
+    this.helperPivotCache = new WeakMap();
+    return this.helperPivotCache;
+  },
+
+  getHelperPivot: function TraversalHelper_getHelperPivot(aRoot) {
+    let pivot = this.helperPivotCache.get(aRoot.DOMNode);
+    if (!pivot) {
+      pivot = Utils.AccService.createAccessiblePivot(aRoot);
+      this.helperPivotCache.set(aRoot.DOMNode, pivot);
+    }
+
+    return pivot;
+  },
+
+  move: function TraversalHelper_move(aVirtualCursor, aMethod, aRule) {
+    let rule = TraversalRules[aRule];
+
+    if (rule.containerRule) {
+      let moved = false;
+      let helperPivot = this.getHelperPivot(aVirtualCursor.root);
+      helperPivot.position = aVirtualCursor.position;
+
+      // We continue to step through containers until there is one with an
+      // atomic child (via 'Simple') on which we could land.
+      while (!moved) {
+        if (helperPivot[aMethod](rule)) {
+          aVirtualCursor.modalRoot = helperPivot.position;
+          moved = aVirtualCursor.moveFirst(TraversalRules.Simple);
+          aVirtualCursor.modalRoot = null;
+        } else {
+          // If we failed to step to another container, break and return false.
+          break;
+        }
+      }
+
+      return moved;
+    } else {
+      return aVirtualCursor[aMethod](rule);
+    }
+  }
+
+};