Source code

Revision control

Copy as Markdown

Other Tools

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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/. */
#include "nsAccessibilityService.h"
// NOTE: alphabetically ordered
#include "ApplicationAccessibleWrap.h"
#include "ARIAGridAccessible.h"
#include "ARIAMap.h"
#include "CssAltContent.h"
#include "DocAccessible-inl.h"
#include "DocAccessibleChild.h"
#include "FocusManager.h"
#include "mozilla/FocusModel.h"
#include "HTMLCanvasAccessible.h"
#include "HTMLElementAccessibles.h"
#include "HTMLImageMapAccessible.h"
#include "HTMLLinkAccessible.h"
#include "HTMLListAccessible.h"
#include "HTMLSelectAccessible.h"
#include "HTMLTableAccessible.h"
#include "HyperTextAccessible.h"
#include "RootAccessible.h"
#include "nsAccUtils.h"
#include "nsArrayUtils.h"
#include "nsAttrName.h"
#include "nsDOMTokenList.h"
#include "nsCRT.h"
#include "nsEventShell.h"
#include "nsGkAtoms.h"
#include "nsIFrameInlines.h"
#include "nsServiceManagerUtils.h"
#include "nsTextFormatter.h"
#include "OuterDocAccessible.h"
#include "Pivot.h"
#include "mozilla/a11y/Role.h"
#ifdef MOZ_ACCESSIBILITY_ATK
# include "RootAccessibleWrap.h"
#endif
#include "States.h"
#include "Statistics.h"
#include "TextLeafAccessible.h"
#include "xpcAccessibleApplication.h"
#ifdef XP_WIN
# include "mozilla/a11y/Compatibility.h"
# include "mozilla/StaticPtr.h"
#endif
#ifdef A11Y_LOG
# include "Logging.h"
#endif
#include "nsExceptionHandler.h"
#include "nsImageFrame.h"
#include "nsIObserverService.h"
#include "nsMenuPopupFrame.h"
#include "nsLayoutUtils.h"
#include "nsTreeBodyFrame.h"
#include "nsTreeUtils.h"
#include "mozilla/a11y/AccTypes.h"
#include "mozilla/ArrayUtils.h"
#include "mozilla/dom/ContentParent.h"
#include "mozilla/dom/DOMStringList.h"
#include "mozilla/dom/EventTarget.h"
#include "mozilla/dom/HTMLTableElement.h"
#include "mozilla/Preferences.h"
#include "mozilla/PresShell.h"
#include "mozilla/ProfilerMarkers.h"
#include "mozilla/RefPtr.h"
#include "mozilla/Services.h"
#include "XULAlertAccessible.h"
#include "XULComboboxAccessible.h"
#include "XULElementAccessibles.h"
#include "XULFormControlAccessible.h"
#include "XULListboxAccessible.h"
#include "XULMenuAccessible.h"
#include "XULTabAccessible.h"
#include "XULTreeGridAccessible.h"
using namespace mozilla;
using namespace mozilla::a11y;
using namespace mozilla::dom;
/**
* Accessibility service force enable/disable preference.
* Supported values:
* Accessibility is force enabled (accessibility should always be enabled): -1
* Accessibility is enabled (will be started upon a request, default value): 0
* Accessibility is force disabled (never enable accessibility): 1
*/
#define PREF_ACCESSIBILITY_FORCE_DISABLED "accessibility.force_disabled"
////////////////////////////////////////////////////////////////////////////////
// Statics
////////////////////////////////////////////////////////////////////////////////
/**
* If the element has an ARIA attribute that requires a specific Accessible
* class, create and return it. Otherwise, return null.
*/
static LocalAccessible* MaybeCreateSpecificARIAAccessible(
const nsRoleMapEntry* aRoleMapEntry, const LocalAccessible* aContext,
nsIContent* aContent, DocAccessible* aDocument) {
if (aRoleMapEntry && aRoleMapEntry->accTypes & eTableCell) {
if (aContent->IsAnyOfHTMLElements(nsGkAtoms::td, nsGkAtoms::th) &&
aContext->IsHTMLTableRow()) {
// Don't use ARIAGridCellAccessible for a valid td/th because
// HTMLTableCellAccessible can provide additional info; e.g. row/col span
// from the layout engine.
return nullptr;
}
// A cell must be in a row.
const Accessible* parent = aContext;
if (parent->IsGeneric()) {
parent = parent->GetNonGenericParent();
}
if (!parent || parent->Role() != roles::ROW) {
return nullptr;
}
// That row must be in a table, though there may be an intervening rowgroup.
parent = parent->GetNonGenericParent();
if (!parent) {
return nullptr;
}
if (!parent->IsTable() && parent->Role() == roles::ROWGROUP) {
parent = parent->GetNonGenericParent();
if (!parent) {
return nullptr;
}
}
if (parent->IsTable()) {
return new ARIAGridCellAccessible(aContent, aDocument);
}
}
return nullptr;
}
// Send a request to all content processes that they build and send back
// information about the given cache domains.
static bool SendCacheDomainRequestToAllContentProcesses(
uint64_t aCacheDomains) {
if (!XRE_IsParentProcess()) {
return false;
}
bool sentAll = true;
nsTArray<ContentParent*> contentParents;
ContentParent::GetAll(contentParents);
for (auto* parent : contentParents) {
sentAll = sentAll && parent->SendSetCacheDomains(aCacheDomains);
}
return sentAll;
}
/**
* Return true if the element must be a generic Accessible, even if it has been
* marked presentational with role="presentation", etc. MustBeAccessible causes
* an Accessible to be created as if it weren't marked presentational at all;
* e.g. <table role="presentation" tabindex="0"> will expose roles::TABLE and
* support TableAccessible. In contrast, this function causes a generic
* Accessible to be created; e.g. <table role="presentation" style="position:
* fixed;"> will expose roles::TEXT_CONTAINER and will not support
* TableAccessible. This is necessary in certain cases for the
* RemoteAccessible cache.
*/
static bool MustBeGenericAccessible(nsIContent* aContent,
DocAccessible* aDocument) {
if (aContent->IsInNativeAnonymousSubtree() || aContent->IsSVGElement()) {
// We should not force create accs for anonymous content.
// This is an issue for inputs, which have an intermediate
// container with relevant overflow styling between the input
// and its internal input content.
// We should also avoid this for SVG elements (ie. `<foreignobject>`s
// which have default overflow:hidden styling).
return false;
}
nsIFrame* frame = aContent->GetPrimaryFrame();
MOZ_ASSERT(frame);
nsAutoCString overflow;
frame->Style()->GetComputedPropertyValue(eCSSProperty_overflow, overflow);
// If the frame has been transformed, and the content has any children, we
// should create an Accessible so that we can account for the transform when
// calculating the Accessible's bounds using the parent process cache.
// Ditto for content which is position: fixed or sticky or has overflow
// styling (auto, scroll, hidden).
// However, don't do this for XUL widgets, as this breaks XUL a11y code
// expectations in some cases. XUL widgets are only used in the parent
// process and can't be cached anyway.
return !aContent->IsXULElement() &&
((aContent->HasChildren() && frame->IsTransformed()) ||
frame->IsStickyPositioned() ||
(frame->StyleDisplay()->mPosition == StylePositionProperty::Fixed &&
nsLayoutUtils::IsReallyFixedPos(frame)) ||
overflow.Equals("auto"_ns) || overflow.Equals("scroll"_ns) ||
overflow.Equals("hidden"_ns));
}
/**
* Return true if the element must be accessible.
*/
static bool MustBeAccessible(nsIContent* aContent, DocAccessible* aDocument) {
if (nsIFrame* frame = aContent->GetPrimaryFrame()) {
// This document might be invisible when it first loads. Therefore, we must
// check focusability irrespective of visibility here. Otherwise, we might
// not create Accessibles for some focusable elements; e.g. a span with only
// a tabindex. Elements that are invisible within this document are excluded
// earlier in CreateAccessible.
if (frame->IsFocusable(IsFocusableFlags::IgnoreVisibility)) {
return true;
}
}
// Return true if the element has an attribute (ARIA, title, or relation) that
// requires the creation of an Accessible for the element.
if (aContent->IsElement()) {
uint32_t attrCount = aContent->AsElement()->GetAttrCount();
for (uint32_t attrIdx = 0; attrIdx < attrCount; attrIdx++) {
const nsAttrName* attr = aContent->AsElement()->GetAttrNameAt(attrIdx);
if (attr->NamespaceEquals(kNameSpaceID_None)) {
nsAtom* attrAtom = attr->Atom();
if (attrAtom == nsGkAtoms::title && aContent->IsHTMLElement()) {
// If the author provided a title on an element that would not
// be accessible normally, assume an intent and make it accessible.
return true;
}
nsDependentAtomString attrStr(attrAtom);
if (!StringBeginsWith(attrStr, u"aria-"_ns)) continue; // not ARIA
// A global state or a property and in case of token defined.
uint8_t attrFlags = aria::AttrCharacteristicsFor(attrAtom);
if ((attrFlags & ATTR_GLOBAL) &&
(!(attrFlags & ATTR_VALTOKEN) ||
nsAccUtils::HasDefinedARIAToken(aContent, attrAtom))) {
return true;
}
}
}
// If the given ID is referred by relation attribute then create an
// Accessible for it.
nsAutoString id;
if (nsCoreUtils::GetID(aContent, id) && !id.IsEmpty()) {
return aDocument->IsDependentID(aContent->AsElement(), id);
}
}
return false;
}
bool nsAccessibilityService::ShouldCreateImgAccessible(
mozilla::dom::Element* aElement, DocAccessible* aDocument) {
// The element must have a layout frame for us to proceed. If there is no
// frame, the image is likely hidden.
nsIFrame* frame = aElement->GetPrimaryFrame();
if (!frame) {
return false;
}
// If the element is not an img, not an embedded image via embed or object,
// and not a pseudo-element with CSS content alt text, then we should not
// create an accessible.
if (!aElement->IsHTMLElement(nsGkAtoms::img) &&
((!aElement->IsHTMLElement(nsGkAtoms::embed) &&
!aElement->IsHTMLElement(nsGkAtoms::object)) ||
frame->AccessibleType() != AccType::eImageType) &&
!CssAltContent(aElement)) {
return false;
}
nsAutoString newAltText;
const bool hasAlt = aElement->GetAttr(nsGkAtoms::alt, newAltText);
if (!hasAlt || !newAltText.IsEmpty()) {
// If there is no alt attribute, we should create an accessible. The
// author may have missed the attribute, and the AT may want to provide a
// name. If there is alt text, we should create an accessible.
return true;
}
if (newAltText.IsEmpty() && (nsCoreUtils::HasClickListener(aElement) ||
MustBeAccessible(aElement, aDocument))) {
// If there is empty alt text, but there is a click listener for this img,
// or if it otherwise must be an accessible (e.g., if it has an aria-label
// attribute), we should create an accessible.
return true;
}
// Otherwise, no alt text means we should not create an accessible.
return false;
}
/**
* Return true if the SVG element should be accessible
*/
static bool MustSVGElementBeAccessible(nsIContent* aContent,
DocAccessible* aDocument) {
for (nsIContent* childElm = aContent->GetFirstChild(); childElm;
childElm = childElm->GetNextSibling()) {
if (childElm->IsAnyOfSVGElements(nsGkAtoms::title, nsGkAtoms::desc)) {
return true;
}
}
return MustBeAccessible(aContent, aDocument);
}
/**
* Return an accessible for the content if the SVG element requires the creation
* of an Accessible.
*/
static RefPtr<LocalAccessible> MaybeCreateSVGAccessible(
nsIContent* aContent, DocAccessible* aDocument) {
if (aContent->IsSVGGeometryElement() ||
aContent->IsSVGElement(nsGkAtoms::image)) {
// Shape elements: rect, circle, ellipse, line, path, polygon, and polyline.
// 'use' and 'text' graphic elements require special support.
if (MustSVGElementBeAccessible(aContent, aDocument)) {
return new EnumRoleAccessible<roles::GRAPHIC>(aContent, aDocument);
}
} else if (aContent->IsSVGElement(nsGkAtoms::text)) {
return new HyperTextAccessible(aContent->AsElement(), aDocument);
} else if (aContent->IsSVGElement(nsGkAtoms::svg)) {
// An <svg> element could contain <foreignObject>, which contains HTML but
// does not normally create its own Accessible. This means that the <svg>
// Accessible could have TextLeafAccessible children, so it must be a
// HyperTextAccessible.
return new EnumRoleHyperTextAccessible<roles::DIAGRAM>(aContent, aDocument);
} else if (aContent->IsSVGElement(nsGkAtoms::g) &&
MustSVGElementBeAccessible(aContent, aDocument)) {
// <g> can also contain <foreignObject>.
return new EnumRoleHyperTextAccessible<roles::GROUPING>(aContent,
aDocument);
} else if (aContent->IsSVGElement(nsGkAtoms::a)) {
return new HTMLLinkAccessible(aContent, aDocument);
}
return nullptr;
}
/**
* Used by XULMap.h to map both menupopup and popup elements
*/
LocalAccessible* CreateMenupopupAccessible(Element* aElement,
LocalAccessible* aContext) {
#ifdef MOZ_ACCESSIBILITY_ATK
// ATK considers this node to be redundant when within menubars, and it makes
// menu navigation with assistive technologies more difficult
// XXX In the future we will should this for consistency across the
// nsIAccessible implementations on each platform for a consistent scripting
// environment, but then strip out redundant accessibles in the AccessibleWrap
// class for each platform.
nsIContent* parent = aElement->GetParent();
if (parent && parent->IsXULElement(nsGkAtoms::menu)) return nullptr;
#endif
return new XULMenupopupAccessible(aElement, aContext->Document());
}
static uint64_t GetCacheDomainsForKnownClients(uint64_t aCacheDomains) {
// Only check clients in the parent process.
if (!XRE_IsParentProcess()) {
return aCacheDomains;
}
return a11y::GetCacheDomainsForKnownClients(aCacheDomains);
}
////////////////////////////////////////////////////////////////////////////////
// LocalAccessible constructors
static LocalAccessible* New_HyperText(Element* aElement,
LocalAccessible* aContext) {
return new HyperTextAccessible(aElement, aContext->Document());
}
template <typename AccClass>
static LocalAccessible* New_HTMLDtOrDd(Element* aElement,
LocalAccessible* aContext) {
nsIContent* parent = aContext->GetContent();
if (parent->IsHTMLElement(nsGkAtoms::div)) {
// It is conforming in HTML to use a div to group dt/dd elements.
parent = parent->GetParent();
}
if (parent && parent->IsHTMLElement(nsGkAtoms::dl)) {
return new AccClass(aElement, aContext->Document());
}
return nullptr;
}
/**
* Cached value of the PREF_ACCESSIBILITY_FORCE_DISABLED preference.
*/
static int32_t sPlatformDisabledState = 0;
////////////////////////////////////////////////////////////////////////////////
// Markup maps array.
#define Attr(name, value) {nsGkAtoms::name, nsGkAtoms::value}
#define AttrFromDOM(name, DOMAttrName) \
{nsGkAtoms::name, nullptr, nsGkAtoms::DOMAttrName}
#define AttrFromDOMIf(name, DOMAttrName, DOMAttrValue) \
{nsGkAtoms::name, nullptr, nsGkAtoms::DOMAttrName, nsGkAtoms::DOMAttrValue}
#define MARKUPMAP(atom, new_func, r, ...) \
{nsGkAtoms::atom, new_func, static_cast<a11y::role>(r), {__VA_ARGS__}},
static const MarkupMapInfo sHTMLMarkupMapList[] = {
#include "HTMLMarkupMap.h"
};
static const MarkupMapInfo sMathMLMarkupMapList[] = {
#include "MathMLMarkupMap.h"
};
#undef MARKUPMAP
#define XULMAP(atom, ...) {nsGkAtoms::atom, __VA_ARGS__},
#define XULMAP_TYPE(atom, new_type) \
XULMAP( \
atom, \
[](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* { \
return new new_type(aElement, aContext->Document()); \
})
static const XULMarkupMapInfo sXULMarkupMapList[] = {
#include "XULMap.h"
};
#undef XULMAP_TYPE
#undef XULMAP
#undef Attr
#undef AttrFromDOM
#undef AttrFromDOMIf
////////////////////////////////////////////////////////////////////////////////
// nsAccessibilityService
////////////////////////////////////////////////////////////////////////////////
nsAccessibilityService* nsAccessibilityService::gAccessibilityService = nullptr;
ApplicationAccessible* nsAccessibilityService::gApplicationAccessible = nullptr;
xpcAccessibleApplication* nsAccessibilityService::gXPCApplicationAccessible =
nullptr;
uint32_t nsAccessibilityService::gConsumers = 0;
uint64_t nsAccessibilityService::gCacheDomains =
nsAccessibilityService::kDefaultCacheDomains;
nsAccessibilityService::nsAccessibilityService()
: mHTMLMarkupMap(std::size(sHTMLMarkupMapList)),
mMathMLMarkupMap(std::size(sMathMLMarkupMapList)),
mXULMarkupMap(std::size(sXULMarkupMapList)) {}
nsAccessibilityService::~nsAccessibilityService() {
NS_ASSERTION(IsShutdown(), "Accessibility wasn't shutdown!");
gAccessibilityService = nullptr;
}
////////////////////////////////////////////////////////////////////////////////
// nsIListenerChangeListener
NS_IMETHODIMP
nsAccessibilityService::ListenersChanged(nsIArray* aEventChanges) {
uint32_t targetCount;
nsresult rv = aEventChanges->GetLength(&targetCount);
NS_ENSURE_SUCCESS(rv, rv);
for (uint32_t i = 0; i < targetCount; i++) {
nsCOMPtr<nsIEventListenerChange> change =
do_QueryElementAt(aEventChanges, i);
RefPtr<EventTarget> target;
change->GetTarget(getter_AddRefs(target));
nsIContent* content(nsIContent::FromEventTargetOrNull(target));
if (!content || !content->IsHTMLElement()) {
continue;
}
uint32_t changeCount;
change->GetCountOfEventListenerChangesAffectingAccessibility(&changeCount);
NS_ENSURE_SUCCESS(rv, rv);
if (changeCount) {
Document* ownerDoc = content->OwnerDoc();
DocAccessible* document = GetExistingDocAccessible(ownerDoc);
if (document) {
LocalAccessible* acc = document->GetAccessible(content);
if (!acc && (content == document->GetContent() ||
content == document->DocumentNode()->GetRootElement())) {
acc = document;
}
if (!acc && content->IsElement() &&
content->AsElement()->IsHTMLElement(nsGkAtoms::area)) {
// For area accessibles, we have to recreate the entire image map,
// since the image map accessible manages the tree itself. The click
// listener change may require us to update the role for the
// accessible associated with the area element.
LocalAccessible* areaAcc =
document->GetAccessibleEvenIfNotInMap(content);
if (areaAcc && areaAcc->LocalParent()) {
document->RecreateAccessible(areaAcc->LocalParent()->GetContent());
}
}
if (!acc && nsCoreUtils::HasClickListener(content)) {
// Create an accessible for a inaccessible element having click event
// handler.
document->ContentInserted(content, content->GetNextSibling());
} else if (acc) {
if ((acc->IsHTMLLink() && !acc->AsHTMLLink()->IsLinked()) ||
(content->IsElement() &&
content->AsElement()->IsHTMLElement(nsGkAtoms::a) &&
!acc->IsHTMLLink())) {
// An HTML link without an href attribute should have a generic
// role, unless it has a click listener. Since we might have gained
// or lost a click listener here, recreate the accessible so that we
// can create the correct type of accessible. If it was a link, it
// may no longer be one. If it wasn't, it may become one.
document->RecreateAccessible(content);
}
// A click listener change might mean losing or gaining an action.
document->QueueCacheUpdate(acc, CacheDomain::Actions);
}
}
}
}
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// nsISupports
NS_IMPL_ISUPPORTS_INHERITED(nsAccessibilityService, DocManager, nsIObserver,
nsIListenerChangeListener,
nsISelectionListener) // from SelectionManager
////////////////////////////////////////////////////////////////////////////////
// nsIObserver
NS_IMETHODIMP
nsAccessibilityService::Observe(nsISupports* aSubject, const char* aTopic,
const char16_t* aData) {
if (!nsCRT::strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
Shutdown();
}
return NS_OK;
}
void nsAccessibilityService::NotifyOfAnchorJumpTo(nsIContent* aTargetNode) {
Document* documentNode = aTargetNode->GetUncomposedDoc();
if (!documentNode) {
return;
}
DocAccessible* document = GetDocAccessible(documentNode);
if (!document) {
return;
}
// If the document has focus when we get this notification, ensure that
// we fire a start scrolling event.
const Accessible* focusedAcc = FocusedAccessible();
if (focusedAcc &&
(focusedAcc == document || focusedAcc->IsNonInteractive())) {
LocalAccessible* targetAcc =
document->GetAccessibleOrContainer(aTargetNode);
// If targetAcc is the document, this isn't useful. It's possible we just
// haven't built the initial tree yet. Regardless, we don't want to fire an
// event for the document here.
if (targetAcc && !targetAcc->IsDoc()) {
nsEventShell::FireEvent(nsIAccessibleEvent::EVENT_SCROLLING_START,
targetAcc);
document->SetAnchorJump(nullptr);
} else {
// We can't find the target accessible in the document yet. Set the
// anchor jump so that we can fire the scrolling start event later.
document->SetAnchorJump(aTargetNode);
}
} else {
document->SetAnchorJump(aTargetNode);
}
}
void nsAccessibilityService::FireAccessibleEvent(uint32_t aEvent,
LocalAccessible* aTarget) {
nsEventShell::FireEvent(aEvent, aTarget);
}
void nsAccessibilityService::NotifyOfPossibleBoundsChange(
mozilla::PresShell* aPresShell, nsIContent* aContent) {
if (IPCAccessibilityActive()) {
DocAccessible* document = aPresShell->GetDocAccessible();
if (document) {
LocalAccessible* accessible = document->GetAccessible(aContent);
if (!accessible && aContent == document->GetContent()) {
// DocAccessible::GetAccessible() won't return the document if a root
// element like body is passed. In that case we need the doc accessible
// itself.
accessible = document;
}
if (accessible) {
document->QueueCacheUpdate(accessible, CacheDomain::Bounds);
}
}
}
}
void nsAccessibilityService::NotifyOfComputedStyleChange(
mozilla::PresShell* aPresShell, nsIContent* aContent) {
DocAccessible* document = aPresShell->GetDocAccessible();
if (!document) {
return;
}
LocalAccessible* accessible = document->GetAccessible(aContent);
if (!accessible && aContent == document->GetContent()) {
// DocAccessible::GetAccessible() won't return the document if a root
// element like body is passed. In that case we need the doc accessible
// itself.
accessible = document;
}
if (!accessible && aContent && aContent->HasChildren() &&
!aContent->IsInNativeAnonymousSubtree()) {
// If the content has children and its frame has a transform, create an
// Accessible so that we can account for the transform when calculating
// the Accessible's bounds using the parent process cache. Ditto for
// position: fixed/sticky and content with overflow styling (hidden, auto,
// scroll)
if (const nsIFrame* frame = aContent->GetPrimaryFrame()) {
const auto& disp = *frame->StyleDisplay();
if (disp.HasTransform(frame) ||
disp.mPosition == StylePositionProperty::Fixed ||
disp.mPosition == StylePositionProperty::Sticky ||
disp.IsScrollableOverflow()) {
document->ContentInserted(aContent, aContent->GetNextSibling());
}
}
} else if (accessible && IPCAccessibilityActive()) {
accessible->MaybeQueueCacheUpdateForStyleChanges();
}
}
void nsAccessibilityService::NotifyOfResolutionChange(
mozilla::PresShell* aPresShell, float aResolution) {
DocAccessible* document = aPresShell->GetDocAccessible();
if (document && document->IPCDoc()) {
AutoTArray<mozilla::a11y::CacheData, 1> data;
RefPtr<AccAttributes> fields = new AccAttributes();
fields->SetAttribute(CacheKey::Resolution, aResolution);
data.AppendElement(mozilla::a11y::CacheData(0, fields));
document->IPCDoc()->SendCache(CacheUpdateType::Update, data);
}
}
void nsAccessibilityService::NotifyOfDevPixelRatioChange(
mozilla::PresShell* aPresShell, int32_t aAppUnitsPerDevPixel) {
DocAccessible* document = aPresShell->GetDocAccessible();
if (document && document->IPCDoc()) {
AutoTArray<mozilla::a11y::CacheData, 1> data;
RefPtr<AccAttributes> fields = new AccAttributes();
fields->SetAttribute(CacheKey::AppUnitsPerDevPixel, aAppUnitsPerDevPixel);
data.AppendElement(mozilla::a11y::CacheData(0, fields));
document->IPCDoc()->SendCache(CacheUpdateType::Update, data);
}
}
void nsAccessibilityService::NotifyAttrElementWillChange(
mozilla::dom::Element* aElement, nsAtom* aAttr) {
mozilla::dom::Document* doc = aElement->OwnerDoc();
MOZ_ASSERT(doc);
if (DocAccessible* docAcc = GetDocAccessible(doc)) {
docAcc->AttrElementWillChange(aElement, aAttr);
}
}
void nsAccessibilityService::NotifyAttrElementChanged(
mozilla::dom::Element* aElement, nsAtom* aAttr) {
mozilla::dom::Document* doc = aElement->OwnerDoc();
MOZ_ASSERT(doc);
if (DocAccessible* docAcc = GetDocAccessible(doc)) {
docAcc->AttrElementChanged(aElement, aAttr);
}
}
LocalAccessible* nsAccessibilityService::GetRootDocumentAccessible(
PresShell* aPresShell, bool aCanCreate) {
PresShell* presShell = aPresShell;
Document* documentNode = aPresShell->GetDocument();
if (documentNode) {
nsCOMPtr<nsIDocShellTreeItem> treeItem(documentNode->GetDocShell());
if (treeItem) {
nsCOMPtr<nsIDocShellTreeItem> rootTreeItem;
treeItem->GetInProcessRootTreeItem(getter_AddRefs(rootTreeItem));
if (treeItem != rootTreeItem) {
nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(rootTreeItem));
presShell = docShell->GetPresShell();
}
return aCanCreate ? GetDocAccessible(presShell)
: presShell->GetDocAccessible();
}
}
return nullptr;
}
void nsAccessibilityService::NotifyOfTabPanelVisibilityChange(
PresShell* aPresShell, Element* aPanel, bool aNowVisible) {
MOZ_ASSERT(aPanel->GetParent()->IsXULElement(nsGkAtoms::tabpanels));
DocAccessible* document = GetDocAccessible(aPresShell);
if (!document) {
return;
}
if (LocalAccessible* acc = document->GetAccessible(aPanel)) {
RefPtr<AccEvent> event =
new AccStateChangeEvent(acc, states::OFFSCREEN, aNowVisible);
document->FireDelayedEvent(event);
}
}
void nsAccessibilityService::ContentRangeInserted(PresShell* aPresShell,
nsIContent* aStartChild,
nsIContent* aEndChild) {
DocAccessible* document = GetDocAccessible(aPresShell);
#ifdef A11Y_LOG
if (logging::IsEnabled(logging::eTree)) {
logging::MsgBegin("TREE", "content inserted; doc: %p", document);
logging::Node("container", aStartChild->GetParentNode());
for (nsIContent* child = aStartChild; child != aEndChild;
child = child->GetNextSibling()) {
logging::Node("content", child);
}
logging::MsgEnd();
logging::Stack();
}
#endif
if (document) {
document->ContentInserted(aStartChild, aEndChild);
}
}
void nsAccessibilityService::ScheduleAccessibilitySubtreeUpdate(
PresShell* aPresShell, nsIContent* aContent) {
DocAccessible* document = GetDocAccessible(aPresShell);
#ifdef A11Y_LOG
if (logging::IsEnabled(logging::eTree)) {
logging::MsgBegin("TREE", "schedule update; doc: %p", document);
logging::Node("content node", aContent);
logging::MsgEnd();
}
#endif
if (document) {
document->ScheduleTreeUpdate(aContent);
}
}
void nsAccessibilityService::ContentRemoved(PresShell* aPresShell,
nsIContent* aChildNode) {
DocAccessible* document = GetDocAccessible(aPresShell);
#ifdef A11Y_LOG
if (logging::IsEnabled(logging::eTree)) {
logging::MsgBegin("TREE", "content removed; doc: %p", document);
logging::Node("container node", aChildNode->GetFlattenedTreeParent());
logging::Node("content node", aChildNode);
logging::MsgEnd();
}
#endif
if (document) {
document->ContentRemoved(aChildNode);
}
#ifdef A11Y_LOG
if (logging::IsEnabled(logging::eTree)) {
logging::MsgEnd();
logging::Stack();
}
#endif
}
void nsAccessibilityService::TableLayoutGuessMaybeChanged(
PresShell* aPresShell, nsIContent* aContent) {
if (DocAccessible* document = GetDocAccessible(aPresShell)) {
if (LocalAccessible* acc = document->GetAccessible(aContent)) {
if (LocalAccessible* table = nsAccUtils::TableFor(acc)) {
document->QueueCacheUpdate(table, CacheDomain::Table);
}
}
}
}
void nsAccessibilityService::ComboboxOptionMaybeChanged(
PresShell* aPresShell, nsIContent* aMutatingNode) {
DocAccessible* document = GetDocAccessible(aPresShell);
if (!document) {
return;
}
for (nsIContent* cur = aMutatingNode; cur; cur = cur->GetParent()) {
if (cur->IsHTMLElement(nsGkAtoms::option)) {
if (LocalAccessible* accessible = document->GetAccessible(cur)) {
document->FireDelayedEvent(nsIAccessibleEvent::EVENT_NAME_CHANGE,
accessible);
break;
}
if (cur->IsHTMLElement(nsGkAtoms::select)) {
break;
}
}
}
}
void nsAccessibilityService::UpdateText(PresShell* aPresShell,
nsIContent* aContent) {
DocAccessible* document = GetDocAccessible(aPresShell);
if (document) document->UpdateText(aContent);
}
void nsAccessibilityService::TreeViewChanged(PresShell* aPresShell,
nsIContent* aContent,
nsITreeView* aView) {
DocAccessible* document = GetDocAccessible(aPresShell);
if (document) {
LocalAccessible* accessible = document->GetAccessible(aContent);
if (accessible) {
XULTreeAccessible* treeAcc = accessible->AsXULTree();
if (treeAcc) treeAcc->TreeViewChanged(aView);
}
}
}
void nsAccessibilityService::RangeValueChanged(PresShell* aPresShell,
nsIContent* aContent) {
DocAccessible* document = GetDocAccessible(aPresShell);
if (document) {
LocalAccessible* accessible = document->GetAccessible(aContent);
if (accessible) {
document->FireDelayedEvent(nsIAccessibleEvent::EVENT_VALUE_CHANGE,
accessible);
}
}
}
void nsAccessibilityService::UpdateImageMap(nsImageFrame* aImageFrame) {
PresShell* presShell = aImageFrame->PresShell();
DocAccessible* document = GetDocAccessible(presShell);
if (document) {
LocalAccessible* accessible =
document->GetAccessible(aImageFrame->GetContent());
if (accessible) {
HTMLImageMapAccessible* imageMap = accessible->AsImageMap();
if (imageMap) {
imageMap->UpdateChildAreas();
return;
}
// If image map was initialized after we created an accessible (that'll
// be an image accessible) then recreate it.
RecreateAccessible(presShell, aImageFrame->GetContent());
}
}
}
void nsAccessibilityService::UpdateLabelValue(PresShell* aPresShell,
nsIContent* aLabelElm,
const nsString& aNewValue) {
DocAccessible* document = GetDocAccessible(aPresShell);
if (document) {
LocalAccessible* accessible = document->GetAccessible(aLabelElm);
if (accessible) {
XULLabelAccessible* xulLabel = accessible->AsXULLabel();
NS_ASSERTION(xulLabel,
"UpdateLabelValue was called for wrong accessible!");
if (xulLabel) xulLabel->UpdateLabelValue(aNewValue);
}
}
}
void nsAccessibilityService::PresShellActivated(PresShell* aPresShell) {
DocAccessible* document = aPresShell->GetDocAccessible();
if (document) {
RootAccessible* rootDocument = document->RootAccessible();
NS_ASSERTION(rootDocument, "Entirely broken tree: no root document!");
if (rootDocument) rootDocument->DocumentActivated(document);
}
}
void nsAccessibilityService::RecreateAccessible(PresShell* aPresShell,
nsIContent* aContent) {
DocAccessible* document = GetDocAccessible(aPresShell);
if (document) document->RecreateAccessible(aContent);
}
void nsAccessibilityService::GetStringRole(uint32_t aRole, nsAString& aString) {
#define ROLE(geckoRole, stringRole, ariaRole, atkRole, macRole, macSubrole, \
msaaRole, ia2Role, androidClass, iosIsElement, uiaControlType, \
nameRule) \
case roles::geckoRole: \
aString.AssignLiteral(stringRole); \
return;
switch (aRole) {
#include "RoleMap.h"
default:
aString.AssignLiteral("unknown");
return;
}
#undef ROLE
}
void nsAccessibilityService::GetStringStates(uint32_t aState,
uint32_t aExtraState,
nsISupports** aStringStates) {
RefPtr<DOMStringList> stringStates =
GetStringStates(nsAccUtils::To64State(aState, aExtraState));
// unknown state
if (!stringStates->Length()) {
stringStates->Add(u"unknown"_ns);
}
stringStates.forget(aStringStates);
}
already_AddRefed<DOMStringList> nsAccessibilityService::GetStringStates(
uint64_t aStates) const {
RefPtr<DOMStringList> stringStates = new DOMStringList();
if (aStates & states::UNAVAILABLE) {
stringStates->Add(u"unavailable"_ns);
}
if (aStates & states::SELECTED) {
stringStates->Add(u"selected"_ns);
}
if (aStates & states::FOCUSED) {
stringStates->Add(u"focused"_ns);
}
if (aStates & states::PRESSED) {
stringStates->Add(u"pressed"_ns);
}
if (aStates & states::CHECKED) {
stringStates->Add(u"checked"_ns);
}
if (aStates & states::MIXED) {
stringStates->Add(u"mixed"_ns);
}
if (aStates & states::READONLY) {
stringStates->Add(u"readonly"_ns);
}
if (aStates & states::HOTTRACKED) {
stringStates->Add(u"hottracked"_ns);
}
if (aStates & states::DEFAULT) {
stringStates->Add(u"default"_ns);
}
if (aStates & states::EXPANDED) {
stringStates->Add(u"expanded"_ns);
}
if (aStates & states::COLLAPSED) {
stringStates->Add(u"collapsed"_ns);
}
if (aStates & states::BUSY) {
stringStates->Add(u"busy"_ns);
}
if (aStates & states::FLOATING) {
stringStates->Add(u"floating"_ns);
}
if (aStates & states::ANIMATED) {
stringStates->Add(u"animated"_ns);
}
if (aStates & states::INVISIBLE) {
stringStates->Add(u"invisible"_ns);
}
if (aStates & states::OFFSCREEN) {
stringStates->Add(u"offscreen"_ns);
}
if (aStates & states::SIZEABLE) {
stringStates->Add(u"sizeable"_ns);
}
if (aStates & states::MOVEABLE) {
stringStates->Add(u"moveable"_ns);
}
if (aStates & states::SELFVOICING) {
stringStates->Add(u"selfvoicing"_ns);
}
if (aStates & states::FOCUSABLE) {
stringStates->Add(u"focusable"_ns);
}
if (aStates & states::SELECTABLE) {
stringStates->Add(u"selectable"_ns);
}
if (aStates & states::LINKED) {
stringStates->Add(u"linked"_ns);
}
if (aStates & states::TRAVERSED) {
stringStates->Add(u"traversed"_ns);
}
if (aStates & states::MULTISELECTABLE) {
stringStates->Add(u"multiselectable"_ns);
}
if (aStates & states::EXTSELECTABLE) {
stringStates->Add(u"extselectable"_ns);
}
if (aStates & states::PROTECTED) {
stringStates->Add(u"protected"_ns);
}
if (aStates & states::HASPOPUP) {
stringStates->Add(u"haspopup"_ns);
}
if (aStates & states::REQUIRED) {
stringStates->Add(u"required"_ns);
}
if (aStates & states::ALERT) {
stringStates->Add(u"alert"_ns);
}
if (aStates & states::INVALID) {
stringStates->Add(u"invalid"_ns);
}
if (aStates & states::CHECKABLE) {
stringStates->Add(u"checkable"_ns);
}
if (aStates & states::SUPPORTS_AUTOCOMPLETION) {
stringStates->Add(u"autocompletion"_ns);
}
if (aStates & states::DEFUNCT) {
stringStates->Add(u"defunct"_ns);
}
if (aStates & states::SELECTABLE_TEXT) {
stringStates->Add(u"selectable text"_ns);
}
if (aStates & states::EDITABLE) {
stringStates->Add(u"editable"_ns);
}
if (aStates & states::ACTIVE) {
stringStates->Add(u"active"_ns);
}
if (aStates & states::MODAL) {
stringStates->Add(u"modal"_ns);
}
if (aStates & states::MULTI_LINE) {
stringStates->Add(u"multi line"_ns);
}
if (aStates & states::HORIZONTAL) {
stringStates->Add(u"horizontal"_ns);
}
if (aStates & states::OPAQUE1) {
stringStates->Add(u"opaque"_ns);
}
if (aStates & states::SINGLE_LINE) {
stringStates->Add(u"single line"_ns);
}
if (aStates & states::TRANSIENT) {
stringStates->Add(u"transient"_ns);
}
if (aStates & states::VERTICAL) {
stringStates->Add(u"vertical"_ns);
}
if (aStates & states::STALE) {
stringStates->Add(u"stale"_ns);
}
if (aStates & states::ENABLED) {
stringStates->Add(u"enabled"_ns);
}
if (aStates & states::SENSITIVE) {
stringStates->Add(u"sensitive"_ns);
}
if (aStates & states::EXPANDABLE) {
stringStates->Add(u"expandable"_ns);
}
if (aStates & states::PINNED) {
stringStates->Add(u"pinned"_ns);
}
if (aStates & states::CURRENT) {
stringStates->Add(u"current"_ns);
}
return stringStates.forget();
}
void nsAccessibilityService::GetStringEventType(uint32_t aEventType,
nsAString& aString) {
static_assert(
nsIAccessibleEvent::EVENT_LAST_ENTRY == std::size(kEventTypeNames),
"nsIAccessibleEvent constants are out of sync to kEventTypeNames");
if (aEventType >= std::size(kEventTypeNames)) {
aString.AssignLiteral("unknown");
return;
}
aString.AssignASCII(kEventTypeNames[aEventType]);
}
void nsAccessibilityService::GetStringEventType(uint32_t aEventType,
nsACString& aString) {
MOZ_ASSERT(nsIAccessibleEvent::EVENT_LAST_ENTRY == std::size(kEventTypeNames),
"nsIAccessibleEvent constants are out of sync to kEventTypeNames");
if (aEventType >= std::size(kEventTypeNames)) {
aString.AssignLiteral("unknown");
return;
}
aString = nsDependentCString(kEventTypeNames[aEventType]);
}
void nsAccessibilityService::GetStringRelationType(uint32_t aRelationType,
nsAString& aString) {
NS_ENSURE_TRUE_VOID(aRelationType <=
static_cast<uint32_t>(RelationType::LAST));
#define RELATIONTYPE(geckoType, geckoTypeName, atkType, msaaType, ia2Type) \
case RelationType::geckoType: \
aString.AssignLiteral(geckoTypeName); \
return;
RelationType relationType = static_cast<RelationType>(aRelationType);
switch (relationType) {
#include "RelationTypeMap.h"
default:
aString.AssignLiteral("unknown");
return;
}
#undef RELATIONTYPE
}
////////////////////////////////////////////////////////////////////////////////
// nsAccessibilityService public
LocalAccessible* nsAccessibilityService::CreateAccessible(
nsINode* aNode, LocalAccessible* aContext, bool* aIsSubtreeHidden) {
MOZ_ASSERT(aContext, "No context provided");
MOZ_ASSERT(aNode, "No node to create an accessible for");
MOZ_ASSERT(gConsumers, "No creation after shutdown");
if (aIsSubtreeHidden) *aIsSubtreeHidden = false;
DocAccessible* document = aContext->Document();
MOZ_ASSERT(!document->GetAccessible(aNode),
"We already have an accessible for this node.");
if (aNode->IsDocument()) {
// If it's document node then ask accessible document loader for
// document accessible, otherwise return null.
return GetDocAccessible(aNode->AsDocument());
}
// We have a content node.
if (!aNode->GetComposedDoc()) {
NS_WARNING("Creating accessible for node with no document");
return nullptr;
}
if (aNode->OwnerDoc() != document->DocumentNode()) {
NS_ERROR("Creating accessible for wrong document");
return nullptr;
}
if (!aNode->IsContent()) return nullptr;
nsIContent* content = aNode->AsContent();
if (aria::HasDefinedARIAHidden(content)) {
if (aIsSubtreeHidden) {
*aIsSubtreeHidden = true;
}
return nullptr;
}
// Check frame and its visibility.
nsIFrame* frame = content->GetPrimaryFrame();
if (frame) {
// If invisible or inert, we don't create an accessible, but we don't mark
// it with aIsSubtreeHidden = true, since visibility: hidden frame allows
// visible elements in subtree, and inert elements allow non-inert
// elements.
if (!frame->StyleVisibility()->IsVisible() || frame->StyleUI()->IsInert()) {
return nullptr;
}
} else if (nsCoreUtils::CanCreateAccessibleWithoutFrame(content)) {
// display:contents element doesn't have a frame, but retains the
// semantics. All its children are unaffected.
const nsRoleMapEntry* roleMapEntry = aria::GetRoleMap(content->AsElement());
RefPtr<LocalAccessible> newAcc = MaybeCreateSpecificARIAAccessible(
roleMapEntry, aContext, content, document);
const MarkupMapInfo* markupMap = nullptr;
if (!newAcc) {
markupMap = GetMarkupMapInfoFor(content);
if (markupMap && markupMap->new_func) {
newAcc = markupMap->new_func(content->AsElement(), aContext);
}
}
// SVG elements are not in a markup map, but we may still need to create an
// accessible for one, even in the case of display:contents.
if (!newAcc && content->IsSVGElement()) {
newAcc = MaybeCreateSVGAccessible(content, document);
}
// Check whether this element has an ARIA role or attribute that requires
// us to create an Accessible.
const bool hasNonPresentationalARIARole =
roleMapEntry && !roleMapEntry->Is(nsGkAtoms::presentation) &&
!roleMapEntry->Is(nsGkAtoms::none);
if (!newAcc &&
(hasNonPresentationalARIARole || MustBeAccessible(content, document))) {
newAcc = new HyperTextAccessible(content, document);
}
// If there's still no Accessible but we do have an entry in the markup
// map for this non-presentational element, create a generic
// HyperTextAccessible.
if (!newAcc && markupMap &&
(!roleMapEntry || hasNonPresentationalARIARole)) {
newAcc = new HyperTextAccessible(content, document);
}
if (newAcc) {
document->BindToDocument(newAcc, roleMapEntry);
}
return newAcc;
} else {
if (aIsSubtreeHidden) {
*aIsSubtreeHidden = true;
}
return nullptr;
}
if (frame->IsHiddenByContentVisibilityOnAnyAncestor(
nsIFrame::IncludeContentVisibility::Hidden)) {
if (aIsSubtreeHidden) {
*aIsSubtreeHidden = true;
}
return nullptr;
}
if (nsMenuPopupFrame* popupFrame = do_QueryFrame(frame)) {
// Hidden tooltips and panels don't create accessibles in the whole subtree.
// Showing them gets handled by RootAccessible::ProcessDOMEvent.
if (content->IsAnyOfXULElements(nsGkAtoms::tooltip, nsGkAtoms::panel)) {
nsPopupState popupState = popupFrame->PopupState();
if (popupState == ePopupHiding || popupState == ePopupInvisible ||
popupState == ePopupClosed) {
if (aIsSubtreeHidden) {
*aIsSubtreeHidden = true;
}
return nullptr;
}
}
}
if (frame->GetContent() != content) {
// Not the main content for this frame. This happens because <area>
// elements return the image frame as their primary frame. The main content
// for the image frame is the image content. If the frame is not an image
// frame or the node is not an area element then null is returned.
// This setup will change when bug 135040 is fixed. Make sure we don't