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 "DocAccessibleChild.h"
8
9 #include "nsAccessibilityService.h"
10 #include "Accessible-inl.h"
11 #include "ProxyAccessible.h"
12 #include "Relation.h"
13 #include "HyperTextAccessible-inl.h"
14 #include "TextLeafAccessible.h"
15 #include "ImageAccessible.h"
16 #include "TableAccessible.h"
17 #include "TableCellAccessible.h"
18 #include "nsIPersistentProperties2.h"
19 #include "nsAccUtils.h"
20 #ifdef MOZ_ACCESSIBILITY_ATK
21 # include "AccessibleWrap.h"
22 #endif
23 #include "mozilla/PresShell.h"
24 #include "mozilla/a11y/DocAccessiblePlatformExtChild.h"
25
26 namespace mozilla {
27 namespace a11y {
28
IdToAccessible(const uint64_t & aID) const29 Accessible* DocAccessibleChild::IdToAccessible(const uint64_t& aID) const {
30 if (!aID) return mDoc;
31
32 if (!mDoc) return nullptr;
33
34 return mDoc->GetAccessibleByUniqueID(reinterpret_cast<void*>(aID));
35 }
36
IdToAccessibleLink(const uint64_t & aID) const37 Accessible* DocAccessibleChild::IdToAccessibleLink(const uint64_t& aID) const {
38 Accessible* acc = IdToAccessible(aID);
39 return acc && acc->IsLink() ? acc : nullptr;
40 }
41
IdToAccessibleSelect(const uint64_t & aID) const42 Accessible* DocAccessibleChild::IdToAccessibleSelect(
43 const uint64_t& aID) const {
44 Accessible* acc = IdToAccessible(aID);
45 return acc && acc->IsSelect() ? acc : nullptr;
46 }
47
IdToHyperTextAccessible(const uint64_t & aID) const48 HyperTextAccessible* DocAccessibleChild::IdToHyperTextAccessible(
49 const uint64_t& aID) const {
50 Accessible* acc = IdToAccessible(aID);
51 return acc && acc->IsHyperText() ? acc->AsHyperText() : nullptr;
52 }
53
IdToTextLeafAccessible(const uint64_t & aID) const54 TextLeafAccessible* DocAccessibleChild::IdToTextLeafAccessible(
55 const uint64_t& aID) const {
56 Accessible* acc = IdToAccessible(aID);
57 return acc && acc->IsTextLeaf() ? acc->AsTextLeaf() : nullptr;
58 }
59
IdToImageAccessible(const uint64_t & aID) const60 ImageAccessible* DocAccessibleChild::IdToImageAccessible(
61 const uint64_t& aID) const {
62 Accessible* acc = IdToAccessible(aID);
63 return (acc && acc->IsImage()) ? acc->AsImage() : nullptr;
64 }
65
IdToTableCellAccessible(const uint64_t & aID) const66 TableCellAccessible* DocAccessibleChild::IdToTableCellAccessible(
67 const uint64_t& aID) const {
68 Accessible* acc = IdToAccessible(aID);
69 return (acc && acc->IsTableCell()) ? acc->AsTableCell() : nullptr;
70 }
71
IdToTableAccessible(const uint64_t & aID) const72 TableAccessible* DocAccessibleChild::IdToTableAccessible(
73 const uint64_t& aID) const {
74 Accessible* acc = IdToAccessible(aID);
75 return (acc && acc->IsTable()) ? acc->AsTable() : nullptr;
76 }
77
RecvState(const uint64_t & aID,uint64_t * aState)78 mozilla::ipc::IPCResult DocAccessibleChild::RecvState(const uint64_t& aID,
79 uint64_t* aState) {
80 Accessible* acc = IdToAccessible(aID);
81 if (!acc) {
82 *aState = states::DEFUNCT;
83 return IPC_OK();
84 }
85
86 *aState = acc->State();
87
88 return IPC_OK();
89 }
90
RecvNativeState(const uint64_t & aID,uint64_t * aState)91 mozilla::ipc::IPCResult DocAccessibleChild::RecvNativeState(const uint64_t& aID,
92 uint64_t* aState) {
93 Accessible* acc = IdToAccessible(aID);
94 if (!acc) {
95 *aState = states::DEFUNCT;
96 return IPC_OK();
97 }
98
99 *aState = acc->NativeState();
100
101 return IPC_OK();
102 }
103
RecvName(const uint64_t & aID,nsString * aName,uint32_t * aFlag)104 mozilla::ipc::IPCResult DocAccessibleChild::RecvName(const uint64_t& aID,
105 nsString* aName,
106 uint32_t* aFlag) {
107 Accessible* acc = IdToAccessible(aID);
108 if (!acc) return IPC_OK();
109
110 *aFlag = acc->Name(*aName);
111 return IPC_OK();
112 }
113
RecvValue(const uint64_t & aID,nsString * aValue)114 mozilla::ipc::IPCResult DocAccessibleChild::RecvValue(const uint64_t& aID,
115 nsString* aValue) {
116 Accessible* acc = IdToAccessible(aID);
117 if (!acc) {
118 return IPC_OK();
119 }
120
121 acc->Value(*aValue);
122 return IPC_OK();
123 }
124
RecvHelp(const uint64_t & aID,nsString * aHelp)125 mozilla::ipc::IPCResult DocAccessibleChild::RecvHelp(const uint64_t& aID,
126 nsString* aHelp) {
127 Accessible* acc = IdToAccessible(aID);
128 if (!acc) {
129 return IPC_OK();
130 }
131
132 acc->Help(*aHelp);
133 return IPC_OK();
134 }
135
RecvDescription(const uint64_t & aID,nsString * aDesc)136 mozilla::ipc::IPCResult DocAccessibleChild::RecvDescription(const uint64_t& aID,
137 nsString* aDesc) {
138 Accessible* acc = IdToAccessible(aID);
139 if (!acc) return IPC_OK();
140
141 acc->Description(*aDesc);
142 return IPC_OK();
143 }
144
RecvAttributes(const uint64_t & aID,nsTArray<Attribute> * aAttributes)145 mozilla::ipc::IPCResult DocAccessibleChild::RecvAttributes(
146 const uint64_t& aID, nsTArray<Attribute>* aAttributes) {
147 Accessible* acc = IdToAccessible(aID);
148 if (!acc) return IPC_OK();
149
150 nsCOMPtr<nsIPersistentProperties> props = acc->Attributes();
151 if (!nsAccUtils::PersistentPropertiesToArray(props, aAttributes)) {
152 return IPC_FAIL_NO_REASON(this);
153 }
154 return IPC_OK();
155 }
156
RecvRelationByType(const uint64_t & aID,const uint32_t & aType,nsTArray<uint64_t> * aTargets)157 mozilla::ipc::IPCResult DocAccessibleChild::RecvRelationByType(
158 const uint64_t& aID, const uint32_t& aType, nsTArray<uint64_t>* aTargets) {
159 Accessible* acc = IdToAccessible(aID);
160 if (!acc) return IPC_OK();
161
162 auto type = static_cast<RelationType>(aType);
163 Relation rel = acc->RelationByType(type);
164 while (Accessible* target = rel.Next())
165 aTargets->AppendElement(reinterpret_cast<uint64_t>(target->UniqueID()));
166
167 return IPC_OK();
168 }
169
AddRelation(Accessible * aAcc,RelationType aType,nsTArray<RelationTargets> * aTargets)170 static void AddRelation(Accessible* aAcc, RelationType aType,
171 nsTArray<RelationTargets>* aTargets) {
172 Relation rel = aAcc->RelationByType(aType);
173 nsTArray<uint64_t> targets;
174 while (Accessible* target = rel.Next())
175 targets.AppendElement(reinterpret_cast<uint64_t>(target->UniqueID()));
176
177 if (!targets.IsEmpty()) {
178 RelationTargets* newRelation = aTargets->AppendElement(
179 RelationTargets(static_cast<uint32_t>(aType), nsTArray<uint64_t>()));
180 newRelation->Targets().SwapElements(targets);
181 }
182 }
183
RecvRelations(const uint64_t & aID,nsTArray<RelationTargets> * aRelations)184 mozilla::ipc::IPCResult DocAccessibleChild::RecvRelations(
185 const uint64_t& aID, nsTArray<RelationTargets>* aRelations) {
186 Accessible* acc = IdToAccessible(aID);
187 if (!acc) return IPC_OK();
188
189 #define RELATIONTYPE(gecko, s, a, m, i) \
190 AddRelation(acc, RelationType::gecko, aRelations);
191
192 #include "RelationTypeMap.h"
193 #undef RELATIONTYPE
194
195 return IPC_OK();
196 }
197
RecvIsSearchbox(const uint64_t & aID,bool * aRetVal)198 mozilla::ipc::IPCResult DocAccessibleChild::RecvIsSearchbox(const uint64_t& aID,
199 bool* aRetVal) {
200 Accessible* acc = IdToAccessible(aID);
201 if (!acc) return IPC_OK();
202
203 *aRetVal = acc->IsSearchbox();
204 return IPC_OK();
205 }
206
RecvLandmarkRole(const uint64_t & aID,nsString * aLandmark)207 mozilla::ipc::IPCResult DocAccessibleChild::RecvLandmarkRole(
208 const uint64_t& aID, nsString* aLandmark) {
209 Accessible* acc = IdToAccessible(aID);
210 if (!acc) {
211 return IPC_OK();
212 }
213
214 if (nsAtom* roleAtom = acc->LandmarkRole()) {
215 roleAtom->ToString(*aLandmark);
216 }
217
218 return IPC_OK();
219 }
220
RecvARIARoleAtom(const uint64_t & aID,nsString * aRole)221 mozilla::ipc::IPCResult DocAccessibleChild::RecvARIARoleAtom(
222 const uint64_t& aID, nsString* aRole) {
223 Accessible* acc = IdToAccessible(aID);
224 if (!acc) {
225 return IPC_OK();
226 }
227
228 if (const nsRoleMapEntry* roleMap = acc->ARIARoleMap()) {
229 if (nsStaticAtom* roleAtom = roleMap->roleAtom) {
230 roleAtom->ToString(*aRole);
231 }
232 }
233
234 return IPC_OK();
235 }
236
RecvGroupPosition(const uint64_t & aID,int32_t * aLevel,int32_t * aSimilarItemsInGroup,int32_t * aPositionInGroup)237 mozilla::ipc::IPCResult DocAccessibleChild::RecvGroupPosition(
238 const uint64_t& aID, int32_t* aLevel, int32_t* aSimilarItemsInGroup,
239 int32_t* aPositionInGroup) {
240 Accessible* acc = IdToAccessible(aID);
241 if (acc) {
242 GroupPos groupPos = acc->GroupPosition();
243 *aLevel = groupPos.level;
244 *aSimilarItemsInGroup = groupPos.setSize;
245 *aPositionInGroup = groupPos.posInSet;
246 }
247
248 return IPC_OK();
249 }
250
RecvScrollTo(const uint64_t & aID,const uint32_t & aScrollType)251 mozilla::ipc::IPCResult DocAccessibleChild::RecvScrollTo(
252 const uint64_t& aID, const uint32_t& aScrollType) {
253 Accessible* acc = IdToAccessible(aID);
254 if (acc) {
255 RefPtr<PresShell> presShell = acc->Document()->PresShellPtr();
256 nsCOMPtr<nsIContent> content = acc->GetContent();
257 nsCoreUtils::ScrollTo(presShell, content, aScrollType);
258 }
259
260 return IPC_OK();
261 }
262
RecvScrollToPoint(const uint64_t & aID,const uint32_t & aScrollType,const int32_t & aX,const int32_t & aY)263 mozilla::ipc::IPCResult DocAccessibleChild::RecvScrollToPoint(
264 const uint64_t& aID, const uint32_t& aScrollType, const int32_t& aX,
265 const int32_t& aY) {
266 Accessible* acc = IdToAccessible(aID);
267 if (acc) {
268 acc->ScrollToPoint(aScrollType, aX, aY);
269 }
270
271 return IPC_OK();
272 }
273
RecvAnnounce(const uint64_t & aID,const nsString & aAnnouncement,const uint16_t & aPriority)274 mozilla::ipc::IPCResult DocAccessibleChild::RecvAnnounce(
275 const uint64_t& aID, const nsString& aAnnouncement,
276 const uint16_t& aPriority) {
277 Accessible* acc = IdToAccessible(aID);
278 if (acc) {
279 acc->Announce(aAnnouncement, aPriority);
280 }
281
282 return IPC_OK();
283 }
284
RecvCaretLineNumber(const uint64_t & aID,int32_t * aLineNumber)285 mozilla::ipc::IPCResult DocAccessibleChild::RecvCaretLineNumber(
286 const uint64_t& aID, int32_t* aLineNumber) {
287 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
288 *aLineNumber = acc && acc->IsTextRole() ? acc->CaretLineNumber() : 0;
289 return IPC_OK();
290 }
291
RecvCaretOffset(const uint64_t & aID,int32_t * aOffset)292 mozilla::ipc::IPCResult DocAccessibleChild::RecvCaretOffset(const uint64_t& aID,
293 int32_t* aOffset) {
294 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
295 *aOffset = acc && acc->IsTextRole() ? acc->CaretOffset() : 0;
296 return IPC_OK();
297 }
298
RecvSetCaretOffset(const uint64_t & aID,const int32_t & aOffset)299 mozilla::ipc::IPCResult DocAccessibleChild::RecvSetCaretOffset(
300 const uint64_t& aID, const int32_t& aOffset) {
301 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
302 if (acc && acc->IsTextRole() && acc->IsValidOffset(aOffset)) {
303 acc->SetCaretOffset(aOffset);
304 }
305 return IPC_OK();
306 }
307
RecvCharacterCount(const uint64_t & aID,int32_t * aCount)308 mozilla::ipc::IPCResult DocAccessibleChild::RecvCharacterCount(
309 const uint64_t& aID, int32_t* aCount) {
310 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
311 *aCount = acc ? acc->CharacterCount() : 0;
312 return IPC_OK();
313 }
314
RecvSelectionCount(const uint64_t & aID,int32_t * aCount)315 mozilla::ipc::IPCResult DocAccessibleChild::RecvSelectionCount(
316 const uint64_t& aID, int32_t* aCount) {
317 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
318 *aCount = acc ? acc->SelectionCount() : 0;
319 return IPC_OK();
320 }
321
RecvTextSubstring(const uint64_t & aID,const int32_t & aStartOffset,const int32_t & aEndOffset,nsString * aText,bool * aValid)322 mozilla::ipc::IPCResult DocAccessibleChild::RecvTextSubstring(
323 const uint64_t& aID, const int32_t& aStartOffset, const int32_t& aEndOffset,
324 nsString* aText, bool* aValid) {
325 Accessible* acc = IdToAccessible(aID);
326 if (!acc) {
327 return IPC_OK();
328 }
329
330 TextLeafAccessible* leaf = acc->AsTextLeaf();
331 if (leaf) {
332 if (aStartOffset != 0 || aEndOffset != -1) {
333 // We don't support fetching partial text from a leaf.
334 *aValid = false;
335 return IPC_OK();
336 }
337 *aValid = true;
338 *aText = leaf->Text();
339 return IPC_OK();
340 }
341
342 HyperTextAccessible* hyper = acc->AsHyperText();
343 if (!hyper) {
344 return IPC_OK();
345 }
346
347 *aValid = hyper->IsValidRange(aStartOffset, aEndOffset);
348 hyper->TextSubstring(aStartOffset, aEndOffset, *aText);
349 return IPC_OK();
350 }
351
RecvGetTextAfterOffset(const uint64_t & aID,const int32_t & aOffset,const int32_t & aBoundaryType,nsString * aText,int32_t * aStartOffset,int32_t * aEndOffset)352 mozilla::ipc::IPCResult DocAccessibleChild::RecvGetTextAfterOffset(
353 const uint64_t& aID, const int32_t& aOffset, const int32_t& aBoundaryType,
354 nsString* aText, int32_t* aStartOffset, int32_t* aEndOffset) {
355 *aStartOffset = 0;
356 *aEndOffset = 0;
357 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
358 if (acc) {
359 acc->TextAfterOffset(aOffset, aBoundaryType, aStartOffset, aEndOffset,
360 *aText);
361 }
362 return IPC_OK();
363 }
364
RecvGetTextAtOffset(const uint64_t & aID,const int32_t & aOffset,const int32_t & aBoundaryType,nsString * aText,int32_t * aStartOffset,int32_t * aEndOffset)365 mozilla::ipc::IPCResult DocAccessibleChild::RecvGetTextAtOffset(
366 const uint64_t& aID, const int32_t& aOffset, const int32_t& aBoundaryType,
367 nsString* aText, int32_t* aStartOffset, int32_t* aEndOffset) {
368 *aStartOffset = 0;
369 *aEndOffset = 0;
370 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
371 if (acc) {
372 acc->TextAtOffset(aOffset, aBoundaryType, aStartOffset, aEndOffset, *aText);
373 }
374 return IPC_OK();
375 }
376
RecvGetTextBeforeOffset(const uint64_t & aID,const int32_t & aOffset,const int32_t & aBoundaryType,nsString * aText,int32_t * aStartOffset,int32_t * aEndOffset)377 mozilla::ipc::IPCResult DocAccessibleChild::RecvGetTextBeforeOffset(
378 const uint64_t& aID, const int32_t& aOffset, const int32_t& aBoundaryType,
379 nsString* aText, int32_t* aStartOffset, int32_t* aEndOffset) {
380 *aStartOffset = 0;
381 *aEndOffset = 0;
382 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
383 if (acc) {
384 acc->TextBeforeOffset(aOffset, aBoundaryType, aStartOffset, aEndOffset,
385 *aText);
386 }
387 return IPC_OK();
388 }
389
RecvCharAt(const uint64_t & aID,const int32_t & aOffset,uint16_t * aChar)390 mozilla::ipc::IPCResult DocAccessibleChild::RecvCharAt(const uint64_t& aID,
391 const int32_t& aOffset,
392 uint16_t* aChar) {
393 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
394 *aChar = acc && acc->IsTextRole()
395 ? static_cast<uint16_t>(acc->CharAt(aOffset))
396 : 0;
397 return IPC_OK();
398 }
399
RecvTextAttributes(const uint64_t & aID,const bool & aIncludeDefAttrs,const int32_t & aOffset,nsTArray<Attribute> * aAttributes,int32_t * aStartOffset,int32_t * aEndOffset)400 mozilla::ipc::IPCResult DocAccessibleChild::RecvTextAttributes(
401 const uint64_t& aID, const bool& aIncludeDefAttrs, const int32_t& aOffset,
402 nsTArray<Attribute>* aAttributes, int32_t* aStartOffset,
403 int32_t* aEndOffset) {
404 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
405 if (!acc || !acc->IsTextRole()) {
406 return IPC_OK();
407 }
408
409 nsCOMPtr<nsIPersistentProperties> props =
410 acc->TextAttributes(aIncludeDefAttrs, aOffset, aStartOffset, aEndOffset);
411 if (!nsAccUtils::PersistentPropertiesToArray(props, aAttributes)) {
412 return IPC_FAIL_NO_REASON(this);
413 }
414 return IPC_OK();
415 }
416
RecvDefaultTextAttributes(const uint64_t & aID,nsTArray<Attribute> * aAttributes)417 mozilla::ipc::IPCResult DocAccessibleChild::RecvDefaultTextAttributes(
418 const uint64_t& aID, nsTArray<Attribute>* aAttributes) {
419 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
420 if (!acc || !acc->IsTextRole()) {
421 return IPC_OK();
422 }
423
424 nsCOMPtr<nsIPersistentProperties> props = acc->DefaultTextAttributes();
425 if (!nsAccUtils::PersistentPropertiesToArray(props, aAttributes)) {
426 return IPC_FAIL_NO_REASON(this);
427 }
428 return IPC_OK();
429 }
430
RecvTextBounds(const uint64_t & aID,const int32_t & aStartOffset,const int32_t & aEndOffset,const uint32_t & aCoordType,nsIntRect * aRetVal)431 mozilla::ipc::IPCResult DocAccessibleChild::RecvTextBounds(
432 const uint64_t& aID, const int32_t& aStartOffset, const int32_t& aEndOffset,
433 const uint32_t& aCoordType, nsIntRect* aRetVal) {
434 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
435 if (acc && acc->IsTextRole()) {
436 *aRetVal = acc->TextBounds(aStartOffset, aEndOffset, aCoordType);
437 }
438
439 return IPC_OK();
440 }
441
RecvCharBounds(const uint64_t & aID,const int32_t & aOffset,const uint32_t & aCoordType,nsIntRect * aRetVal)442 mozilla::ipc::IPCResult DocAccessibleChild::RecvCharBounds(
443 const uint64_t& aID, const int32_t& aOffset, const uint32_t& aCoordType,
444 nsIntRect* aRetVal) {
445 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
446 if (acc && acc->IsTextRole()) {
447 *aRetVal = acc->CharBounds(aOffset, aCoordType);
448 }
449
450 return IPC_OK();
451 }
452
RecvOffsetAtPoint(const uint64_t & aID,const int32_t & aX,const int32_t & aY,const uint32_t & aCoordType,int32_t * aRetVal)453 mozilla::ipc::IPCResult DocAccessibleChild::RecvOffsetAtPoint(
454 const uint64_t& aID, const int32_t& aX, const int32_t& aY,
455 const uint32_t& aCoordType, int32_t* aRetVal) {
456 *aRetVal = -1;
457 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
458 if (acc && acc->IsTextRole()) {
459 *aRetVal = acc->OffsetAtPoint(aX, aY, aCoordType);
460 }
461 return IPC_OK();
462 }
463
RecvSelectionBoundsAt(const uint64_t & aID,const int32_t & aSelectionNum,bool * aSucceeded,nsString * aData,int32_t * aStartOffset,int32_t * aEndOffset)464 mozilla::ipc::IPCResult DocAccessibleChild::RecvSelectionBoundsAt(
465 const uint64_t& aID, const int32_t& aSelectionNum, bool* aSucceeded,
466 nsString* aData, int32_t* aStartOffset, int32_t* aEndOffset) {
467 *aSucceeded = false;
468 *aStartOffset = 0;
469 *aEndOffset = 0;
470 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
471 if (acc && acc->IsTextRole()) {
472 *aSucceeded =
473 acc->SelectionBoundsAt(aSelectionNum, aStartOffset, aEndOffset);
474 if (*aSucceeded) {
475 acc->TextSubstring(*aStartOffset, *aEndOffset, *aData);
476 }
477 }
478
479 return IPC_OK();
480 }
481
RecvSetSelectionBoundsAt(const uint64_t & aID,const int32_t & aSelectionNum,const int32_t & aStartOffset,const int32_t & aEndOffset,bool * aSucceeded)482 mozilla::ipc::IPCResult DocAccessibleChild::RecvSetSelectionBoundsAt(
483 const uint64_t& aID, const int32_t& aSelectionNum,
484 const int32_t& aStartOffset, const int32_t& aEndOffset, bool* aSucceeded) {
485 *aSucceeded = false;
486 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
487 if (acc && acc->IsTextRole()) {
488 *aSucceeded =
489 acc->SetSelectionBoundsAt(aSelectionNum, aStartOffset, aEndOffset);
490 }
491
492 return IPC_OK();
493 }
494
RecvAddToSelection(const uint64_t & aID,const int32_t & aStartOffset,const int32_t & aEndOffset,bool * aSucceeded)495 mozilla::ipc::IPCResult DocAccessibleChild::RecvAddToSelection(
496 const uint64_t& aID, const int32_t& aStartOffset, const int32_t& aEndOffset,
497 bool* aSucceeded) {
498 *aSucceeded = false;
499 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
500 if (acc && acc->IsTextRole()) {
501 *aSucceeded = acc->AddToSelection(aStartOffset, aEndOffset);
502 }
503
504 return IPC_OK();
505 }
506
RecvRemoveFromSelection(const uint64_t & aID,const int32_t & aSelectionNum,bool * aSucceeded)507 mozilla::ipc::IPCResult DocAccessibleChild::RecvRemoveFromSelection(
508 const uint64_t& aID, const int32_t& aSelectionNum, bool* aSucceeded) {
509 *aSucceeded = false;
510 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
511 if (acc && acc->IsTextRole()) {
512 *aSucceeded = acc->RemoveFromSelection(aSelectionNum);
513 }
514
515 return IPC_OK();
516 }
517
RecvScrollSubstringTo(const uint64_t & aID,const int32_t & aStartOffset,const int32_t & aEndOffset,const uint32_t & aScrollType)518 mozilla::ipc::IPCResult DocAccessibleChild::RecvScrollSubstringTo(
519 const uint64_t& aID, const int32_t& aStartOffset, const int32_t& aEndOffset,
520 const uint32_t& aScrollType) {
521 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
522 if (acc) {
523 acc->ScrollSubstringTo(aStartOffset, aEndOffset, aScrollType);
524 }
525
526 return IPC_OK();
527 }
528
RecvScrollSubstringToPoint(const uint64_t & aID,const int32_t & aStartOffset,const int32_t & aEndOffset,const uint32_t & aCoordinateType,const int32_t & aX,const int32_t & aY)529 mozilla::ipc::IPCResult DocAccessibleChild::RecvScrollSubstringToPoint(
530 const uint64_t& aID, const int32_t& aStartOffset, const int32_t& aEndOffset,
531 const uint32_t& aCoordinateType, const int32_t& aX, const int32_t& aY) {
532 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
533 if (acc) {
534 acc->ScrollSubstringToPoint(aStartOffset, aEndOffset, aCoordinateType, aX,
535 aY);
536 }
537
538 return IPC_OK();
539 }
540
RecvText(const uint64_t & aID,nsString * aText)541 mozilla::ipc::IPCResult DocAccessibleChild::RecvText(const uint64_t& aID,
542 nsString* aText) {
543 TextLeafAccessible* acc = IdToTextLeafAccessible(aID);
544 if (acc) {
545 *aText = acc->Text();
546 }
547
548 return IPC_OK();
549 }
550
RecvReplaceText(const uint64_t & aID,const nsString & aText)551 mozilla::ipc::IPCResult DocAccessibleChild::RecvReplaceText(
552 const uint64_t& aID, const nsString& aText) {
553 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
554 if (acc && acc->IsTextRole()) {
555 acc->ReplaceText(aText);
556 }
557
558 return IPC_OK();
559 }
560
RecvInsertText(const uint64_t & aID,const nsString & aText,const int32_t & aPosition,bool * aValid)561 mozilla::ipc::IPCResult DocAccessibleChild::RecvInsertText(
562 const uint64_t& aID, const nsString& aText, const int32_t& aPosition,
563 bool* aValid) {
564 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
565 if (acc && acc->IsTextRole()) {
566 *aValid = acc->IsValidOffset(aPosition);
567 acc->InsertText(aText, aPosition);
568 }
569
570 return IPC_OK();
571 }
572
RecvCopyText(const uint64_t & aID,const int32_t & aStartPos,const int32_t & aEndPos,bool * aValid)573 mozilla::ipc::IPCResult DocAccessibleChild::RecvCopyText(
574 const uint64_t& aID, const int32_t& aStartPos, const int32_t& aEndPos,
575 bool* aValid) {
576 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
577 if (acc && acc->IsTextRole()) {
578 acc->CopyText(aStartPos, aEndPos);
579 }
580
581 return IPC_OK();
582 }
583
RecvCutText(const uint64_t & aID,const int32_t & aStartPos,const int32_t & aEndPos,bool * aValid)584 mozilla::ipc::IPCResult DocAccessibleChild::RecvCutText(
585 const uint64_t& aID, const int32_t& aStartPos, const int32_t& aEndPos,
586 bool* aValid) {
587 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
588 if (acc && acc->IsTextRole()) {
589 *aValid = acc->IsValidRange(aStartPos, aEndPos);
590 acc->CutText(aStartPos, aEndPos);
591 }
592
593 return IPC_OK();
594 }
595
RecvDeleteText(const uint64_t & aID,const int32_t & aStartPos,const int32_t & aEndPos,bool * aValid)596 mozilla::ipc::IPCResult DocAccessibleChild::RecvDeleteText(
597 const uint64_t& aID, const int32_t& aStartPos, const int32_t& aEndPos,
598 bool* aValid) {
599 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
600 if (acc && acc->IsTextRole()) {
601 *aValid = acc->IsValidRange(aStartPos, aEndPos);
602 acc->DeleteText(aStartPos, aEndPos);
603 }
604
605 return IPC_OK();
606 }
607
RecvPasteText(const uint64_t & aID,const int32_t & aPosition,bool * aValid)608 mozilla::ipc::IPCResult DocAccessibleChild::RecvPasteText(
609 const uint64_t& aID, const int32_t& aPosition, bool* aValid) {
610 RefPtr<HyperTextAccessible> acc = IdToHyperTextAccessible(aID);
611 if (acc && acc->IsTextRole()) {
612 *aValid = acc->IsValidOffset(aPosition);
613 acc->PasteText(aPosition);
614 }
615
616 return IPC_OK();
617 }
618
RecvImagePosition(const uint64_t & aID,const uint32_t & aCoordType,nsIntPoint * aRetVal)619 mozilla::ipc::IPCResult DocAccessibleChild::RecvImagePosition(
620 const uint64_t& aID, const uint32_t& aCoordType, nsIntPoint* aRetVal) {
621 ImageAccessible* acc = IdToImageAccessible(aID);
622 if (acc) {
623 *aRetVal = acc->Position(aCoordType);
624 }
625
626 return IPC_OK();
627 }
628
RecvImageSize(const uint64_t & aID,nsIntSize * aRetVal)629 mozilla::ipc::IPCResult DocAccessibleChild::RecvImageSize(const uint64_t& aID,
630 nsIntSize* aRetVal) {
631 ImageAccessible* acc = IdToImageAccessible(aID);
632 if (acc) {
633 *aRetVal = acc->Size();
634 }
635
636 return IPC_OK();
637 }
638
RecvStartOffset(const uint64_t & aID,uint32_t * aRetVal,bool * aOk)639 mozilla::ipc::IPCResult DocAccessibleChild::RecvStartOffset(const uint64_t& aID,
640 uint32_t* aRetVal,
641 bool* aOk) {
642 Accessible* acc = IdToAccessibleLink(aID);
643 if (acc) {
644 *aRetVal = acc->StartOffset();
645 *aOk = true;
646 } else {
647 *aRetVal = 0;
648 *aOk = false;
649 }
650
651 return IPC_OK();
652 }
653
RecvEndOffset(const uint64_t & aID,uint32_t * aRetVal,bool * aOk)654 mozilla::ipc::IPCResult DocAccessibleChild::RecvEndOffset(const uint64_t& aID,
655 uint32_t* aRetVal,
656 bool* aOk) {
657 Accessible* acc = IdToAccessibleLink(aID);
658 if (acc) {
659 *aRetVal = acc->EndOffset();
660 *aOk = true;
661 } else {
662 *aRetVal = 0;
663 *aOk = false;
664 }
665
666 return IPC_OK();
667 }
668
RecvIsLinkValid(const uint64_t & aID,bool * aRetVal)669 mozilla::ipc::IPCResult DocAccessibleChild::RecvIsLinkValid(const uint64_t& aID,
670 bool* aRetVal) {
671 Accessible* acc = IdToAccessibleLink(aID);
672 if (acc) {
673 *aRetVal = acc->IsLinkValid();
674 } else {
675 *aRetVal = false;
676 }
677
678 return IPC_OK();
679 }
680
RecvAnchorCount(const uint64_t & aID,uint32_t * aRetVal,bool * aOk)681 mozilla::ipc::IPCResult DocAccessibleChild::RecvAnchorCount(const uint64_t& aID,
682 uint32_t* aRetVal,
683 bool* aOk) {
684 Accessible* acc = IdToAccessibleLink(aID);
685 if (acc) {
686 *aRetVal = acc->AnchorCount();
687 *aOk = true;
688 } else {
689 *aRetVal = 0;
690 *aOk = false;
691 }
692
693 return IPC_OK();
694 }
695
RecvAnchorURIAt(const uint64_t & aID,const uint32_t & aIndex,nsCString * aURI,bool * aOk)696 mozilla::ipc::IPCResult DocAccessibleChild::RecvAnchorURIAt(
697 const uint64_t& aID, const uint32_t& aIndex, nsCString* aURI, bool* aOk) {
698 Accessible* acc = IdToAccessibleLink(aID);
699 *aOk = false;
700 if (acc) {
701 nsCOMPtr<nsIURI> uri = acc->AnchorURIAt(aIndex);
702 if (uri) {
703 uri->GetSpec(*aURI);
704 *aOk = true;
705 }
706 }
707
708 return IPC_OK();
709 }
710
RecvAnchorAt(const uint64_t & aID,const uint32_t & aIndex,uint64_t * aIDOfAnchor,bool * aOk)711 mozilla::ipc::IPCResult DocAccessibleChild::RecvAnchorAt(const uint64_t& aID,
712 const uint32_t& aIndex,
713 uint64_t* aIDOfAnchor,
714 bool* aOk) {
715 *aIDOfAnchor = 0;
716 *aOk = false;
717 Accessible* acc = IdToAccessibleLink(aID);
718 if (acc) {
719 Accessible* anchor = acc->AnchorAt(aIndex);
720 if (anchor) {
721 *aIDOfAnchor = reinterpret_cast<uint64_t>(anchor->UniqueID());
722 *aOk = true;
723 }
724 }
725
726 return IPC_OK();
727 }
728
RecvLinkCount(const uint64_t & aID,uint32_t * aCount)729 mozilla::ipc::IPCResult DocAccessibleChild::RecvLinkCount(const uint64_t& aID,
730 uint32_t* aCount) {
731 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
732 *aCount = acc ? acc->LinkCount() : 0;
733 return IPC_OK();
734 }
735
RecvLinkAt(const uint64_t & aID,const uint32_t & aIndex,uint64_t * aIDOfLink,bool * aOk)736 mozilla::ipc::IPCResult DocAccessibleChild::RecvLinkAt(const uint64_t& aID,
737 const uint32_t& aIndex,
738 uint64_t* aIDOfLink,
739 bool* aOk) {
740 *aIDOfLink = 0;
741 *aOk = false;
742 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
743 if (acc) {
744 Accessible* link = acc->LinkAt(aIndex);
745 if (link) {
746 *aIDOfLink = reinterpret_cast<uint64_t>(link->UniqueID());
747 *aOk = true;
748 }
749 }
750
751 return IPC_OK();
752 }
753
RecvLinkIndexOf(const uint64_t & aID,const uint64_t & aLinkID,int32_t * aIndex)754 mozilla::ipc::IPCResult DocAccessibleChild::RecvLinkIndexOf(
755 const uint64_t& aID, const uint64_t& aLinkID, int32_t* aIndex) {
756 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
757 Accessible* link = IdToAccessible(aLinkID);
758 *aIndex = -1;
759 if (acc && link) {
760 *aIndex = acc->LinkIndexOf(link);
761 }
762
763 return IPC_OK();
764 }
765
RecvLinkIndexAtOffset(const uint64_t & aID,const uint32_t & aOffset,int32_t * aIndex)766 mozilla::ipc::IPCResult DocAccessibleChild::RecvLinkIndexAtOffset(
767 const uint64_t& aID, const uint32_t& aOffset, int32_t* aIndex) {
768 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
769 *aIndex = acc ? acc->LinkIndexAtOffset(aOffset) : -1;
770 return IPC_OK();
771 }
772
RecvTableOfACell(const uint64_t & aID,uint64_t * aTableID,bool * aOk)773 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableOfACell(
774 const uint64_t& aID, uint64_t* aTableID, bool* aOk) {
775 *aTableID = 0;
776 *aOk = false;
777 TableCellAccessible* acc = IdToTableCellAccessible(aID);
778 if (acc) {
779 TableAccessible* table = acc->Table();
780 if (table) {
781 *aTableID = reinterpret_cast<uint64_t>(table->AsAccessible()->UniqueID());
782 *aOk = true;
783 }
784 }
785
786 return IPC_OK();
787 }
788
RecvColIdx(const uint64_t & aID,uint32_t * aIndex)789 mozilla::ipc::IPCResult DocAccessibleChild::RecvColIdx(const uint64_t& aID,
790 uint32_t* aIndex) {
791 *aIndex = 0;
792 TableCellAccessible* acc = IdToTableCellAccessible(aID);
793 if (acc) {
794 *aIndex = acc->ColIdx();
795 }
796
797 return IPC_OK();
798 }
799
RecvRowIdx(const uint64_t & aID,uint32_t * aIndex)800 mozilla::ipc::IPCResult DocAccessibleChild::RecvRowIdx(const uint64_t& aID,
801 uint32_t* aIndex) {
802 *aIndex = 0;
803 TableCellAccessible* acc = IdToTableCellAccessible(aID);
804 if (acc) {
805 *aIndex = acc->RowIdx();
806 }
807
808 return IPC_OK();
809 }
810
RecvGetPosition(const uint64_t & aID,uint32_t * aColIdx,uint32_t * aRowIdx)811 mozilla::ipc::IPCResult DocAccessibleChild::RecvGetPosition(const uint64_t& aID,
812 uint32_t* aColIdx,
813 uint32_t* aRowIdx) {
814 *aColIdx = 0;
815 *aRowIdx = 0;
816 TableCellAccessible* acc = IdToTableCellAccessible(aID);
817 if (acc) {
818 *aColIdx = acc->ColIdx();
819 *aRowIdx = acc->RowIdx();
820 }
821
822 return IPC_OK();
823 }
824
RecvGetColRowExtents(const uint64_t & aID,uint32_t * aColIdx,uint32_t * aRowIdx,uint32_t * aColExtent,uint32_t * aRowExtent)825 mozilla::ipc::IPCResult DocAccessibleChild::RecvGetColRowExtents(
826 const uint64_t& aID, uint32_t* aColIdx, uint32_t* aRowIdx,
827 uint32_t* aColExtent, uint32_t* aRowExtent) {
828 *aColIdx = 0;
829 *aRowIdx = 0;
830 *aColExtent = 0;
831 *aRowExtent = 0;
832 TableCellAccessible* acc = IdToTableCellAccessible(aID);
833 if (acc) {
834 *aColIdx = acc->ColIdx();
835 *aRowIdx = acc->RowIdx();
836 *aColExtent = acc->ColExtent();
837 *aRowExtent = acc->RowExtent();
838 }
839
840 return IPC_OK();
841 }
842
RecvColExtent(const uint64_t & aID,uint32_t * aExtent)843 mozilla::ipc::IPCResult DocAccessibleChild::RecvColExtent(const uint64_t& aID,
844 uint32_t* aExtent) {
845 *aExtent = 0;
846 TableCellAccessible* acc = IdToTableCellAccessible(aID);
847 if (acc) {
848 *aExtent = acc->ColExtent();
849 }
850
851 return IPC_OK();
852 }
853
RecvRowExtent(const uint64_t & aID,uint32_t * aExtent)854 mozilla::ipc::IPCResult DocAccessibleChild::RecvRowExtent(const uint64_t& aID,
855 uint32_t* aExtent) {
856 *aExtent = 0;
857 TableCellAccessible* acc = IdToTableCellAccessible(aID);
858 if (acc) {
859 *aExtent = acc->RowExtent();
860 }
861
862 return IPC_OK();
863 }
864
RecvColHeaderCells(const uint64_t & aID,nsTArray<uint64_t> * aCells)865 mozilla::ipc::IPCResult DocAccessibleChild::RecvColHeaderCells(
866 const uint64_t& aID, nsTArray<uint64_t>* aCells) {
867 TableCellAccessible* acc = IdToTableCellAccessible(aID);
868 if (acc) {
869 AutoTArray<Accessible*, 10> headerCells;
870 acc->ColHeaderCells(&headerCells);
871 aCells->SetCapacity(headerCells.Length());
872 for (uint32_t i = 0; i < headerCells.Length(); ++i) {
873 aCells->AppendElement(
874 reinterpret_cast<uint64_t>(headerCells[i]->UniqueID()));
875 }
876 }
877
878 return IPC_OK();
879 }
880
RecvRowHeaderCells(const uint64_t & aID,nsTArray<uint64_t> * aCells)881 mozilla::ipc::IPCResult DocAccessibleChild::RecvRowHeaderCells(
882 const uint64_t& aID, nsTArray<uint64_t>* aCells) {
883 TableCellAccessible* acc = IdToTableCellAccessible(aID);
884 if (acc) {
885 AutoTArray<Accessible*, 10> headerCells;
886 acc->RowHeaderCells(&headerCells);
887 aCells->SetCapacity(headerCells.Length());
888 for (uint32_t i = 0; i < headerCells.Length(); ++i) {
889 aCells->AppendElement(
890 reinterpret_cast<uint64_t>(headerCells[i]->UniqueID()));
891 }
892 }
893
894 return IPC_OK();
895 }
896
RecvIsCellSelected(const uint64_t & aID,bool * aSelected)897 mozilla::ipc::IPCResult DocAccessibleChild::RecvIsCellSelected(
898 const uint64_t& aID, bool* aSelected) {
899 TableCellAccessible* acc = IdToTableCellAccessible(aID);
900 *aSelected = acc && acc->Selected();
901 return IPC_OK();
902 }
903
RecvTableCaption(const uint64_t & aID,uint64_t * aCaptionID,bool * aOk)904 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableCaption(
905 const uint64_t& aID, uint64_t* aCaptionID, bool* aOk) {
906 *aCaptionID = 0;
907 *aOk = false;
908 TableAccessible* acc = IdToTableAccessible(aID);
909 if (acc) {
910 Accessible* caption = acc->Caption();
911 if (caption) {
912 *aCaptionID = reinterpret_cast<uint64_t>(caption->UniqueID());
913 *aOk = true;
914 }
915 }
916
917 return IPC_OK();
918 }
919
RecvTableSummary(const uint64_t & aID,nsString * aSummary)920 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableSummary(
921 const uint64_t& aID, nsString* aSummary) {
922 TableAccessible* acc = IdToTableAccessible(aID);
923 if (acc) {
924 acc->Summary(*aSummary);
925 }
926
927 return IPC_OK();
928 }
929
RecvTableColumnCount(const uint64_t & aID,uint32_t * aColCount)930 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableColumnCount(
931 const uint64_t& aID, uint32_t* aColCount) {
932 *aColCount = 0;
933 TableAccessible* acc = IdToTableAccessible(aID);
934 if (acc) {
935 *aColCount = acc->ColCount();
936 }
937
938 return IPC_OK();
939 }
940
RecvTableRowCount(const uint64_t & aID,uint32_t * aRowCount)941 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableRowCount(
942 const uint64_t& aID, uint32_t* aRowCount) {
943 *aRowCount = 0;
944 TableAccessible* acc = IdToTableAccessible(aID);
945 if (acc) {
946 *aRowCount = acc->RowCount();
947 }
948
949 return IPC_OK();
950 }
951
RecvTableCellAt(const uint64_t & aID,const uint32_t & aRow,const uint32_t & aCol,uint64_t * aCellID,bool * aOk)952 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableCellAt(
953 const uint64_t& aID, const uint32_t& aRow, const uint32_t& aCol,
954 uint64_t* aCellID, bool* aOk) {
955 *aCellID = 0;
956 *aOk = false;
957 TableAccessible* acc = IdToTableAccessible(aID);
958 if (acc) {
959 Accessible* cell = acc->CellAt(aRow, aCol);
960 if (cell) {
961 *aCellID = reinterpret_cast<uint64_t>(cell->UniqueID());
962 *aOk = true;
963 }
964 }
965
966 return IPC_OK();
967 }
968
RecvTableCellIndexAt(const uint64_t & aID,const uint32_t & aRow,const uint32_t & aCol,int32_t * aIndex)969 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableCellIndexAt(
970 const uint64_t& aID, const uint32_t& aRow, const uint32_t& aCol,
971 int32_t* aIndex) {
972 *aIndex = -1;
973 TableAccessible* acc = IdToTableAccessible(aID);
974 if (acc) {
975 *aIndex = acc->CellIndexAt(aRow, aCol);
976 }
977
978 return IPC_OK();
979 }
980
RecvTableColumnIndexAt(const uint64_t & aID,const uint32_t & aCellIndex,int32_t * aCol)981 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableColumnIndexAt(
982 const uint64_t& aID, const uint32_t& aCellIndex, int32_t* aCol) {
983 *aCol = -1;
984 TableAccessible* acc = IdToTableAccessible(aID);
985 if (acc) {
986 *aCol = acc->ColIndexAt(aCellIndex);
987 }
988
989 return IPC_OK();
990 }
991
RecvTableRowIndexAt(const uint64_t & aID,const uint32_t & aCellIndex,int32_t * aRow)992 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableRowIndexAt(
993 const uint64_t& aID, const uint32_t& aCellIndex, int32_t* aRow) {
994 *aRow = -1;
995 TableAccessible* acc = IdToTableAccessible(aID);
996 if (acc) {
997 *aRow = acc->RowIndexAt(aCellIndex);
998 }
999
1000 return IPC_OK();
1001 }
1002
RecvTableRowAndColumnIndicesAt(const uint64_t & aID,const uint32_t & aCellIndex,int32_t * aRow,int32_t * aCol)1003 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableRowAndColumnIndicesAt(
1004 const uint64_t& aID, const uint32_t& aCellIndex, int32_t* aRow,
1005 int32_t* aCol) {
1006 *aRow = -1;
1007 *aCol = -1;
1008 TableAccessible* acc = IdToTableAccessible(aID);
1009 if (acc) {
1010 acc->RowAndColIndicesAt(aCellIndex, aRow, aCol);
1011 }
1012
1013 return IPC_OK();
1014 }
1015
RecvTableColumnExtentAt(const uint64_t & aID,const uint32_t & aRow,const uint32_t & aCol,uint32_t * aExtent)1016 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableColumnExtentAt(
1017 const uint64_t& aID, const uint32_t& aRow, const uint32_t& aCol,
1018 uint32_t* aExtent) {
1019 *aExtent = 0;
1020 TableAccessible* acc = IdToTableAccessible(aID);
1021 if (acc) {
1022 *aExtent = acc->ColExtentAt(aRow, aCol);
1023 }
1024
1025 return IPC_OK();
1026 }
1027
RecvTableRowExtentAt(const uint64_t & aID,const uint32_t & aRow,const uint32_t & aCol,uint32_t * aExtent)1028 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableRowExtentAt(
1029 const uint64_t& aID, const uint32_t& aRow, const uint32_t& aCol,
1030 uint32_t* aExtent) {
1031 *aExtent = 0;
1032 TableAccessible* acc = IdToTableAccessible(aID);
1033 if (acc) {
1034 *aExtent = acc->RowExtentAt(aRow, aCol);
1035 }
1036
1037 return IPC_OK();
1038 }
1039
RecvTableColumnDescription(const uint64_t & aID,const uint32_t & aCol,nsString * aDescription)1040 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableColumnDescription(
1041 const uint64_t& aID, const uint32_t& aCol, nsString* aDescription) {
1042 TableAccessible* acc = IdToTableAccessible(aID);
1043 if (acc) {
1044 acc->ColDescription(aCol, *aDescription);
1045 }
1046
1047 return IPC_OK();
1048 }
1049
RecvTableRowDescription(const uint64_t & aID,const uint32_t & aRow,nsString * aDescription)1050 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableRowDescription(
1051 const uint64_t& aID, const uint32_t& aRow, nsString* aDescription) {
1052 TableAccessible* acc = IdToTableAccessible(aID);
1053 if (acc) {
1054 acc->RowDescription(aRow, *aDescription);
1055 }
1056
1057 return IPC_OK();
1058 }
1059
RecvTableColumnSelected(const uint64_t & aID,const uint32_t & aCol,bool * aSelected)1060 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableColumnSelected(
1061 const uint64_t& aID, const uint32_t& aCol, bool* aSelected) {
1062 *aSelected = false;
1063 TableAccessible* acc = IdToTableAccessible(aID);
1064 if (acc) {
1065 *aSelected = acc->IsColSelected(aCol);
1066 }
1067
1068 return IPC_OK();
1069 }
1070
RecvTableRowSelected(const uint64_t & aID,const uint32_t & aRow,bool * aSelected)1071 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableRowSelected(
1072 const uint64_t& aID, const uint32_t& aRow, bool* aSelected) {
1073 *aSelected = false;
1074 TableAccessible* acc = IdToTableAccessible(aID);
1075 if (acc) {
1076 *aSelected = acc->IsRowSelected(aRow);
1077 }
1078
1079 return IPC_OK();
1080 }
1081
RecvTableCellSelected(const uint64_t & aID,const uint32_t & aRow,const uint32_t & aCol,bool * aSelected)1082 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableCellSelected(
1083 const uint64_t& aID, const uint32_t& aRow, const uint32_t& aCol,
1084 bool* aSelected) {
1085 *aSelected = false;
1086 TableAccessible* acc = IdToTableAccessible(aID);
1087 if (acc) {
1088 *aSelected = acc->IsCellSelected(aRow, aCol);
1089 }
1090
1091 return IPC_OK();
1092 }
1093
RecvTableSelectedCellCount(const uint64_t & aID,uint32_t * aSelectedCells)1094 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableSelectedCellCount(
1095 const uint64_t& aID, uint32_t* aSelectedCells) {
1096 *aSelectedCells = 0;
1097 TableAccessible* acc = IdToTableAccessible(aID);
1098 if (acc) {
1099 *aSelectedCells = acc->SelectedCellCount();
1100 }
1101
1102 return IPC_OK();
1103 }
1104
RecvTableSelectedColumnCount(const uint64_t & aID,uint32_t * aSelectedColumns)1105 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableSelectedColumnCount(
1106 const uint64_t& aID, uint32_t* aSelectedColumns) {
1107 *aSelectedColumns = 0;
1108 TableAccessible* acc = IdToTableAccessible(aID);
1109 if (acc) {
1110 *aSelectedColumns = acc->SelectedColCount();
1111 }
1112
1113 return IPC_OK();
1114 }
1115
RecvTableSelectedRowCount(const uint64_t & aID,uint32_t * aSelectedRows)1116 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableSelectedRowCount(
1117 const uint64_t& aID, uint32_t* aSelectedRows) {
1118 *aSelectedRows = 0;
1119 TableAccessible* acc = IdToTableAccessible(aID);
1120 if (acc) {
1121 *aSelectedRows = acc->SelectedRowCount();
1122 }
1123
1124 return IPC_OK();
1125 }
1126
RecvTableSelectedCells(const uint64_t & aID,nsTArray<uint64_t> * aCellIDs)1127 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableSelectedCells(
1128 const uint64_t& aID, nsTArray<uint64_t>* aCellIDs) {
1129 TableAccessible* acc = IdToTableAccessible(aID);
1130 if (acc) {
1131 AutoTArray<Accessible*, 30> cells;
1132 acc->SelectedCells(&cells);
1133 aCellIDs->SetCapacity(cells.Length());
1134 for (uint32_t i = 0; i < cells.Length(); ++i) {
1135 aCellIDs->AppendElement(reinterpret_cast<uint64_t>(cells[i]->UniqueID()));
1136 }
1137 }
1138
1139 return IPC_OK();
1140 }
1141
RecvTableSelectedCellIndices(const uint64_t & aID,nsTArray<uint32_t> * aCellIndices)1142 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableSelectedCellIndices(
1143 const uint64_t& aID, nsTArray<uint32_t>* aCellIndices) {
1144 TableAccessible* acc = IdToTableAccessible(aID);
1145 if (acc) {
1146 acc->SelectedCellIndices(aCellIndices);
1147 }
1148
1149 return IPC_OK();
1150 }
1151
RecvTableSelectedColumnIndices(const uint64_t & aID,nsTArray<uint32_t> * aColumnIndices)1152 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableSelectedColumnIndices(
1153 const uint64_t& aID, nsTArray<uint32_t>* aColumnIndices) {
1154 TableAccessible* acc = IdToTableAccessible(aID);
1155 if (acc) {
1156 acc->SelectedColIndices(aColumnIndices);
1157 }
1158
1159 return IPC_OK();
1160 }
1161
RecvTableSelectedRowIndices(const uint64_t & aID,nsTArray<uint32_t> * aRowIndices)1162 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableSelectedRowIndices(
1163 const uint64_t& aID, nsTArray<uint32_t>* aRowIndices) {
1164 TableAccessible* acc = IdToTableAccessible(aID);
1165 if (acc) {
1166 acc->SelectedRowIndices(aRowIndices);
1167 }
1168
1169 return IPC_OK();
1170 }
1171
RecvTableSelectColumn(const uint64_t & aID,const uint32_t & aCol)1172 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableSelectColumn(
1173 const uint64_t& aID, const uint32_t& aCol) {
1174 TableAccessible* acc = IdToTableAccessible(aID);
1175 if (acc) {
1176 acc->SelectCol(aCol);
1177 }
1178
1179 return IPC_OK();
1180 }
1181
RecvTableSelectRow(const uint64_t & aID,const uint32_t & aRow)1182 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableSelectRow(
1183 const uint64_t& aID, const uint32_t& aRow) {
1184 TableAccessible* acc = IdToTableAccessible(aID);
1185 if (acc) {
1186 acc->SelectRow(aRow);
1187 }
1188
1189 return IPC_OK();
1190 }
1191
RecvTableUnselectColumn(const uint64_t & aID,const uint32_t & aCol)1192 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableUnselectColumn(
1193 const uint64_t& aID, const uint32_t& aCol) {
1194 TableAccessible* acc = IdToTableAccessible(aID);
1195 if (acc) {
1196 acc->UnselectCol(aCol);
1197 }
1198
1199 return IPC_OK();
1200 }
1201
RecvTableUnselectRow(const uint64_t & aID,const uint32_t & aRow)1202 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableUnselectRow(
1203 const uint64_t& aID, const uint32_t& aRow) {
1204 TableAccessible* acc = IdToTableAccessible(aID);
1205 if (acc) {
1206 acc->UnselectRow(aRow);
1207 }
1208
1209 return IPC_OK();
1210 }
1211
RecvTableIsProbablyForLayout(const uint64_t & aID,bool * aForLayout)1212 mozilla::ipc::IPCResult DocAccessibleChild::RecvTableIsProbablyForLayout(
1213 const uint64_t& aID, bool* aForLayout) {
1214 *aForLayout = false;
1215 TableAccessible* acc = IdToTableAccessible(aID);
1216 if (acc) {
1217 *aForLayout = acc->IsProbablyLayoutTable();
1218 }
1219
1220 return IPC_OK();
1221 }
1222
RecvAtkTableColumnHeader(const uint64_t & aID,const int32_t & aCol,uint64_t * aHeader,bool * aOk)1223 mozilla::ipc::IPCResult DocAccessibleChild::RecvAtkTableColumnHeader(
1224 const uint64_t& aID, const int32_t& aCol, uint64_t* aHeader, bool* aOk) {
1225 *aHeader = 0;
1226 *aOk = false;
1227
1228 #ifdef MOZ_ACCESSIBILITY_ATK
1229 TableAccessible* acc = IdToTableAccessible(aID);
1230 if (acc) {
1231 Accessible* header = AccessibleWrap::GetColumnHeader(acc, aCol);
1232 if (header) {
1233 *aHeader = reinterpret_cast<uint64_t>(header->UniqueID());
1234 *aOk = true;
1235 }
1236 }
1237 #endif
1238
1239 return IPC_OK();
1240 }
1241
RecvAtkTableRowHeader(const uint64_t & aID,const int32_t & aRow,uint64_t * aHeader,bool * aOk)1242 mozilla::ipc::IPCResult DocAccessibleChild::RecvAtkTableRowHeader(
1243 const uint64_t& aID, const int32_t& aRow, uint64_t* aHeader, bool* aOk) {
1244 *aHeader = 0;
1245 *aOk = false;
1246
1247 #ifdef MOZ_ACCESSIBILITY_ATK
1248 TableAccessible* acc = IdToTableAccessible(aID);
1249 if (acc) {
1250 Accessible* header = AccessibleWrap::GetRowHeader(acc, aRow);
1251 if (header) {
1252 *aHeader = reinterpret_cast<uint64_t>(header->UniqueID());
1253 *aOk = true;
1254 }
1255 }
1256 #endif
1257
1258 return IPC_OK();
1259 }
1260
RecvSelectedItems(const uint64_t & aID,nsTArray<uint64_t> * aSelectedItemIDs)1261 mozilla::ipc::IPCResult DocAccessibleChild::RecvSelectedItems(
1262 const uint64_t& aID, nsTArray<uint64_t>* aSelectedItemIDs) {
1263 Accessible* acc = IdToAccessibleSelect(aID);
1264 if (acc) {
1265 AutoTArray<Accessible*, 10> selectedItems;
1266 acc->SelectedItems(&selectedItems);
1267 aSelectedItemIDs->SetCapacity(selectedItems.Length());
1268 for (size_t i = 0; i < selectedItems.Length(); ++i) {
1269 aSelectedItemIDs->AppendElement(
1270 reinterpret_cast<uint64_t>(selectedItems[i]->UniqueID()));
1271 }
1272 }
1273
1274 return IPC_OK();
1275 }
1276
RecvSelectedItemCount(const uint64_t & aID,uint32_t * aCount)1277 mozilla::ipc::IPCResult DocAccessibleChild::RecvSelectedItemCount(
1278 const uint64_t& aID, uint32_t* aCount) {
1279 *aCount = 0;
1280 Accessible* acc = IdToAccessibleSelect(aID);
1281 if (acc) {
1282 *aCount = acc->SelectedItemCount();
1283 }
1284
1285 return IPC_OK();
1286 }
1287
RecvGetSelectedItem(const uint64_t & aID,const uint32_t & aIndex,uint64_t * aSelected,bool * aOk)1288 mozilla::ipc::IPCResult DocAccessibleChild::RecvGetSelectedItem(
1289 const uint64_t& aID, const uint32_t& aIndex, uint64_t* aSelected,
1290 bool* aOk) {
1291 *aSelected = 0;
1292 *aOk = false;
1293 Accessible* acc = IdToAccessibleSelect(aID);
1294 if (acc) {
1295 Accessible* item = acc->GetSelectedItem(aIndex);
1296 if (item) {
1297 *aSelected = reinterpret_cast<uint64_t>(item->UniqueID());
1298 *aOk = true;
1299 }
1300 }
1301
1302 return IPC_OK();
1303 }
1304
RecvIsItemSelected(const uint64_t & aID,const uint32_t & aIndex,bool * aSelected)1305 mozilla::ipc::IPCResult DocAccessibleChild::RecvIsItemSelected(
1306 const uint64_t& aID, const uint32_t& aIndex, bool* aSelected) {
1307 *aSelected = false;
1308 Accessible* acc = IdToAccessibleSelect(aID);
1309 if (acc) {
1310 *aSelected = acc->IsItemSelected(aIndex);
1311 }
1312
1313 return IPC_OK();
1314 }
1315
RecvAddItemToSelection(const uint64_t & aID,const uint32_t & aIndex,bool * aSuccess)1316 mozilla::ipc::IPCResult DocAccessibleChild::RecvAddItemToSelection(
1317 const uint64_t& aID, const uint32_t& aIndex, bool* aSuccess) {
1318 *aSuccess = false;
1319 Accessible* acc = IdToAccessibleSelect(aID);
1320 if (acc) {
1321 *aSuccess = acc->AddItemToSelection(aIndex);
1322 }
1323
1324 return IPC_OK();
1325 }
1326
RecvRemoveItemFromSelection(const uint64_t & aID,const uint32_t & aIndex,bool * aSuccess)1327 mozilla::ipc::IPCResult DocAccessibleChild::RecvRemoveItemFromSelection(
1328 const uint64_t& aID, const uint32_t& aIndex, bool* aSuccess) {
1329 *aSuccess = false;
1330 Accessible* acc = IdToAccessibleSelect(aID);
1331 if (acc) {
1332 *aSuccess = acc->RemoveItemFromSelection(aIndex);
1333 }
1334
1335 return IPC_OK();
1336 }
1337
RecvSelectAll(const uint64_t & aID,bool * aSuccess)1338 mozilla::ipc::IPCResult DocAccessibleChild::RecvSelectAll(const uint64_t& aID,
1339 bool* aSuccess) {
1340 *aSuccess = false;
1341 Accessible* acc = IdToAccessibleSelect(aID);
1342 if (acc) {
1343 *aSuccess = acc->SelectAll();
1344 }
1345
1346 return IPC_OK();
1347 }
1348
RecvUnselectAll(const uint64_t & aID,bool * aSuccess)1349 mozilla::ipc::IPCResult DocAccessibleChild::RecvUnselectAll(const uint64_t& aID,
1350 bool* aSuccess) {
1351 *aSuccess = false;
1352 Accessible* acc = IdToAccessibleSelect(aID);
1353 if (acc) {
1354 *aSuccess = acc->UnselectAll();
1355 }
1356
1357 return IPC_OK();
1358 }
1359
RecvTakeSelection(const uint64_t & aID)1360 mozilla::ipc::IPCResult DocAccessibleChild::RecvTakeSelection(
1361 const uint64_t& aID) {
1362 Accessible* acc = IdToAccessible(aID);
1363 if (acc) {
1364 acc->TakeSelection();
1365 }
1366
1367 return IPC_OK();
1368 }
1369
RecvSetSelected(const uint64_t & aID,const bool & aSelect)1370 mozilla::ipc::IPCResult DocAccessibleChild::RecvSetSelected(
1371 const uint64_t& aID, const bool& aSelect) {
1372 Accessible* acc = IdToAccessible(aID);
1373 if (acc) {
1374 acc->SetSelected(aSelect);
1375 }
1376
1377 return IPC_OK();
1378 }
1379
RecvDoAction(const uint64_t & aID,const uint8_t & aIndex,bool * aSuccess)1380 mozilla::ipc::IPCResult DocAccessibleChild::RecvDoAction(const uint64_t& aID,
1381 const uint8_t& aIndex,
1382 bool* aSuccess) {
1383 *aSuccess = false;
1384 Accessible* acc = IdToAccessible(aID);
1385 if (acc) {
1386 *aSuccess = acc->DoAction(aIndex);
1387 }
1388
1389 return IPC_OK();
1390 }
1391
RecvActionCount(const uint64_t & aID,uint8_t * aCount)1392 mozilla::ipc::IPCResult DocAccessibleChild::RecvActionCount(const uint64_t& aID,
1393 uint8_t* aCount) {
1394 *aCount = 0;
1395 Accessible* acc = IdToAccessible(aID);
1396 if (acc) {
1397 *aCount = acc->ActionCount();
1398 }
1399
1400 return IPC_OK();
1401 }
1402
RecvActionDescriptionAt(const uint64_t & aID,const uint8_t & aIndex,nsString * aDescription)1403 mozilla::ipc::IPCResult DocAccessibleChild::RecvActionDescriptionAt(
1404 const uint64_t& aID, const uint8_t& aIndex, nsString* aDescription) {
1405 Accessible* acc = IdToAccessible(aID);
1406 if (acc) {
1407 acc->ActionDescriptionAt(aIndex, *aDescription);
1408 }
1409
1410 return IPC_OK();
1411 }
1412
RecvActionNameAt(const uint64_t & aID,const uint8_t & aIndex,nsString * aName)1413 mozilla::ipc::IPCResult DocAccessibleChild::RecvActionNameAt(
1414 const uint64_t& aID, const uint8_t& aIndex, nsString* aName) {
1415 Accessible* acc = IdToAccessible(aID);
1416 if (acc) {
1417 acc->ActionNameAt(aIndex, *aName);
1418 }
1419
1420 return IPC_OK();
1421 }
1422
RecvAccessKey(const uint64_t & aID,uint32_t * aKey,uint32_t * aModifierMask)1423 mozilla::ipc::IPCResult DocAccessibleChild::RecvAccessKey(
1424 const uint64_t& aID, uint32_t* aKey, uint32_t* aModifierMask) {
1425 *aKey = 0;
1426 *aModifierMask = 0;
1427 Accessible* acc = IdToAccessible(aID);
1428 if (acc) {
1429 KeyBinding kb = acc->AccessKey();
1430 *aKey = kb.Key();
1431 *aModifierMask = kb.ModifierMask();
1432 }
1433
1434 return IPC_OK();
1435 }
1436
RecvKeyboardShortcut(const uint64_t & aID,uint32_t * aKey,uint32_t * aModifierMask)1437 mozilla::ipc::IPCResult DocAccessibleChild::RecvKeyboardShortcut(
1438 const uint64_t& aID, uint32_t* aKey, uint32_t* aModifierMask) {
1439 *aKey = 0;
1440 *aModifierMask = 0;
1441 Accessible* acc = IdToAccessible(aID);
1442 if (acc) {
1443 KeyBinding kb = acc->KeyboardShortcut();
1444 *aKey = kb.Key();
1445 *aModifierMask = kb.ModifierMask();
1446 }
1447
1448 return IPC_OK();
1449 }
1450
RecvAtkKeyBinding(const uint64_t & aID,nsString * aResult)1451 mozilla::ipc::IPCResult DocAccessibleChild::RecvAtkKeyBinding(
1452 const uint64_t& aID, nsString* aResult) {
1453 #ifdef MOZ_ACCESSIBILITY_ATK
1454 Accessible* acc = IdToAccessible(aID);
1455 if (acc) {
1456 AccessibleWrap::GetKeyBinding(acc, *aResult);
1457 }
1458 #endif
1459 return IPC_OK();
1460 }
1461
RecvCurValue(const uint64_t & aID,double * aValue)1462 mozilla::ipc::IPCResult DocAccessibleChild::RecvCurValue(const uint64_t& aID,
1463 double* aValue) {
1464 *aValue = UnspecifiedNaN<double>();
1465 Accessible* acc = IdToAccessible(aID);
1466 if (acc) {
1467 *aValue = acc->CurValue();
1468 }
1469
1470 return IPC_OK();
1471 }
1472
RecvSetCurValue(const uint64_t & aID,const double & aValue,bool * aRetVal)1473 mozilla::ipc::IPCResult DocAccessibleChild::RecvSetCurValue(
1474 const uint64_t& aID, const double& aValue, bool* aRetVal) {
1475 *aRetVal = false;
1476 Accessible* acc = IdToAccessible(aID);
1477 if (acc) {
1478 *aRetVal = acc->SetCurValue(aValue);
1479 }
1480
1481 return IPC_OK();
1482 }
1483
RecvMinValue(const uint64_t & aID,double * aValue)1484 mozilla::ipc::IPCResult DocAccessibleChild::RecvMinValue(const uint64_t& aID,
1485 double* aValue) {
1486 *aValue = UnspecifiedNaN<double>();
1487 Accessible* acc = IdToAccessible(aID);
1488 if (acc) {
1489 *aValue = acc->MinValue();
1490 }
1491
1492 return IPC_OK();
1493 }
1494
RecvMaxValue(const uint64_t & aID,double * aValue)1495 mozilla::ipc::IPCResult DocAccessibleChild::RecvMaxValue(const uint64_t& aID,
1496 double* aValue) {
1497 *aValue = UnspecifiedNaN<double>();
1498 Accessible* acc = IdToAccessible(aID);
1499 if (acc) {
1500 *aValue = acc->MaxValue();
1501 }
1502
1503 return IPC_OK();
1504 }
1505
RecvStep(const uint64_t & aID,double * aStep)1506 mozilla::ipc::IPCResult DocAccessibleChild::RecvStep(const uint64_t& aID,
1507 double* aStep) {
1508 *aStep = UnspecifiedNaN<double>();
1509 Accessible* acc = IdToAccessible(aID);
1510 if (acc) {
1511 *aStep = acc->Step();
1512 }
1513
1514 return IPC_OK();
1515 }
1516
RecvTakeFocus(const uint64_t & aID)1517 mozilla::ipc::IPCResult DocAccessibleChild::RecvTakeFocus(const uint64_t& aID) {
1518 Accessible* acc = IdToAccessible(aID);
1519 if (acc) {
1520 acc->TakeFocus();
1521 }
1522
1523 return IPC_OK();
1524 }
1525
RecvFocusedChild(const uint64_t & aID,uint64_t * aChild,bool * aOk)1526 mozilla::ipc::IPCResult DocAccessibleChild::RecvFocusedChild(
1527 const uint64_t& aID, uint64_t* aChild, bool* aOk) {
1528 *aChild = 0;
1529 *aOk = false;
1530 Accessible* acc = IdToAccessible(aID);
1531 if (acc) {
1532 Accessible* child = acc->FocusedChild();
1533 if (child) {
1534 *aChild = reinterpret_cast<uint64_t>(child->UniqueID());
1535 *aOk = true;
1536 }
1537 }
1538 return IPC_OK();
1539 }
1540
RecvLanguage(const uint64_t & aID,nsString * aLocale)1541 mozilla::ipc::IPCResult DocAccessibleChild::RecvLanguage(const uint64_t& aID,
1542 nsString* aLocale) {
1543 Accessible* acc = IdToAccessible(aID);
1544 if (acc) {
1545 acc->Language(*aLocale);
1546 }
1547
1548 return IPC_OK();
1549 }
1550
RecvDocType(const uint64_t & aID,nsString * aType)1551 mozilla::ipc::IPCResult DocAccessibleChild::RecvDocType(const uint64_t& aID,
1552 nsString* aType) {
1553 Accessible* acc = IdToAccessible(aID);
1554 if (acc && acc->IsDoc()) {
1555 acc->AsDoc()->DocType(*aType);
1556 }
1557
1558 return IPC_OK();
1559 }
1560
RecvTitle(const uint64_t & aID,nsString * aTitle)1561 mozilla::ipc::IPCResult DocAccessibleChild::RecvTitle(const uint64_t& aID,
1562 nsString* aTitle) {
1563 Accessible* acc = IdToAccessible(aID);
1564 if (acc) {
1565 mozilla::ErrorResult rv;
1566 acc->GetContent()->GetTextContent(*aTitle, rv);
1567 }
1568
1569 return IPC_OK();
1570 }
1571
RecvURL(const uint64_t & aID,nsString * aURL)1572 mozilla::ipc::IPCResult DocAccessibleChild::RecvURL(const uint64_t& aID,
1573 nsString* aURL) {
1574 Accessible* acc = IdToAccessible(aID);
1575 if (acc && acc->IsDoc()) {
1576 acc->AsDoc()->URL(*aURL);
1577 }
1578
1579 return IPC_OK();
1580 }
1581
RecvMimeType(const uint64_t & aID,nsString * aMime)1582 mozilla::ipc::IPCResult DocAccessibleChild::RecvMimeType(const uint64_t& aID,
1583 nsString* aMime) {
1584 Accessible* acc = IdToAccessible(aID);
1585 if (acc && acc->IsDoc()) {
1586 acc->AsDoc()->MimeType(*aMime);
1587 }
1588
1589 return IPC_OK();
1590 }
1591
RecvURLDocTypeMimeType(const uint64_t & aID,nsString * aURL,nsString * aDocType,nsString * aMimeType)1592 mozilla::ipc::IPCResult DocAccessibleChild::RecvURLDocTypeMimeType(
1593 const uint64_t& aID, nsString* aURL, nsString* aDocType,
1594 nsString* aMimeType) {
1595 Accessible* acc = IdToAccessible(aID);
1596 if (acc && acc->IsDoc()) {
1597 DocAccessible* doc = acc->AsDoc();
1598 doc->URL(*aURL);
1599 doc->DocType(*aDocType);
1600 doc->MimeType(*aMimeType);
1601 }
1602
1603 return IPC_OK();
1604 }
1605
RecvChildAtPoint(const uint64_t & aID,const int32_t & aX,const int32_t & aY,const uint32_t & aWhich,PDocAccessibleChild ** aResultDoc,uint64_t * aResultID)1606 mozilla::ipc::IPCResult DocAccessibleChild::RecvChildAtPoint(
1607 const uint64_t& aID, const int32_t& aX, const int32_t& aY,
1608 const uint32_t& aWhich, PDocAccessibleChild** aResultDoc,
1609 uint64_t* aResultID) {
1610 *aResultDoc = nullptr;
1611 *aResultID = 0;
1612 Accessible* acc = IdToAccessible(aID);
1613 if (acc && !acc->IsDefunct()) {
1614 int32_t x = aX;
1615 int32_t y = aY;
1616 Accessible* result = acc->ChildAtPoint(
1617 x, y, static_cast<Accessible::EWhichChildAtPoint>(aWhich));
1618 if (result) {
1619 // Accessible::ChildAtPoint can return an Accessible from a descendant
1620 // document.
1621 *aResultDoc = result->Document()->IPCDoc();
1622 *aResultID =
1623 result->IsDoc() ? 0 : reinterpret_cast<uint64_t>(result->UniqueID());
1624 }
1625 }
1626
1627 return IPC_OK();
1628 }
1629
RecvExtents(const uint64_t & aID,const bool & aNeedsScreenCoords,int32_t * aX,int32_t * aY,int32_t * aWidth,int32_t * aHeight)1630 mozilla::ipc::IPCResult DocAccessibleChild::RecvExtents(
1631 const uint64_t& aID, const bool& aNeedsScreenCoords, int32_t* aX,
1632 int32_t* aY, int32_t* aWidth, int32_t* aHeight) {
1633 *aX = 0;
1634 *aY = 0;
1635 *aWidth = 0;
1636 *aHeight = 0;
1637 Accessible* acc = IdToAccessible(aID);
1638 if (acc && !acc->IsDefunct()) {
1639 nsIntRect screenRect = acc->Bounds();
1640 if (!screenRect.IsEmpty()) {
1641 if (aNeedsScreenCoords) {
1642 nsIntPoint winCoords =
1643 nsCoreUtils::GetScreenCoordsForWindow(acc->GetNode());
1644 screenRect.x -= winCoords.x;
1645 screenRect.y -= winCoords.y;
1646 }
1647
1648 *aX = screenRect.x;
1649 *aY = screenRect.y;
1650 *aWidth = screenRect.width;
1651 *aHeight = screenRect.height;
1652 }
1653 }
1654 return IPC_OK();
1655 }
1656
RecvExtentsInCSSPixels(const uint64_t & aID,int32_t * aX,int32_t * aY,int32_t * aWidth,int32_t * aHeight)1657 mozilla::ipc::IPCResult DocAccessibleChild::RecvExtentsInCSSPixels(
1658 const uint64_t& aID, int32_t* aX, int32_t* aY, int32_t* aWidth,
1659 int32_t* aHeight) {
1660 *aX = 0;
1661 *aY = 0;
1662 *aWidth = 0;
1663 *aHeight = 0;
1664 Accessible* acc = IdToAccessible(aID);
1665 if (acc && !acc->IsDefunct()) {
1666 nsIntRect screenRect = acc->BoundsInCSSPixels();
1667 if (!screenRect.IsEmpty()) {
1668 *aX = screenRect.x;
1669 *aY = screenRect.y;
1670 *aWidth = screenRect.width;
1671 *aHeight = screenRect.height;
1672 }
1673 }
1674 return IPC_OK();
1675 }
1676
RecvDOMNodeID(const uint64_t & aID,nsString * aDOMNodeID)1677 mozilla::ipc::IPCResult DocAccessibleChild::RecvDOMNodeID(
1678 const uint64_t& aID, nsString* aDOMNodeID) {
1679 Accessible* acc = IdToAccessible(aID);
1680 if (!acc) {
1681 return IPC_OK();
1682 }
1683
1684 nsIContent* content = acc->GetContent();
1685 if (!content) {
1686 return IPC_OK();
1687 }
1688
1689 nsAtom* id = content->GetID();
1690 if (id) {
1691 id->ToString(*aDOMNodeID);
1692 }
1693
1694 return IPC_OK();
1695 }
1696
RecvRestoreFocus()1697 mozilla::ipc::IPCResult DocAccessibleChild::RecvRestoreFocus() {
1698 FocusMgr()->ForceFocusEvent();
1699 return IPC_OK();
1700 }
1701
DeallocPDocAccessiblePlatformExtChild(PDocAccessiblePlatformExtChild * aActor)1702 bool DocAccessibleChild::DeallocPDocAccessiblePlatformExtChild(
1703 PDocAccessiblePlatformExtChild* aActor) {
1704 delete aActor;
1705 return true;
1706 }
1707
1708 PDocAccessiblePlatformExtChild*
AllocPDocAccessiblePlatformExtChild()1709 DocAccessibleChild::AllocPDocAccessiblePlatformExtChild() {
1710 return new DocAccessiblePlatformExtChild();
1711 }
1712
GetPlatformExtension()1713 DocAccessiblePlatformExtChild* DocAccessibleChild::GetPlatformExtension() {
1714 return static_cast<DocAccessiblePlatformExtChild*>(
1715 SingleManagedOrNull(ManagedPDocAccessiblePlatformExtChild()));
1716 }
1717
1718 } // namespace a11y
1719 } // namespace mozilla
1720