summaryrefslogtreecommitdiffstats
path: root/accessible/ipc/RemoteAccessible.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'accessible/ipc/RemoteAccessible.cpp')
-rw-r--r--accessible/ipc/RemoteAccessible.cpp2092
1 files changed, 2092 insertions, 0 deletions
diff --git a/accessible/ipc/RemoteAccessible.cpp b/accessible/ipc/RemoteAccessible.cpp
new file mode 100644
index 0000000000..772fc58776
--- /dev/null
+++ b/accessible/ipc/RemoteAccessible.cpp
@@ -0,0 +1,2092 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* 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 "ARIAMap.h"
+#include "CachedTableAccessible.h"
+#include "RemoteAccessible.h"
+#include "mozilla/a11y/DocAccessibleParent.h"
+#include "mozilla/a11y/DocManager.h"
+#include "mozilla/a11y/Platform.h"
+#include "mozilla/a11y/TableAccessible.h"
+#include "mozilla/a11y/TableCellAccessible.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/BrowserParent.h"
+#include "mozilla/dom/CanonicalBrowsingContext.h"
+#include "mozilla/gfx/Matrix.h"
+#include "nsAccessibilityService.h"
+#include "mozilla/Unused.h"
+#include "nsAccUtils.h"
+#include "nsTextEquivUtils.h"
+#include "Pivot.h"
+#include "Relation.h"
+#include "mozilla/a11y/RelationType.h"
+#include "xpcAccessibleDocument.h"
+
+#ifdef A11Y_LOG
+# include "Logging.h"
+# define VERIFY_CACHE(domain) \
+ if (logging::IsEnabled(logging::eCache)) { \
+ Unused << mDoc->SendVerifyCache(mID, domain, mCachedFields); \
+ }
+#else
+# define VERIFY_CACHE(domain) \
+ do { \
+ } while (0)
+
+#endif
+
+namespace mozilla {
+namespace a11y {
+
+void RemoteAccessible::Shutdown() {
+ MOZ_DIAGNOSTIC_ASSERT(!IsDoc());
+ xpcAccessibleDocument* xpcDoc =
+ GetAccService()->GetCachedXPCDocument(Document());
+ if (xpcDoc) {
+ xpcDoc->NotifyOfShutdown(static_cast<RemoteAccessible*>(this));
+ }
+
+ if (IsTable() || IsTableCell()) {
+ CachedTableAccessible::Invalidate(this);
+ }
+
+ // Remove this acc's relation map from the doc's map of
+ // reverse relations. Prune forward relations associated with this
+ // acc's reverse relations. This also removes the acc's map of reverse
+ // rels from the mDoc's mReverseRelations.
+ PruneRelationsOnShutdown();
+
+ // XXX Ideally this wouldn't be necessary, but it seems OuterDoc
+ // accessibles can be destroyed before the doc they own.
+ uint32_t childCount = mChildren.Length();
+ if (!IsOuterDoc()) {
+ for (uint32_t idx = 0; idx < childCount; idx++) mChildren[idx]->Shutdown();
+ } else {
+ if (childCount > 1) {
+ MOZ_CRASH("outer doc has too many documents!");
+ } else if (childCount == 1) {
+ mChildren[0]->AsDoc()->Unbind();
+ }
+ }
+
+ mChildren.Clear();
+ ProxyDestroyed(static_cast<RemoteAccessible*>(this));
+ mDoc->RemoveAccessible(static_cast<RemoteAccessible*>(this));
+}
+
+void RemoteAccessible::SetChildDoc(DocAccessibleParent* aChildDoc) {
+ MOZ_ASSERT(aChildDoc);
+ MOZ_ASSERT(mChildren.Length() == 0);
+ mChildren.AppendElement(aChildDoc);
+}
+
+void RemoteAccessible::ClearChildDoc(DocAccessibleParent* aChildDoc) {
+ MOZ_ASSERT(aChildDoc);
+ // This is possible if we're replacing one document with another: Doc 1
+ // has not had a chance to remove itself, but was already replaced by Doc 2
+ // in SetChildDoc(). This could result in two subsequent calls to
+ // ClearChildDoc() even though mChildren.Length() == 1.
+ MOZ_ASSERT(mChildren.Length() <= 1);
+ mChildren.RemoveElement(aChildDoc);
+}
+
+uint32_t RemoteAccessible::EmbeddedChildCount() {
+ size_t count = 0, kids = mChildren.Length();
+ for (size_t i = 0; i < kids; i++) {
+ if (mChildren[i]->IsEmbeddedObject()) {
+ count++;
+ }
+ }
+
+ return count;
+}
+
+int32_t RemoteAccessible::IndexOfEmbeddedChild(Accessible* aChild) {
+ size_t index = 0, kids = mChildren.Length();
+ for (size_t i = 0; i < kids; i++) {
+ if (mChildren[i]->IsEmbeddedObject()) {
+ if (mChildren[i] == aChild) {
+ return index;
+ }
+
+ index++;
+ }
+ }
+
+ return -1;
+}
+
+Accessible* RemoteAccessible::EmbeddedChildAt(uint32_t aChildIdx) {
+ size_t index = 0, kids = mChildren.Length();
+ for (size_t i = 0; i < kids; i++) {
+ if (!mChildren[i]->IsEmbeddedObject()) {
+ continue;
+ }
+
+ if (index == aChildIdx) {
+ return mChildren[i];
+ }
+
+ index++;
+ }
+
+ return nullptr;
+}
+
+LocalAccessible* RemoteAccessible::OuterDocOfRemoteBrowser() const {
+ auto tab = static_cast<dom::BrowserParent*>(mDoc->Manager());
+ dom::Element* frame = tab->GetOwnerElement();
+ NS_ASSERTION(frame, "why isn't the tab in a frame!");
+ if (!frame) return nullptr;
+
+ DocAccessible* chromeDoc = GetExistingDocAccessible(frame->OwnerDoc());
+
+ return chromeDoc ? chromeDoc->GetAccessible(frame) : nullptr;
+}
+
+void RemoteAccessible::SetParent(RemoteAccessible* aParent) {
+ if (!aParent) {
+ mParent = kNoParent;
+ } else {
+ MOZ_ASSERT(!IsDoc() || !aParent->IsDoc());
+ mParent = aParent->ID();
+ }
+}
+
+RemoteAccessible* RemoteAccessible::RemoteParent() const {
+ if (mParent == kNoParent) {
+ return nullptr;
+ }
+
+ // if we are not a document then are parent is another proxy in the same
+ // document. That means we can just ask our document for the proxy with our
+ // parent id.
+ if (!IsDoc()) {
+ return Document()->GetAccessible(mParent);
+ }
+
+ // If we are a top level document then our parent is not a proxy.
+ if (AsDoc()->IsTopLevel()) {
+ return nullptr;
+ }
+
+ // Finally if we are a non top level document then our parent id is for a
+ // proxy in our parent document so get the proxy from there.
+ DocAccessibleParent* parentDoc = AsDoc()->ParentDoc();
+ MOZ_ASSERT(parentDoc);
+ MOZ_ASSERT(mParent);
+ return parentDoc->GetAccessible(mParent);
+}
+
+void RemoteAccessible::ApplyCache(CacheUpdateType aUpdateType,
+ AccAttributes* aFields) {
+ if (!aFields) {
+ MOZ_ASSERT_UNREACHABLE("ApplyCache called with aFields == null");
+ return;
+ }
+
+ const nsTArray<bool> relUpdatesNeeded = PreProcessRelations(aFields);
+ if (auto maybeViewportCache =
+ aFields->GetAttribute<nsTArray<uint64_t>>(CacheKey::Viewport)) {
+ // Updating the viewport cache means the offscreen state of this
+ // document's accessibles has changed. Update the HashSet we use for
+ // checking offscreen state here.
+ MOZ_ASSERT(IsDoc(),
+ "Fetched the viewport cache from a non-doc accessible?");
+ AsDoc()->mOnScreenAccessibles.Clear();
+ for (auto id : *maybeViewportCache) {
+ AsDoc()->mOnScreenAccessibles.Insert(id);
+ }
+ }
+
+ if (aUpdateType == CacheUpdateType::Initial) {
+ mCachedFields = aFields;
+ } else {
+ if (!mCachedFields) {
+ // The fields cache can be uninitialized if there were no cache-worthy
+ // fields in the initial cache push.
+ // We don't do a simple assign because we don't want to store the
+ // DeleteEntry entries.
+ mCachedFields = new AccAttributes();
+ }
+ mCachedFields->Update(aFields);
+ }
+
+ if (IsTextLeaf()) {
+ RemoteAccessible* parent = RemoteParent();
+ if (parent && parent->IsHyperText()) {
+ parent->InvalidateCachedHyperTextOffsets();
+ }
+ }
+
+ PostProcessRelations(relUpdatesNeeded);
+}
+
+ENameValueFlag RemoteAccessible::Name(nsString& aName) const {
+ ENameValueFlag nameFlag = eNameOK;
+ if (mCachedFields) {
+ if (IsText()) {
+ mCachedFields->GetAttribute(CacheKey::Text, aName);
+ return eNameOK;
+ }
+ auto cachedNameFlag =
+ mCachedFields->GetAttribute<int32_t>(CacheKey::NameValueFlag);
+ if (cachedNameFlag) {
+ nameFlag = static_cast<ENameValueFlag>(*cachedNameFlag);
+ }
+ if (mCachedFields->GetAttribute(CacheKey::Name, aName)) {
+ VERIFY_CACHE(CacheDomain::NameAndDescription);
+ return nameFlag;
+ }
+ }
+
+ MOZ_ASSERT(aName.IsEmpty());
+ aName.SetIsVoid(true);
+ return nameFlag;
+}
+
+void RemoteAccessible::Description(nsString& aDescription) const {
+ if (mCachedFields) {
+ mCachedFields->GetAttribute(CacheKey::Description, aDescription);
+ VERIFY_CACHE(CacheDomain::NameAndDescription);
+ }
+}
+
+void RemoteAccessible::Value(nsString& aValue) const {
+ if (mCachedFields) {
+ if (mCachedFields->HasAttribute(CacheKey::TextValue)) {
+ mCachedFields->GetAttribute(CacheKey::TextValue, aValue);
+ VERIFY_CACHE(CacheDomain::Value);
+ return;
+ }
+
+ if (HasNumericValue()) {
+ double checkValue = CurValue();
+ if (!std::isnan(checkValue)) {
+ aValue.AppendFloat(checkValue);
+ }
+ return;
+ }
+
+ const nsRoleMapEntry* roleMapEntry = ARIARoleMap();
+ // Value of textbox is a textified subtree.
+ if (roleMapEntry && roleMapEntry->Is(nsGkAtoms::textbox)) {
+ nsTextEquivUtils::GetTextEquivFromSubtree(this, aValue);
+ return;
+ }
+
+ if (IsCombobox()) {
+ // For combo boxes, rely on selection state to determine the value.
+ const Accessible* option =
+ const_cast<RemoteAccessible*>(this)->GetSelectedItem(0);
+ if (option) {
+ option->Name(aValue);
+ } else {
+ // If no selected item, determine the value from descendant elements.
+ nsTextEquivUtils::GetTextEquivFromSubtree(this, aValue);
+ }
+ return;
+ }
+
+ if (IsTextLeaf() || IsImage()) {
+ if (const Accessible* actionAcc = ActionAncestor()) {
+ if (const_cast<Accessible*>(actionAcc)->State() & states::LINKED) {
+ // Text and image descendants of links expose the link URL as the
+ // value.
+ return actionAcc->Value(aValue);
+ }
+ }
+ }
+ }
+}
+
+double RemoteAccessible::CurValue() const {
+ if (mCachedFields) {
+ if (auto value =
+ mCachedFields->GetAttribute<double>(CacheKey::NumericValue)) {
+ VERIFY_CACHE(CacheDomain::Value);
+ return *value;
+ }
+ }
+
+ return UnspecifiedNaN<double>();
+}
+
+double RemoteAccessible::MinValue() const {
+ if (mCachedFields) {
+ if (auto min = mCachedFields->GetAttribute<double>(CacheKey::MinValue)) {
+ VERIFY_CACHE(CacheDomain::Value);
+ return *min;
+ }
+ }
+
+ return UnspecifiedNaN<double>();
+}
+
+double RemoteAccessible::MaxValue() const {
+ if (mCachedFields) {
+ if (auto max = mCachedFields->GetAttribute<double>(CacheKey::MaxValue)) {
+ VERIFY_CACHE(CacheDomain::Value);
+ return *max;
+ }
+ }
+
+ return UnspecifiedNaN<double>();
+}
+
+double RemoteAccessible::Step() const {
+ if (mCachedFields) {
+ if (auto step = mCachedFields->GetAttribute<double>(CacheKey::Step)) {
+ VERIFY_CACHE(CacheDomain::Value);
+ return *step;
+ }
+ }
+
+ return UnspecifiedNaN<double>();
+}
+
+bool RemoteAccessible::SetCurValue(double aValue) {
+ if (!HasNumericValue() || IsProgress()) {
+ return false;
+ }
+
+ const uint32_t kValueCannotChange = states::READONLY | states::UNAVAILABLE;
+ if (State() & kValueCannotChange) {
+ return false;
+ }
+
+ double checkValue = MinValue();
+ if (!std::isnan(checkValue) && aValue < checkValue) {
+ return false;
+ }
+
+ checkValue = MaxValue();
+ if (!std::isnan(checkValue) && aValue > checkValue) {
+ return false;
+ }
+
+ Unused << mDoc->SendSetCurValue(mID, aValue);
+ return true;
+}
+
+bool RemoteAccessible::ContainsPoint(int32_t aX, int32_t aY) {
+ if (!BoundsWithOffset(Nothing(), true).Contains(aX, aY)) {
+ return false;
+ }
+ if (!IsTextLeaf()) {
+ if (IsImage() || IsImageMap() || !HasChildren() ||
+ RefPtr{DisplayStyle()} != nsGkAtoms::inlinevalue) {
+ // This isn't an inline element that might contain text, so we don't need
+ // to walk lines. It's enough that our rect contains the point.
+ return true;
+ }
+ // Non-image inline elements with children can wrap across lines just like
+ // text leaves; see below.
+ // Walk the children, which will walk the lines of text in any text leaves.
+ uint32_t count = ChildCount();
+ for (uint32_t c = 0; c < count; ++c) {
+ RemoteAccessible* child = RemoteChildAt(c);
+ if (child->Role() == roles::TEXT_CONTAINER && child->IsClipped()) {
+ // There is a clipped child. This is a candidate for fuzzy hit testing.
+ // See RemoteAccessible::DoFuzzyHittesting.
+ return true;
+ }
+ if (child->ContainsPoint(aX, aY)) {
+ return true;
+ }
+ }
+ // None of our descendants contain the point, so nor do we.
+ return false;
+ }
+ // This is a text leaf. The text might wrap across lines, which means our
+ // rect might cover a wider area than the actual text. For example, if the
+ // text begins in the middle of the first line and wraps on to the second,
+ // the rect will cover the start of the first line and the end of the second.
+ auto lines = GetCachedTextLines();
+ if (!lines) {
+ // This means the text is empty or occupies a single line (but does not
+ // begin the line). In that case, the Bounds check above is sufficient,
+ // since there's only one rect.
+ return true;
+ }
+ uint32_t length = lines->Length();
+ MOZ_ASSERT(length > 0,
+ "Line starts shouldn't be in cache if there aren't any");
+ if (length == 0 || (length == 1 && (*lines)[0] == 0)) {
+ // This means the text begins and occupies a single line. Again, the Bounds
+ // check above is sufficient.
+ return true;
+ }
+ // Walk the lines of the text. Even if this text doesn't start at the
+ // beginning of a line (i.e. lines[0] > 0), we always want to consider its
+ // first line.
+ int32_t lineStart = 0;
+ for (uint32_t index = 0; index <= length; ++index) {
+ int32_t lineEnd;
+ if (index < length) {
+ int32_t nextLineStart = (*lines)[index];
+ if (nextLineStart == 0) {
+ // This Accessible starts at the beginning of a line. Here, we always
+ // treat 0 as the first line start anyway.
+ MOZ_ASSERT(index == 0);
+ continue;
+ }
+ lineEnd = nextLineStart - 1;
+ } else {
+ // This is the last line.
+ lineEnd = static_cast<int32_t>(nsAccUtils::TextLength(this)) - 1;
+ }
+ MOZ_ASSERT(lineEnd >= lineStart);
+ nsRect lineRect = GetCachedCharRect(lineStart);
+ if (lineEnd > lineStart) {
+ lineRect.UnionRect(lineRect, GetCachedCharRect(lineEnd));
+ }
+ if (BoundsWithOffset(Some(lineRect), true).Contains(aX, aY)) {
+ return true;
+ }
+ lineStart = lineEnd + 1;
+ }
+ return false;
+}
+
+RemoteAccessible* RemoteAccessible::DoFuzzyHittesting() {
+ uint32_t childCount = ChildCount();
+ if (!childCount) {
+ return nullptr;
+ }
+ // Check if this match has a clipped child.
+ // This usually indicates invisible text, and we're
+ // interested in returning the inner text content
+ // even if it doesn't contain the point we're hittesting.
+ RemoteAccessible* clippedContainer = nullptr;
+ for (uint32_t i = 0; i < childCount; i++) {
+ RemoteAccessible* child = RemoteChildAt(i);
+ if (child->Role() == roles::TEXT_CONTAINER) {
+ if (child->IsClipped()) {
+ clippedContainer = child;
+ break;
+ }
+ }
+ }
+ // If we found a clipped container, descend it in search of
+ // meaningful text leaves. Ignore non-text-leaf/text-container
+ // siblings.
+ RemoteAccessible* container = clippedContainer;
+ while (container) {
+ RemoteAccessible* textLeaf = nullptr;
+ bool continueSearch = false;
+ childCount = container->ChildCount();
+ for (uint32_t i = 0; i < childCount; i++) {
+ RemoteAccessible* child = container->RemoteChildAt(i);
+ if (child->Role() == roles::TEXT_CONTAINER) {
+ container = child;
+ continueSearch = true;
+ break;
+ }
+ if (child->IsTextLeaf()) {
+ textLeaf = child;
+ // Don't break here -- it's possible a text container
+ // exists as another sibling, and we should descend as
+ // deep as possible.
+ }
+ }
+ if (textLeaf) {
+ return textLeaf;
+ }
+ if (!continueSearch) {
+ // We didn't find anything useful in this set of siblings.
+ // Don't keep searching
+ break;
+ }
+ }
+ return nullptr;
+}
+
+Accessible* RemoteAccessible::ChildAtPoint(
+ int32_t aX, int32_t aY, LocalAccessible::EWhichChildAtPoint aWhichChild) {
+ // Elements that are partially on-screen should have their bounds masked by
+ // their containing scroll area so hittesting yields results that are
+ // consistent with the content's visual representation. Pass this value to
+ // bounds calculation functions to indicate that we're hittesting.
+ const bool hitTesting = true;
+
+ if (IsOuterDoc() && aWhichChild == EWhichChildAtPoint::DirectChild) {
+ // This is an iframe, which is as deep as the viewport cache goes. The
+ // caller wants a direct child, which can only be the embedded document.
+ if (BoundsWithOffset(Nothing(), hitTesting).Contains(aX, aY)) {
+ return RemoteFirstChild();
+ }
+ return nullptr;
+ }
+
+ RemoteAccessible* lastMatch = nullptr;
+ // If `this` is a document, use its viewport cache instead of
+ // the cache of its parent document.
+ if (DocAccessibleParent* doc = IsDoc() ? AsDoc() : mDoc) {
+ if (!doc->mCachedFields) {
+ // A client call might arrive after we've constructed doc but before we
+ // get a cache push for it.
+ return nullptr;
+ }
+ if (auto maybeViewportCache =
+ doc->mCachedFields->GetAttribute<nsTArray<uint64_t>>(
+ CacheKey::Viewport)) {
+ // The retrieved viewport cache contains acc IDs in hittesting order.
+ // That is, items earlier in the list have z-indexes that are larger than
+ // those later in the list. If you were to build a tree by z-index, where
+ // chilren have larger z indices than their parents, iterating this list
+ // is essentially a postorder tree traversal.
+ const nsTArray<uint64_t>& viewportCache = *maybeViewportCache;
+
+ for (auto id : viewportCache) {
+ RemoteAccessible* acc = doc->GetAccessible(id);
+ if (!acc) {
+ // This can happen if the acc died in between
+ // pushing the viewport cache and doing this hittest
+ continue;
+ }
+
+ if (acc->IsOuterDoc() &&
+ aWhichChild == EWhichChildAtPoint::DeepestChild &&
+ acc->BoundsWithOffset(Nothing(), hitTesting).Contains(aX, aY)) {
+ // acc is an iframe, which is as deep as the viewport cache goes. This
+ // iframe contains the requested point.
+ RemoteAccessible* innerDoc = acc->RemoteFirstChild();
+ if (innerDoc) {
+ MOZ_ASSERT(innerDoc->IsDoc());
+ // Search the embedded document's viewport cache so we return the
+ // deepest descendant in that embedded document.
+ Accessible* deepestAcc = innerDoc->ChildAtPoint(
+ aX, aY, EWhichChildAtPoint::DeepestChild);
+ MOZ_ASSERT(!deepestAcc || deepestAcc->IsRemote());
+ lastMatch = deepestAcc ? deepestAcc->AsRemote() : nullptr;
+ break;
+ }
+ // If there is no embedded document, the iframe itself is the deepest
+ // descendant.
+ lastMatch = acc;
+ break;
+ }
+
+ if (acc == this) {
+ MOZ_ASSERT(!acc->IsOuterDoc());
+ // Even though we're searching from the doc's cache
+ // this call shouldn't pass the boundary defined by
+ // the acc this call originated on. If we hit `this`,
+ // return our most recent match.
+ if (!lastMatch &&
+ BoundsWithOffset(Nothing(), hitTesting).Contains(aX, aY)) {
+ // If we haven't found a match, but `this` contains the point we're
+ // looking for, set it as our temp last match so we can
+ // (potentially) do fuzzy hittesting on it below.
+ lastMatch = acc;
+ }
+ break;
+ }
+
+ if (acc->ContainsPoint(aX, aY)) {
+ // Because our rects are in hittesting order, the
+ // first match we encounter is guaranteed to be the
+ // deepest match.
+ lastMatch = acc;
+ break;
+ }
+ }
+ if (lastMatch) {
+ RemoteAccessible* fuzzyMatch = lastMatch->DoFuzzyHittesting();
+ lastMatch = fuzzyMatch ? fuzzyMatch : lastMatch;
+ }
+ }
+ }
+
+ if (aWhichChild == EWhichChildAtPoint::DirectChild && lastMatch) {
+ // lastMatch is the deepest match. Walk up to the direct child of this.
+ RemoteAccessible* parent = lastMatch->RemoteParent();
+ for (;;) {
+ if (parent == this) {
+ break;
+ }
+ if (!parent || parent->IsDoc()) {
+ // `this` is not an ancestor of lastMatch. Ignore lastMatch.
+ lastMatch = nullptr;
+ break;
+ }
+ lastMatch = parent;
+ parent = parent->RemoteParent();
+ }
+ } else if (aWhichChild == EWhichChildAtPoint::DeepestChild && lastMatch &&
+ !IsDoc() && !IsAncestorOf(lastMatch)) {
+ // If we end up with a match that is not in the ancestor chain
+ // of the accessible this call originated on, we should ignore it.
+ // This can happen when the aX, aY given are outside `this`.
+ lastMatch = nullptr;
+ }
+
+ if (!lastMatch && BoundsWithOffset(Nothing(), hitTesting).Contains(aX, aY)) {
+ // Even though the hit target isn't inside `this`, the point is still
+ // within our bounds, so fall back to `this`.
+ return this;
+ }
+
+ return lastMatch;
+}
+
+Maybe<nsRect> RemoteAccessible::RetrieveCachedBounds() const {
+ if (!mCachedFields) {
+ return Nothing();
+ }
+
+ Maybe<const nsTArray<int32_t>&> maybeArray =
+ mCachedFields->GetAttribute<nsTArray<int32_t>>(
+ CacheKey::ParentRelativeBounds);
+ if (maybeArray) {
+ const nsTArray<int32_t>& relativeBoundsArr = *maybeArray;
+ MOZ_ASSERT(relativeBoundsArr.Length() == 4,
+ "Incorrectly sized bounds array");
+ nsRect relativeBoundsRect(relativeBoundsArr[0], relativeBoundsArr[1],
+ relativeBoundsArr[2], relativeBoundsArr[3]);
+ return Some(relativeBoundsRect);
+ }
+
+ return Nothing();
+}
+
+void RemoteAccessible::ApplyCrossDocOffset(nsRect& aBounds) const {
+ if (!IsDoc()) {
+ // We should only apply cross-doc offsets to documents. If we're anything
+ // else, return early here.
+ return;
+ }
+
+ RemoteAccessible* parentAcc = RemoteParent();
+ if (!parentAcc || !parentAcc->IsOuterDoc()) {
+ return;
+ }
+
+ Maybe<const nsTArray<int32_t>&> maybeOffset =
+ parentAcc->mCachedFields->GetAttribute<nsTArray<int32_t>>(
+ CacheKey::CrossDocOffset);
+ if (!maybeOffset) {
+ return;
+ }
+
+ MOZ_ASSERT(maybeOffset->Length() == 2);
+ const nsTArray<int32_t>& offset = *maybeOffset;
+ // Our retrieved value is in app units, so we don't need to do any
+ // unit conversion here.
+ aBounds.MoveBy(offset[0], offset[1]);
+}
+
+bool RemoteAccessible::ApplyTransform(nsRect& aCumulativeBounds) const {
+ // First, attempt to retrieve the transform from the cache.
+ Maybe<const UniquePtr<gfx::Matrix4x4>&> maybeTransform =
+ mCachedFields->GetAttribute<UniquePtr<gfx::Matrix4x4>>(
+ CacheKey::TransformMatrix);
+ if (!maybeTransform) {
+ return false;
+ }
+
+ auto mtxInPixels = gfx::Matrix4x4Typed<CSSPixel, CSSPixel>::FromUnknownMatrix(
+ *(*maybeTransform));
+
+ // Our matrix is in CSS Pixels, so we need our rect to be in CSS
+ // Pixels too. Convert before applying.
+ auto boundsInPixels = CSSRect::FromAppUnits(aCumulativeBounds);
+ boundsInPixels = mtxInPixels.TransformBounds(boundsInPixels);
+ aCumulativeBounds = CSSRect::ToAppUnits(boundsInPixels);
+
+ return true;
+}
+
+bool RemoteAccessible::ApplyScrollOffset(nsRect& aBounds) const {
+ Maybe<const nsTArray<int32_t>&> maybeScrollPosition =
+ mCachedFields->GetAttribute<nsTArray<int32_t>>(CacheKey::ScrollPosition);
+
+ if (!maybeScrollPosition || maybeScrollPosition->Length() != 2) {
+ return false;
+ }
+ // Our retrieved value is in app units, so we don't need to do any
+ // unit conversion here.
+ const nsTArray<int32_t>& scrollPosition = *maybeScrollPosition;
+
+ // Scroll position is an inverse representation of scroll offset (since the
+ // further the scroll bar moves down the page, the further the page content
+ // moves up/closer to the origin).
+ nsPoint scrollOffset(-scrollPosition[0], -scrollPosition[1]);
+
+ aBounds.MoveBy(scrollOffset.x, scrollOffset.y);
+
+ // Return true here even if the scroll offset was 0,0 because the RV is used
+ // as a scroll container indicator. Non-scroll containers won't have cached
+ // scroll position.
+ return true;
+}
+
+nsRect RemoteAccessible::BoundsInAppUnits() const {
+ if (dom::CanonicalBrowsingContext* cbc = mDoc->GetBrowsingContext()->Top()) {
+ if (dom::BrowserParent* bp = cbc->GetBrowserParent()) {
+ DocAccessibleParent* topDoc = bp->GetTopLevelDocAccessible();
+ if (topDoc && topDoc->mCachedFields) {
+ auto appUnitsPerDevPixel = topDoc->mCachedFields->GetAttribute<int32_t>(
+ CacheKey::AppUnitsPerDevPixel);
+ MOZ_ASSERT(appUnitsPerDevPixel);
+ return LayoutDeviceIntRect::ToAppUnits(Bounds(), *appUnitsPerDevPixel);
+ }
+ }
+ }
+ return LayoutDeviceIntRect::ToAppUnits(Bounds(), AppUnitsPerCSSPixel());
+}
+
+bool RemoteAccessible::IsFixedPos() const {
+ MOZ_ASSERT(mCachedFields);
+ if (auto maybePosition =
+ mCachedFields->GetAttribute<RefPtr<nsAtom>>(CacheKey::CssPosition)) {
+ return *maybePosition == nsGkAtoms::fixed;
+ }
+
+ return false;
+}
+
+bool RemoteAccessible::IsOverflowHidden() const {
+ MOZ_ASSERT(mCachedFields);
+ if (auto maybeOverflow =
+ mCachedFields->GetAttribute<RefPtr<nsAtom>>(CacheKey::CSSOverflow)) {
+ return *maybeOverflow == nsGkAtoms::hidden;
+ }
+
+ return false;
+}
+
+bool RemoteAccessible::IsClipped() const {
+ MOZ_ASSERT(mCachedFields);
+ if (mCachedFields->GetAttribute<bool>(CacheKey::IsClipped)) {
+ return true;
+ }
+
+ return false;
+}
+
+LayoutDeviceIntRect RemoteAccessible::BoundsWithOffset(
+ Maybe<nsRect> aOffset, bool aBoundsAreForHittesting) const {
+ Maybe<nsRect> maybeBounds = RetrieveCachedBounds();
+ if (maybeBounds) {
+ nsRect bounds = *maybeBounds;
+ // maybeBounds is parent-relative. However, the transform matrix we cache
+ // (if any) is meant to operate on self-relative rects. Therefore, make
+ // bounds self-relative until after we transform.
+ bounds.MoveTo(0, 0);
+ const DocAccessibleParent* topDoc = IsDoc() ? AsDoc() : nullptr;
+
+ if (aOffset.isSome()) {
+ // The rect we've passed in is in app units, so no conversion needed.
+ nsRect internalRect = *aOffset;
+ bounds.SetRectX(bounds.x + internalRect.x, internalRect.width);
+ bounds.SetRectY(bounds.y + internalRect.y, internalRect.height);
+ }
+
+ Unused << ApplyTransform(bounds);
+ // Now apply the parent-relative offset.
+ bounds.MoveBy(maybeBounds->TopLeft());
+
+ ApplyCrossDocOffset(bounds);
+
+ LayoutDeviceIntRect devPxBounds;
+ const Accessible* acc = Parent();
+ bool encounteredFixedContainer = IsFixedPos();
+ while (acc && acc->IsRemote()) {
+ // Return early if we're hit testing and our cumulative bounds are empty,
+ // since walking the ancestor chain won't produce any hits.
+ if (aBoundsAreForHittesting && bounds.IsEmpty()) {
+ return LayoutDeviceIntRect{};
+ }
+
+ RemoteAccessible* remoteAcc = const_cast<Accessible*>(acc)->AsRemote();
+
+ if (Maybe<nsRect> maybeRemoteBounds = remoteAcc->RetrieveCachedBounds()) {
+ nsRect remoteBounds = *maybeRemoteBounds;
+ // We need to take into account a non-1 resolution set on the
+ // presshell. This happens with async pinch zooming, among other
+ // things. We can't reliably query this value in the parent process,
+ // so we retrieve it from the document's cache.
+ if (remoteAcc->IsDoc()) {
+ // Apply the document's resolution to the bounds we've gathered
+ // thus far. We do this before applying the document's offset
+ // because document accs should not have their bounds scaled by
+ // their own resolution. They should be scaled by the resolution
+ // of their containing document (if any).
+ Maybe<float> res =
+ remoteAcc->AsDoc()->mCachedFields->GetAttribute<float>(
+ CacheKey::Resolution);
+ MOZ_ASSERT(res, "No cached document resolution found.");
+ bounds.ScaleRoundOut(res.valueOr(1.0f));
+
+ topDoc = remoteAcc->AsDoc();
+ }
+
+ // We don't account for the document offset of iframes when
+ // computing parent-relative bounds. Instead, we store this value
+ // separately on all iframes and apply it here. See the comments in
+ // LocalAccessible::BundleFieldsForCache where we set the
+ // nsGkAtoms::crossorigin attribute.
+ remoteAcc->ApplyCrossDocOffset(remoteBounds);
+ if (!encounteredFixedContainer) {
+ // Apply scroll offset, if applicable. Only the contents of an
+ // element are affected by its scroll offset, which is why this call
+ // happens in this loop instead of both inside and outside of
+ // the loop (like ApplyTransform).
+ // Never apply scroll offsets past a fixed container.
+ const bool hasScrollArea = remoteAcc->ApplyScrollOffset(bounds);
+
+ // If we are hit testing and the Accessible has a scroll area, ensure
+ // that the bounds we've calculated so far are constrained to the
+ // bounds of the scroll area. Without this, we'll "hit" the off-screen
+ // portions of accs that are are partially (but not fully) within the
+ // scroll area. This is also a problem for accs with overflow:hidden;
+ if (aBoundsAreForHittesting &&
+ (hasScrollArea || remoteAcc->IsOverflowHidden())) {
+ nsRect selfRelativeVisibleBounds(0, 0, remoteBounds.width,
+ remoteBounds.height);
+ bounds = bounds.SafeIntersect(selfRelativeVisibleBounds);
+ }
+ }
+ if (remoteAcc->IsDoc()) {
+ // Fixed elements are document relative, so if we've hit a
+ // document we're now subject to that document's styling
+ // (including scroll offsets that operate on it).
+ // This ordering is important, we don't want to apply scroll
+ // offsets on this doc's content.
+ encounteredFixedContainer = false;
+ }
+ if (!encounteredFixedContainer) {
+ // The transform matrix we cache (if any) is meant to operate on
+ // self-relative rects. Therefore, we must apply the transform before
+ // we make bounds parent-relative.
+ Unused << remoteAcc->ApplyTransform(bounds);
+ // Regardless of whether this is a doc, we should offset `bounds`
+ // by the bounds retrieved here. This is how we build screen
+ // coordinates from relative coordinates.
+ bounds.MoveBy(remoteBounds.X(), remoteBounds.Y());
+ }
+
+ if (remoteAcc->IsFixedPos()) {
+ encounteredFixedContainer = true;
+ }
+ // we can't just break here if we're scroll suppressed because we still
+ // need to find the top doc.
+ }
+ acc = acc->Parent();
+ }
+
+ MOZ_ASSERT(topDoc);
+ if (topDoc) {
+ // We use the top documents app-units-per-dev-pixel even though
+ // theoretically nested docs can have different values. Practically,
+ // that isn't likely since we only offer zoom controls for the top
+ // document and all subdocuments inherit from it.
+ auto appUnitsPerDevPixel = topDoc->mCachedFields->GetAttribute<int32_t>(
+ CacheKey::AppUnitsPerDevPixel);
+ MOZ_ASSERT(appUnitsPerDevPixel);
+ if (appUnitsPerDevPixel) {
+ // Convert our existing `bounds` rect from app units to dev pixels
+ devPxBounds = LayoutDeviceIntRect::FromAppUnitsToNearest(
+ bounds, *appUnitsPerDevPixel);
+ }
+ }
+
+#if !defined(ANDROID)
+ // This block is not thread safe because it queries a LocalAccessible.
+ // It is also not needed in Android since the only local accessible is
+ // the outer doc browser that has an offset of 0.
+ // acc could be null if the OuterDocAccessible died before the top level
+ // DocAccessibleParent.
+ if (LocalAccessible* localAcc =
+ acc ? const_cast<Accessible*>(acc)->AsLocal() : nullptr) {
+ // LocalAccessible::Bounds returns screen-relative bounds in
+ // dev pixels.
+ LayoutDeviceIntRect localBounds = localAcc->Bounds();
+
+ // The root document will always have an APZ resolution of 1,
+ // so we don't factor in its scale here. We also don't scale
+ // by GetFullZoom because LocalAccessible::Bounds already does
+ // that.
+ devPxBounds.MoveBy(localBounds.X(), localBounds.Y());
+ }
+#endif
+
+ return devPxBounds;
+ }
+
+ return LayoutDeviceIntRect();
+}
+
+LayoutDeviceIntRect RemoteAccessible::Bounds() const {
+ return BoundsWithOffset(Nothing());
+}
+
+Relation RemoteAccessible::RelationByType(RelationType aType) const {
+ // We are able to handle some relations completely in the
+ // parent process, without the help of the cache. Those
+ // relations are enumerated here. Other relations, whose
+ // types are stored in kRelationTypeAtoms, are processed
+ // below using the cache.
+ if (aType == RelationType::CONTAINING_TAB_PANE) {
+ if (dom::CanonicalBrowsingContext* cbc = mDoc->GetBrowsingContext()) {
+ if (dom::CanonicalBrowsingContext* topCbc = cbc->Top()) {
+ if (dom::BrowserParent* bp = topCbc->GetBrowserParent()) {
+ return Relation(bp->GetTopLevelDocAccessible());
+ }
+ }
+ }
+ return Relation();
+ }
+
+ if (aType == RelationType::LINKS_TO && Role() == roles::LINK) {
+ Pivot p = Pivot(mDoc);
+ nsString href;
+ Value(href);
+ int32_t i = href.FindChar('#');
+ int32_t len = static_cast<int32_t>(href.Length());
+ if (i != -1 && i < (len - 1)) {
+ nsDependentSubstring anchorName = Substring(href, i + 1, len);
+ MustPruneSameDocRule rule;
+ Accessible* nameMatch = nullptr;
+ for (Accessible* match = p.Next(mDoc, rule); match;
+ match = p.Next(match, rule)) {
+ nsString currID;
+ match->DOMNodeID(currID);
+ MOZ_ASSERT(match->IsRemote());
+ if (anchorName.Equals(currID)) {
+ return Relation(match->AsRemote());
+ }
+ if (!nameMatch) {
+ nsString currName = match->AsRemote()->GetCachedHTMLNameAttribute();
+ if (match->TagName() == nsGkAtoms::a && anchorName.Equals(currName)) {
+ // If we find an element with a matching ID, we should return
+ // that, but if we don't we should return the first anchor with
+ // a matching name. To avoid doing two traversals, store the first
+ // name match here.
+ nameMatch = match;
+ }
+ }
+ }
+ return nameMatch ? Relation(nameMatch->AsRemote()) : Relation();
+ }
+
+ return Relation();
+ }
+
+ // Handle ARIA tree, treegrid parent/child relations. Each of these cases
+ // relies on cached group info. To find the parent of an accessible, use the
+ // unified conceptual parent.
+ if (aType == RelationType::NODE_CHILD_OF) {
+ const nsRoleMapEntry* roleMapEntry = ARIARoleMap();
+ if (roleMapEntry && (roleMapEntry->role == roles::OUTLINEITEM ||
+ roleMapEntry->role == roles::LISTITEM ||
+ roleMapEntry->role == roles::ROW)) {
+ if (const AccGroupInfo* groupInfo =
+ const_cast<RemoteAccessible*>(this)->GetOrCreateGroupInfo()) {
+ return Relation(groupInfo->ConceptualParent());
+ }
+ }
+ return Relation();
+ }
+
+ // To find the children of a parent, provide an iterator through its items.
+ if (aType == RelationType::NODE_PARENT_OF) {
+ const nsRoleMapEntry* roleMapEntry = ARIARoleMap();
+ if (roleMapEntry && (roleMapEntry->role == roles::OUTLINEITEM ||
+ roleMapEntry->role == roles::LISTITEM ||
+ roleMapEntry->role == roles::ROW ||
+ roleMapEntry->role == roles::OUTLINE ||
+ roleMapEntry->role == roles::LIST ||
+ roleMapEntry->role == roles::TREE_TABLE)) {
+ return Relation(new ItemIterator(this));
+ }
+ return Relation();
+ }
+
+ if (aType == RelationType::MEMBER_OF) {
+ Relation rel = Relation();
+ // HTML radio buttons with cached names should be grouped.
+ if (IsHTMLRadioButton()) {
+ nsString name = GetCachedHTMLNameAttribute();
+ if (name.IsEmpty()) {
+ return rel;
+ }
+
+ RemoteAccessible* ancestor = RemoteParent();
+ while (ancestor && ancestor->Role() != roles::FORM && ancestor != mDoc) {
+ ancestor = ancestor->RemoteParent();
+ }
+ if (ancestor) {
+ // Sometimes we end up with an unparented acc here, potentially
+ // because the acc is being moved. See bug 1807639.
+ // Pivot expects to be created with a non-null mRoot.
+ Pivot p = Pivot(ancestor);
+ PivotRadioNameRule rule(name);
+ Accessible* match = p.Next(ancestor, rule);
+ while (match) {
+ rel.AppendTarget(match->AsRemote());
+ match = p.Next(match, rule);
+ }
+ }
+ return rel;
+ }
+
+ if (IsARIARole(nsGkAtoms::radio)) {
+ // ARIA radio buttons should be grouped by their radio group
+ // parent, if one exists.
+ RemoteAccessible* currParent = RemoteParent();
+ while (currParent && currParent->Role() != roles::RADIO_GROUP) {
+ currParent = currParent->RemoteParent();
+ }
+
+ if (currParent && currParent->Role() == roles::RADIO_GROUP) {
+ // If we found a radiogroup parent, search for all
+ // roles::RADIOBUTTON children and add them to our relation.
+ // This search will include the radio button this method
+ // was called from, which is expected.
+ Pivot p = Pivot(currParent);
+ PivotRoleRule rule(roles::RADIOBUTTON);
+ Accessible* match = p.Next(currParent, rule);
+ while (match) {
+ MOZ_ASSERT(match->IsRemote(),
+ "We should only be traversing the remote tree.");
+ rel.AppendTarget(match->AsRemote());
+ match = p.Next(match, rule);
+ }
+ }
+ }
+ // By webkit's standard, aria radio buttons do not get grouped
+ // if they lack a group parent, so we return an empty
+ // relation here if the above check fails.
+ return rel;
+ }
+
+ Relation rel;
+ if (!mCachedFields) {
+ return rel;
+ }
+
+ for (const auto& data : kRelationTypeAtoms) {
+ if (data.mType != aType ||
+ (data.mValidTag && TagName() != data.mValidTag)) {
+ continue;
+ }
+
+ if (auto maybeIds =
+ mCachedFields->GetAttribute<nsTArray<uint64_t>>(data.mAtom)) {
+ rel.AppendIter(new RemoteAccIterator(*maybeIds, Document()));
+ }
+ // Each relation type has only one relevant cached attribute,
+ // so break after we've handled the attr for this type,
+ // even if we didn't find any targets.
+ break;
+ }
+
+ if (auto accRelMapEntry = mDoc->mReverseRelations.Lookup(ID())) {
+ if (auto reverseIdsEntry = accRelMapEntry.Data().Lookup(aType)) {
+ rel.AppendIter(new RemoteAccIterator(reverseIdsEntry.Data(), Document()));
+ }
+ }
+
+ // We handle these relations here rather than before cached relations because
+ // the cached relations need to take precedence. For example, a <figure> with
+ // both aria-labelledby and a <figcaption> must return two LABELLED_BY
+ // targets: the aria-labelledby and then the <figcaption>.
+ if (aType == RelationType::LABELLED_BY && TagName() == nsGkAtoms::figure) {
+ uint32_t count = ChildCount();
+ for (uint32_t c = 0; c < count; ++c) {
+ RemoteAccessible* child = RemoteChildAt(c);
+ MOZ_ASSERT(child);
+ if (child->TagName() == nsGkAtoms::figcaption) {
+ rel.AppendTarget(child);
+ }
+ }
+ } else if (aType == RelationType::LABEL_FOR &&
+ TagName() == nsGkAtoms::figcaption) {
+ if (RemoteAccessible* parent = RemoteParent()) {
+ if (parent->TagName() == nsGkAtoms::figure) {
+ rel.AppendTarget(parent);
+ }
+ }
+ }
+
+ return rel;
+}
+
+void RemoteAccessible::AppendTextTo(nsAString& aText, uint32_t aStartOffset,
+ uint32_t aLength) {
+ if (IsText()) {
+ if (mCachedFields) {
+ if (auto text = mCachedFields->GetAttribute<nsString>(CacheKey::Text)) {
+ aText.Append(Substring(*text, aStartOffset, aLength));
+ }
+ VERIFY_CACHE(CacheDomain::Text);
+ }
+ return;
+ }
+
+ if (aStartOffset != 0 || aLength == 0) {
+ return;
+ }
+
+ if (IsHTMLBr()) {
+ aText += kForcedNewLineChar;
+ } else if (RemoteParent() && nsAccUtils::MustPrune(RemoteParent())) {
+ // Expose the embedded object accessible as imaginary embedded object
+ // character if its parent hypertext accessible doesn't expose children to
+ // AT.
+ aText += kImaginaryEmbeddedObjectChar;
+ } else {
+ aText += kEmbeddedObjectChar;
+ }
+}
+
+nsTArray<bool> RemoteAccessible::PreProcessRelations(AccAttributes* aFields) {
+ nsTArray<bool> updateTracker(ArrayLength(kRelationTypeAtoms));
+ for (auto const& data : kRelationTypeAtoms) {
+ if (data.mValidTag) {
+ // The relation we're currently processing only applies to particular
+ // elements. Check to see if we're one of them.
+ nsAtom* tag = TagName();
+ if (!tag) {
+ // TagName() returns null on an initial cache push -- check aFields
+ // for a tag name instead.
+ if (auto maybeTag =
+ aFields->GetAttribute<RefPtr<nsAtom>>(CacheKey::TagName)) {
+ tag = *maybeTag;
+ }
+ }
+ MOZ_ASSERT(
+ tag || IsTextLeaf() || IsDoc(),
+ "Could not fetch tag via TagName() or from initial cache push!");
+ if (tag != data.mValidTag) {
+ // If this rel doesn't apply to us, do no pre-processing. Also,
+ // note in our updateTracker that we should do no post-processing.
+ updateTracker.AppendElement(false);
+ continue;
+ }
+ }
+
+ nsStaticAtom* const relAtom = data.mAtom;
+ auto newRelationTargets =
+ aFields->GetAttribute<nsTArray<uint64_t>>(relAtom);
+ bool shouldAddNewImplicitRels =
+ newRelationTargets && newRelationTargets->Length();
+
+ // Remove existing implicit relations if we need to perform an update, or
+ // if we've received a DeleteEntry(). Only do this if mCachedFields is
+ // initialized. If mCachedFields is not initialized, we still need to
+ // construct the update array so we correctly handle reverse rels in
+ // PostProcessRelations.
+ if ((shouldAddNewImplicitRels ||
+ aFields->GetAttribute<DeleteEntry>(relAtom)) &&
+ mCachedFields) {
+ if (auto maybeOldIDs =
+ mCachedFields->GetAttribute<nsTArray<uint64_t>>(relAtom)) {
+ for (uint64_t id : *maybeOldIDs) {
+ // For each target, fetch its reverse relation map
+ // We need to call `Lookup` here instead of `LookupOrInsert` because
+ // it's possible the ID we're querying is from an acc that has since
+ // been Shutdown(), and so has intentionally removed its reverse rels
+ // from the doc's reverse rel cache.
+ if (auto reverseRels = Document()->mReverseRelations.Lookup(id)) {
+ // Then fetch its reverse relation's ID list. This should be safe
+ // to do via LookupOrInsert because by the time we've gotten here,
+ // we know the acc and `this` are still alive in the doc. If we hit
+ // the following assert, we don't have parity on implicit/explicit
+ // rels and something is wrong.
+ nsTArray<uint64_t>& reverseRelIDs =
+ reverseRels->LookupOrInsert(data.mReverseType);
+ // There might be other reverse relations stored for this acc, so
+ // remove our ID instead of deleting the array entirely.
+ DebugOnly<bool> removed = reverseRelIDs.RemoveElement(ID());
+ MOZ_ASSERT(removed, "Can't find old reverse relation");
+ }
+ }
+ }
+ }
+
+ updateTracker.AppendElement(shouldAddNewImplicitRels);
+ }
+
+ return updateTracker;
+}
+
+void RemoteAccessible::PostProcessRelations(const nsTArray<bool>& aToUpdate) {
+ size_t updateCount = aToUpdate.Length();
+ MOZ_ASSERT(updateCount == ArrayLength(kRelationTypeAtoms),
+ "Did not note update status for every relation type!");
+ for (size_t i = 0; i < updateCount; i++) {
+ if (aToUpdate.ElementAt(i)) {
+ // Since kRelationTypeAtoms was used to generate aToUpdate, we
+ // know the ith entry of aToUpdate corresponds to the relation type in
+ // the ith entry of kRelationTypeAtoms. Fetch the related data here.
+ auto const& data = kRelationTypeAtoms[i];
+
+ const nsTArray<uint64_t>& newIDs =
+ *mCachedFields->GetAttribute<nsTArray<uint64_t>>(data.mAtom);
+ for (uint64_t id : newIDs) {
+ nsTHashMap<RelationType, nsTArray<uint64_t>>& relations =
+ Document()->mReverseRelations.LookupOrInsert(id);
+ nsTArray<uint64_t>& ids = relations.LookupOrInsert(data.mReverseType);
+ ids.AppendElement(ID());
+ }
+ }
+ }
+}
+
+void RemoteAccessible::PruneRelationsOnShutdown() {
+ auto reverseRels = mDoc->mReverseRelations.Lookup(ID());
+ if (!reverseRels) {
+ return;
+ }
+ for (auto const& data : kRelationTypeAtoms) {
+ // Fetch the list of targets for this reverse relation
+ auto reverseTargetList = reverseRels->Lookup(data.mReverseType);
+ if (!reverseTargetList) {
+ continue;
+ }
+ for (uint64_t id : *reverseTargetList) {
+ // For each target, retrieve its corresponding forward relation target
+ // list
+ RemoteAccessible* affectedAcc = mDoc->GetAccessible(id);
+ if (!affectedAcc) {
+ // It's possible the affect acc also shut down, in which case
+ // we don't have anything to update.
+ continue;
+ }
+ if (auto forwardTargetList =
+ affectedAcc->mCachedFields
+ ->GetMutableAttribute<nsTArray<uint64_t>>(data.mAtom)) {
+ forwardTargetList->RemoveElement(ID());
+ if (!forwardTargetList->Length()) {
+ // The ID we removed was the only thing in the list, so remove the
+ // entry from the cache entirely -- don't leave an empty array.
+ affectedAcc->mCachedFields->Remove(data.mAtom);
+ }
+ }
+ }
+ }
+ // Remove this ID from the document's map of reverse relations.
+ reverseRels.Remove();
+}
+
+uint32_t RemoteAccessible::GetCachedTextLength() {
+ MOZ_ASSERT(!HasChildren());
+ if (!mCachedFields) {
+ return 0;
+ }
+ VERIFY_CACHE(CacheDomain::Text);
+ auto text = mCachedFields->GetAttribute<nsString>(CacheKey::Text);
+ if (!text) {
+ return 0;
+ }
+ return text->Length();
+}
+
+Maybe<const nsTArray<int32_t>&> RemoteAccessible::GetCachedTextLines() {
+ MOZ_ASSERT(!HasChildren());
+ if (!mCachedFields) {
+ return Nothing();
+ }
+ VERIFY_CACHE(CacheDomain::Text);
+ return mCachedFields->GetAttribute<nsTArray<int32_t>>(
+ CacheKey::TextLineStarts);
+}
+
+nsRect RemoteAccessible::GetCachedCharRect(int32_t aOffset) {
+ MOZ_ASSERT(IsText());
+ if (!mCachedFields) {
+ return nsRect();
+ }
+
+ if (Maybe<const nsTArray<int32_t>&> maybeCharData =
+ mCachedFields->GetAttribute<nsTArray<int32_t>>(
+ CacheKey::TextBounds)) {
+ const nsTArray<int32_t>& charData = *maybeCharData;
+ const int32_t index = aOffset * kNumbersInRect;
+ if (index < static_cast<int32_t>(charData.Length())) {
+ return nsRect(charData[index], charData[index + 1], charData[index + 2],
+ charData[index + 3]);
+ }
+ // It is valid for a client to call this with an offset 1 after the last
+ // character because of the insertion point at the end of text boxes.
+ MOZ_ASSERT(index == static_cast<int32_t>(charData.Length()));
+ }
+
+ return nsRect();
+}
+
+void RemoteAccessible::DOMNodeID(nsString& aID) const {
+ if (mCachedFields) {
+ mCachedFields->GetAttribute(CacheKey::DOMNodeID, aID);
+ VERIFY_CACHE(CacheDomain::DOMNodeIDAndClass);
+ }
+}
+
+void RemoteAccessible::ScrollToPoint(uint32_t aScrollType, int32_t aX,
+ int32_t aY) {
+ Unused << mDoc->SendScrollToPoint(mID, aScrollType, aX, aY);
+}
+
+#if !defined(XP_WIN)
+void RemoteAccessible::Announce(const nsString& aAnnouncement,
+ uint16_t aPriority) {
+ Unused << mDoc->SendAnnounce(mID, aAnnouncement, aPriority);
+}
+#endif // !defined(XP_WIN)
+
+void RemoteAccessible::ScrollSubstringToPoint(int32_t aStartOffset,
+ int32_t aEndOffset,
+ uint32_t aCoordinateType,
+ int32_t aX, int32_t aY) {
+ Unused << mDoc->SendScrollSubstringToPoint(mID, aStartOffset, aEndOffset,
+ aCoordinateType, aX, aY);
+}
+
+RefPtr<const AccAttributes> RemoteAccessible::GetCachedTextAttributes() {
+ MOZ_ASSERT(IsText() || IsHyperText());
+ if (mCachedFields) {
+ auto attrs = mCachedFields->GetAttributeRefPtr<AccAttributes>(
+ CacheKey::TextAttributes);
+ VERIFY_CACHE(CacheDomain::Text);
+ return attrs;
+ }
+ return nullptr;
+}
+
+already_AddRefed<AccAttributes> RemoteAccessible::DefaultTextAttributes() {
+ RefPtr<const AccAttributes> attrs = GetCachedTextAttributes();
+ RefPtr<AccAttributes> result = new AccAttributes();
+ if (attrs) {
+ attrs->CopyTo(result);
+ }
+ return result.forget();
+}
+
+RefPtr<const AccAttributes> RemoteAccessible::GetCachedARIAAttributes() const {
+ if (mCachedFields) {
+ auto attrs = mCachedFields->GetAttributeRefPtr<AccAttributes>(
+ CacheKey::ARIAAttributes);
+ VERIFY_CACHE(CacheDomain::ARIA);
+ return attrs;
+ }
+ return nullptr;
+}
+
+nsString RemoteAccessible::GetCachedHTMLNameAttribute() const {
+ if (mCachedFields) {
+ if (auto maybeName =
+ mCachedFields->GetAttribute<nsString>(CacheKey::DOMName)) {
+ return *maybeName;
+ }
+ }
+ return nsString();
+}
+
+uint64_t RemoteAccessible::State() {
+ uint64_t state = 0;
+ if (mCachedFields) {
+ if (auto rawState =
+ mCachedFields->GetAttribute<uint64_t>(CacheKey::State)) {
+ VERIFY_CACHE(CacheDomain::State);
+ state = *rawState;
+ // Handle states that are derived from other states.
+ if (!(state & states::UNAVAILABLE)) {
+ state |= states::ENABLED | states::SENSITIVE;
+ }
+ if (state & states::EXPANDABLE && !(state & states::EXPANDED)) {
+ state |= states::COLLAPSED;
+ }
+ }
+
+ ApplyImplicitState(state);
+
+ auto* cbc = mDoc->GetBrowsingContext();
+ if (cbc && !cbc->IsActive()) {
+ // If our browsing context is _not_ active, we're in a background tab
+ // and inherently offscreen.
+ state |= states::OFFSCREEN;
+ } else {
+ // If we're in an active browsing context, there are a few scenarios we
+ // need to address:
+ // - We are an iframe document in the visual viewport
+ // - We are an iframe document out of the visual viewport
+ // - We are non-iframe content in the visual viewport
+ // - We are non-iframe content out of the visual viewport
+ // We assume top level tab docs are on screen if their BC is active, so
+ // we don't need additional handling for them here.
+ if (!mDoc->IsTopLevel()) {
+ // Here we handle iframes and iframe content.
+ // We use an iframe's outer doc's position in the embedding document's
+ // viewport to determine if the iframe has been scrolled offscreen.
+ Accessible* docParent = mDoc->Parent();
+ // In rare cases, we might not have an outer doc yet. Return if that's
+ // the case.
+ if (NS_WARN_IF(!docParent || !docParent->IsRemote())) {
+ return state;
+ }
+
+ RemoteAccessible* outerDoc = docParent->AsRemote();
+ DocAccessibleParent* embeddingDocument = outerDoc->Document();
+ if (embeddingDocument &&
+ !embeddingDocument->mOnScreenAccessibles.Contains(outerDoc->ID())) {
+ // Our embedding document's viewport cache doesn't contain the ID of
+ // our outer doc, so this iframe (and any of its content) is
+ // offscreen.
+ state |= states::OFFSCREEN;
+ } else if (this != mDoc && !mDoc->mOnScreenAccessibles.Contains(ID())) {
+ // Our embedding document's viewport cache contains the ID of our
+ // outer doc, but the iframe's viewport cache doesn't contain our ID.
+ // We are offscreen.
+ state |= states::OFFSCREEN;
+ }
+ } else if (this != mDoc && !mDoc->mOnScreenAccessibles.Contains(ID())) {
+ // We are top level tab content (but not a top level tab doc).
+ // If our tab doc's viewport cache doesn't contain our ID, we're
+ // offscreen.
+ state |= states::OFFSCREEN;
+ }
+ }
+ }
+
+ return state;
+}
+
+already_AddRefed<AccAttributes> RemoteAccessible::Attributes() {
+ RefPtr<AccAttributes> attributes = new AccAttributes();
+ nsAccessibilityService* accService = GetAccService();
+ if (!accService) {
+ // The service can be shut down before RemoteAccessibles. If it is shut
+ // down, we can't calculate some attributes. We're about to die anyway.
+ return attributes.forget();
+ }
+
+ if (mCachedFields) {
+ // We use GetAttribute instead of GetAttributeRefPtr because we need
+ // nsAtom, not const nsAtom.
+ if (auto tag =
+ mCachedFields->GetAttribute<RefPtr<nsAtom>>(CacheKey::TagName)) {
+ attributes->SetAttribute(nsGkAtoms::tag, *tag);
+ }
+
+ GroupPos groupPos = GroupPosition();
+ nsAccUtils::SetAccGroupAttrs(attributes, groupPos.level, groupPos.setSize,
+ groupPos.posInSet);
+
+ bool hierarchical = false;
+ uint32_t itemCount = AccGroupInfo::TotalItemCount(this, &hierarchical);
+ if (itemCount) {
+ attributes->SetAttribute(nsGkAtoms::child_item_count,
+ static_cast<int32_t>(itemCount));
+ }
+
+ if (hierarchical) {
+ attributes->SetAttribute(nsGkAtoms::tree, true);
+ }
+
+ if (auto inputType =
+ mCachedFields->GetAttribute<RefPtr<nsAtom>>(CacheKey::InputType)) {
+ attributes->SetAttribute(nsGkAtoms::textInputType, *inputType);
+ }
+
+ if (RefPtr<nsAtom> display = DisplayStyle()) {
+ attributes->SetAttribute(nsGkAtoms::display, display);
+ }
+
+ if (TableCellAccessible* cell = AsTableCell()) {
+ TableAccessible* table = cell->Table();
+ uint32_t row = cell->RowIdx();
+ uint32_t col = cell->ColIdx();
+ int32_t cellIdx = table->CellIndexAt(row, col);
+ if (cellIdx != -1) {
+ attributes->SetAttribute(nsGkAtoms::tableCellIndex, cellIdx);
+ }
+ }
+
+ if (bool layoutGuess = TableIsProbablyForLayout()) {
+ attributes->SetAttribute(nsGkAtoms::layout_guess, layoutGuess);
+ }
+
+ accService->MarkupAttributes(this, attributes);
+
+ const nsRoleMapEntry* roleMap = ARIARoleMap();
+ nsAutoString role;
+ mCachedFields->GetAttribute(CacheKey::ARIARole, role);
+ if (role.IsEmpty()) {
+ if (roleMap && roleMap->roleAtom != nsGkAtoms::_empty) {
+ // Single, known role.
+ attributes->SetAttribute(nsGkAtoms::xmlroles, roleMap->roleAtom);
+ } else if (nsAtom* landmark = LandmarkRole()) {
+ // Landmark role from markup; e.g. HTML <main>.
+ attributes->SetAttribute(nsGkAtoms::xmlroles, landmark);
+ }
+ } else {
+ // Unknown role or multiple roles.
+ attributes->SetAttribute(nsGkAtoms::xmlroles, std::move(role));
+ }
+
+ if (roleMap) {
+ nsAutoString live;
+ if (nsAccUtils::GetLiveAttrValue(roleMap->liveAttRule, live)) {
+ attributes->SetAttribute(nsGkAtoms::aria_live, std::move(live));
+ }
+ }
+
+ if (auto ariaAttrs = GetCachedARIAAttributes()) {
+ ariaAttrs->CopyTo(attributes);
+ }
+
+ nsAccUtils::SetLiveContainerAttributes(attributes, this);
+
+ nsString id;
+ DOMNodeID(id);
+ if (!id.IsEmpty()) {
+ attributes->SetAttribute(nsGkAtoms::id, std::move(id));
+ }
+
+ nsString className;
+ mCachedFields->GetAttribute(CacheKey::DOMNodeClass, className);
+ if (!className.IsEmpty()) {
+ attributes->SetAttribute(nsGkAtoms::_class, std::move(className));
+ }
+
+ if (IsImage()) {
+ nsString src;
+ mCachedFields->GetAttribute(CacheKey::SrcURL, src);
+ if (!src.IsEmpty()) {
+ attributes->SetAttribute(nsGkAtoms::src, std::move(src));
+ }
+ }
+
+ if (IsTextField()) {
+ nsString placeholder;
+ mCachedFields->GetAttribute(CacheKey::HTMLPlaceholder, placeholder);
+ if (!placeholder.IsEmpty()) {
+ attributes->SetAttribute(nsGkAtoms::placeholder,
+ std::move(placeholder));
+ attributes->Remove(nsGkAtoms::aria_placeholder);
+ }
+ }
+
+ nsString popupType;
+ mCachedFields->GetAttribute(CacheKey::PopupType, popupType);
+ if (!popupType.IsEmpty()) {
+ attributes->SetAttribute(nsGkAtoms::ispopup, std::move(popupType));
+ }
+ }
+
+ nsAutoString name;
+ if (Name(name) != eNameFromSubtree && !name.IsVoid()) {
+ attributes->SetAttribute(nsGkAtoms::explicit_name, true);
+ }
+
+ // Expose the string value via the valuetext attribute. We test for the value
+ // interface because we don't want to expose traditional Value() information
+ // such as URLs on links and documents, or text in an input.
+ // XXX This is only needed for ATK, since other APIs have native ways to
+ // retrieve value text. We should probably move this into ATK specific code.
+ // For now, we do this because LocalAccessible does it.
+ if (HasNumericValue()) {
+ nsString valuetext;
+ Value(valuetext);
+ attributes->SetAttribute(nsGkAtoms::aria_valuetext, std::move(valuetext));
+ }
+
+ return attributes.forget();
+}
+
+nsAtom* RemoteAccessible::TagName() const {
+ if (mCachedFields) {
+ if (auto tag =
+ mCachedFields->GetAttribute<RefPtr<nsAtom>>(CacheKey::TagName)) {
+ return *tag;
+ }
+ }
+
+ return nullptr;
+}
+
+already_AddRefed<nsAtom> RemoteAccessible::InputType() const {
+ if (mCachedFields) {
+ if (auto inputType =
+ mCachedFields->GetAttribute<RefPtr<nsAtom>>(CacheKey::InputType)) {
+ RefPtr<nsAtom> result = *inputType;
+ return result.forget();
+ }
+ }
+
+ return nullptr;
+}
+
+already_AddRefed<nsAtom> RemoteAccessible::DisplayStyle() const {
+ if (mCachedFields) {
+ if (auto display =
+ mCachedFields->GetAttribute<RefPtr<nsAtom>>(CacheKey::CSSDisplay)) {
+ RefPtr<nsAtom> result = *display;
+ return result.forget();
+ }
+ }
+ return nullptr;
+}
+
+float RemoteAccessible::Opacity() const {
+ if (mCachedFields) {
+ if (auto opacity = mCachedFields->GetAttribute<float>(CacheKey::Opacity)) {
+ return *opacity;
+ }
+ }
+
+ return 1.0f;
+}
+
+void RemoteAccessible::LiveRegionAttributes(nsAString* aLive,
+ nsAString* aRelevant,
+ Maybe<bool>* aAtomic,
+ nsAString* aBusy) const {
+ if (!mCachedFields) {
+ return;
+ }
+ RefPtr<const AccAttributes> attrs = GetCachedARIAAttributes();
+ if (!attrs) {
+ return;
+ }
+ if (aLive) {
+ attrs->GetAttribute(nsGkAtoms::aria_live, *aLive);
+ }
+ if (aRelevant) {
+ attrs->GetAttribute(nsGkAtoms::aria_relevant, *aRelevant);
+ }
+ if (aAtomic) {
+ if (auto value =
+ attrs->GetAttribute<RefPtr<nsAtom>>(nsGkAtoms::aria_atomic)) {
+ *aAtomic = Some(*value == nsGkAtoms::_true);
+ }
+ }
+ if (aBusy) {
+ attrs->GetAttribute(nsGkAtoms::aria_busy, *aBusy);
+ }
+}
+
+Maybe<bool> RemoteAccessible::ARIASelected() const {
+ if (mCachedFields) {
+ return mCachedFields->GetAttribute<bool>(CacheKey::ARIASelected);
+ }
+ return Nothing();
+}
+
+nsAtom* RemoteAccessible::GetPrimaryAction() const {
+ if (mCachedFields) {
+ if (auto action = mCachedFields->GetAttribute<RefPtr<nsAtom>>(
+ CacheKey::PrimaryAction)) {
+ return *action;
+ }
+ }
+
+ return nullptr;
+}
+
+uint8_t RemoteAccessible::ActionCount() const {
+ uint8_t actionCount = 0;
+ if (mCachedFields) {
+ if (HasPrimaryAction() || ActionAncestor()) {
+ actionCount++;
+ }
+
+ if (mCachedFields->HasAttribute(CacheKey::HasLongdesc)) {
+ actionCount++;
+ }
+ VERIFY_CACHE(CacheDomain::Actions);
+ }
+
+ return actionCount;
+}
+
+void RemoteAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) {
+ if (mCachedFields) {
+ aName.Truncate();
+ nsAtom* action = GetPrimaryAction();
+ bool hasActionAncestor = !action && ActionAncestor();
+
+ switch (aIndex) {
+ case 0:
+ if (action) {
+ action->ToString(aName);
+ } else if (hasActionAncestor) {
+ aName.AssignLiteral("click ancestor");
+ } else if (mCachedFields->HasAttribute(CacheKey::HasLongdesc)) {
+ aName.AssignLiteral("showlongdesc");
+ }
+ break;
+ case 1:
+ if ((action || hasActionAncestor) &&
+ mCachedFields->HasAttribute(CacheKey::HasLongdesc)) {
+ aName.AssignLiteral("showlongdesc");
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ VERIFY_CACHE(CacheDomain::Actions);
+}
+
+bool RemoteAccessible::DoAction(uint8_t aIndex) const {
+ if (ActionCount() < aIndex + 1) {
+ return false;
+ }
+
+ Unused << mDoc->SendDoActionAsync(mID, aIndex);
+ return true;
+}
+
+KeyBinding RemoteAccessible::AccessKey() const {
+ if (mCachedFields) {
+ if (auto value =
+ mCachedFields->GetAttribute<uint64_t>(CacheKey::AccessKey)) {
+ return KeyBinding(*value);
+ }
+ }
+ return KeyBinding();
+}
+
+void RemoteAccessible::SelectionRanges(nsTArray<TextRange>* aRanges) const {
+ Document()->SelectionRanges(aRanges);
+}
+
+bool RemoteAccessible::RemoveFromSelection(int32_t aSelectionNum) {
+ MOZ_ASSERT(IsHyperText());
+ if (SelectionCount() <= aSelectionNum) {
+ return false;
+ }
+
+ Unused << mDoc->SendRemoveTextSelection(mID, aSelectionNum);
+
+ return true;
+}
+
+void RemoteAccessible::ARIAGroupPosition(int32_t* aLevel, int32_t* aSetSize,
+ int32_t* aPosInSet) const {
+ if (!mCachedFields) {
+ return;
+ }
+
+ if (aLevel) {
+ if (auto level =
+ mCachedFields->GetAttribute<int32_t>(nsGkAtoms::aria_level)) {
+ *aLevel = *level;
+ }
+ }
+ if (aSetSize) {
+ if (auto setsize =
+ mCachedFields->GetAttribute<int32_t>(nsGkAtoms::aria_setsize)) {
+ *aSetSize = *setsize;
+ }
+ }
+ if (aPosInSet) {
+ if (auto posinset =
+ mCachedFields->GetAttribute<int32_t>(nsGkAtoms::aria_posinset)) {
+ *aPosInSet = *posinset;
+ }
+ }
+}
+
+AccGroupInfo* RemoteAccessible::GetGroupInfo() const {
+ if (!mCachedFields) {
+ return nullptr;
+ }
+
+ if (auto groupInfo = mCachedFields->GetAttribute<UniquePtr<AccGroupInfo>>(
+ CacheKey::GroupInfo)) {
+ return groupInfo->get();
+ }
+
+ return nullptr;
+}
+
+AccGroupInfo* RemoteAccessible::GetOrCreateGroupInfo() {
+ AccGroupInfo* groupInfo = GetGroupInfo();
+ if (groupInfo) {
+ return groupInfo;
+ }
+
+ groupInfo = AccGroupInfo::CreateGroupInfo(this);
+ if (groupInfo) {
+ if (!mCachedFields) {
+ mCachedFields = new AccAttributes();
+ }
+
+ mCachedFields->SetAttribute(CacheKey::GroupInfo, groupInfo);
+ }
+
+ return groupInfo;
+}
+
+void RemoteAccessible::InvalidateGroupInfo() {
+ if (mCachedFields) {
+ mCachedFields->Remove(CacheKey::GroupInfo);
+ }
+}
+
+void RemoteAccessible::GetPositionAndSetSize(int32_t* aPosInSet,
+ int32_t* aSetSize) {
+ if (IsHTMLRadioButton()) {
+ *aSetSize = 0;
+ Relation rel = RelationByType(RelationType::MEMBER_OF);
+ while (Accessible* radio = rel.Next()) {
+ ++*aSetSize;
+ if (radio == this) {
+ *aPosInSet = *aSetSize;
+ }
+ }
+ return;
+ }
+
+ Accessible::GetPositionAndSetSize(aPosInSet, aSetSize);
+}
+
+bool RemoteAccessible::HasPrimaryAction() const {
+ return mCachedFields && mCachedFields->HasAttribute(CacheKey::PrimaryAction);
+}
+
+void RemoteAccessible::TakeFocus() const { Unused << mDoc->SendTakeFocus(mID); }
+
+void RemoteAccessible::ScrollTo(uint32_t aHow) const {
+ Unused << mDoc->SendScrollTo(mID, aHow);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// SelectAccessible
+
+void RemoteAccessible::SelectedItems(nsTArray<Accessible*>* aItems) {
+ Pivot p = Pivot(this);
+ PivotStateRule rule(states::SELECTED);
+ for (Accessible* selected = p.First(rule); selected;
+ selected = p.Next(selected, rule)) {
+ aItems->AppendElement(selected);
+ }
+}
+
+uint32_t RemoteAccessible::SelectedItemCount() {
+ uint32_t count = 0;
+ Pivot p = Pivot(this);
+ PivotStateRule rule(states::SELECTED);
+ for (Accessible* selected = p.First(rule); selected;
+ selected = p.Next(selected, rule)) {
+ count++;
+ }
+
+ return count;
+}
+
+Accessible* RemoteAccessible::GetSelectedItem(uint32_t aIndex) {
+ uint32_t index = 0;
+ Accessible* selected = nullptr;
+ Pivot p = Pivot(this);
+ PivotStateRule rule(states::SELECTED);
+ for (selected = p.First(rule); selected && index < aIndex;
+ selected = p.Next(selected, rule)) {
+ index++;
+ }
+
+ return selected;
+}
+
+bool RemoteAccessible::IsItemSelected(uint32_t aIndex) {
+ uint32_t index = 0;
+ Accessible* selectable = nullptr;
+ Pivot p = Pivot(this);
+ PivotStateRule rule(states::SELECTABLE);
+ for (selectable = p.First(rule); selectable && index < aIndex;
+ selectable = p.Next(selectable, rule)) {
+ index++;
+ }
+
+ return selectable && selectable->State() & states::SELECTED;
+}
+
+bool RemoteAccessible::AddItemToSelection(uint32_t aIndex) {
+ uint32_t index = 0;
+ Accessible* selectable = nullptr;
+ Pivot p = Pivot(this);
+ PivotStateRule rule(states::SELECTABLE);
+ for (selectable = p.First(rule); selectable && index < aIndex;
+ selectable = p.Next(selectable, rule)) {
+ index++;
+ }
+
+ if (selectable) selectable->SetSelected(true);
+
+ return static_cast<bool>(selectable);
+}
+
+bool RemoteAccessible::RemoveItemFromSelection(uint32_t aIndex) {
+ uint32_t index = 0;
+ Accessible* selectable = nullptr;
+ Pivot p = Pivot(this);
+ PivotStateRule rule(states::SELECTABLE);
+ for (selectable = p.First(rule); selectable && index < aIndex;
+ selectable = p.Next(selectable, rule)) {
+ index++;
+ }
+
+ if (selectable) selectable->SetSelected(false);
+
+ return static_cast<bool>(selectable);
+}
+
+bool RemoteAccessible::SelectAll() {
+ if ((State() & states::MULTISELECTABLE) == 0) {
+ return false;
+ }
+
+ bool success = false;
+ Accessible* selectable = nullptr;
+ Pivot p = Pivot(this);
+ PivotStateRule rule(states::SELECTABLE);
+ for (selectable = p.First(rule); selectable;
+ selectable = p.Next(selectable, rule)) {
+ success = true;
+ selectable->SetSelected(true);
+ }
+ return success;
+}
+
+bool RemoteAccessible::UnselectAll() {
+ if ((State() & states::MULTISELECTABLE) == 0) {
+ return false;
+ }
+
+ bool success = false;
+ Accessible* selectable = nullptr;
+ Pivot p = Pivot(this);
+ PivotStateRule rule(states::SELECTABLE);
+ for (selectable = p.First(rule); selectable;
+ selectable = p.Next(selectable, rule)) {
+ success = true;
+ selectable->SetSelected(false);
+ }
+ return success;
+}
+
+void RemoteAccessible::TakeSelection() {
+ Unused << mDoc->SendTakeSelection(mID);
+}
+
+void RemoteAccessible::SetSelected(bool aSelect) {
+ Unused << mDoc->SendSetSelected(mID, aSelect);
+}
+
+TableAccessible* RemoteAccessible::AsTable() {
+ if (IsTable()) {
+ return CachedTableAccessible::GetFrom(this);
+ }
+ return nullptr;
+}
+
+TableCellAccessible* RemoteAccessible::AsTableCell() {
+ if (IsTableCell()) {
+ return CachedTableCellAccessible::GetFrom(this);
+ }
+ return nullptr;
+}
+
+bool RemoteAccessible::TableIsProbablyForLayout() {
+ if (mCachedFields) {
+ if (auto layoutGuess =
+ mCachedFields->GetAttribute<bool>(CacheKey::TableLayoutGuess)) {
+ return *layoutGuess;
+ }
+ }
+ return false;
+}
+
+nsTArray<int32_t>& RemoteAccessible::GetCachedHyperTextOffsets() {
+ if (mCachedFields) {
+ if (auto offsets = mCachedFields->GetMutableAttribute<nsTArray<int32_t>>(
+ CacheKey::HyperTextOffsets)) {
+ return *offsets;
+ }
+ }
+ nsTArray<int32_t> newOffsets;
+ if (!mCachedFields) {
+ mCachedFields = new AccAttributes();
+ }
+ mCachedFields->SetAttribute(CacheKey::HyperTextOffsets,
+ std::move(newOffsets));
+ return *mCachedFields->GetMutableAttribute<nsTArray<int32_t>>(
+ CacheKey::HyperTextOffsets);
+}
+
+void RemoteAccessible::SetCaretOffset(int32_t aOffset) {
+ Unused << mDoc->SendSetCaretOffset(mID, aOffset);
+}
+
+Maybe<int32_t> RemoteAccessible::GetIntARIAAttr(nsAtom* aAttrName) const {
+ if (RefPtr<const AccAttributes> attrs = GetCachedARIAAttributes()) {
+ if (auto val = attrs->GetAttribute<int32_t>(aAttrName)) {
+ return val;
+ }
+ }
+ return Nothing();
+}
+
+void RemoteAccessible::Language(nsAString& aLocale) {
+ if (!IsHyperText()) {
+ return;
+ }
+ if (auto attrs = GetCachedTextAttributes()) {
+ attrs->GetAttribute(nsGkAtoms::language, aLocale);
+ }
+}
+
+void RemoteAccessible::ReplaceText(const nsAString& aText) {
+ Unused << mDoc->SendReplaceText(mID, aText);
+}
+
+void RemoteAccessible::InsertText(const nsAString& aText, int32_t aPosition) {
+ Unused << mDoc->SendInsertText(mID, aText, aPosition);
+}
+
+void RemoteAccessible::CopyText(int32_t aStartPos, int32_t aEndPos) {
+ Unused << mDoc->SendCopyText(mID, aStartPos, aEndPos);
+}
+
+void RemoteAccessible::CutText(int32_t aStartPos, int32_t aEndPos) {
+ Unused << mDoc->SendCutText(mID, aStartPos, aEndPos);
+}
+
+void RemoteAccessible::DeleteText(int32_t aStartPos, int32_t aEndPos) {
+ Unused << mDoc->SendDeleteText(mID, aStartPos, aEndPos);
+}
+
+void RemoteAccessible::PasteText(int32_t aPosition) {
+ Unused << mDoc->SendPasteText(mID, aPosition);
+}
+
+size_t RemoteAccessible::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) {
+ return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+}
+
+size_t RemoteAccessible::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) {
+ size_t size = 0;
+
+ // Count attributes.
+ if (mCachedFields) {
+ size += mCachedFields->SizeOfIncludingThis(aMallocSizeOf);
+ }
+
+ // We don't recurse into mChildren because they're already counted in their
+ // document's mAccessibles.
+ size += mChildren.ShallowSizeOfExcludingThis(aMallocSizeOf);
+
+ return size;
+}
+
+} // namespace a11y
+} // namespace mozilla