1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim: set ts=2 et sw=2 tw=80: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6
7 #include "RemoteAccessible.h"
8 #include "mozilla/a11y/DocAccessibleParent.h"
9 #include "DocAccessible.h"
10 #include "AccAttributes.h"
11 #include "mozilla/a11y/DocManager.h"
12 #include "mozilla/dom/Element.h"
13 #include "mozilla/dom/BrowserParent.h"
14 #include "mozilla/Unused.h"
15 #include "mozilla/a11y/Platform.h"
16 #include "RelationType.h"
17 #include "mozilla/a11y/Role.h"
18 #include "mozilla/StaticPrefs_accessibility.h"
19
20 namespace mozilla {
21 namespace a11y {
22
State()23 uint64_t RemoteAccessible::State() {
24 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
25 return RemoteAccessibleBase<RemoteAccessible>::State();
26 }
27 uint64_t state = 0;
28 Unused << mDoc->SendState(mID, &state);
29 return state;
30 }
31
NativeState() const32 uint64_t RemoteAccessible::NativeState() const {
33 uint64_t state = 0;
34 Unused << mDoc->SendNativeState(mID, &state);
35 return state;
36 }
37
Name(nsString & aName) const38 ENameValueFlag RemoteAccessible::Name(nsString& aName) const {
39 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
40 return RemoteAccessibleBase<RemoteAccessible>::Name(aName);
41 }
42
43 uint32_t flag = 0;
44 Unused << mDoc->SendName(mID, &aName, &flag);
45 return static_cast<ENameValueFlag>(flag);
46 }
47
Value(nsString & aValue) const48 void RemoteAccessible::Value(nsString& aValue) const {
49 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
50 RemoteAccessibleBase<RemoteAccessible>::Value(aValue);
51 return;
52 }
53
54 Unused << mDoc->SendValue(mID, &aValue);
55 }
56
Help(nsString & aHelp) const57 void RemoteAccessible::Help(nsString& aHelp) const {
58 Unused << mDoc->SendHelp(mID, &aHelp);
59 }
60
Description(nsString & aDesc) const61 void RemoteAccessible::Description(nsString& aDesc) const {
62 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
63 RemoteAccessibleBase<RemoteAccessible>::Description(aDesc);
64 return;
65 }
66
67 Unused << mDoc->SendDescription(mID, &aDesc);
68 }
69
Attributes()70 already_AddRefed<AccAttributes> RemoteAccessible::Attributes() {
71 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
72 return RemoteAccessibleBase<RemoteAccessible>::Attributes();
73 }
74 RefPtr<AccAttributes> attrs;
75 Unused << mDoc->SendAttributes(mID, &attrs);
76 return attrs.forget();
77 }
78
RelationByType(RelationType aType) const79 nsTArray<RemoteAccessible*> RemoteAccessible::RelationByType(
80 RelationType aType) const {
81 nsTArray<uint64_t> targetIDs;
82 Unused << mDoc->SendRelationByType(mID, static_cast<uint32_t>(aType),
83 &targetIDs);
84
85 size_t targetCount = targetIDs.Length();
86 nsTArray<RemoteAccessible*> targets(targetCount);
87 for (size_t i = 0; i < targetCount; i++) {
88 if (RemoteAccessible* proxy = mDoc->GetAccessible(targetIDs[i])) {
89 targets.AppendElement(proxy);
90 }
91 }
92
93 return targets;
94 }
95
Relations(nsTArray<RelationType> * aTypes,nsTArray<nsTArray<RemoteAccessible * >> * aTargetSets) const96 void RemoteAccessible::Relations(
97 nsTArray<RelationType>* aTypes,
98 nsTArray<nsTArray<RemoteAccessible*>>* aTargetSets) const {
99 nsTArray<RelationTargets> ipcRelations;
100 Unused << mDoc->SendRelations(mID, &ipcRelations);
101
102 size_t relationCount = ipcRelations.Length();
103 aTypes->SetCapacity(relationCount);
104 aTargetSets->SetCapacity(relationCount);
105 for (size_t i = 0; i < relationCount; i++) {
106 uint32_t type = ipcRelations[i].Type();
107 if (type > static_cast<uint32_t>(RelationType::LAST)) continue;
108
109 size_t targetCount = ipcRelations[i].Targets().Length();
110 nsTArray<RemoteAccessible*> targets(targetCount);
111 for (size_t j = 0; j < targetCount; j++) {
112 if (RemoteAccessible* proxy =
113 mDoc->GetAccessible(ipcRelations[i].Targets()[j])) {
114 targets.AppendElement(proxy);
115 }
116 }
117
118 if (targets.IsEmpty()) continue;
119
120 aTargetSets->AppendElement(std::move(targets));
121 aTypes->AppendElement(static_cast<RelationType>(type));
122 }
123 }
124
IsSearchbox() const125 bool RemoteAccessible::IsSearchbox() const {
126 bool retVal = false;
127 Unused << mDoc->SendIsSearchbox(mID, &retVal);
128 return retVal;
129 }
130
LandmarkRole() const131 nsAtom* RemoteAccessible::LandmarkRole() const {
132 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
133 return RemoteAccessibleBase<RemoteAccessible>::LandmarkRole();
134 }
135
136 nsString landmark;
137 Unused << mDoc->SendLandmarkRole(mID, &landmark);
138 return NS_GetStaticAtom(landmark);
139 }
140
ARIARoleAtom() const141 nsStaticAtom* RemoteAccessible::ARIARoleAtom() const {
142 nsString role;
143 Unused << mDoc->SendARIARoleAtom(mID, &role);
144 return NS_GetStaticAtom(role);
145 }
146
GroupPosition()147 GroupPos RemoteAccessible::GroupPosition() {
148 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
149 return RemoteAccessibleBase<RemoteAccessible>::GroupPosition();
150 }
151
152 GroupPos groupPos;
153 Unused << mDoc->SendGroupPosition(mID, &groupPos.level, &groupPos.setSize,
154 &groupPos.posInSet);
155 return groupPos;
156 }
157
ScrollTo(uint32_t aScrollType)158 void RemoteAccessible::ScrollTo(uint32_t aScrollType) {
159 Unused << mDoc->SendScrollTo(mID, aScrollType);
160 }
161
ScrollToPoint(uint32_t aScrollType,int32_t aX,int32_t aY)162 void RemoteAccessible::ScrollToPoint(uint32_t aScrollType, int32_t aX,
163 int32_t aY) {
164 Unused << mDoc->SendScrollToPoint(mID, aScrollType, aX, aY);
165 }
166
Announce(const nsString & aAnnouncement,uint16_t aPriority)167 void RemoteAccessible::Announce(const nsString& aAnnouncement,
168 uint16_t aPriority) {
169 Unused << mDoc->SendAnnounce(mID, aAnnouncement, aPriority);
170 }
171
CaretLineNumber()172 int32_t RemoteAccessible::CaretLineNumber() {
173 int32_t line = -1;
174 Unused << mDoc->SendCaretOffset(mID, &line);
175 return line;
176 }
177
CaretOffset() const178 int32_t RemoteAccessible::CaretOffset() const {
179 int32_t offset = 0;
180 Unused << mDoc->SendCaretOffset(mID, &offset);
181 return offset;
182 }
183
SetCaretOffset(int32_t aOffset)184 void RemoteAccessible::SetCaretOffset(int32_t aOffset) {
185 Unused << mDoc->SendSetCaretOffset(mID, aOffset);
186 }
187
CharacterCount() const188 uint32_t RemoteAccessible::CharacterCount() const {
189 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
190 return RemoteAccessibleBase<RemoteAccessible>::CharacterCount();
191 }
192 int32_t count = 0;
193 Unused << mDoc->SendCharacterCount(mID, &count);
194 return count;
195 }
196
SelectionCount()197 int32_t RemoteAccessible::SelectionCount() {
198 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
199 return RemoteAccessibleBase<RemoteAccessible>::SelectionCount();
200 }
201 int32_t count = 0;
202 Unused << mDoc->SendSelectionCount(mID, &count);
203 return count;
204 }
205
TextSubstring(int32_t aStartOffset,int32_t aEndOfset,nsAString & aText) const206 void RemoteAccessible::TextSubstring(int32_t aStartOffset, int32_t aEndOfset,
207 nsAString& aText) const {
208 bool valid;
209 nsString text;
210 Unused << mDoc->SendTextSubstring(mID, aStartOffset, aEndOfset, &text,
211 &valid);
212 aText = std::move(text);
213 }
214
TextAfterOffset(int32_t aOffset,AccessibleTextBoundary aBoundaryType,int32_t * aStartOffset,int32_t * aEndOffset,nsAString & aText)215 void RemoteAccessible::TextAfterOffset(int32_t aOffset,
216 AccessibleTextBoundary aBoundaryType,
217 int32_t* aStartOffset,
218 int32_t* aEndOffset, nsAString& aText) {
219 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
220 return RemoteAccessibleBase<RemoteAccessible>::TextAfterOffset(
221 aOffset, aBoundaryType, aStartOffset, aEndOffset, aText);
222 }
223 nsString text;
224 Unused << mDoc->SendGetTextAfterOffset(mID, aOffset, aBoundaryType, &text,
225 aStartOffset, aEndOffset);
226 aText = std::move(text);
227 }
228
TextAtOffset(int32_t aOffset,AccessibleTextBoundary aBoundaryType,int32_t * aStartOffset,int32_t * aEndOffset,nsAString & aText)229 void RemoteAccessible::TextAtOffset(int32_t aOffset,
230 AccessibleTextBoundary aBoundaryType,
231 int32_t* aStartOffset, int32_t* aEndOffset,
232 nsAString& aText) {
233 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
234 return RemoteAccessibleBase<RemoteAccessible>::TextAtOffset(
235 aOffset, aBoundaryType, aStartOffset, aEndOffset, aText);
236 }
237 nsString text;
238 Unused << mDoc->SendGetTextAtOffset(mID, aOffset, aBoundaryType, &text,
239 aStartOffset, aEndOffset);
240 aText = std::move(text);
241 }
242
TextBeforeOffset(int32_t aOffset,AccessibleTextBoundary aBoundaryType,int32_t * aStartOffset,int32_t * aEndOffset,nsAString & aText)243 void RemoteAccessible::TextBeforeOffset(int32_t aOffset,
244 AccessibleTextBoundary aBoundaryType,
245 int32_t* aStartOffset,
246 int32_t* aEndOffset, nsAString& aText) {
247 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
248 return RemoteAccessibleBase<RemoteAccessible>::TextBeforeOffset(
249 aOffset, aBoundaryType, aStartOffset, aEndOffset, aText);
250 }
251 nsString text;
252 Unused << mDoc->SendGetTextBeforeOffset(mID, aOffset, aBoundaryType, &text,
253 aStartOffset, aEndOffset);
254 aText = std::move(text);
255 }
256
CharAt(int32_t aOffset)257 char16_t RemoteAccessible::CharAt(int32_t aOffset) {
258 uint16_t retval = 0;
259 Unused << mDoc->SendCharAt(mID, aOffset, &retval);
260 return static_cast<char16_t>(retval);
261 }
262
TextAttributes(bool aIncludeDefAttrs,int32_t aOffset,int32_t * aStartOffset,int32_t * aEndOffset)263 already_AddRefed<AccAttributes> RemoteAccessible::TextAttributes(
264 bool aIncludeDefAttrs, int32_t aOffset, int32_t* aStartOffset,
265 int32_t* aEndOffset) {
266 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
267 return RemoteAccessibleBase<RemoteAccessible>::TextAttributes(
268 aIncludeDefAttrs, aOffset, aStartOffset, aEndOffset);
269 }
270 RefPtr<AccAttributes> attrs;
271 Unused << mDoc->SendTextAttributes(mID, aIncludeDefAttrs, aOffset, &attrs,
272 aStartOffset, aEndOffset);
273 return attrs.forget();
274 }
275
DefaultTextAttributes()276 already_AddRefed<AccAttributes> RemoteAccessible::DefaultTextAttributes() {
277 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
278 return RemoteAccessibleBase<RemoteAccessible>::DefaultTextAttributes();
279 }
280 RefPtr<AccAttributes> attrs;
281 Unused << mDoc->SendDefaultTextAttributes(mID, &attrs);
282 return attrs.forget();
283 }
284
TextBounds(int32_t aStartOffset,int32_t aEndOffset,uint32_t aCoordType)285 LayoutDeviceIntRect RemoteAccessible::TextBounds(int32_t aStartOffset,
286 int32_t aEndOffset,
287 uint32_t aCoordType) {
288 LayoutDeviceIntRect rect;
289 Unused << mDoc->SendTextBounds(mID, aStartOffset, aEndOffset, aCoordType,
290 &rect);
291 return rect;
292 }
293
CharBounds(int32_t aOffset,uint32_t aCoordType)294 LayoutDeviceIntRect RemoteAccessible::CharBounds(int32_t aOffset,
295 uint32_t aCoordType) {
296 LayoutDeviceIntRect rect;
297 Unused << mDoc->SendCharBounds(mID, aOffset, aCoordType, &rect);
298 return rect;
299 }
300
OffsetAtPoint(int32_t aX,int32_t aY,uint32_t aCoordType)301 int32_t RemoteAccessible::OffsetAtPoint(int32_t aX, int32_t aY,
302 uint32_t aCoordType) {
303 int32_t retVal = -1;
304 Unused << mDoc->SendOffsetAtPoint(mID, aX, aY, aCoordType, &retVal);
305 return retVal;
306 }
307
SelectionBoundsAt(int32_t aSelectionNum,nsString & aData,int32_t * aStartOffset,int32_t * aEndOffset)308 bool RemoteAccessible::SelectionBoundsAt(int32_t aSelectionNum, nsString& aData,
309 int32_t* aStartOffset,
310 int32_t* aEndOffset) {
311 bool retVal = false;
312 Unused << mDoc->SendSelectionBoundsAt(mID, aSelectionNum, &retVal, &aData,
313 aStartOffset, aEndOffset);
314 return retVal;
315 }
316
SetSelectionBoundsAt(int32_t aSelectionNum,int32_t aStartOffset,int32_t aEndOffset)317 bool RemoteAccessible::SetSelectionBoundsAt(int32_t aSelectionNum,
318 int32_t aStartOffset,
319 int32_t aEndOffset) {
320 bool retVal = false;
321 Unused << mDoc->SendSetSelectionBoundsAt(mID, aSelectionNum, aStartOffset,
322 aEndOffset, &retVal);
323 return retVal;
324 }
325
AddToSelection(int32_t aStartOffset,int32_t aEndOffset)326 bool RemoteAccessible::AddToSelection(int32_t aStartOffset,
327 int32_t aEndOffset) {
328 bool retVal = false;
329 Unused << mDoc->SendAddToSelection(mID, aStartOffset, aEndOffset, &retVal);
330 return retVal;
331 }
332
RemoveFromSelection(int32_t aSelectionNum)333 bool RemoteAccessible::RemoveFromSelection(int32_t aSelectionNum) {
334 bool retVal = false;
335 Unused << mDoc->SendRemoveFromSelection(mID, aSelectionNum, &retVal);
336 return retVal;
337 }
338
ScrollSubstringTo(int32_t aStartOffset,int32_t aEndOffset,uint32_t aScrollType)339 void RemoteAccessible::ScrollSubstringTo(int32_t aStartOffset,
340 int32_t aEndOffset,
341 uint32_t aScrollType) {
342 Unused << mDoc->SendScrollSubstringTo(mID, aStartOffset, aEndOffset,
343 aScrollType);
344 }
345
ScrollSubstringToPoint(int32_t aStartOffset,int32_t aEndOffset,uint32_t aCoordinateType,int32_t aX,int32_t aY)346 void RemoteAccessible::ScrollSubstringToPoint(int32_t aStartOffset,
347 int32_t aEndOffset,
348 uint32_t aCoordinateType,
349 int32_t aX, int32_t aY) {
350 Unused << mDoc->SendScrollSubstringToPoint(mID, aStartOffset, aEndOffset,
351 aCoordinateType, aX, aY);
352 }
353
Text(nsString * aText)354 void RemoteAccessible::Text(nsString* aText) {
355 Unused << mDoc->SendText(mID, aText);
356 }
357
ReplaceText(const nsString & aText)358 void RemoteAccessible::ReplaceText(const nsString& aText) {
359 Unused << mDoc->SendReplaceText(mID, aText);
360 }
361
InsertText(const nsString & aText,int32_t aPosition)362 bool RemoteAccessible::InsertText(const nsString& aText, int32_t aPosition) {
363 bool valid;
364 Unused << mDoc->SendInsertText(mID, aText, aPosition, &valid);
365 return valid;
366 }
367
CopyText(int32_t aStartPos,int32_t aEndPos)368 bool RemoteAccessible::CopyText(int32_t aStartPos, int32_t aEndPos) {
369 bool valid;
370 Unused << mDoc->SendCopyText(mID, aStartPos, aEndPos, &valid);
371 return valid;
372 }
373
CutText(int32_t aStartPos,int32_t aEndPos)374 bool RemoteAccessible::CutText(int32_t aStartPos, int32_t aEndPos) {
375 bool valid;
376 Unused << mDoc->SendCutText(mID, aStartPos, aEndPos, &valid);
377 return valid;
378 }
379
DeleteText(int32_t aStartPos,int32_t aEndPos)380 bool RemoteAccessible::DeleteText(int32_t aStartPos, int32_t aEndPos) {
381 bool valid;
382 Unused << mDoc->SendDeleteText(mID, aStartPos, aEndPos, &valid);
383 return valid;
384 }
385
PasteText(int32_t aPosition)386 bool RemoteAccessible::PasteText(int32_t aPosition) {
387 bool valid;
388 Unused << mDoc->SendPasteText(mID, aPosition, &valid);
389 return valid;
390 }
391
ImagePosition(uint32_t aCoordType)392 LayoutDeviceIntPoint RemoteAccessible::ImagePosition(uint32_t aCoordType) {
393 LayoutDeviceIntPoint retVal;
394 Unused << mDoc->SendImagePosition(mID, aCoordType, &retVal);
395 return retVal;
396 }
397
ImageSize()398 LayoutDeviceIntSize RemoteAccessible::ImageSize() {
399 LayoutDeviceIntSize retVal;
400 Unused << mDoc->SendImageSize(mID, &retVal);
401 return retVal;
402 }
403
StartOffset()404 uint32_t RemoteAccessible::StartOffset() {
405 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
406 return RemoteAccessibleBase<RemoteAccessible>::StartOffset();
407 }
408 uint32_t retVal = 0;
409 bool ok;
410 Unused << mDoc->SendStartOffset(mID, &retVal, &ok);
411 return retVal;
412 }
413
EndOffset()414 uint32_t RemoteAccessible::EndOffset() {
415 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
416 return RemoteAccessibleBase<RemoteAccessible>::EndOffset();
417 }
418 bool ok;
419 uint32_t retVal = 0;
420 Unused << mDoc->SendEndOffset(mID, &retVal, &ok);
421 return retVal;
422 }
423
IsLinkValid()424 bool RemoteAccessible::IsLinkValid() {
425 bool retVal = false;
426 Unused << mDoc->SendIsLinkValid(mID, &retVal);
427 return retVal;
428 }
429
AnchorCount(bool * aOk)430 uint32_t RemoteAccessible::AnchorCount(bool* aOk) {
431 uint32_t retVal = 0;
432 Unused << mDoc->SendAnchorCount(mID, &retVal, aOk);
433 return retVal;
434 }
435
AnchorURIAt(uint32_t aIndex,nsCString & aURI,bool * aOk)436 void RemoteAccessible::AnchorURIAt(uint32_t aIndex, nsCString& aURI,
437 bool* aOk) {
438 Unused << mDoc->SendAnchorURIAt(mID, aIndex, &aURI, aOk);
439 }
440
AnchorAt(uint32_t aIndex)441 RemoteAccessible* RemoteAccessible::AnchorAt(uint32_t aIndex) {
442 uint64_t id = 0;
443 bool ok = false;
444 Unused << mDoc->SendAnchorAt(mID, aIndex, &id, &ok);
445 return ok ? mDoc->GetAccessible(id) : nullptr;
446 }
447
LinkCount()448 uint32_t RemoteAccessible::LinkCount() {
449 uint32_t retVal = 0;
450 Unused << mDoc->SendLinkCount(mID, &retVal);
451 return retVal;
452 }
453
LinkAt(const uint32_t & aIndex)454 RemoteAccessible* RemoteAccessible::LinkAt(const uint32_t& aIndex) {
455 uint64_t linkID = 0;
456 bool ok = false;
457 Unused << mDoc->SendLinkAt(mID, aIndex, &linkID, &ok);
458 return ok ? mDoc->GetAccessible(linkID) : nullptr;
459 }
460
LinkIndexAtOffset(uint32_t aOffset)461 int32_t RemoteAccessible::LinkIndexAtOffset(uint32_t aOffset) {
462 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
463 return RemoteAccessibleBase<RemoteAccessible>::LinkIndexAtOffset(aOffset);
464 }
465 int32_t retVal = -1;
466 Unused << mDoc->SendLinkIndexAtOffset(mID, aOffset, &retVal);
467 return retVal;
468 }
469
TableOfACell()470 RemoteAccessible* RemoteAccessible::TableOfACell() {
471 uint64_t tableID = 0;
472 bool ok = false;
473 Unused << mDoc->SendTableOfACell(mID, &tableID, &ok);
474 return ok ? mDoc->GetAccessible(tableID) : nullptr;
475 }
476
ColIdx()477 uint32_t RemoteAccessible::ColIdx() {
478 uint32_t index = 0;
479 Unused << mDoc->SendColIdx(mID, &index);
480 return index;
481 }
482
RowIdx()483 uint32_t RemoteAccessible::RowIdx() {
484 uint32_t index = 0;
485 Unused << mDoc->SendRowIdx(mID, &index);
486 return index;
487 }
488
GetColRowExtents(uint32_t * aColIdx,uint32_t * aRowIdx,uint32_t * aColExtent,uint32_t * aRowExtent)489 void RemoteAccessible::GetColRowExtents(uint32_t* aColIdx, uint32_t* aRowIdx,
490 uint32_t* aColExtent,
491 uint32_t* aRowExtent) {
492 Unused << mDoc->SendGetColRowExtents(mID, aColIdx, aRowIdx, aColExtent,
493 aRowExtent);
494 }
495
GetPosition(uint32_t * aColIdx,uint32_t * aRowIdx)496 void RemoteAccessible::GetPosition(uint32_t* aColIdx, uint32_t* aRowIdx) {
497 Unused << mDoc->SendGetPosition(mID, aColIdx, aRowIdx);
498 }
499
ColExtent()500 uint32_t RemoteAccessible::ColExtent() {
501 uint32_t extent = 0;
502 Unused << mDoc->SendColExtent(mID, &extent);
503 return extent;
504 }
505
RowExtent()506 uint32_t RemoteAccessible::RowExtent() {
507 uint32_t extent = 0;
508 Unused << mDoc->SendRowExtent(mID, &extent);
509 return extent;
510 }
511
ColHeaderCells(nsTArray<RemoteAccessible * > * aCells)512 void RemoteAccessible::ColHeaderCells(nsTArray<RemoteAccessible*>* aCells) {
513 nsTArray<uint64_t> targetIDs;
514 Unused << mDoc->SendColHeaderCells(mID, &targetIDs);
515
516 size_t targetCount = targetIDs.Length();
517 for (size_t i = 0; i < targetCount; i++) {
518 aCells->AppendElement(mDoc->GetAccessible(targetIDs[i]));
519 }
520 }
521
RowHeaderCells(nsTArray<RemoteAccessible * > * aCells)522 void RemoteAccessible::RowHeaderCells(nsTArray<RemoteAccessible*>* aCells) {
523 nsTArray<uint64_t> targetIDs;
524 Unused << mDoc->SendRowHeaderCells(mID, &targetIDs);
525
526 size_t targetCount = targetIDs.Length();
527 for (size_t i = 0; i < targetCount; i++) {
528 aCells->AppendElement(mDoc->GetAccessible(targetIDs[i]));
529 }
530 }
531
IsCellSelected()532 bool RemoteAccessible::IsCellSelected() {
533 bool selected = false;
534 Unused << mDoc->SendIsCellSelected(mID, &selected);
535 return selected;
536 }
537
TableCaption()538 RemoteAccessible* RemoteAccessible::TableCaption() {
539 uint64_t captionID = 0;
540 bool ok = false;
541 Unused << mDoc->SendTableCaption(mID, &captionID, &ok);
542 return ok ? mDoc->GetAccessible(captionID) : nullptr;
543 }
544
TableSummary(nsString & aSummary)545 void RemoteAccessible::TableSummary(nsString& aSummary) {
546 Unused << mDoc->SendTableSummary(mID, &aSummary);
547 }
548
TableColumnCount()549 uint32_t RemoteAccessible::TableColumnCount() {
550 uint32_t count = 0;
551 Unused << mDoc->SendTableColumnCount(mID, &count);
552 return count;
553 }
554
TableRowCount()555 uint32_t RemoteAccessible::TableRowCount() {
556 uint32_t count = 0;
557 Unused << mDoc->SendTableRowCount(mID, &count);
558 return count;
559 }
560
TableCellAt(uint32_t aRow,uint32_t aCol)561 RemoteAccessible* RemoteAccessible::TableCellAt(uint32_t aRow, uint32_t aCol) {
562 uint64_t cellID = 0;
563 bool ok = false;
564 Unused << mDoc->SendTableCellAt(mID, aRow, aCol, &cellID, &ok);
565 return ok ? mDoc->GetAccessible(cellID) : nullptr;
566 }
567
TableCellIndexAt(uint32_t aRow,uint32_t aCol)568 int32_t RemoteAccessible::TableCellIndexAt(uint32_t aRow, uint32_t aCol) {
569 int32_t index = 0;
570 Unused << mDoc->SendTableCellIndexAt(mID, aRow, aCol, &index);
571 return index;
572 }
573
TableColumnIndexAt(uint32_t aCellIndex)574 int32_t RemoteAccessible::TableColumnIndexAt(uint32_t aCellIndex) {
575 int32_t index = 0;
576 Unused << mDoc->SendTableColumnIndexAt(mID, aCellIndex, &index);
577 return index;
578 }
579
TableRowIndexAt(uint32_t aCellIndex)580 int32_t RemoteAccessible::TableRowIndexAt(uint32_t aCellIndex) {
581 int32_t index = 0;
582 Unused << mDoc->SendTableRowIndexAt(mID, aCellIndex, &index);
583 return index;
584 }
585
TableRowAndColumnIndicesAt(uint32_t aCellIndex,int32_t * aRow,int32_t * aCol)586 void RemoteAccessible::TableRowAndColumnIndicesAt(uint32_t aCellIndex,
587 int32_t* aRow,
588 int32_t* aCol) {
589 Unused << mDoc->SendTableRowAndColumnIndicesAt(mID, aCellIndex, aRow, aCol);
590 }
591
TableColumnExtentAt(uint32_t aRow,uint32_t aCol)592 uint32_t RemoteAccessible::TableColumnExtentAt(uint32_t aRow, uint32_t aCol) {
593 uint32_t extent = 0;
594 Unused << mDoc->SendTableColumnExtentAt(mID, aRow, aCol, &extent);
595 return extent;
596 }
597
TableRowExtentAt(uint32_t aRow,uint32_t aCol)598 uint32_t RemoteAccessible::TableRowExtentAt(uint32_t aRow, uint32_t aCol) {
599 uint32_t extent = 0;
600 Unused << mDoc->SendTableRowExtentAt(mID, aRow, aCol, &extent);
601 return extent;
602 }
603
TableColumnDescription(uint32_t aCol,nsString & aDescription)604 void RemoteAccessible::TableColumnDescription(uint32_t aCol,
605 nsString& aDescription) {
606 Unused << mDoc->SendTableColumnDescription(mID, aCol, &aDescription);
607 }
608
TableRowDescription(uint32_t aRow,nsString & aDescription)609 void RemoteAccessible::TableRowDescription(uint32_t aRow,
610 nsString& aDescription) {
611 Unused << mDoc->SendTableRowDescription(mID, aRow, &aDescription);
612 }
613
TableColumnSelected(uint32_t aCol)614 bool RemoteAccessible::TableColumnSelected(uint32_t aCol) {
615 bool selected = false;
616 Unused << mDoc->SendTableColumnSelected(mID, aCol, &selected);
617 return selected;
618 }
619
TableRowSelected(uint32_t aRow)620 bool RemoteAccessible::TableRowSelected(uint32_t aRow) {
621 bool selected = false;
622 Unused << mDoc->SendTableRowSelected(mID, aRow, &selected);
623 return selected;
624 }
625
TableCellSelected(uint32_t aRow,uint32_t aCol)626 bool RemoteAccessible::TableCellSelected(uint32_t aRow, uint32_t aCol) {
627 bool selected = false;
628 Unused << mDoc->SendTableCellSelected(mID, aRow, aCol, &selected);
629 return selected;
630 }
631
TableSelectedCellCount()632 uint32_t RemoteAccessible::TableSelectedCellCount() {
633 uint32_t count = 0;
634 Unused << mDoc->SendTableSelectedCellCount(mID, &count);
635 return count;
636 }
637
TableSelectedColumnCount()638 uint32_t RemoteAccessible::TableSelectedColumnCount() {
639 uint32_t count = 0;
640 Unused << mDoc->SendTableSelectedColumnCount(mID, &count);
641 return count;
642 }
643
TableSelectedRowCount()644 uint32_t RemoteAccessible::TableSelectedRowCount() {
645 uint32_t count = 0;
646 Unused << mDoc->SendTableSelectedRowCount(mID, &count);
647 return count;
648 }
649
TableSelectedCells(nsTArray<RemoteAccessible * > * aCellIDs)650 void RemoteAccessible::TableSelectedCells(
651 nsTArray<RemoteAccessible*>* aCellIDs) {
652 AutoTArray<uint64_t, 30> cellIDs;
653 Unused << mDoc->SendTableSelectedCells(mID, &cellIDs);
654 aCellIDs->SetCapacity(cellIDs.Length());
655 for (uint32_t i = 0; i < cellIDs.Length(); ++i) {
656 aCellIDs->AppendElement(mDoc->GetAccessible(cellIDs[i]));
657 }
658 }
659
TableSelectedCellIndices(nsTArray<uint32_t> * aCellIndices)660 void RemoteAccessible::TableSelectedCellIndices(
661 nsTArray<uint32_t>* aCellIndices) {
662 Unused << mDoc->SendTableSelectedCellIndices(mID, aCellIndices);
663 }
664
TableSelectedColumnIndices(nsTArray<uint32_t> * aColumnIndices)665 void RemoteAccessible::TableSelectedColumnIndices(
666 nsTArray<uint32_t>* aColumnIndices) {
667 Unused << mDoc->SendTableSelectedColumnIndices(mID, aColumnIndices);
668 }
669
TableSelectedRowIndices(nsTArray<uint32_t> * aRowIndices)670 void RemoteAccessible::TableSelectedRowIndices(
671 nsTArray<uint32_t>* aRowIndices) {
672 Unused << mDoc->SendTableSelectedRowIndices(mID, aRowIndices);
673 }
674
TableSelectColumn(uint32_t aCol)675 void RemoteAccessible::TableSelectColumn(uint32_t aCol) {
676 Unused << mDoc->SendTableSelectColumn(mID, aCol);
677 }
678
TableSelectRow(uint32_t aRow)679 void RemoteAccessible::TableSelectRow(uint32_t aRow) {
680 Unused << mDoc->SendTableSelectRow(mID, aRow);
681 }
682
TableUnselectColumn(uint32_t aCol)683 void RemoteAccessible::TableUnselectColumn(uint32_t aCol) {
684 Unused << mDoc->SendTableUnselectColumn(mID, aCol);
685 }
686
TableUnselectRow(uint32_t aRow)687 void RemoteAccessible::TableUnselectRow(uint32_t aRow) {
688 Unused << mDoc->SendTableUnselectRow(mID, aRow);
689 }
690
TableIsProbablyForLayout()691 bool RemoteAccessible::TableIsProbablyForLayout() {
692 bool forLayout = false;
693 Unused << mDoc->SendTableIsProbablyForLayout(mID, &forLayout);
694 return forLayout;
695 }
696
AtkTableColumnHeader(int32_t aCol)697 RemoteAccessible* RemoteAccessible::AtkTableColumnHeader(int32_t aCol) {
698 uint64_t headerID = 0;
699 bool ok = false;
700 Unused << mDoc->SendAtkTableColumnHeader(mID, aCol, &headerID, &ok);
701 return ok ? mDoc->GetAccessible(headerID) : nullptr;
702 }
703
AtkTableRowHeader(int32_t aRow)704 RemoteAccessible* RemoteAccessible::AtkTableRowHeader(int32_t aRow) {
705 uint64_t headerID = 0;
706 bool ok = false;
707 Unused << mDoc->SendAtkTableRowHeader(mID, aRow, &headerID, &ok);
708 return ok ? mDoc->GetAccessible(headerID) : nullptr;
709 }
710
SelectedItems(nsTArray<Accessible * > * aSelectedItems)711 void RemoteAccessible::SelectedItems(nsTArray<Accessible*>* aSelectedItems) {
712 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
713 RemoteAccessibleBase<RemoteAccessible>::SelectedItems(aSelectedItems);
714 return;
715 }
716
717 AutoTArray<uint64_t, 10> itemIDs;
718 Unused << mDoc->SendSelectedItems(mID, &itemIDs);
719 aSelectedItems->SetCapacity(itemIDs.Length());
720 for (size_t i = 0; i < itemIDs.Length(); ++i) {
721 aSelectedItems->AppendElement(mDoc->GetAccessible(itemIDs[i]));
722 }
723 }
724
SelectedItemCount()725 uint32_t RemoteAccessible::SelectedItemCount() {
726 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
727 return RemoteAccessibleBase<RemoteAccessible>::SelectedItemCount();
728 }
729
730 uint32_t count = 0;
731 Unused << mDoc->SendSelectedItemCount(mID, &count);
732 return count;
733 }
734
GetSelectedItem(uint32_t aIndex)735 Accessible* RemoteAccessible::GetSelectedItem(uint32_t aIndex) {
736 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
737 return RemoteAccessibleBase<RemoteAccessible>::GetSelectedItem(aIndex);
738 }
739
740 uint64_t selectedItemID = 0;
741 bool ok = false;
742 Unused << mDoc->SendGetSelectedItem(mID, aIndex, &selectedItemID, &ok);
743 return ok ? mDoc->GetAccessible(selectedItemID) : nullptr;
744 }
745
IsItemSelected(uint32_t aIndex)746 bool RemoteAccessible::IsItemSelected(uint32_t aIndex) {
747 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
748 return RemoteAccessibleBase<RemoteAccessible>::IsItemSelected(aIndex);
749 }
750
751 bool selected = false;
752 Unused << mDoc->SendIsItemSelected(mID, aIndex, &selected);
753 return selected;
754 }
755
AddItemToSelection(uint32_t aIndex)756 bool RemoteAccessible::AddItemToSelection(uint32_t aIndex) {
757 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
758 return RemoteAccessibleBase<RemoteAccessible>::AddItemToSelection(aIndex);
759 }
760
761 bool success = false;
762 Unused << mDoc->SendAddItemToSelection(mID, aIndex, &success);
763 return success;
764 }
765
RemoveItemFromSelection(uint32_t aIndex)766 bool RemoteAccessible::RemoveItemFromSelection(uint32_t aIndex) {
767 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
768 return RemoteAccessibleBase<RemoteAccessible>::RemoveItemFromSelection(
769 aIndex);
770 }
771
772 bool success = false;
773 Unused << mDoc->SendRemoveItemFromSelection(mID, aIndex, &success);
774 return success;
775 }
776
SelectAll()777 bool RemoteAccessible::SelectAll() {
778 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
779 return RemoteAccessibleBase<RemoteAccessible>::SelectAll();
780 }
781
782 bool success = false;
783 Unused << mDoc->SendSelectAll(mID, &success);
784 return success;
785 }
786
UnselectAll()787 bool RemoteAccessible::UnselectAll() {
788 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
789 return RemoteAccessibleBase<RemoteAccessible>::UnselectAll();
790 }
791
792 bool success = false;
793 Unused << mDoc->SendUnselectAll(mID, &success);
794 return success;
795 }
796
DoAction(uint8_t aIndex) const797 bool RemoteAccessible::DoAction(uint8_t aIndex) const {
798 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
799 return RemoteAccessibleBase<RemoteAccessible>::DoAction(aIndex);
800 }
801
802 bool success = false;
803 Unused << mDoc->SendDoAction(mID, aIndex, &success);
804 return success;
805 }
806
ActionCount() const807 uint8_t RemoteAccessible::ActionCount() const {
808 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
809 return RemoteAccessibleBase<RemoteAccessible>::ActionCount();
810 }
811
812 uint8_t count = 0;
813 Unused << mDoc->SendActionCount(mID, &count);
814 return count;
815 }
816
ActionNameAt(uint8_t aIndex,nsAString & aName)817 void RemoteAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) {
818 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
819 RemoteAccessibleBase<RemoteAccessible>::ActionNameAt(aIndex, aName);
820 return;
821 }
822
823 nsAutoString name;
824 Unused << mDoc->SendActionNameAt(mID, aIndex, &name);
825
826 aName.Assign(name);
827 }
828
AccessKey()829 KeyBinding RemoteAccessible::AccessKey() {
830 uint32_t key = 0;
831 uint32_t modifierMask = 0;
832 Unused << mDoc->SendAccessKey(mID, &key, &modifierMask);
833 return KeyBinding(key, modifierMask);
834 }
835
KeyboardShortcut()836 KeyBinding RemoteAccessible::KeyboardShortcut() {
837 uint32_t key = 0;
838 uint32_t modifierMask = 0;
839 Unused << mDoc->SendKeyboardShortcut(mID, &key, &modifierMask);
840 return KeyBinding(key, modifierMask);
841 }
842
AtkKeyBinding(nsString & aBinding)843 void RemoteAccessible::AtkKeyBinding(nsString& aBinding) {
844 Unused << mDoc->SendAtkKeyBinding(mID, &aBinding);
845 }
846
CurValue() const847 double RemoteAccessible::CurValue() const {
848 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
849 return RemoteAccessibleBase<RemoteAccessible>::CurValue();
850 }
851
852 double val = UnspecifiedNaN<double>();
853 Unused << mDoc->SendCurValue(mID, &val);
854 return val;
855 }
856
SetCurValue(double aValue)857 bool RemoteAccessible::SetCurValue(double aValue) {
858 bool success = false;
859 Unused << mDoc->SendSetCurValue(mID, aValue, &success);
860 return success;
861 }
862
MinValue() const863 double RemoteAccessible::MinValue() const {
864 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
865 return RemoteAccessibleBase<RemoteAccessible>::MinValue();
866 }
867
868 double val = UnspecifiedNaN<double>();
869 Unused << mDoc->SendMinValue(mID, &val);
870 return val;
871 }
872
MaxValue() const873 double RemoteAccessible::MaxValue() const {
874 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
875 return RemoteAccessibleBase<RemoteAccessible>::MaxValue();
876 }
877
878 double val = UnspecifiedNaN<double>();
879 Unused << mDoc->SendMaxValue(mID, &val);
880 return val;
881 }
882
Step() const883 double RemoteAccessible::Step() const {
884 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
885 return RemoteAccessibleBase<RemoteAccessible>::Step();
886 }
887
888 double step = UnspecifiedNaN<double>();
889 Unused << mDoc->SendStep(mID, &step);
890 return step;
891 }
892
FocusedChild()893 RemoteAccessible* RemoteAccessible::FocusedChild() {
894 if (IsOuterDoc()) {
895 // If FocusedChild was called on an outer doc, it should behave
896 // like a non-doc accessible and return its focused child, or null.
897 // If the inner doc is OOP (fission), calling FocusedChild on the outer
898 // doc would return null.
899 RemoteAccessible* child = RemoteFirstChild();
900 if (!child) {
901 return (State() & states::FOCUSED) ? this : nullptr;
902 }
903 MOZ_ASSERT(child->IsDoc());
904 return (child->State() & states::FOCUSED) ? child : nullptr;
905 }
906
907 auto* doc = mDoc;
908 uint64_t id = mID;
909 if (IsDoc()) {
910 // If this is a doc we should return the focused descendant, not just the
911 // direct child. In order to do that, we need to get a doc that is in
912 // the same process as the focused accessible. So we need the focused doc.
913 if (dom::BrowserParent* browser = dom::BrowserParent::GetFocused()) {
914 if (auto* focusedDoc = browser->GetTopLevelDocAccessible()) {
915 if (!focusedDoc->IsTopLevel()) {
916 // Redirect SendFocusedChild to OOP iframe doc.
917 doc = focusedDoc;
918 }
919 }
920 }
921 }
922
923 PDocAccessibleParent* resultDoc = nullptr;
924 uint64_t resultID = 0;
925 Unused << doc->SendFocusedChild(id, &resultDoc, &resultID);
926
927 auto* useDoc = static_cast<DocAccessibleParent*>(resultDoc);
928 // If useDoc is null, this means there is no focused child.
929 return useDoc ? useDoc->GetAccessible(resultID) : nullptr;
930 }
931
ChildAtPoint(int32_t aX,int32_t aY,LocalAccessible::EWhichChildAtPoint aWhichChild)932 Accessible* RemoteAccessible::ChildAtPoint(
933 int32_t aX, int32_t aY, LocalAccessible::EWhichChildAtPoint aWhichChild) {
934 RemoteAccessible* target = this;
935 do {
936 if (target->IsOuterDoc()) {
937 if (target->ChildCount() == 0) {
938 // Return the OuterDoc if the requested point is within its bounds.
939 LayoutDeviceIntRect rect = target->Bounds();
940 if (rect.Contains(aX, aY)) {
941 return target;
942 }
943 return nullptr;
944 }
945 DocAccessibleParent* childDoc = target->RemoteChildAt(0)->AsDoc();
946 MOZ_ASSERT(childDoc);
947 if (childDoc->IsTopLevelInContentProcess()) {
948 // This is an OOP iframe. Remote calls can only work within their
949 // process, so they stop at OOP iframes.
950 if (aWhichChild == Accessible::EWhichChildAtPoint::DirectChild) {
951 // Return the child document if it's within the bounds of the iframe.
952 LayoutDeviceIntRect docRect = target->Bounds();
953 if (docRect.Contains(aX, aY)) {
954 return childDoc;
955 }
956 return nullptr;
957 }
958 // We must continue the search from the child document.
959 target = childDoc;
960 }
961 }
962 PDocAccessibleParent* resultDoc = nullptr;
963 uint64_t resultID = 0;
964 Unused << target->mDoc->SendChildAtPoint(target->mID, aX, aY,
965 static_cast<uint32_t>(aWhichChild),
966 &resultDoc, &resultID);
967 // If resultDoc is null, this means there is no child at this point.
968 auto useDoc = static_cast<DocAccessibleParent*>(resultDoc);
969 target = resultDoc ? useDoc->GetAccessible(resultID) : nullptr;
970 } while (target && target->IsOuterDoc() &&
971 aWhichChild == Accessible::EWhichChildAtPoint::DeepestChild);
972 return target;
973 }
974
Bounds() const975 LayoutDeviceIntRect RemoteAccessible::Bounds() const {
976 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
977 return RemoteAccessibleBase<RemoteAccessible>::Bounds();
978 }
979
980 LayoutDeviceIntRect rect;
981 Unused << mDoc->SendExtents(mID, false, &(rect.x), &(rect.y), &(rect.width),
982 &(rect.height));
983 return rect;
984 }
985
BoundsInCSSPixels()986 nsIntRect RemoteAccessible::BoundsInCSSPixels() {
987 nsIntRect rect;
988 Unused << mDoc->SendExtentsInCSSPixels(mID, &rect.x, &rect.y, &rect.width,
989 &rect.height);
990 return rect;
991 }
992
Language(nsString & aLocale)993 void RemoteAccessible::Language(nsString& aLocale) {
994 Unused << mDoc->SendLanguage(mID, &aLocale);
995 }
996
DocType(nsString & aType)997 void RemoteAccessible::DocType(nsString& aType) {
998 Unused << mDoc->SendDocType(mID, &aType);
999 }
1000
Title(nsString & aTitle)1001 void RemoteAccessible::Title(nsString& aTitle) {
1002 Unused << mDoc->SendTitle(mID, &aTitle);
1003 }
1004
URL(nsString & aURL)1005 void RemoteAccessible::URL(nsString& aURL) {
1006 Unused << mDoc->SendURL(mID, &aURL);
1007 }
1008
MimeType(nsString aMime)1009 void RemoteAccessible::MimeType(nsString aMime) {
1010 Unused << mDoc->SendMimeType(mID, &aMime);
1011 }
1012
URLDocTypeMimeType(nsString & aURL,nsString & aDocType,nsString & aMimeType)1013 void RemoteAccessible::URLDocTypeMimeType(nsString& aURL, nsString& aDocType,
1014 nsString& aMimeType) {
1015 Unused << mDoc->SendURLDocTypeMimeType(mID, &aURL, &aDocType, &aMimeType);
1016 }
1017
Extents(bool aNeedsScreenCoords,int32_t * aX,int32_t * aY,int32_t * aWidth,int32_t * aHeight)1018 void RemoteAccessible::Extents(bool aNeedsScreenCoords, int32_t* aX,
1019 int32_t* aY, int32_t* aWidth, int32_t* aHeight) {
1020 Unused << mDoc->SendExtents(mID, aNeedsScreenCoords, aX, aY, aWidth, aHeight);
1021 }
1022
DOMNodeID(nsString & aID) const1023 void RemoteAccessible::DOMNodeID(nsString& aID) const {
1024 if (StaticPrefs::accessibility_cache_enabled_AtStartup()) {
1025 return RemoteAccessibleBase<RemoteAccessible>::DOMNodeID(aID);
1026 }
1027 Unused << mDoc->SendDOMNodeID(mID, &aID);
1028 }
1029
1030 } // namespace a11y
1031 } // namespace mozilla
1032