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