519 lines
14 KiB
JavaScript
519 lines
14 KiB
JavaScript
/* 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/. */
|
|
|
|
const lazy = {};
|
|
|
|
ChromeUtils.defineESModuleGetters(lazy, {
|
|
error: "chrome://remote/content/shared/webdriver/Errors.sys.mjs",
|
|
Log: "chrome://remote/content/shared/Log.sys.mjs",
|
|
waitForObserverTopic: "chrome://remote/content/marionette/sync.sys.mjs",
|
|
});
|
|
|
|
ChromeUtils.defineLazyGetter(lazy, "logger", () => lazy.Log.get());
|
|
|
|
ChromeUtils.defineLazyGetter(lazy, "service", () => {
|
|
try {
|
|
return Cc["@mozilla.org/accessibilityService;1"].getService(
|
|
Ci.nsIAccessibilityService
|
|
);
|
|
} catch (e) {
|
|
lazy.logger.warn("Accessibility module is not present");
|
|
return undefined;
|
|
}
|
|
});
|
|
|
|
/** @namespace */
|
|
export const accessibility = {
|
|
get service() {
|
|
return lazy.service;
|
|
},
|
|
};
|
|
|
|
/**
|
|
* Accessible states used to check element"s state from the accessiblity API
|
|
* perspective.
|
|
*
|
|
* Note: if gecko is built with --disable-accessibility, the interfaces
|
|
* are not defined. This is why we use getters instead to be able to use
|
|
* these statically.
|
|
*/
|
|
accessibility.State = {
|
|
get Unavailable() {
|
|
return Ci.nsIAccessibleStates.STATE_UNAVAILABLE;
|
|
},
|
|
get Focusable() {
|
|
return Ci.nsIAccessibleStates.STATE_FOCUSABLE;
|
|
},
|
|
get Selectable() {
|
|
return Ci.nsIAccessibleStates.STATE_SELECTABLE;
|
|
},
|
|
get Selected() {
|
|
return Ci.nsIAccessibleStates.STATE_SELECTED;
|
|
},
|
|
};
|
|
|
|
/**
|
|
* Accessible object roles that support some action.
|
|
*/
|
|
accessibility.ActionableRoles = new Set([
|
|
"checkbutton",
|
|
"check menu item",
|
|
"check rich option",
|
|
"combobox",
|
|
"combobox option",
|
|
"entry",
|
|
"key",
|
|
"link",
|
|
"listbox option",
|
|
"listbox rich option",
|
|
"menuitem",
|
|
"option",
|
|
"outlineitem",
|
|
"pagetab",
|
|
"pushbutton",
|
|
"radiobutton",
|
|
"radio menu item",
|
|
"rowheader",
|
|
"slider",
|
|
"spinbutton",
|
|
"switch",
|
|
]);
|
|
|
|
/**
|
|
* Factory function that constructs a new {@code accessibility.Checks}
|
|
* object with enforced strictness or not.
|
|
*/
|
|
accessibility.get = function (strict = false) {
|
|
return new accessibility.Checks(!!strict);
|
|
};
|
|
|
|
/**
|
|
* Wait for the document accessibility state to be different from STATE_BUSY.
|
|
*
|
|
* @param {Document} doc
|
|
* The document to wait for.
|
|
* @returns {Promise}
|
|
* A promise which resolves when the document's accessibility state is no
|
|
* longer busy.
|
|
*/
|
|
function waitForDocumentAccessibility(doc) {
|
|
const documentAccessible = accessibility.service.getAccessibleFor(doc);
|
|
const state = {};
|
|
documentAccessible.getState(state, {});
|
|
if ((state.value & Ci.nsIAccessibleStates.STATE_BUSY) == 0) {
|
|
return Promise.resolve();
|
|
}
|
|
|
|
// Accessibility for the doc is busy, so wait for the state to change.
|
|
return lazy.waitForObserverTopic("accessible-event", {
|
|
checkFn: subject => {
|
|
// If event type does not match expected type, skip the event.
|
|
// If event's accessible does not match expected accessible,
|
|
// skip the event.
|
|
const event = subject.QueryInterface(Ci.nsIAccessibleEvent);
|
|
return (
|
|
event.eventType === Ci.nsIAccessibleEvent.EVENT_STATE_CHANGE &&
|
|
event.accessible === documentAccessible
|
|
);
|
|
},
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Retrieve the Accessible for the provided element.
|
|
*
|
|
* @param {Element} element
|
|
* The element for which we need to retrieve the accessible.
|
|
*
|
|
* @returns {nsIAccessible|null}
|
|
* The Accessible object corresponding to the provided element or null if
|
|
* the accessibility service is not available.
|
|
*/
|
|
accessibility.getAccessible = async function (element) {
|
|
if (!accessibility.service) {
|
|
return null;
|
|
}
|
|
|
|
// First, wait for accessibility to be ready for the element's document.
|
|
await waitForDocumentAccessibility(element.ownerDocument);
|
|
|
|
const acc = accessibility.service.getAccessibleFor(element);
|
|
if (acc) {
|
|
return acc;
|
|
}
|
|
|
|
// The Accessible doesn't exist yet. This can happen because a11y tree
|
|
// mutations happen during refresh driver ticks. Stop the refresh driver from
|
|
// doing its regular ticks and force two refresh driver ticks: the first to
|
|
// let layout update and notify a11y, and the second to let a11y process
|
|
// updates.
|
|
const windowUtils = element.ownerGlobal.windowUtils;
|
|
windowUtils.advanceTimeAndRefresh(0);
|
|
windowUtils.advanceTimeAndRefresh(0);
|
|
// Go back to normal refresh driver ticks.
|
|
windowUtils.restoreNormalRefresh();
|
|
return accessibility.service.getAccessibleFor(element);
|
|
};
|
|
|
|
/**
|
|
* Retrieve the accessible name for the provided element.
|
|
*
|
|
* @param {Element} element
|
|
* The element for which we need to retrieve the accessible name.
|
|
*
|
|
* @returns {string}
|
|
* The accessible name.
|
|
*/
|
|
accessibility.getAccessibleName = async function (element) {
|
|
const accessible = await accessibility.getAccessible(element);
|
|
if (!accessible) {
|
|
return "";
|
|
}
|
|
|
|
// If name is null (absent), expose the empty string.
|
|
if (accessible.name === null) {
|
|
return "";
|
|
}
|
|
|
|
return accessible.name;
|
|
};
|
|
|
|
/**
|
|
* Compute the role for the provided element.
|
|
*
|
|
* @param {Element} element
|
|
* The element for which we need to compute the role.
|
|
*
|
|
* @returns {string}
|
|
* The computed role.
|
|
*/
|
|
accessibility.getComputedRole = async function (element) {
|
|
const accessible = await accessibility.getAccessible(element);
|
|
if (!accessible) {
|
|
// If it's not in the a11y tree, it's probably presentational.
|
|
return "none";
|
|
}
|
|
|
|
return accessible.computedARIARole;
|
|
};
|
|
|
|
/**
|
|
* Component responsible for interacting with platform accessibility
|
|
* API.
|
|
*
|
|
* Its methods serve as wrappers for testing content and chrome
|
|
* accessibility as well as accessibility of user interactions.
|
|
*/
|
|
accessibility.Checks = class {
|
|
/**
|
|
* @param {boolean} strict
|
|
* Flag indicating whether the accessibility issue should be logged
|
|
* or cause an error to be thrown. Default is to log to stdout.
|
|
*/
|
|
constructor(strict) {
|
|
this.strict = strict;
|
|
}
|
|
|
|
/**
|
|
* Assert that the element has a corresponding accessible object, and retrieve
|
|
* this accessible. Note that if the accessibility.Checks component was
|
|
* created in non-strict mode, this helper will not attempt to resolve the
|
|
* accessible at all and will simply return null.
|
|
*
|
|
* @param {DOMElement|XULElement} element
|
|
* Element to get the accessible object for.
|
|
* @param {boolean=} mustHaveAccessible
|
|
* Flag indicating that the element must have an accessible object.
|
|
* Defaults to not require this.
|
|
*
|
|
* @returns {Promise.<nsIAccessible>}
|
|
* Promise with an accessibility object for the given element.
|
|
*/
|
|
async assertAccessible(element, mustHaveAccessible = false) {
|
|
if (!this.strict) {
|
|
return null;
|
|
}
|
|
|
|
const accessible = await accessibility.getAccessible(element);
|
|
if (!accessible && mustHaveAccessible) {
|
|
this.error("Element does not have an accessible object", element);
|
|
}
|
|
|
|
return accessible;
|
|
}
|
|
|
|
/**
|
|
* Test if the accessible has a role that supports some arbitrary
|
|
* action.
|
|
*
|
|
* @param {nsIAccessible} accessible
|
|
* Accessible object.
|
|
*
|
|
* @returns {boolean}
|
|
* True if an actionable role is found on the accessible, false
|
|
* otherwise.
|
|
*/
|
|
isActionableRole(accessible) {
|
|
return accessibility.ActionableRoles.has(
|
|
accessibility.service.getStringRole(accessible.role)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Test if an accessible has at least one action that it supports.
|
|
*
|
|
* @param {nsIAccessible} accessible
|
|
* Accessible object.
|
|
*
|
|
* @returns {boolean}
|
|
* True if the accessible has at least one supported action,
|
|
* false otherwise.
|
|
*/
|
|
hasActionCount(accessible) {
|
|
return accessible.actionCount > 0;
|
|
}
|
|
|
|
/**
|
|
* Test if an accessible has a valid name.
|
|
*
|
|
* @param {nsIAccessible} accessible
|
|
* Accessible object.
|
|
*
|
|
* @returns {boolean}
|
|
* True if the accessible has a non-empty valid name, or false if
|
|
* this is not the case.
|
|
*/
|
|
hasValidName(accessible) {
|
|
return accessible.name && accessible.name.trim();
|
|
}
|
|
|
|
/**
|
|
* Test if an accessible has a {@code hidden} attribute.
|
|
*
|
|
* @param {nsIAccessible} accessible
|
|
* Accessible object.
|
|
*
|
|
* @returns {boolean}
|
|
* True if the accessible object has a {@code hidden} attribute,
|
|
* false otherwise.
|
|
*/
|
|
hasHiddenAttribute(accessible) {
|
|
let hidden = false;
|
|
try {
|
|
hidden = accessible.attributes.getStringProperty("hidden");
|
|
} catch (e) {}
|
|
// if the property is missing, error will be thrown
|
|
return hidden && hidden === "true";
|
|
}
|
|
|
|
/**
|
|
* Verify if an accessible has a given state.
|
|
* Test if an accessible has a given state.
|
|
*
|
|
* @param {nsIAccessible} accessible
|
|
* Accessible object to test.
|
|
* @param {number} stateToMatch
|
|
* State to match.
|
|
*
|
|
* @returns {boolean}
|
|
* True if |accessible| has |stateToMatch|, false otherwise.
|
|
*/
|
|
matchState(accessible, stateToMatch) {
|
|
let state = {};
|
|
accessible.getState(state, {});
|
|
return !!(state.value & stateToMatch);
|
|
}
|
|
|
|
/**
|
|
* Test if an accessible is hidden from the user.
|
|
*
|
|
* @param {nsIAccessible} accessible
|
|
* Accessible object.
|
|
*
|
|
* @returns {boolean}
|
|
* True if element is hidden from user, false otherwise.
|
|
*/
|
|
isHidden(accessible) {
|
|
if (!accessible) {
|
|
return true;
|
|
}
|
|
|
|
while (accessible) {
|
|
if (this.hasHiddenAttribute(accessible)) {
|
|
return true;
|
|
}
|
|
accessible = accessible.parent;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Test if the element's visible state corresponds to its accessibility
|
|
* API visibility.
|
|
*
|
|
* @param {nsIAccessible} accessible
|
|
* Accessible object.
|
|
* @param {DOMElement|XULElement} element
|
|
* Element associated with |accessible|.
|
|
* @param {boolean} visible
|
|
* Visibility state of |element|.
|
|
*
|
|
* @throws ElementNotAccessibleError
|
|
* If |element|'s visibility state does not correspond to
|
|
* |accessible|'s.
|
|
*/
|
|
assertVisible(accessible, element, visible) {
|
|
let hiddenAccessibility = this.isHidden(accessible);
|
|
|
|
let message;
|
|
if (visible && hiddenAccessibility) {
|
|
message =
|
|
"Element is not currently visible via the accessibility API " +
|
|
"and may not be manipulated by it";
|
|
} else if (!visible && !hiddenAccessibility) {
|
|
message =
|
|
"Element is currently only visible via the accessibility API " +
|
|
"and can be manipulated by it";
|
|
}
|
|
this.error(message, element);
|
|
}
|
|
|
|
/**
|
|
* Test if the element's unavailable accessibility state matches the
|
|
* enabled state.
|
|
*
|
|
* @param {nsIAccessible} accessible
|
|
* Accessible object.
|
|
* @param {DOMElement|XULElement} element
|
|
* Element associated with |accessible|.
|
|
* @param {boolean} enabled
|
|
* Enabled state of |element|.
|
|
*
|
|
* @throws ElementNotAccessibleError
|
|
* If |element|'s enabled state does not match |accessible|'s.
|
|
*/
|
|
assertEnabled(accessible, element, enabled) {
|
|
if (!accessible) {
|
|
return;
|
|
}
|
|
|
|
let win = element.ownerGlobal;
|
|
let disabledAccessibility = this.matchState(
|
|
accessible,
|
|
accessibility.State.Unavailable
|
|
);
|
|
let explorable =
|
|
win.getComputedStyle(element).getPropertyValue("pointer-events") !==
|
|
"none";
|
|
|
|
let message;
|
|
if (!explorable && !disabledAccessibility) {
|
|
message =
|
|
"Element is enabled but is not explorable via the " +
|
|
"accessibility API";
|
|
} else if (enabled && disabledAccessibility) {
|
|
message = "Element is enabled but disabled via the accessibility API";
|
|
} else if (!enabled && !disabledAccessibility) {
|
|
message = "Element is disabled but enabled via the accessibility API";
|
|
}
|
|
this.error(message, element);
|
|
}
|
|
|
|
/**
|
|
* Test if it is possible to activate an element with the accessibility
|
|
* API.
|
|
*
|
|
* @param {nsIAccessible} accessible
|
|
* Accessible object.
|
|
* @param {DOMElement|XULElement} element
|
|
* Element associated with |accessible|.
|
|
*
|
|
* @throws ElementNotAccessibleError
|
|
* If it is impossible to activate |element| with |accessible|.
|
|
*/
|
|
assertActionable(accessible, element) {
|
|
if (!accessible) {
|
|
return;
|
|
}
|
|
|
|
let message;
|
|
if (!this.hasActionCount(accessible)) {
|
|
message = "Element does not support any accessible actions";
|
|
} else if (!this.isActionableRole(accessible)) {
|
|
message =
|
|
"Element does not have a correct accessibility role " +
|
|
"and may not be manipulated via the accessibility API";
|
|
} else if (!this.hasValidName(accessible)) {
|
|
message = "Element is missing an accessible name";
|
|
} else if (!this.matchState(accessible, accessibility.State.Focusable)) {
|
|
message = "Element is not focusable via the accessibility API";
|
|
}
|
|
|
|
this.error(message, element);
|
|
}
|
|
|
|
/**
|
|
* Test that an element's selected state corresponds to its
|
|
* accessibility API selected state.
|
|
*
|
|
* @param {nsIAccessible} accessible
|
|
* Accessible object.
|
|
* @param {DOMElement|XULElement} element
|
|
* Element associated with |accessible|.
|
|
* @param {boolean} selected
|
|
* The |element|s selected state.
|
|
*
|
|
* @throws ElementNotAccessibleError
|
|
* If |element|'s selected state does not correspond to
|
|
* |accessible|'s.
|
|
*/
|
|
assertSelected(accessible, element, selected) {
|
|
if (!accessible) {
|
|
return;
|
|
}
|
|
|
|
// element is not selectable via the accessibility API
|
|
if (!this.matchState(accessible, accessibility.State.Selectable)) {
|
|
return;
|
|
}
|
|
|
|
let selectedAccessibility = this.matchState(
|
|
accessible,
|
|
accessibility.State.Selected
|
|
);
|
|
|
|
let message;
|
|
if (selected && !selectedAccessibility) {
|
|
message =
|
|
"Element is selected but not selected via the accessibility API";
|
|
} else if (!selected && selectedAccessibility) {
|
|
message =
|
|
"Element is not selected but selected via the accessibility API";
|
|
}
|
|
this.error(message, element);
|
|
}
|
|
|
|
/**
|
|
* Throw an error if strict accessibility checks are enforced and log
|
|
* the error to the log.
|
|
*
|
|
* @param {string} message
|
|
* @param {DOMElement|XULElement} element
|
|
* Element that caused an error.
|
|
*
|
|
* @throws ElementNotAccessibleError
|
|
* If |strict| is true.
|
|
*/
|
|
error(message, element) {
|
|
if (!message || !this.strict) {
|
|
return;
|
|
}
|
|
if (element) {
|
|
let { id, tagName, className } = element;
|
|
message += `: id: ${id}, tagName: ${tagName}, className: ${className}`;
|
|
}
|
|
|
|
throw new lazy.error.ElementNotAccessibleError(message);
|
|
}
|
|
};
|