1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "content/browser/accessibility/browser_accessibility_win.h"
6
7 #include <UIAutomationClient.h>
8 #include <UIAutomationCoreApi.h>
9
10 #include "base/strings/string_number_conversions.h"
11 #include "base/strings/string_split.h"
12 #include "base/strings/string_util.h"
13 #include "base/strings/utf_string_conversions.h"
14 #include "base/win/enum_variant.h"
15 #include "base/win/scoped_comptr.h"
16 #include "base/win/windows_version.h"
17 #include "content/browser/accessibility/browser_accessibility_manager_win.h"
18 #include "content/browser/accessibility/browser_accessibility_state_impl.h"
19 #include "content/common/accessibility_messages.h"
20 #include "content/public/common/content_client.h"
21 #include "ui/accessibility/ax_text_utils.h"
22 #include "ui/base/win/accessibility_ids_win.h"
23 #include "ui/base/win/accessibility_misc_utils.h"
24 #include "ui/base/win/atl_module.h"
25
26 namespace content {
27
28 // These nonstandard GUIDs are taken directly from the Mozilla sources
29 // (accessible/src/msaa/nsAccessNodeWrap.cpp); some documentation is here:
30 // http://developer.mozilla.org/en/Accessibility/AT-APIs/ImplementationFeatures/MSAA
31 const GUID GUID_ISimpleDOM = {
32 0x0c539790, 0x12e4, 0x11cf,
33 0xb6, 0x61, 0x00, 0xaa, 0x00, 0x4c, 0xd6, 0xd8};
34 const GUID GUID_IAccessibleContentDocument = {
35 0xa5d8e1f3, 0x3571, 0x4d8f,
36 0x95, 0x21, 0x07, 0xed, 0x28, 0xfb, 0x07, 0x2e};
37
38 const base::char16 BrowserAccessibilityWin::kEmbeddedCharacter[] = L"\xfffc";
39
40 // static
41 LONG BrowserAccessibilityWin::next_unique_id_win_ =
42 base::win::kFirstBrowserAccessibilityManagerAccessibilityId;
43
44 //
45 // BrowserAccessibilityRelation
46 //
47 // A simple implementation of IAccessibleRelation, used to represent
48 // a relationship between two accessible nodes in the tree.
49 //
50
51 class BrowserAccessibilityRelation
52 : public CComObjectRootEx<CComMultiThreadModel>,
53 public IAccessibleRelation {
54 BEGIN_COM_MAP(BrowserAccessibilityRelation)
COM_INTERFACE_ENTRY(IAccessibleRelation)55 COM_INTERFACE_ENTRY(IAccessibleRelation)
56 END_COM_MAP()
57
58 CONTENT_EXPORT BrowserAccessibilityRelation() {}
~BrowserAccessibilityRelation()59 CONTENT_EXPORT virtual ~BrowserAccessibilityRelation() {}
60
61 CONTENT_EXPORT void Initialize(BrowserAccessibilityWin* owner,
62 const base::string16& type);
63 CONTENT_EXPORT void AddTarget(int target_id);
64
65 // IAccessibleRelation methods.
66 CONTENT_EXPORT STDMETHODIMP get_relationType(BSTR* relation_type);
67 CONTENT_EXPORT STDMETHODIMP get_nTargets(long* n_targets);
68 CONTENT_EXPORT STDMETHODIMP get_target(long target_index, IUnknown** target);
69 CONTENT_EXPORT STDMETHODIMP get_targets(long max_targets,
70 IUnknown** targets,
71 long* n_targets);
72
73 // IAccessibleRelation methods not implemented.
get_localizedRelationType(BSTR * relation_type)74 CONTENT_EXPORT STDMETHODIMP get_localizedRelationType(BSTR* relation_type) {
75 return E_NOTIMPL;
76 }
77
78 private:
79 base::string16 type_;
80 base::win::ScopedComPtr<BrowserAccessibilityWin> owner_;
81 std::vector<int> target_ids_;
82 };
83
Initialize(BrowserAccessibilityWin * owner,const base::string16 & type)84 void BrowserAccessibilityRelation::Initialize(BrowserAccessibilityWin* owner,
85 const base::string16& type) {
86 owner_ = owner;
87 type_ = type;
88 }
89
AddTarget(int target_id)90 void BrowserAccessibilityRelation::AddTarget(int target_id) {
91 target_ids_.push_back(target_id);
92 }
93
get_relationType(BSTR * relation_type)94 STDMETHODIMP BrowserAccessibilityRelation::get_relationType(
95 BSTR* relation_type) {
96 if (!relation_type)
97 return E_INVALIDARG;
98
99 if (!owner_->instance_active())
100 return E_FAIL;
101
102 *relation_type = SysAllocString(type_.c_str());
103 DCHECK(*relation_type);
104 return S_OK;
105 }
106
get_nTargets(long * n_targets)107 STDMETHODIMP BrowserAccessibilityRelation::get_nTargets(long* n_targets) {
108 if (!n_targets)
109 return E_INVALIDARG;
110
111 if (!owner_->instance_active())
112 return E_FAIL;
113
114 *n_targets = static_cast<long>(target_ids_.size());
115
116 BrowserAccessibilityManager* manager = owner_->manager();
117 for (long i = *n_targets - 1; i >= 0; --i) {
118 BrowserAccessibility* result = manager->GetFromID(target_ids_[i]);
119 if (!result || !result->instance_active()) {
120 *n_targets = 0;
121 break;
122 }
123 }
124 return S_OK;
125 }
126
get_target(long target_index,IUnknown ** target)127 STDMETHODIMP BrowserAccessibilityRelation::get_target(long target_index,
128 IUnknown** target) {
129 if (!target)
130 return E_INVALIDARG;
131
132 if (!owner_->instance_active())
133 return E_FAIL;
134
135 if (target_index < 0 ||
136 target_index >= static_cast<long>(target_ids_.size())) {
137 return E_INVALIDARG;
138 }
139
140 BrowserAccessibilityManager* manager = owner_->manager();
141 BrowserAccessibility* result =
142 manager->GetFromID(target_ids_[target_index]);
143 if (!result || !result->instance_active())
144 return E_FAIL;
145
146 *target = static_cast<IAccessible*>(
147 result->ToBrowserAccessibilityWin()->NewReference());
148 return S_OK;
149 }
150
get_targets(long max_targets,IUnknown ** targets,long * n_targets)151 STDMETHODIMP BrowserAccessibilityRelation::get_targets(long max_targets,
152 IUnknown** targets,
153 long* n_targets) {
154 if (!targets || !n_targets)
155 return E_INVALIDARG;
156
157 if (!owner_->instance_active())
158 return E_FAIL;
159
160 long count = static_cast<long>(target_ids_.size());
161 if (count > max_targets)
162 count = max_targets;
163
164 *n_targets = count;
165 if (count == 0)
166 return S_FALSE;
167
168 for (long i = 0; i < count; ++i) {
169 HRESULT result = get_target(i, &targets[i]);
170 if (result != S_OK)
171 return result;
172 }
173
174 return S_OK;
175 }
176
177 //
178 // BrowserAccessibilityWin
179 //
180
181 // static
Create()182 BrowserAccessibility* BrowserAccessibility::Create() {
183 ui::win::CreateATLModuleIfNeeded();
184 CComObject<BrowserAccessibilityWin>* instance;
185 HRESULT hr = CComObject<BrowserAccessibilityWin>::CreateInstance(&instance);
186 DCHECK(SUCCEEDED(hr));
187 return instance->NewReference();
188 }
189
ToBrowserAccessibilityWin()190 BrowserAccessibilityWin* BrowserAccessibility::ToBrowserAccessibilityWin() {
191 return static_cast<BrowserAccessibilityWin*>(this);
192 }
193
BrowserAccessibilityWin()194 BrowserAccessibilityWin::BrowserAccessibilityWin()
195 : ia_role_(0),
196 ia_state_(0),
197 ia2_role_(0),
198 ia2_state_(0),
199 first_time_(true),
200 old_ia_state_(0),
201 previous_scroll_x_(0),
202 previous_scroll_y_(0) {
203 // Start unique IDs at -1 and decrement each time, because get_accChild
204 // uses positive IDs to enumerate children, so we use negative IDs to
205 // clearly distinguish between indices and unique IDs.
206 unique_id_win_ = next_unique_id_win_;
207 if (next_unique_id_win_ ==
208 base::win::kLastBrowserAccessibilityManagerAccessibilityId) {
209 next_unique_id_win_ =
210 base::win::kFirstBrowserAccessibilityManagerAccessibilityId;
211 }
212 next_unique_id_win_--;
213 }
214
~BrowserAccessibilityWin()215 BrowserAccessibilityWin::~BrowserAccessibilityWin() {
216 for (size_t i = 0; i < relations_.size(); ++i)
217 relations_[i]->Release();
218 }
219
220 //
221 // IAccessible methods.
222 //
223 // Conventions:
224 // * Always test for instance_active() first and return E_FAIL if it's false.
225 // * Always check for invalid arguments first, even if they're unused.
226 // * Return S_FALSE if the only output is a string argument and it's empty.
227 //
228
accDoDefaultAction(VARIANT var_id)229 HRESULT BrowserAccessibilityWin::accDoDefaultAction(VARIANT var_id) {
230 if (!instance_active())
231 return E_FAIL;
232
233 BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
234 if (!target)
235 return E_INVALIDARG;
236
237 manager()->DoDefaultAction(*target);
238 return S_OK;
239 }
240
accHitTest(LONG x_left,LONG y_top,VARIANT * child)241 STDMETHODIMP BrowserAccessibilityWin::accHitTest(LONG x_left,
242 LONG y_top,
243 VARIANT* child) {
244 if (!instance_active())
245 return E_FAIL;
246
247 if (!child)
248 return E_INVALIDARG;
249
250 gfx::Point point(x_left, y_top);
251 if (!GetGlobalBoundsRect().Contains(point)) {
252 // Return S_FALSE and VT_EMPTY when the outside the object's boundaries.
253 child->vt = VT_EMPTY;
254 return S_FALSE;
255 }
256
257 BrowserAccessibility* result = BrowserAccessibilityForPoint(point);
258 if (result == this) {
259 // Point is within this object.
260 child->vt = VT_I4;
261 child->lVal = CHILDID_SELF;
262 } else {
263 child->vt = VT_DISPATCH;
264 child->pdispVal = result->ToBrowserAccessibilityWin()->NewReference();
265 }
266 return S_OK;
267 }
268
accLocation(LONG * x_left,LONG * y_top,LONG * width,LONG * height,VARIANT var_id)269 STDMETHODIMP BrowserAccessibilityWin::accLocation(LONG* x_left,
270 LONG* y_top,
271 LONG* width,
272 LONG* height,
273 VARIANT var_id) {
274 if (!instance_active())
275 return E_FAIL;
276
277 if (!x_left || !y_top || !width || !height)
278 return E_INVALIDARG;
279
280 BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
281 if (!target)
282 return E_INVALIDARG;
283
284 gfx::Rect bounds = target->GetGlobalBoundsRect();
285 *x_left = bounds.x();
286 *y_top = bounds.y();
287 *width = bounds.width();
288 *height = bounds.height();
289
290 return S_OK;
291 }
292
accNavigate(LONG nav_dir,VARIANT start,VARIANT * end)293 STDMETHODIMP BrowserAccessibilityWin::accNavigate(LONG nav_dir,
294 VARIANT start,
295 VARIANT* end) {
296 BrowserAccessibilityWin* target = GetTargetFromChildID(start);
297 if (!target)
298 return E_INVALIDARG;
299
300 if ((nav_dir == NAVDIR_LASTCHILD || nav_dir == NAVDIR_FIRSTCHILD) &&
301 start.lVal != CHILDID_SELF) {
302 // MSAA states that navigating to first/last child can only be from self.
303 return E_INVALIDARG;
304 }
305
306 uint32 child_count = target->PlatformChildCount();
307
308 BrowserAccessibility* result = NULL;
309 switch (nav_dir) {
310 case NAVDIR_DOWN:
311 case NAVDIR_UP:
312 case NAVDIR_LEFT:
313 case NAVDIR_RIGHT:
314 // These directions are not implemented, matching Mozilla and IE.
315 return E_NOTIMPL;
316 case NAVDIR_FIRSTCHILD:
317 if (child_count > 0)
318 result = target->PlatformGetChild(0);
319 break;
320 case NAVDIR_LASTCHILD:
321 if (child_count > 0)
322 result = target->PlatformGetChild(child_count - 1);
323 break;
324 case NAVDIR_NEXT:
325 result = target->GetNextSibling();
326 break;
327 case NAVDIR_PREVIOUS:
328 result = target->GetPreviousSibling();
329 break;
330 }
331
332 if (!result) {
333 end->vt = VT_EMPTY;
334 return S_FALSE;
335 }
336
337 end->vt = VT_DISPATCH;
338 end->pdispVal = result->ToBrowserAccessibilityWin()->NewReference();
339 return S_OK;
340 }
341
get_accChild(VARIANT var_child,IDispatch ** disp_child)342 STDMETHODIMP BrowserAccessibilityWin::get_accChild(VARIANT var_child,
343 IDispatch** disp_child) {
344 if (!instance_active())
345 return E_FAIL;
346
347 if (!disp_child)
348 return E_INVALIDARG;
349
350 *disp_child = NULL;
351
352 BrowserAccessibilityWin* target = GetTargetFromChildID(var_child);
353 if (!target)
354 return E_INVALIDARG;
355
356 (*disp_child) = target->NewReference();
357 return S_OK;
358 }
359
get_accChildCount(LONG * child_count)360 STDMETHODIMP BrowserAccessibilityWin::get_accChildCount(LONG* child_count) {
361 if (!instance_active())
362 return E_FAIL;
363
364 if (!child_count)
365 return E_INVALIDARG;
366
367 *child_count = PlatformChildCount();
368
369 return S_OK;
370 }
371
get_accDefaultAction(VARIANT var_id,BSTR * def_action)372 STDMETHODIMP BrowserAccessibilityWin::get_accDefaultAction(VARIANT var_id,
373 BSTR* def_action) {
374 if (!instance_active())
375 return E_FAIL;
376
377 if (!def_action)
378 return E_INVALIDARG;
379
380 BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
381 if (!target)
382 return E_INVALIDARG;
383
384 return target->GetStringAttributeAsBstr(
385 ui::AX_ATTR_SHORTCUT, def_action);
386 }
387
get_accDescription(VARIANT var_id,BSTR * desc)388 STDMETHODIMP BrowserAccessibilityWin::get_accDescription(VARIANT var_id,
389 BSTR* desc) {
390 if (!instance_active())
391 return E_FAIL;
392
393 if (!desc)
394 return E_INVALIDARG;
395
396 BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
397 if (!target)
398 return E_INVALIDARG;
399
400 return target->GetStringAttributeAsBstr(
401 ui::AX_ATTR_DESCRIPTION, desc);
402 }
403
get_accFocus(VARIANT * focus_child)404 STDMETHODIMP BrowserAccessibilityWin::get_accFocus(VARIANT* focus_child) {
405 if (!instance_active())
406 return E_FAIL;
407
408 if (!focus_child)
409 return E_INVALIDARG;
410
411 BrowserAccessibilityWin* focus = static_cast<BrowserAccessibilityWin*>(
412 manager()->GetFocus(this));
413 if (focus == this) {
414 focus_child->vt = VT_I4;
415 focus_child->lVal = CHILDID_SELF;
416 } else if (focus == NULL) {
417 focus_child->vt = VT_EMPTY;
418 } else {
419 focus_child->vt = VT_DISPATCH;
420 focus_child->pdispVal = focus->NewReference();
421 }
422
423 return S_OK;
424 }
425
get_accHelp(VARIANT var_id,BSTR * help)426 STDMETHODIMP BrowserAccessibilityWin::get_accHelp(VARIANT var_id, BSTR* help) {
427 if (!instance_active())
428 return E_FAIL;
429
430 if (!help)
431 return E_INVALIDARG;
432
433 BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
434 if (!target)
435 return E_INVALIDARG;
436
437 return target->GetStringAttributeAsBstr(
438 ui::AX_ATTR_HELP, help);
439 }
440
get_accKeyboardShortcut(VARIANT var_id,BSTR * acc_key)441 STDMETHODIMP BrowserAccessibilityWin::get_accKeyboardShortcut(VARIANT var_id,
442 BSTR* acc_key) {
443 if (!instance_active())
444 return E_FAIL;
445
446 if (!acc_key)
447 return E_INVALIDARG;
448
449 BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
450 if (!target)
451 return E_INVALIDARG;
452
453 return target->GetStringAttributeAsBstr(
454 ui::AX_ATTR_SHORTCUT, acc_key);
455 }
456
get_accName(VARIANT var_id,BSTR * name)457 STDMETHODIMP BrowserAccessibilityWin::get_accName(VARIANT var_id, BSTR* name) {
458 if (!instance_active())
459 return E_FAIL;
460
461 if (!name)
462 return E_INVALIDARG;
463
464 BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
465 if (!target)
466 return E_INVALIDARG;
467
468 std::string name_str = target->name();
469
470 // If the name is empty, see if it's labeled by another element.
471 if (name_str.empty()) {
472 int title_elem_id;
473 if (target->GetIntAttribute(ui::AX_ATTR_TITLE_UI_ELEMENT,
474 &title_elem_id)) {
475 BrowserAccessibility* title_elem =
476 manager()->GetFromID(title_elem_id);
477 if (title_elem)
478 name_str = title_elem->GetTextRecursive();
479 }
480 }
481
482 if (name_str.empty())
483 return S_FALSE;
484
485 *name = SysAllocString(base::UTF8ToUTF16(name_str).c_str());
486
487 DCHECK(*name);
488 return S_OK;
489 }
490
get_accParent(IDispatch ** disp_parent)491 STDMETHODIMP BrowserAccessibilityWin::get_accParent(IDispatch** disp_parent) {
492 if (!instance_active())
493 return E_FAIL;
494
495 if (!disp_parent)
496 return E_INVALIDARG;
497
498 IAccessible* parent_obj = GetParent()->ToBrowserAccessibilityWin();
499 if (parent_obj == NULL) {
500 // This happens if we're the root of the tree;
501 // return the IAccessible for the window.
502 parent_obj =
503 manager()->ToBrowserAccessibilityManagerWin()->GetParentIAccessible();
504 // |parent| can only be NULL if the manager was created before the parent
505 // IAccessible was known and it wasn't subsequently set before a client
506 // requested it. This has been fixed. |parent| may also be NULL during
507 // destruction. Possible cases where this could occur include tabs being
508 // dragged to a new window, etc.
509 if (!parent_obj) {
510 DVLOG(1) << "In Function: "
511 << __FUNCTION__
512 << ". Parent IAccessible interface is NULL. Returning failure";
513 return E_FAIL;
514 }
515 }
516 parent_obj->AddRef();
517 *disp_parent = parent_obj;
518 return S_OK;
519 }
520
get_accRole(VARIANT var_id,VARIANT * role)521 STDMETHODIMP BrowserAccessibilityWin::get_accRole(VARIANT var_id,
522 VARIANT* role) {
523 if (!instance_active())
524 return E_FAIL;
525
526 if (!role)
527 return E_INVALIDARG;
528
529 BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
530 if (!target)
531 return E_INVALIDARG;
532
533 if (!target->role_name_.empty()) {
534 role->vt = VT_BSTR;
535 role->bstrVal = SysAllocString(target->role_name_.c_str());
536 } else {
537 role->vt = VT_I4;
538 role->lVal = target->ia_role_;
539 }
540 return S_OK;
541 }
542
get_accState(VARIANT var_id,VARIANT * state)543 STDMETHODIMP BrowserAccessibilityWin::get_accState(VARIANT var_id,
544 VARIANT* state) {
545 if (!instance_active())
546 return E_FAIL;
547
548 if (!state)
549 return E_INVALIDARG;
550
551 BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
552 if (!target)
553 return E_INVALIDARG;
554
555 state->vt = VT_I4;
556 state->lVal = target->ia_state_;
557 if (manager()->GetFocus(NULL) == this)
558 state->lVal |= STATE_SYSTEM_FOCUSED;
559
560 return S_OK;
561 }
562
get_accValue(VARIANT var_id,BSTR * value)563 STDMETHODIMP BrowserAccessibilityWin::get_accValue(VARIANT var_id,
564 BSTR* value) {
565 if (!instance_active())
566 return E_FAIL;
567
568 if (!value)
569 return E_INVALIDARG;
570
571 BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
572 if (!target)
573 return E_INVALIDARG;
574
575 if (target->ia_role() == ROLE_SYSTEM_PROGRESSBAR ||
576 target->ia_role() == ROLE_SYSTEM_SCROLLBAR ||
577 target->ia_role() == ROLE_SYSTEM_SLIDER) {
578 base::string16 value_text = target->GetValueText();
579 *value = SysAllocString(value_text.c_str());
580 DCHECK(*value);
581 return S_OK;
582 }
583
584 // Expose color well value.
585 if (target->ia2_role() == IA2_ROLE_COLOR_CHOOSER) {
586 int r = target->GetIntAttribute(
587 ui::AX_ATTR_COLOR_VALUE_RED);
588 int g = target->GetIntAttribute(
589 ui::AX_ATTR_COLOR_VALUE_GREEN);
590 int b = target->GetIntAttribute(
591 ui::AX_ATTR_COLOR_VALUE_BLUE);
592 base::string16 value_text;
593 value_text = base::IntToString16((r * 100) / 255) + L"% red " +
594 base::IntToString16((g * 100) / 255) + L"% green " +
595 base::IntToString16((b * 100) / 255) + L"% blue";
596 *value = SysAllocString(value_text.c_str());
597 DCHECK(*value);
598 return S_OK;
599 }
600
601 *value = SysAllocString(base::UTF8ToUTF16(target->value()).c_str());
602 DCHECK(*value);
603 return S_OK;
604 }
605
get_accHelpTopic(BSTR * help_file,VARIANT var_id,LONG * topic_id)606 STDMETHODIMP BrowserAccessibilityWin::get_accHelpTopic(BSTR* help_file,
607 VARIANT var_id,
608 LONG* topic_id) {
609 return E_NOTIMPL;
610 }
611
get_accSelection(VARIANT * selected)612 STDMETHODIMP BrowserAccessibilityWin::get_accSelection(VARIANT* selected) {
613 if (!instance_active())
614 return E_FAIL;
615
616 if (GetRole() != ui::AX_ROLE_LIST_BOX)
617 return E_NOTIMPL;
618
619 unsigned long selected_count = 0;
620 for (size_t i = 0; i < InternalChildCount(); ++i) {
621 if (InternalGetChild(i)->HasState(ui::AX_STATE_SELECTED))
622 ++selected_count;
623 }
624
625 if (selected_count == 0) {
626 selected->vt = VT_EMPTY;
627 return S_OK;
628 }
629
630 if (selected_count == 1) {
631 for (size_t i = 0; i < InternalChildCount(); ++i) {
632 if (InternalGetChild(i)->HasState(ui::AX_STATE_SELECTED)) {
633 selected->vt = VT_DISPATCH;
634 selected->pdispVal =
635 InternalGetChild(i)->ToBrowserAccessibilityWin()->NewReference();
636 return S_OK;
637 }
638 }
639 }
640
641 // Multiple items are selected.
642 base::win::EnumVariant* enum_variant =
643 new base::win::EnumVariant(selected_count);
644 enum_variant->AddRef();
645 unsigned long index = 0;
646 for (size_t i = 0; i < InternalChildCount(); ++i) {
647 if (InternalGetChild(i)->HasState(ui::AX_STATE_SELECTED)) {
648 enum_variant->ItemAt(index)->vt = VT_DISPATCH;
649 enum_variant->ItemAt(index)->pdispVal =
650 InternalGetChild(i)->ToBrowserAccessibilityWin()->NewReference();
651 ++index;
652 }
653 }
654 selected->vt = VT_UNKNOWN;
655 selected->punkVal = static_cast<IUnknown*>(
656 static_cast<base::win::IUnknownImpl*>(enum_variant));
657 return S_OK;
658 }
659
accSelect(LONG flags_sel,VARIANT var_id)660 STDMETHODIMP BrowserAccessibilityWin::accSelect(
661 LONG flags_sel, VARIANT var_id) {
662 if (!instance_active())
663 return E_FAIL;
664
665 if (flags_sel & SELFLAG_TAKEFOCUS) {
666 manager()->SetFocus(this, true);
667 return S_OK;
668 }
669
670 return S_FALSE;
671 }
672
673 //
674 // IAccessible2 methods.
675 //
676
role(LONG * role)677 STDMETHODIMP BrowserAccessibilityWin::role(LONG* role) {
678 if (!instance_active())
679 return E_FAIL;
680
681 if (!role)
682 return E_INVALIDARG;
683
684 *role = ia2_role_;
685
686 return S_OK;
687 }
688
get_attributes(BSTR * attributes)689 STDMETHODIMP BrowserAccessibilityWin::get_attributes(BSTR* attributes) {
690 if (!instance_active())
691 return E_FAIL;
692
693 if (!attributes)
694 return E_INVALIDARG;
695
696 // The iaccessible2 attributes are a set of key-value pairs
697 // separated by semicolons, with a colon between the key and the value.
698 base::string16 str;
699 for (unsigned int i = 0; i < ia2_attributes_.size(); ++i) {
700 if (i != 0)
701 str += L';';
702 str += ia2_attributes_[i];
703 }
704
705 if (str.empty())
706 return S_FALSE;
707
708 *attributes = SysAllocString(str.c_str());
709 DCHECK(*attributes);
710 return S_OK;
711 }
712
get_states(AccessibleStates * states)713 STDMETHODIMP BrowserAccessibilityWin::get_states(AccessibleStates* states) {
714 if (!instance_active())
715 return E_FAIL;
716
717 if (!states)
718 return E_INVALIDARG;
719
720 *states = ia2_state_;
721
722 return S_OK;
723 }
724
get_uniqueID(LONG * unique_id)725 STDMETHODIMP BrowserAccessibilityWin::get_uniqueID(LONG* unique_id) {
726 if (!instance_active())
727 return E_FAIL;
728
729 if (!unique_id)
730 return E_INVALIDARG;
731
732 *unique_id = unique_id_win_;
733 return S_OK;
734 }
735
get_windowHandle(HWND * window_handle)736 STDMETHODIMP BrowserAccessibilityWin::get_windowHandle(HWND* window_handle) {
737 if (!instance_active())
738 return E_FAIL;
739
740 if (!window_handle)
741 return E_INVALIDARG;
742
743 *window_handle =
744 manager()->ToBrowserAccessibilityManagerWin()->GetParentHWND();
745 if (!*window_handle)
746 return E_FAIL;
747
748 return S_OK;
749 }
750
get_indexInParent(LONG * index_in_parent)751 STDMETHODIMP BrowserAccessibilityWin::get_indexInParent(LONG* index_in_parent) {
752 if (!instance_active())
753 return E_FAIL;
754
755 if (!index_in_parent)
756 return E_INVALIDARG;
757
758 *index_in_parent = this->GetIndexInParent();
759 return S_OK;
760 }
761
get_nRelations(LONG * n_relations)762 STDMETHODIMP BrowserAccessibilityWin::get_nRelations(LONG* n_relations) {
763 if (!instance_active())
764 return E_FAIL;
765
766 if (!n_relations)
767 return E_INVALIDARG;
768
769 *n_relations = relations_.size();
770 return S_OK;
771 }
772
get_relation(LONG relation_index,IAccessibleRelation ** relation)773 STDMETHODIMP BrowserAccessibilityWin::get_relation(
774 LONG relation_index,
775 IAccessibleRelation** relation) {
776 if (!instance_active())
777 return E_FAIL;
778
779 if (relation_index < 0 ||
780 relation_index >= static_cast<long>(relations_.size())) {
781 return E_INVALIDARG;
782 }
783
784 if (!relation)
785 return E_INVALIDARG;
786
787 relations_[relation_index]->AddRef();
788 *relation = relations_[relation_index];
789 return S_OK;
790 }
791
get_relations(LONG max_relations,IAccessibleRelation ** relations,LONG * n_relations)792 STDMETHODIMP BrowserAccessibilityWin::get_relations(
793 LONG max_relations,
794 IAccessibleRelation** relations,
795 LONG* n_relations) {
796 if (!instance_active())
797 return E_FAIL;
798
799 if (!relations || !n_relations)
800 return E_INVALIDARG;
801
802 long count = static_cast<long>(relations_.size());
803 *n_relations = count;
804 if (count == 0)
805 return S_FALSE;
806
807 for (long i = 0; i < count; ++i) {
808 relations_[i]->AddRef();
809 relations[i] = relations_[i];
810 }
811
812 return S_OK;
813 }
814
scrollTo(enum IA2ScrollType scroll_type)815 STDMETHODIMP BrowserAccessibilityWin::scrollTo(enum IA2ScrollType scroll_type) {
816 if (!instance_active())
817 return E_FAIL;
818
819 gfx::Rect r = GetLocation();
820 switch(scroll_type) {
821 case IA2_SCROLL_TYPE_TOP_LEFT:
822 manager()->ScrollToMakeVisible(*this, gfx::Rect(r.x(), r.y(), 0, 0));
823 break;
824 case IA2_SCROLL_TYPE_BOTTOM_RIGHT:
825 manager()->ScrollToMakeVisible(
826 *this, gfx::Rect(r.right(), r.bottom(), 0, 0));
827 break;
828 case IA2_SCROLL_TYPE_TOP_EDGE:
829 manager()->ScrollToMakeVisible(
830 *this, gfx::Rect(r.x(), r.y(), r.width(), 0));
831 break;
832 case IA2_SCROLL_TYPE_BOTTOM_EDGE:
833 manager()->ScrollToMakeVisible(
834 *this, gfx::Rect(r.x(), r.bottom(), r.width(), 0));
835 break;
836 case IA2_SCROLL_TYPE_LEFT_EDGE:
837 manager()->ScrollToMakeVisible(
838 *this, gfx::Rect(r.x(), r.y(), 0, r.height()));
839 break;
840 case IA2_SCROLL_TYPE_RIGHT_EDGE:
841 manager()->ScrollToMakeVisible(
842 *this, gfx::Rect(r.right(), r.y(), 0, r.height()));
843 break;
844 case IA2_SCROLL_TYPE_ANYWHERE:
845 default:
846 manager()->ScrollToMakeVisible(*this, r);
847 break;
848 }
849
850 manager()->ToBrowserAccessibilityManagerWin()->TrackScrollingObject(this);
851
852 return S_OK;
853 }
854
scrollToPoint(enum IA2CoordinateType coordinate_type,LONG x,LONG y)855 STDMETHODIMP BrowserAccessibilityWin::scrollToPoint(
856 enum IA2CoordinateType coordinate_type,
857 LONG x,
858 LONG y) {
859 if (!instance_active())
860 return E_FAIL;
861
862 gfx::Point scroll_to(x, y);
863
864 if (coordinate_type == IA2_COORDTYPE_SCREEN_RELATIVE) {
865 scroll_to -= manager()->GetViewBounds().OffsetFromOrigin();
866 } else if (coordinate_type == IA2_COORDTYPE_PARENT_RELATIVE) {
867 if (GetParent())
868 scroll_to += GetParent()->GetLocation().OffsetFromOrigin();
869 } else {
870 return E_INVALIDARG;
871 }
872
873 manager()->ScrollToPoint(*this, scroll_to);
874 manager()->ToBrowserAccessibilityManagerWin()->TrackScrollingObject(this);
875
876 return S_OK;
877 }
878
get_groupPosition(LONG * group_level,LONG * similar_items_in_group,LONG * position_in_group)879 STDMETHODIMP BrowserAccessibilityWin::get_groupPosition(
880 LONG* group_level,
881 LONG* similar_items_in_group,
882 LONG* position_in_group) {
883 if (!instance_active())
884 return E_FAIL;
885
886 if (!group_level || !similar_items_in_group || !position_in_group)
887 return E_INVALIDARG;
888
889 if (GetRole() == ui::AX_ROLE_LIST_BOX_OPTION &&
890 GetParent() &&
891 GetParent()->GetRole() == ui::AX_ROLE_LIST_BOX) {
892 *group_level = 0;
893 *similar_items_in_group = GetParent()->PlatformChildCount();
894 *position_in_group = GetIndexInParent() + 1;
895 return S_OK;
896 }
897
898 return E_NOTIMPL;
899 }
900
901 //
902 // IAccessibleApplication methods.
903 //
904
get_appName(BSTR * app_name)905 STDMETHODIMP BrowserAccessibilityWin::get_appName(BSTR* app_name) {
906 // No need to check |instance_active()| because this interface is
907 // global, and doesn't depend on any local state.
908
909 if (!app_name)
910 return E_INVALIDARG;
911
912 // GetProduct() returns a string like "Chrome/aa.bb.cc.dd", split out
913 // the part before the "/".
914 std::vector<std::string> product_components;
915 base::SplitString(GetContentClient()->GetProduct(), '/', &product_components);
916 DCHECK_EQ(2U, product_components.size());
917 if (product_components.size() != 2)
918 return E_FAIL;
919 *app_name = SysAllocString(base::UTF8ToUTF16(product_components[0]).c_str());
920 DCHECK(*app_name);
921 return *app_name ? S_OK : E_FAIL;
922 }
923
get_appVersion(BSTR * app_version)924 STDMETHODIMP BrowserAccessibilityWin::get_appVersion(BSTR* app_version) {
925 // No need to check |instance_active()| because this interface is
926 // global, and doesn't depend on any local state.
927
928 if (!app_version)
929 return E_INVALIDARG;
930
931 // GetProduct() returns a string like "Chrome/aa.bb.cc.dd", split out
932 // the part after the "/".
933 std::vector<std::string> product_components;
934 base::SplitString(GetContentClient()->GetProduct(), '/', &product_components);
935 DCHECK_EQ(2U, product_components.size());
936 if (product_components.size() != 2)
937 return E_FAIL;
938 *app_version =
939 SysAllocString(base::UTF8ToUTF16(product_components[1]).c_str());
940 DCHECK(*app_version);
941 return *app_version ? S_OK : E_FAIL;
942 }
943
get_toolkitName(BSTR * toolkit_name)944 STDMETHODIMP BrowserAccessibilityWin::get_toolkitName(BSTR* toolkit_name) {
945 // No need to check |instance_active()| because this interface is
946 // global, and doesn't depend on any local state.
947
948 if (!toolkit_name)
949 return E_INVALIDARG;
950
951 // This is hard-coded; all products based on the Chromium engine
952 // will have the same toolkit name, so that assistive technology can
953 // detect any Chrome-based product.
954 *toolkit_name = SysAllocString(L"Chrome");
955 DCHECK(*toolkit_name);
956 return *toolkit_name ? S_OK : E_FAIL;
957 }
958
get_toolkitVersion(BSTR * toolkit_version)959 STDMETHODIMP BrowserAccessibilityWin::get_toolkitVersion(
960 BSTR* toolkit_version) {
961 // No need to check |instance_active()| because this interface is
962 // global, and doesn't depend on any local state.
963
964 if (!toolkit_version)
965 return E_INVALIDARG;
966
967 std::string user_agent = GetContentClient()->GetUserAgent();
968 *toolkit_version = SysAllocString(base::UTF8ToUTF16(user_agent).c_str());
969 DCHECK(*toolkit_version);
970 return *toolkit_version ? S_OK : E_FAIL;
971 }
972
973 //
974 // IAccessibleImage methods.
975 //
976
get_description(BSTR * desc)977 STDMETHODIMP BrowserAccessibilityWin::get_description(BSTR* desc) {
978 if (!instance_active())
979 return E_FAIL;
980
981 if (!desc)
982 return E_INVALIDARG;
983
984 return GetStringAttributeAsBstr(
985 ui::AX_ATTR_DESCRIPTION, desc);
986 }
987
get_imagePosition(enum IA2CoordinateType coordinate_type,LONG * x,LONG * y)988 STDMETHODIMP BrowserAccessibilityWin::get_imagePosition(
989 enum IA2CoordinateType coordinate_type,
990 LONG* x,
991 LONG* y) {
992 if (!instance_active())
993 return E_FAIL;
994
995 if (!x || !y)
996 return E_INVALIDARG;
997
998 if (coordinate_type == IA2_COORDTYPE_SCREEN_RELATIVE) {
999 HWND parent_hwnd =
1000 manager()->ToBrowserAccessibilityManagerWin()->GetParentHWND();
1001 if (!parent_hwnd)
1002 return E_FAIL;
1003 POINT top_left = {0, 0};
1004 ::ClientToScreen(parent_hwnd, &top_left);
1005 *x = GetLocation().x() + top_left.x;
1006 *y = GetLocation().y() + top_left.y;
1007 } else if (coordinate_type == IA2_COORDTYPE_PARENT_RELATIVE) {
1008 *x = GetLocation().x();
1009 *y = GetLocation().y();
1010 if (GetParent()) {
1011 *x -= GetParent()->GetLocation().x();
1012 *y -= GetParent()->GetLocation().y();
1013 }
1014 } else {
1015 return E_INVALIDARG;
1016 }
1017
1018 return S_OK;
1019 }
1020
get_imageSize(LONG * height,LONG * width)1021 STDMETHODIMP BrowserAccessibilityWin::get_imageSize(LONG* height, LONG* width) {
1022 if (!instance_active())
1023 return E_FAIL;
1024
1025 if (!height || !width)
1026 return E_INVALIDARG;
1027
1028 *height = GetLocation().height();
1029 *width = GetLocation().width();
1030 return S_OK;
1031 }
1032
1033 //
1034 // IAccessibleTable methods.
1035 //
1036
get_accessibleAt(long row,long column,IUnknown ** accessible)1037 STDMETHODIMP BrowserAccessibilityWin::get_accessibleAt(
1038 long row,
1039 long column,
1040 IUnknown** accessible) {
1041 if (!instance_active())
1042 return E_FAIL;
1043
1044 if (!accessible)
1045 return E_INVALIDARG;
1046
1047 int columns;
1048 int rows;
1049 if (!GetIntAttribute(
1050 ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
1051 !GetIntAttribute(
1052 ui::AX_ATTR_TABLE_ROW_COUNT, &rows) ||
1053 columns <= 0 ||
1054 rows <= 0) {
1055 return S_FALSE;
1056 }
1057
1058 if (row < 0 || row >= rows || column < 0 || column >= columns)
1059 return E_INVALIDARG;
1060
1061 const std::vector<int32>& cell_ids = GetIntListAttribute(
1062 ui::AX_ATTR_CELL_IDS);
1063 DCHECK_EQ(columns * rows, static_cast<int>(cell_ids.size()));
1064
1065 int cell_id = cell_ids[row * columns + column];
1066 BrowserAccessibilityWin* cell = GetFromID(cell_id);
1067 if (cell) {
1068 *accessible = static_cast<IAccessible*>(cell->NewReference());
1069 return S_OK;
1070 }
1071
1072 *accessible = NULL;
1073 return E_INVALIDARG;
1074 }
1075
get_caption(IUnknown ** accessible)1076 STDMETHODIMP BrowserAccessibilityWin::get_caption(IUnknown** accessible) {
1077 if (!instance_active())
1078 return E_FAIL;
1079
1080 if (!accessible)
1081 return E_INVALIDARG;
1082
1083 // TODO(dmazzoni): implement
1084 return S_FALSE;
1085 }
1086
get_childIndex(long row,long column,long * cell_index)1087 STDMETHODIMP BrowserAccessibilityWin::get_childIndex(long row,
1088 long column,
1089 long* cell_index) {
1090 if (!instance_active())
1091 return E_FAIL;
1092
1093 if (!cell_index)
1094 return E_INVALIDARG;
1095
1096 int columns;
1097 int rows;
1098 if (!GetIntAttribute(
1099 ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
1100 !GetIntAttribute(
1101 ui::AX_ATTR_TABLE_ROW_COUNT, &rows) ||
1102 columns <= 0 ||
1103 rows <= 0) {
1104 return S_FALSE;
1105 }
1106
1107 if (row < 0 || row >= rows || column < 0 || column >= columns)
1108 return E_INVALIDARG;
1109
1110 const std::vector<int32>& cell_ids = GetIntListAttribute(
1111 ui::AX_ATTR_CELL_IDS);
1112 const std::vector<int32>& unique_cell_ids = GetIntListAttribute(
1113 ui::AX_ATTR_UNIQUE_CELL_IDS);
1114 DCHECK_EQ(columns * rows, static_cast<int>(cell_ids.size()));
1115 int cell_id = cell_ids[row * columns + column];
1116 for (size_t i = 0; i < unique_cell_ids.size(); ++i) {
1117 if (unique_cell_ids[i] == cell_id) {
1118 *cell_index = (long)i;
1119 return S_OK;
1120 }
1121 }
1122
1123 return S_FALSE;
1124 }
1125
get_columnDescription(long column,BSTR * description)1126 STDMETHODIMP BrowserAccessibilityWin::get_columnDescription(long column,
1127 BSTR* description) {
1128 if (!instance_active())
1129 return E_FAIL;
1130
1131 if (!description)
1132 return E_INVALIDARG;
1133
1134 int columns;
1135 int rows;
1136 if (!GetIntAttribute(
1137 ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
1138 !GetIntAttribute(ui::AX_ATTR_TABLE_ROW_COUNT, &rows) ||
1139 columns <= 0 ||
1140 rows <= 0) {
1141 return S_FALSE;
1142 }
1143
1144 if (column < 0 || column >= columns)
1145 return E_INVALIDARG;
1146
1147 const std::vector<int32>& cell_ids = GetIntListAttribute(
1148 ui::AX_ATTR_CELL_IDS);
1149 for (int i = 0; i < rows; ++i) {
1150 int cell_id = cell_ids[i * columns + column];
1151 BrowserAccessibilityWin* cell = static_cast<BrowserAccessibilityWin*>(
1152 manager()->GetFromID(cell_id));
1153 if (cell && cell->GetRole() == ui::AX_ROLE_COLUMN_HEADER) {
1154 base::string16 cell_name = cell->GetString16Attribute(
1155 ui::AX_ATTR_NAME);
1156 if (cell_name.size() > 0) {
1157 *description = SysAllocString(cell_name.c_str());
1158 return S_OK;
1159 }
1160
1161 return cell->GetStringAttributeAsBstr(
1162 ui::AX_ATTR_DESCRIPTION, description);
1163 }
1164 }
1165
1166 return S_FALSE;
1167 }
1168
get_columnExtentAt(long row,long column,long * n_columns_spanned)1169 STDMETHODIMP BrowserAccessibilityWin::get_columnExtentAt(
1170 long row,
1171 long column,
1172 long* n_columns_spanned) {
1173 if (!instance_active())
1174 return E_FAIL;
1175
1176 if (!n_columns_spanned)
1177 return E_INVALIDARG;
1178
1179 int columns;
1180 int rows;
1181 if (!GetIntAttribute(
1182 ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
1183 !GetIntAttribute(ui::AX_ATTR_TABLE_ROW_COUNT, &rows) ||
1184 columns <= 0 ||
1185 rows <= 0) {
1186 return S_FALSE;
1187 }
1188
1189 if (row < 0 || row >= rows || column < 0 || column >= columns)
1190 return E_INVALIDARG;
1191
1192 const std::vector<int32>& cell_ids = GetIntListAttribute(
1193 ui::AX_ATTR_CELL_IDS);
1194 int cell_id = cell_ids[row * columns + column];
1195 BrowserAccessibilityWin* cell = static_cast<BrowserAccessibilityWin*>(
1196 manager()->GetFromID(cell_id));
1197 int colspan;
1198 if (cell &&
1199 cell->GetIntAttribute(
1200 ui::AX_ATTR_TABLE_CELL_COLUMN_SPAN, &colspan) &&
1201 colspan >= 1) {
1202 *n_columns_spanned = colspan;
1203 return S_OK;
1204 }
1205
1206 return S_FALSE;
1207 }
1208
get_columnHeader(IAccessibleTable ** accessible_table,long * starting_row_index)1209 STDMETHODIMP BrowserAccessibilityWin::get_columnHeader(
1210 IAccessibleTable** accessible_table,
1211 long* starting_row_index) {
1212 // TODO(dmazzoni): implement
1213 return E_NOTIMPL;
1214 }
1215
get_columnIndex(long cell_index,long * column_index)1216 STDMETHODIMP BrowserAccessibilityWin::get_columnIndex(long cell_index,
1217 long* column_index) {
1218 if (!instance_active())
1219 return E_FAIL;
1220
1221 if (!column_index)
1222 return E_INVALIDARG;
1223
1224 const std::vector<int32>& unique_cell_ids = GetIntListAttribute(
1225 ui::AX_ATTR_UNIQUE_CELL_IDS);
1226 int cell_id_count = static_cast<int>(unique_cell_ids.size());
1227 if (cell_index < 0)
1228 return E_INVALIDARG;
1229 if (cell_index >= cell_id_count)
1230 return S_FALSE;
1231
1232 int cell_id = unique_cell_ids[cell_index];
1233 BrowserAccessibilityWin* cell =
1234 manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
1235 int col_index;
1236 if (cell &&
1237 cell->GetIntAttribute(
1238 ui::AX_ATTR_TABLE_CELL_COLUMN_INDEX, &col_index)) {
1239 *column_index = col_index;
1240 return S_OK;
1241 }
1242
1243 return S_FALSE;
1244 }
1245
get_nColumns(long * column_count)1246 STDMETHODIMP BrowserAccessibilityWin::get_nColumns(long* column_count) {
1247 if (!instance_active())
1248 return E_FAIL;
1249
1250 if (!column_count)
1251 return E_INVALIDARG;
1252
1253 int columns;
1254 if (GetIntAttribute(
1255 ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns)) {
1256 *column_count = columns;
1257 return S_OK;
1258 }
1259
1260 return S_FALSE;
1261 }
1262
get_nRows(long * row_count)1263 STDMETHODIMP BrowserAccessibilityWin::get_nRows(long* row_count) {
1264 if (!instance_active())
1265 return E_FAIL;
1266
1267 if (!row_count)
1268 return E_INVALIDARG;
1269
1270 int rows;
1271 if (GetIntAttribute(ui::AX_ATTR_TABLE_ROW_COUNT, &rows)) {
1272 *row_count = rows;
1273 return S_OK;
1274 }
1275
1276 return S_FALSE;
1277 }
1278
get_nSelectedChildren(long * cell_count)1279 STDMETHODIMP BrowserAccessibilityWin::get_nSelectedChildren(long* cell_count) {
1280 if (!instance_active())
1281 return E_FAIL;
1282
1283 if (!cell_count)
1284 return E_INVALIDARG;
1285
1286 // TODO(dmazzoni): add support for selected cells/rows/columns in tables.
1287 *cell_count = 0;
1288 return S_OK;
1289 }
1290
get_nSelectedColumns(long * column_count)1291 STDMETHODIMP BrowserAccessibilityWin::get_nSelectedColumns(long* column_count) {
1292 if (!instance_active())
1293 return E_FAIL;
1294
1295 if (!column_count)
1296 return E_INVALIDARG;
1297
1298 *column_count = 0;
1299 return S_OK;
1300 }
1301
get_nSelectedRows(long * row_count)1302 STDMETHODIMP BrowserAccessibilityWin::get_nSelectedRows(long* row_count) {
1303 if (!instance_active())
1304 return E_FAIL;
1305
1306 if (!row_count)
1307 return E_INVALIDARG;
1308
1309 *row_count = 0;
1310 return S_OK;
1311 }
1312
get_rowDescription(long row,BSTR * description)1313 STDMETHODIMP BrowserAccessibilityWin::get_rowDescription(long row,
1314 BSTR* description) {
1315 if (!instance_active())
1316 return E_FAIL;
1317
1318 if (!description)
1319 return E_INVALIDARG;
1320
1321 int columns;
1322 int rows;
1323 if (!GetIntAttribute(
1324 ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
1325 !GetIntAttribute(ui::AX_ATTR_TABLE_ROW_COUNT, &rows) ||
1326 columns <= 0 ||
1327 rows <= 0) {
1328 return S_FALSE;
1329 }
1330
1331 if (row < 0 || row >= rows)
1332 return E_INVALIDARG;
1333
1334 const std::vector<int32>& cell_ids = GetIntListAttribute(
1335 ui::AX_ATTR_CELL_IDS);
1336 for (int i = 0; i < columns; ++i) {
1337 int cell_id = cell_ids[row * columns + i];
1338 BrowserAccessibilityWin* cell =
1339 manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
1340 if (cell && cell->GetRole() == ui::AX_ROLE_ROW_HEADER) {
1341 base::string16 cell_name = cell->GetString16Attribute(
1342 ui::AX_ATTR_NAME);
1343 if (cell_name.size() > 0) {
1344 *description = SysAllocString(cell_name.c_str());
1345 return S_OK;
1346 }
1347
1348 return cell->GetStringAttributeAsBstr(
1349 ui::AX_ATTR_DESCRIPTION, description);
1350 }
1351 }
1352
1353 return S_FALSE;
1354 }
1355
get_rowExtentAt(long row,long column,long * n_rows_spanned)1356 STDMETHODIMP BrowserAccessibilityWin::get_rowExtentAt(long row,
1357 long column,
1358 long* n_rows_spanned) {
1359 if (!instance_active())
1360 return E_FAIL;
1361
1362 if (!n_rows_spanned)
1363 return E_INVALIDARG;
1364
1365 int columns;
1366 int rows;
1367 if (!GetIntAttribute(
1368 ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
1369 !GetIntAttribute(ui::AX_ATTR_TABLE_ROW_COUNT, &rows) ||
1370 columns <= 0 ||
1371 rows <= 0) {
1372 return S_FALSE;
1373 }
1374
1375 if (row < 0 || row >= rows || column < 0 || column >= columns)
1376 return E_INVALIDARG;
1377
1378 const std::vector<int32>& cell_ids = GetIntListAttribute(
1379 ui::AX_ATTR_CELL_IDS);
1380 int cell_id = cell_ids[row * columns + column];
1381 BrowserAccessibilityWin* cell =
1382 manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
1383 int rowspan;
1384 if (cell &&
1385 cell->GetIntAttribute(
1386 ui::AX_ATTR_TABLE_CELL_ROW_SPAN, &rowspan) &&
1387 rowspan >= 1) {
1388 *n_rows_spanned = rowspan;
1389 return S_OK;
1390 }
1391
1392 return S_FALSE;
1393 }
1394
get_rowHeader(IAccessibleTable ** accessible_table,long * starting_column_index)1395 STDMETHODIMP BrowserAccessibilityWin::get_rowHeader(
1396 IAccessibleTable** accessible_table,
1397 long* starting_column_index) {
1398 // TODO(dmazzoni): implement
1399 return E_NOTIMPL;
1400 }
1401
get_rowIndex(long cell_index,long * row_index)1402 STDMETHODIMP BrowserAccessibilityWin::get_rowIndex(long cell_index,
1403 long* row_index) {
1404 if (!instance_active())
1405 return E_FAIL;
1406
1407 if (!row_index)
1408 return E_INVALIDARG;
1409
1410 const std::vector<int32>& unique_cell_ids = GetIntListAttribute(
1411 ui::AX_ATTR_UNIQUE_CELL_IDS);
1412 int cell_id_count = static_cast<int>(unique_cell_ids.size());
1413 if (cell_index < 0)
1414 return E_INVALIDARG;
1415 if (cell_index >= cell_id_count)
1416 return S_FALSE;
1417
1418 int cell_id = unique_cell_ids[cell_index];
1419 BrowserAccessibilityWin* cell =
1420 manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
1421 int cell_row_index;
1422 if (cell &&
1423 cell->GetIntAttribute(
1424 ui::AX_ATTR_TABLE_CELL_ROW_INDEX, &cell_row_index)) {
1425 *row_index = cell_row_index;
1426 return S_OK;
1427 }
1428
1429 return S_FALSE;
1430 }
1431
get_selectedChildren(long max_children,long ** children,long * n_children)1432 STDMETHODIMP BrowserAccessibilityWin::get_selectedChildren(long max_children,
1433 long** children,
1434 long* n_children) {
1435 if (!instance_active())
1436 return E_FAIL;
1437
1438 if (!children || !n_children)
1439 return E_INVALIDARG;
1440
1441 // TODO(dmazzoni): Implement this.
1442 *n_children = 0;
1443 return S_OK;
1444 }
1445
get_selectedColumns(long max_columns,long ** columns,long * n_columns)1446 STDMETHODIMP BrowserAccessibilityWin::get_selectedColumns(long max_columns,
1447 long** columns,
1448 long* n_columns) {
1449 if (!instance_active())
1450 return E_FAIL;
1451
1452 if (!columns || !n_columns)
1453 return E_INVALIDARG;
1454
1455 // TODO(dmazzoni): Implement this.
1456 *n_columns = 0;
1457 return S_OK;
1458 }
1459
get_selectedRows(long max_rows,long ** rows,long * n_rows)1460 STDMETHODIMP BrowserAccessibilityWin::get_selectedRows(long max_rows,
1461 long** rows,
1462 long* n_rows) {
1463 if (!instance_active())
1464 return E_FAIL;
1465
1466 if (!rows || !n_rows)
1467 return E_INVALIDARG;
1468
1469 // TODO(dmazzoni): Implement this.
1470 *n_rows = 0;
1471 return S_OK;
1472 }
1473
get_summary(IUnknown ** accessible)1474 STDMETHODIMP BrowserAccessibilityWin::get_summary(IUnknown** accessible) {
1475 if (!instance_active())
1476 return E_FAIL;
1477
1478 if (!accessible)
1479 return E_INVALIDARG;
1480
1481 // TODO(dmazzoni): implement
1482 return S_FALSE;
1483 }
1484
get_isColumnSelected(long column,boolean * is_selected)1485 STDMETHODIMP BrowserAccessibilityWin::get_isColumnSelected(
1486 long column,
1487 boolean* is_selected) {
1488 if (!instance_active())
1489 return E_FAIL;
1490
1491 if (!is_selected)
1492 return E_INVALIDARG;
1493
1494 // TODO(dmazzoni): Implement this.
1495 *is_selected = false;
1496 return S_OK;
1497 }
1498
get_isRowSelected(long row,boolean * is_selected)1499 STDMETHODIMP BrowserAccessibilityWin::get_isRowSelected(long row,
1500 boolean* is_selected) {
1501 if (!instance_active())
1502 return E_FAIL;
1503
1504 if (!is_selected)
1505 return E_INVALIDARG;
1506
1507 // TODO(dmazzoni): Implement this.
1508 *is_selected = false;
1509 return S_OK;
1510 }
1511
get_isSelected(long row,long column,boolean * is_selected)1512 STDMETHODIMP BrowserAccessibilityWin::get_isSelected(long row,
1513 long column,
1514 boolean* is_selected) {
1515 if (!instance_active())
1516 return E_FAIL;
1517
1518 if (!is_selected)
1519 return E_INVALIDARG;
1520
1521 // TODO(dmazzoni): Implement this.
1522 *is_selected = false;
1523 return S_OK;
1524 }
1525
get_rowColumnExtentsAtIndex(long index,long * row,long * column,long * row_extents,long * column_extents,boolean * is_selected)1526 STDMETHODIMP BrowserAccessibilityWin::get_rowColumnExtentsAtIndex(
1527 long index,
1528 long* row,
1529 long* column,
1530 long* row_extents,
1531 long* column_extents,
1532 boolean* is_selected) {
1533 if (!instance_active())
1534 return E_FAIL;
1535
1536 if (!row || !column || !row_extents || !column_extents || !is_selected)
1537 return E_INVALIDARG;
1538
1539 const std::vector<int32>& unique_cell_ids = GetIntListAttribute(
1540 ui::AX_ATTR_UNIQUE_CELL_IDS);
1541 int cell_id_count = static_cast<int>(unique_cell_ids.size());
1542 if (index < 0)
1543 return E_INVALIDARG;
1544 if (index >= cell_id_count)
1545 return S_FALSE;
1546
1547 int cell_id = unique_cell_ids[index];
1548 BrowserAccessibilityWin* cell =
1549 manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
1550 int rowspan;
1551 int colspan;
1552 if (cell &&
1553 cell->GetIntAttribute(
1554 ui::AX_ATTR_TABLE_CELL_ROW_SPAN, &rowspan) &&
1555 cell->GetIntAttribute(
1556 ui::AX_ATTR_TABLE_CELL_COLUMN_SPAN, &colspan) &&
1557 rowspan >= 1 &&
1558 colspan >= 1) {
1559 *row_extents = rowspan;
1560 *column_extents = colspan;
1561 return S_OK;
1562 }
1563
1564 return S_FALSE;
1565 }
1566
1567 //
1568 // IAccessibleTable2 methods.
1569 //
1570
get_cellAt(long row,long column,IUnknown ** cell)1571 STDMETHODIMP BrowserAccessibilityWin::get_cellAt(long row,
1572 long column,
1573 IUnknown** cell) {
1574 return get_accessibleAt(row, column, cell);
1575 }
1576
get_nSelectedCells(long * cell_count)1577 STDMETHODIMP BrowserAccessibilityWin::get_nSelectedCells(long* cell_count) {
1578 return get_nSelectedChildren(cell_count);
1579 }
1580
get_selectedCells(IUnknown *** cells,long * n_selected_cells)1581 STDMETHODIMP BrowserAccessibilityWin::get_selectedCells(
1582 IUnknown*** cells,
1583 long* n_selected_cells) {
1584 if (!instance_active())
1585 return E_FAIL;
1586
1587 if (!cells || !n_selected_cells)
1588 return E_INVALIDARG;
1589
1590 // TODO(dmazzoni): Implement this.
1591 *n_selected_cells = 0;
1592 return S_OK;
1593 }
1594
get_selectedColumns(long ** columns,long * n_columns)1595 STDMETHODIMP BrowserAccessibilityWin::get_selectedColumns(long** columns,
1596 long* n_columns) {
1597 if (!instance_active())
1598 return E_FAIL;
1599
1600 if (!columns || !n_columns)
1601 return E_INVALIDARG;
1602
1603 // TODO(dmazzoni): Implement this.
1604 *n_columns = 0;
1605 return S_OK;
1606 }
1607
get_selectedRows(long ** rows,long * n_rows)1608 STDMETHODIMP BrowserAccessibilityWin::get_selectedRows(long** rows,
1609 long* n_rows) {
1610 if (!instance_active())
1611 return E_FAIL;
1612
1613 if (!rows || !n_rows)
1614 return E_INVALIDARG;
1615
1616 // TODO(dmazzoni): Implement this.
1617 *n_rows = 0;
1618 return S_OK;
1619 }
1620
1621
1622 //
1623 // IAccessibleTableCell methods.
1624 //
1625
get_columnExtent(long * n_columns_spanned)1626 STDMETHODIMP BrowserAccessibilityWin::get_columnExtent(
1627 long* n_columns_spanned) {
1628 if (!instance_active())
1629 return E_FAIL;
1630
1631 if (!n_columns_spanned)
1632 return E_INVALIDARG;
1633
1634 int colspan;
1635 if (GetIntAttribute(
1636 ui::AX_ATTR_TABLE_CELL_COLUMN_SPAN, &colspan) &&
1637 colspan >= 1) {
1638 *n_columns_spanned = colspan;
1639 return S_OK;
1640 }
1641
1642 return S_FALSE;
1643 }
1644
get_columnHeaderCells(IUnknown *** cell_accessibles,long * n_column_header_cells)1645 STDMETHODIMP BrowserAccessibilityWin::get_columnHeaderCells(
1646 IUnknown*** cell_accessibles,
1647 long* n_column_header_cells) {
1648 if (!instance_active())
1649 return E_FAIL;
1650
1651 if (!cell_accessibles || !n_column_header_cells)
1652 return E_INVALIDARG;
1653
1654 *n_column_header_cells = 0;
1655
1656 int column;
1657 if (!GetIntAttribute(
1658 ui::AX_ATTR_TABLE_CELL_COLUMN_INDEX, &column)) {
1659 return S_FALSE;
1660 }
1661
1662 BrowserAccessibility* table = GetParent();
1663 while (table && table->GetRole() != ui::AX_ROLE_TABLE)
1664 table = table->GetParent();
1665 if (!table) {
1666 NOTREACHED();
1667 return S_FALSE;
1668 }
1669
1670 int columns;
1671 int rows;
1672 if (!table->GetIntAttribute(
1673 ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
1674 !table->GetIntAttribute(
1675 ui::AX_ATTR_TABLE_ROW_COUNT, &rows)) {
1676 return S_FALSE;
1677 }
1678 if (columns <= 0 || rows <= 0 || column < 0 || column >= columns)
1679 return S_FALSE;
1680
1681 const std::vector<int32>& cell_ids = table->GetIntListAttribute(
1682 ui::AX_ATTR_CELL_IDS);
1683
1684 for (int i = 0; i < rows; ++i) {
1685 int cell_id = cell_ids[i * columns + column];
1686 BrowserAccessibilityWin* cell =
1687 manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
1688 if (cell && cell->GetRole() == ui::AX_ROLE_COLUMN_HEADER)
1689 (*n_column_header_cells)++;
1690 }
1691
1692 *cell_accessibles = static_cast<IUnknown**>(CoTaskMemAlloc(
1693 (*n_column_header_cells) * sizeof(cell_accessibles[0])));
1694 int index = 0;
1695 for (int i = 0; i < rows; ++i) {
1696 int cell_id = cell_ids[i * columns + column];
1697 BrowserAccessibility* cell = manager()->GetFromID(cell_id);
1698 if (cell && cell->GetRole() == ui::AX_ROLE_COLUMN_HEADER) {
1699 (*cell_accessibles)[index] = static_cast<IAccessible*>(
1700 cell->ToBrowserAccessibilityWin()->NewReference());
1701 ++index;
1702 }
1703 }
1704
1705 return S_OK;
1706 }
1707
get_columnIndex(long * column_index)1708 STDMETHODIMP BrowserAccessibilityWin::get_columnIndex(long* column_index) {
1709 if (!instance_active())
1710 return E_FAIL;
1711
1712 if (!column_index)
1713 return E_INVALIDARG;
1714
1715 int column;
1716 if (GetIntAttribute(
1717 ui::AX_ATTR_TABLE_CELL_COLUMN_INDEX, &column)) {
1718 *column_index = column;
1719 return S_OK;
1720 }
1721
1722 return S_FALSE;
1723 }
1724
get_rowExtent(long * n_rows_spanned)1725 STDMETHODIMP BrowserAccessibilityWin::get_rowExtent(long* n_rows_spanned) {
1726 if (!instance_active())
1727 return E_FAIL;
1728
1729 if (!n_rows_spanned)
1730 return E_INVALIDARG;
1731
1732 int rowspan;
1733 if (GetIntAttribute(
1734 ui::AX_ATTR_TABLE_CELL_ROW_SPAN, &rowspan) &&
1735 rowspan >= 1) {
1736 *n_rows_spanned = rowspan;
1737 return S_OK;
1738 }
1739
1740 return S_FALSE;
1741 }
1742
get_rowHeaderCells(IUnknown *** cell_accessibles,long * n_row_header_cells)1743 STDMETHODIMP BrowserAccessibilityWin::get_rowHeaderCells(
1744 IUnknown*** cell_accessibles,
1745 long* n_row_header_cells) {
1746 if (!instance_active())
1747 return E_FAIL;
1748
1749 if (!cell_accessibles || !n_row_header_cells)
1750 return E_INVALIDARG;
1751
1752 *n_row_header_cells = 0;
1753
1754 int row;
1755 if (!GetIntAttribute(
1756 ui::AX_ATTR_TABLE_CELL_ROW_INDEX, &row)) {
1757 return S_FALSE;
1758 }
1759
1760 BrowserAccessibility* table = GetParent();
1761 while (table && table->GetRole() != ui::AX_ROLE_TABLE)
1762 table = table->GetParent();
1763 if (!table) {
1764 NOTREACHED();
1765 return S_FALSE;
1766 }
1767
1768 int columns;
1769 int rows;
1770 if (!table->GetIntAttribute(
1771 ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
1772 !table->GetIntAttribute(
1773 ui::AX_ATTR_TABLE_ROW_COUNT, &rows)) {
1774 return S_FALSE;
1775 }
1776 if (columns <= 0 || rows <= 0 || row < 0 || row >= rows)
1777 return S_FALSE;
1778
1779 const std::vector<int32>& cell_ids = table->GetIntListAttribute(
1780 ui::AX_ATTR_CELL_IDS);
1781
1782 for (int i = 0; i < columns; ++i) {
1783 int cell_id = cell_ids[row * columns + i];
1784 BrowserAccessibility* cell = manager()->GetFromID(cell_id);
1785 if (cell && cell->GetRole() == ui::AX_ROLE_ROW_HEADER)
1786 (*n_row_header_cells)++;
1787 }
1788
1789 *cell_accessibles = static_cast<IUnknown**>(CoTaskMemAlloc(
1790 (*n_row_header_cells) * sizeof(cell_accessibles[0])));
1791 int index = 0;
1792 for (int i = 0; i < columns; ++i) {
1793 int cell_id = cell_ids[row * columns + i];
1794 BrowserAccessibility* cell = manager()->GetFromID(cell_id);
1795 if (cell && cell->GetRole() == ui::AX_ROLE_ROW_HEADER) {
1796 (*cell_accessibles)[index] = static_cast<IAccessible*>(
1797 cell->ToBrowserAccessibilityWin()->NewReference());
1798 ++index;
1799 }
1800 }
1801
1802 return S_OK;
1803 }
1804
get_rowIndex(long * row_index)1805 STDMETHODIMP BrowserAccessibilityWin::get_rowIndex(long* row_index) {
1806 if (!instance_active())
1807 return E_FAIL;
1808
1809 if (!row_index)
1810 return E_INVALIDARG;
1811
1812 int row;
1813 if (GetIntAttribute(ui::AX_ATTR_TABLE_CELL_ROW_INDEX, &row)) {
1814 *row_index = row;
1815 return S_OK;
1816 }
1817 return S_FALSE;
1818 }
1819
get_isSelected(boolean * is_selected)1820 STDMETHODIMP BrowserAccessibilityWin::get_isSelected(boolean* is_selected) {
1821 if (!instance_active())
1822 return E_FAIL;
1823
1824 if (!is_selected)
1825 return E_INVALIDARG;
1826
1827 *is_selected = false;
1828 return S_OK;
1829 }
1830
get_rowColumnExtents(long * row_index,long * column_index,long * row_extents,long * column_extents,boolean * is_selected)1831 STDMETHODIMP BrowserAccessibilityWin::get_rowColumnExtents(
1832 long* row_index,
1833 long* column_index,
1834 long* row_extents,
1835 long* column_extents,
1836 boolean* is_selected) {
1837 if (!instance_active())
1838 return E_FAIL;
1839
1840 if (!row_index ||
1841 !column_index ||
1842 !row_extents ||
1843 !column_extents ||
1844 !is_selected) {
1845 return E_INVALIDARG;
1846 }
1847
1848 int row;
1849 int column;
1850 int rowspan;
1851 int colspan;
1852 if (GetIntAttribute(ui::AX_ATTR_TABLE_CELL_ROW_INDEX, &row) &&
1853 GetIntAttribute(
1854 ui::AX_ATTR_TABLE_CELL_COLUMN_INDEX, &column) &&
1855 GetIntAttribute(
1856 ui::AX_ATTR_TABLE_CELL_ROW_SPAN, &rowspan) &&
1857 GetIntAttribute(
1858 ui::AX_ATTR_TABLE_CELL_COLUMN_SPAN, &colspan)) {
1859 *row_index = row;
1860 *column_index = column;
1861 *row_extents = rowspan;
1862 *column_extents = colspan;
1863 *is_selected = false;
1864 return S_OK;
1865 }
1866
1867 return S_FALSE;
1868 }
1869
get_table(IUnknown ** table)1870 STDMETHODIMP BrowserAccessibilityWin::get_table(IUnknown** table) {
1871 if (!instance_active())
1872 return E_FAIL;
1873
1874 if (!table)
1875 return E_INVALIDARG;
1876
1877
1878 int row;
1879 int column;
1880 GetIntAttribute(ui::AX_ATTR_TABLE_CELL_ROW_INDEX, &row);
1881 GetIntAttribute(ui::AX_ATTR_TABLE_CELL_COLUMN_INDEX, &column);
1882
1883 BrowserAccessibility* find_table = GetParent();
1884 while (find_table && find_table->GetRole() != ui::AX_ROLE_TABLE)
1885 find_table = find_table->GetParent();
1886 if (!find_table) {
1887 NOTREACHED();
1888 return S_FALSE;
1889 }
1890
1891 *table = static_cast<IAccessibleTable*>(
1892 find_table->ToBrowserAccessibilityWin()->NewReference());
1893
1894 return S_OK;
1895 }
1896
1897 //
1898 // IAccessibleText methods.
1899 //
1900
get_nCharacters(LONG * n_characters)1901 STDMETHODIMP BrowserAccessibilityWin::get_nCharacters(LONG* n_characters) {
1902 if (!instance_active())
1903 return E_FAIL;
1904
1905 if (!n_characters)
1906 return E_INVALIDARG;
1907
1908 *n_characters = TextForIAccessibleText().length();
1909 return S_OK;
1910 }
1911
get_caretOffset(LONG * offset)1912 STDMETHODIMP BrowserAccessibilityWin::get_caretOffset(LONG* offset) {
1913 if (!instance_active())
1914 return E_FAIL;
1915
1916 if (!offset)
1917 return E_INVALIDARG;
1918
1919 *offset = 0;
1920 if (GetRole() == ui::AX_ROLE_TEXT_FIELD ||
1921 GetRole() == ui::AX_ROLE_TEXT_AREA) {
1922 int sel_start = 0;
1923 if (GetIntAttribute(ui::AX_ATTR_TEXT_SEL_START,
1924 &sel_start))
1925 *offset = sel_start;
1926 }
1927
1928 return S_OK;
1929 }
1930
get_characterExtents(LONG offset,enum IA2CoordinateType coordinate_type,LONG * out_x,LONG * out_y,LONG * out_width,LONG * out_height)1931 STDMETHODIMP BrowserAccessibilityWin::get_characterExtents(
1932 LONG offset,
1933 enum IA2CoordinateType coordinate_type,
1934 LONG* out_x,
1935 LONG* out_y,
1936 LONG* out_width,
1937 LONG* out_height) {
1938 if (!instance_active())
1939 return E_FAIL;
1940
1941 if (!out_x || !out_y || !out_width || !out_height)
1942 return E_INVALIDARG;
1943
1944 const base::string16& text_str = TextForIAccessibleText();
1945 HandleSpecialTextOffset(text_str, &offset);
1946
1947 if (offset < 0 || offset > static_cast<LONG>(text_str.size()))
1948 return E_INVALIDARG;
1949
1950 gfx::Rect character_bounds;
1951 if (coordinate_type == IA2_COORDTYPE_SCREEN_RELATIVE) {
1952 character_bounds = GetGlobalBoundsForRange(offset, 1);
1953 } else if (coordinate_type == IA2_COORDTYPE_PARENT_RELATIVE) {
1954 character_bounds = GetLocalBoundsForRange(offset, 1);
1955 character_bounds -= GetLocation().OffsetFromOrigin();
1956 } else {
1957 return E_INVALIDARG;
1958 }
1959
1960 *out_x = character_bounds.x();
1961 *out_y = character_bounds.y();
1962 *out_width = character_bounds.width();
1963 *out_height = character_bounds.height();
1964
1965 return S_OK;
1966 }
1967
get_nSelections(LONG * n_selections)1968 STDMETHODIMP BrowserAccessibilityWin::get_nSelections(LONG* n_selections) {
1969 if (!instance_active())
1970 return E_FAIL;
1971
1972 if (!n_selections)
1973 return E_INVALIDARG;
1974
1975 *n_selections = 0;
1976 if (GetRole() == ui::AX_ROLE_TEXT_FIELD ||
1977 GetRole() == ui::AX_ROLE_TEXT_AREA) {
1978 int sel_start = 0;
1979 int sel_end = 0;
1980 if (GetIntAttribute(ui::AX_ATTR_TEXT_SEL_START,
1981 &sel_start) &&
1982 GetIntAttribute(ui::AX_ATTR_TEXT_SEL_END, &sel_end) &&
1983 sel_start != sel_end)
1984 *n_selections = 1;
1985 }
1986
1987 return S_OK;
1988 }
1989
get_selection(LONG selection_index,LONG * start_offset,LONG * end_offset)1990 STDMETHODIMP BrowserAccessibilityWin::get_selection(LONG selection_index,
1991 LONG* start_offset,
1992 LONG* end_offset) {
1993 if (!instance_active())
1994 return E_FAIL;
1995
1996 if (!start_offset || !end_offset || selection_index != 0)
1997 return E_INVALIDARG;
1998
1999 *start_offset = 0;
2000 *end_offset = 0;
2001 if (GetRole() == ui::AX_ROLE_TEXT_FIELD ||
2002 GetRole() == ui::AX_ROLE_TEXT_AREA) {
2003 int sel_start = 0;
2004 int sel_end = 0;
2005 if (GetIntAttribute(
2006 ui::AX_ATTR_TEXT_SEL_START, &sel_start) &&
2007 GetIntAttribute(ui::AX_ATTR_TEXT_SEL_END, &sel_end)) {
2008 *start_offset = sel_start;
2009 *end_offset = sel_end;
2010 }
2011 }
2012
2013 return S_OK;
2014 }
2015
get_text(LONG start_offset,LONG end_offset,BSTR * text)2016 STDMETHODIMP BrowserAccessibilityWin::get_text(LONG start_offset,
2017 LONG end_offset,
2018 BSTR* text) {
2019 if (!instance_active())
2020 return E_FAIL;
2021
2022 if (!text)
2023 return E_INVALIDARG;
2024
2025 const base::string16& text_str = TextForIAccessibleText();
2026
2027 // Handle special text offsets.
2028 HandleSpecialTextOffset(text_str, &start_offset);
2029 HandleSpecialTextOffset(text_str, &end_offset);
2030
2031 // The spec allows the arguments to be reversed.
2032 if (start_offset > end_offset) {
2033 LONG tmp = start_offset;
2034 start_offset = end_offset;
2035 end_offset = tmp;
2036 }
2037
2038 // The spec does not allow the start or end offsets to be out or range;
2039 // we must return an error if so.
2040 LONG len = text_str.length();
2041 if (start_offset < 0)
2042 return E_INVALIDARG;
2043 if (end_offset > len)
2044 return E_INVALIDARG;
2045
2046 base::string16 substr = text_str.substr(start_offset,
2047 end_offset - start_offset);
2048 if (substr.empty())
2049 return S_FALSE;
2050
2051 *text = SysAllocString(substr.c_str());
2052 DCHECK(*text);
2053 return S_OK;
2054 }
2055
get_textAtOffset(LONG offset,enum IA2TextBoundaryType boundary_type,LONG * start_offset,LONG * end_offset,BSTR * text)2056 STDMETHODIMP BrowserAccessibilityWin::get_textAtOffset(
2057 LONG offset,
2058 enum IA2TextBoundaryType boundary_type,
2059 LONG* start_offset,
2060 LONG* end_offset,
2061 BSTR* text) {
2062 if (!instance_active())
2063 return E_FAIL;
2064
2065 if (!start_offset || !end_offset || !text)
2066 return E_INVALIDARG;
2067
2068 // The IAccessible2 spec says we don't have to implement the "sentence"
2069 // boundary type, we can just let the screenreader handle it.
2070 if (boundary_type == IA2_TEXT_BOUNDARY_SENTENCE) {
2071 *start_offset = 0;
2072 *end_offset = 0;
2073 *text = NULL;
2074 return S_FALSE;
2075 }
2076
2077 const base::string16& text_str = TextForIAccessibleText();
2078
2079 *start_offset = FindBoundary(
2080 text_str, boundary_type, offset, ui::BACKWARDS_DIRECTION);
2081 *end_offset = FindBoundary(
2082 text_str, boundary_type, offset, ui::FORWARDS_DIRECTION);
2083 return get_text(*start_offset, *end_offset, text);
2084 }
2085
get_textBeforeOffset(LONG offset,enum IA2TextBoundaryType boundary_type,LONG * start_offset,LONG * end_offset,BSTR * text)2086 STDMETHODIMP BrowserAccessibilityWin::get_textBeforeOffset(
2087 LONG offset,
2088 enum IA2TextBoundaryType boundary_type,
2089 LONG* start_offset,
2090 LONG* end_offset,
2091 BSTR* text) {
2092 if (!instance_active())
2093 return E_FAIL;
2094
2095 if (!start_offset || !end_offset || !text)
2096 return E_INVALIDARG;
2097
2098 // The IAccessible2 spec says we don't have to implement the "sentence"
2099 // boundary type, we can just let the screenreader handle it.
2100 if (boundary_type == IA2_TEXT_BOUNDARY_SENTENCE) {
2101 *start_offset = 0;
2102 *end_offset = 0;
2103 *text = NULL;
2104 return S_FALSE;
2105 }
2106
2107 const base::string16& text_str = TextForIAccessibleText();
2108
2109 *start_offset = FindBoundary(
2110 text_str, boundary_type, offset, ui::BACKWARDS_DIRECTION);
2111 *end_offset = offset;
2112 return get_text(*start_offset, *end_offset, text);
2113 }
2114
get_textAfterOffset(LONG offset,enum IA2TextBoundaryType boundary_type,LONG * start_offset,LONG * end_offset,BSTR * text)2115 STDMETHODIMP BrowserAccessibilityWin::get_textAfterOffset(
2116 LONG offset,
2117 enum IA2TextBoundaryType boundary_type,
2118 LONG* start_offset,
2119 LONG* end_offset,
2120 BSTR* text) {
2121 if (!instance_active())
2122 return E_FAIL;
2123
2124 if (!start_offset || !end_offset || !text)
2125 return E_INVALIDARG;
2126
2127 // The IAccessible2 spec says we don't have to implement the "sentence"
2128 // boundary type, we can just let the screenreader handle it.
2129 if (boundary_type == IA2_TEXT_BOUNDARY_SENTENCE) {
2130 *start_offset = 0;
2131 *end_offset = 0;
2132 *text = NULL;
2133 return S_FALSE;
2134 }
2135
2136 const base::string16& text_str = TextForIAccessibleText();
2137
2138 *start_offset = offset;
2139 *end_offset = FindBoundary(
2140 text_str, boundary_type, offset, ui::FORWARDS_DIRECTION);
2141 return get_text(*start_offset, *end_offset, text);
2142 }
2143
get_newText(IA2TextSegment * new_text)2144 STDMETHODIMP BrowserAccessibilityWin::get_newText(IA2TextSegment* new_text) {
2145 if (!instance_active())
2146 return E_FAIL;
2147
2148 if (!new_text)
2149 return E_INVALIDARG;
2150
2151 base::string16 text = TextForIAccessibleText();
2152
2153 new_text->text = SysAllocString(text.c_str());
2154 new_text->start = 0;
2155 new_text->end = static_cast<long>(text.size());
2156 return S_OK;
2157 }
2158
get_oldText(IA2TextSegment * old_text)2159 STDMETHODIMP BrowserAccessibilityWin::get_oldText(IA2TextSegment* old_text) {
2160 if (!instance_active())
2161 return E_FAIL;
2162
2163 if (!old_text)
2164 return E_INVALIDARG;
2165
2166 old_text->text = SysAllocString(old_text_.c_str());
2167 old_text->start = 0;
2168 old_text->end = static_cast<long>(old_text_.size());
2169 return S_OK;
2170 }
2171
get_offsetAtPoint(LONG x,LONG y,enum IA2CoordinateType coord_type,LONG * offset)2172 STDMETHODIMP BrowserAccessibilityWin::get_offsetAtPoint(
2173 LONG x,
2174 LONG y,
2175 enum IA2CoordinateType coord_type,
2176 LONG* offset) {
2177 if (!instance_active())
2178 return E_FAIL;
2179
2180 if (!offset)
2181 return E_INVALIDARG;
2182
2183 // TODO(dmazzoni): implement this. We're returning S_OK for now so that
2184 // screen readers still return partially accurate results rather than
2185 // completely failing.
2186 *offset = 0;
2187 return S_OK;
2188 }
2189
scrollSubstringTo(LONG start_index,LONG end_index,enum IA2ScrollType scroll_type)2190 STDMETHODIMP BrowserAccessibilityWin::scrollSubstringTo(
2191 LONG start_index,
2192 LONG end_index,
2193 enum IA2ScrollType scroll_type) {
2194 // TODO(dmazzoni): adjust this for the start and end index, too.
2195 return scrollTo(scroll_type);
2196 }
2197
scrollSubstringToPoint(LONG start_index,LONG end_index,enum IA2CoordinateType coordinate_type,LONG x,LONG y)2198 STDMETHODIMP BrowserAccessibilityWin::scrollSubstringToPoint(
2199 LONG start_index,
2200 LONG end_index,
2201 enum IA2CoordinateType coordinate_type,
2202 LONG x, LONG y) {
2203 // TODO(dmazzoni): adjust this for the start and end index, too.
2204 return scrollToPoint(coordinate_type, x, y);
2205 }
2206
addSelection(LONG start_offset,LONG end_offset)2207 STDMETHODIMP BrowserAccessibilityWin::addSelection(LONG start_offset,
2208 LONG end_offset) {
2209 if (!instance_active())
2210 return E_FAIL;
2211
2212 const base::string16& text_str = TextForIAccessibleText();
2213 HandleSpecialTextOffset(text_str, &start_offset);
2214 HandleSpecialTextOffset(text_str, &end_offset);
2215
2216 manager()->SetTextSelection(*this, start_offset, end_offset);
2217 return S_OK;
2218 }
2219
removeSelection(LONG selection_index)2220 STDMETHODIMP BrowserAccessibilityWin::removeSelection(LONG selection_index) {
2221 if (!instance_active())
2222 return E_FAIL;
2223
2224 if (selection_index != 0)
2225 return E_INVALIDARG;
2226
2227 manager()->SetTextSelection(*this, 0, 0);
2228 return S_OK;
2229 }
2230
setCaretOffset(LONG offset)2231 STDMETHODIMP BrowserAccessibilityWin::setCaretOffset(LONG offset) {
2232 if (!instance_active())
2233 return E_FAIL;
2234
2235 const base::string16& text_str = TextForIAccessibleText();
2236 HandleSpecialTextOffset(text_str, &offset);
2237 manager()->SetTextSelection(*this, offset, offset);
2238 return S_OK;
2239 }
2240
setSelection(LONG selection_index,LONG start_offset,LONG end_offset)2241 STDMETHODIMP BrowserAccessibilityWin::setSelection(LONG selection_index,
2242 LONG start_offset,
2243 LONG end_offset) {
2244 if (!instance_active())
2245 return E_FAIL;
2246
2247 if (selection_index != 0)
2248 return E_INVALIDARG;
2249
2250 const base::string16& text_str = TextForIAccessibleText();
2251 HandleSpecialTextOffset(text_str, &start_offset);
2252 HandleSpecialTextOffset(text_str, &end_offset);
2253
2254 manager()->SetTextSelection(*this, start_offset, end_offset);
2255 return S_OK;
2256 }
2257
2258 //
2259 // IAccessibleHypertext methods.
2260 //
2261
get_nHyperlinks(long * hyperlink_count)2262 STDMETHODIMP BrowserAccessibilityWin::get_nHyperlinks(long* hyperlink_count) {
2263 if (!instance_active())
2264 return E_FAIL;
2265
2266 if (!hyperlink_count)
2267 return E_INVALIDARG;
2268
2269 *hyperlink_count = hyperlink_offset_to_index_.size();
2270 return S_OK;
2271 }
2272
get_hyperlink(long index,IAccessibleHyperlink ** hyperlink)2273 STDMETHODIMP BrowserAccessibilityWin::get_hyperlink(
2274 long index,
2275 IAccessibleHyperlink** hyperlink) {
2276 if (!instance_active())
2277 return E_FAIL;
2278
2279 if (!hyperlink ||
2280 index < 0 ||
2281 index >= static_cast<long>(hyperlinks_.size())) {
2282 return E_INVALIDARG;
2283 }
2284
2285 BrowserAccessibilityWin* child =
2286 InternalGetChild(hyperlinks_[index])->ToBrowserAccessibilityWin();
2287 *hyperlink = static_cast<IAccessibleHyperlink*>(child->NewReference());
2288 return S_OK;
2289 }
2290
get_hyperlinkIndex(long char_index,long * hyperlink_index)2291 STDMETHODIMP BrowserAccessibilityWin::get_hyperlinkIndex(
2292 long char_index,
2293 long* hyperlink_index) {
2294 if (!instance_active())
2295 return E_FAIL;
2296
2297 if (!hyperlink_index)
2298 return E_INVALIDARG;
2299
2300 *hyperlink_index = -1;
2301
2302 if (char_index < 0 || char_index >= static_cast<long>(hypertext_.size()))
2303 return E_INVALIDARG;
2304
2305 std::map<int32, int32>::iterator it =
2306 hyperlink_offset_to_index_.find(char_index);
2307 if (it == hyperlink_offset_to_index_.end())
2308 return E_FAIL;
2309
2310 *hyperlink_index = it->second;
2311 return S_OK;
2312 }
2313
2314 //
2315 // IAccessibleValue methods.
2316 //
2317
get_currentValue(VARIANT * value)2318 STDMETHODIMP BrowserAccessibilityWin::get_currentValue(VARIANT* value) {
2319 if (!instance_active())
2320 return E_FAIL;
2321
2322 if (!value)
2323 return E_INVALIDARG;
2324
2325 float float_val;
2326 if (GetFloatAttribute(
2327 ui::AX_ATTR_VALUE_FOR_RANGE, &float_val)) {
2328 value->vt = VT_R8;
2329 value->dblVal = float_val;
2330 return S_OK;
2331 }
2332
2333 value->vt = VT_EMPTY;
2334 return S_FALSE;
2335 }
2336
get_minimumValue(VARIANT * value)2337 STDMETHODIMP BrowserAccessibilityWin::get_minimumValue(VARIANT* value) {
2338 if (!instance_active())
2339 return E_FAIL;
2340
2341 if (!value)
2342 return E_INVALIDARG;
2343
2344 float float_val;
2345 if (GetFloatAttribute(ui::AX_ATTR_MIN_VALUE_FOR_RANGE,
2346 &float_val)) {
2347 value->vt = VT_R8;
2348 value->dblVal = float_val;
2349 return S_OK;
2350 }
2351
2352 value->vt = VT_EMPTY;
2353 return S_FALSE;
2354 }
2355
get_maximumValue(VARIANT * value)2356 STDMETHODIMP BrowserAccessibilityWin::get_maximumValue(VARIANT* value) {
2357 if (!instance_active())
2358 return E_FAIL;
2359
2360 if (!value)
2361 return E_INVALIDARG;
2362
2363 float float_val;
2364 if (GetFloatAttribute(ui::AX_ATTR_MAX_VALUE_FOR_RANGE,
2365 &float_val)) {
2366 value->vt = VT_R8;
2367 value->dblVal = float_val;
2368 return S_OK;
2369 }
2370
2371 value->vt = VT_EMPTY;
2372 return S_FALSE;
2373 }
2374
setCurrentValue(VARIANT new_value)2375 STDMETHODIMP BrowserAccessibilityWin::setCurrentValue(VARIANT new_value) {
2376 // TODO(dmazzoni): Implement this.
2377 return E_NOTIMPL;
2378 }
2379
2380 //
2381 // ISimpleDOMDocument methods.
2382 //
2383
get_URL(BSTR * url)2384 STDMETHODIMP BrowserAccessibilityWin::get_URL(BSTR* url) {
2385 if (!instance_active())
2386 return E_FAIL;
2387
2388 if (!url)
2389 return E_INVALIDARG;
2390
2391 return GetStringAttributeAsBstr(ui::AX_ATTR_DOC_URL, url);
2392 }
2393
get_title(BSTR * title)2394 STDMETHODIMP BrowserAccessibilityWin::get_title(BSTR* title) {
2395 if (!instance_active())
2396 return E_FAIL;
2397
2398 if (!title)
2399 return E_INVALIDARG;
2400
2401 return GetStringAttributeAsBstr(ui::AX_ATTR_DOC_TITLE, title);
2402 }
2403
get_mimeType(BSTR * mime_type)2404 STDMETHODIMP BrowserAccessibilityWin::get_mimeType(BSTR* mime_type) {
2405 if (!instance_active())
2406 return E_FAIL;
2407
2408 if (!mime_type)
2409 return E_INVALIDARG;
2410
2411 return GetStringAttributeAsBstr(
2412 ui::AX_ATTR_DOC_MIMETYPE, mime_type);
2413 }
2414
get_docType(BSTR * doc_type)2415 STDMETHODIMP BrowserAccessibilityWin::get_docType(BSTR* doc_type) {
2416 if (!instance_active())
2417 return E_FAIL;
2418
2419 if (!doc_type)
2420 return E_INVALIDARG;
2421
2422 return GetStringAttributeAsBstr(
2423 ui::AX_ATTR_DOC_DOCTYPE, doc_type);
2424 }
2425
2426 //
2427 // ISimpleDOMNode methods.
2428 //
2429
get_nodeInfo(BSTR * node_name,short * name_space_id,BSTR * node_value,unsigned int * num_children,unsigned int * unique_id,unsigned short * node_type)2430 STDMETHODIMP BrowserAccessibilityWin::get_nodeInfo(
2431 BSTR* node_name,
2432 short* name_space_id,
2433 BSTR* node_value,
2434 unsigned int* num_children,
2435 unsigned int* unique_id,
2436 unsigned short* node_type) {
2437 if (!instance_active())
2438 return E_FAIL;
2439
2440 if (!node_name || !name_space_id || !node_value || !num_children ||
2441 !unique_id || !node_type) {
2442 return E_INVALIDARG;
2443 }
2444
2445 base::string16 tag;
2446 if (GetString16Attribute(ui::AX_ATTR_HTML_TAG, &tag))
2447 *node_name = SysAllocString(tag.c_str());
2448 else
2449 *node_name = NULL;
2450
2451 *name_space_id = 0;
2452 *node_value = SysAllocString(base::UTF8ToUTF16(value()).c_str());
2453 *num_children = PlatformChildCount();
2454 *unique_id = unique_id_win_;
2455
2456 if (ia_role_ == ROLE_SYSTEM_DOCUMENT) {
2457 *node_type = NODETYPE_DOCUMENT;
2458 } else if (ia_role_ == ROLE_SYSTEM_TEXT &&
2459 ((ia2_state_ & IA2_STATE_EDITABLE) == 0)) {
2460 *node_type = NODETYPE_TEXT;
2461 } else {
2462 *node_type = NODETYPE_ELEMENT;
2463 }
2464
2465 return S_OK;
2466 }
2467
get_attributes(unsigned short max_attribs,BSTR * attrib_names,short * name_space_id,BSTR * attrib_values,unsigned short * num_attribs)2468 STDMETHODIMP BrowserAccessibilityWin::get_attributes(
2469 unsigned short max_attribs,
2470 BSTR* attrib_names,
2471 short* name_space_id,
2472 BSTR* attrib_values,
2473 unsigned short* num_attribs) {
2474 if (!instance_active())
2475 return E_FAIL;
2476
2477 if (!attrib_names || !name_space_id || !attrib_values || !num_attribs)
2478 return E_INVALIDARG;
2479
2480 *num_attribs = max_attribs;
2481 if (*num_attribs > GetHtmlAttributes().size())
2482 *num_attribs = GetHtmlAttributes().size();
2483
2484 for (unsigned short i = 0; i < *num_attribs; ++i) {
2485 attrib_names[i] = SysAllocString(
2486 base::UTF8ToUTF16(GetHtmlAttributes()[i].first).c_str());
2487 name_space_id[i] = 0;
2488 attrib_values[i] = SysAllocString(
2489 base::UTF8ToUTF16(GetHtmlAttributes()[i].second).c_str());
2490 }
2491 return S_OK;
2492 }
2493
get_attributesForNames(unsigned short num_attribs,BSTR * attrib_names,short * name_space_id,BSTR * attrib_values)2494 STDMETHODIMP BrowserAccessibilityWin::get_attributesForNames(
2495 unsigned short num_attribs,
2496 BSTR* attrib_names,
2497 short* name_space_id,
2498 BSTR* attrib_values) {
2499 if (!instance_active())
2500 return E_FAIL;
2501
2502 if (!attrib_names || !name_space_id || !attrib_values)
2503 return E_INVALIDARG;
2504
2505 for (unsigned short i = 0; i < num_attribs; ++i) {
2506 name_space_id[i] = 0;
2507 bool found = false;
2508 std::string name = base::UTF16ToUTF8((LPCWSTR)attrib_names[i]);
2509 for (unsigned int j = 0; j < GetHtmlAttributes().size(); ++j) {
2510 if (GetHtmlAttributes()[j].first == name) {
2511 attrib_values[i] = SysAllocString(
2512 base::UTF8ToUTF16(GetHtmlAttributes()[j].second).c_str());
2513 found = true;
2514 break;
2515 }
2516 }
2517 if (!found) {
2518 attrib_values[i] = NULL;
2519 }
2520 }
2521 return S_OK;
2522 }
2523
get_computedStyle(unsigned short max_style_properties,boolean use_alternate_view,BSTR * style_properties,BSTR * style_values,unsigned short * num_style_properties)2524 STDMETHODIMP BrowserAccessibilityWin::get_computedStyle(
2525 unsigned short max_style_properties,
2526 boolean use_alternate_view,
2527 BSTR* style_properties,
2528 BSTR* style_values,
2529 unsigned short *num_style_properties) {
2530 if (!instance_active())
2531 return E_FAIL;
2532
2533 if (!style_properties || !style_values)
2534 return E_INVALIDARG;
2535
2536 // We only cache a single style property for now: DISPLAY
2537
2538 base::string16 display;
2539 if (max_style_properties == 0 ||
2540 !GetString16Attribute(ui::AX_ATTR_DISPLAY, &display)) {
2541 *num_style_properties = 0;
2542 return S_OK;
2543 }
2544
2545 *num_style_properties = 1;
2546 style_properties[0] = SysAllocString(L"display");
2547 style_values[0] = SysAllocString(display.c_str());
2548
2549 return S_OK;
2550 }
2551
get_computedStyleForProperties(unsigned short num_style_properties,boolean use_alternate_view,BSTR * style_properties,BSTR * style_values)2552 STDMETHODIMP BrowserAccessibilityWin::get_computedStyleForProperties(
2553 unsigned short num_style_properties,
2554 boolean use_alternate_view,
2555 BSTR* style_properties,
2556 BSTR* style_values) {
2557 if (!instance_active())
2558 return E_FAIL;
2559
2560 if (!style_properties || !style_values)
2561 return E_INVALIDARG;
2562
2563 // We only cache a single style property for now: DISPLAY
2564
2565 for (unsigned short i = 0; i < num_style_properties; ++i) {
2566 base::string16 name = (LPCWSTR)style_properties[i];
2567 base::StringToLowerASCII(&name);
2568 if (name == L"display") {
2569 base::string16 display = GetString16Attribute(
2570 ui::AX_ATTR_DISPLAY);
2571 style_values[i] = SysAllocString(display.c_str());
2572 } else {
2573 style_values[i] = NULL;
2574 }
2575 }
2576
2577 return S_OK;
2578 }
2579
scrollTo(boolean placeTopLeft)2580 STDMETHODIMP BrowserAccessibilityWin::scrollTo(boolean placeTopLeft) {
2581 return scrollTo(placeTopLeft ?
2582 IA2_SCROLL_TYPE_TOP_LEFT : IA2_SCROLL_TYPE_ANYWHERE);
2583 }
2584
get_parentNode(ISimpleDOMNode ** node)2585 STDMETHODIMP BrowserAccessibilityWin::get_parentNode(ISimpleDOMNode** node) {
2586 if (!instance_active())
2587 return E_FAIL;
2588
2589 if (!node)
2590 return E_INVALIDARG;
2591
2592 *node = GetParent()->ToBrowserAccessibilityWin()->NewReference();
2593 return S_OK;
2594 }
2595
get_firstChild(ISimpleDOMNode ** node)2596 STDMETHODIMP BrowserAccessibilityWin::get_firstChild(ISimpleDOMNode** node) {
2597 if (!instance_active())
2598 return E_FAIL;
2599
2600 if (!node)
2601 return E_INVALIDARG;
2602
2603 if (PlatformChildCount() == 0) {
2604 *node = NULL;
2605 return S_FALSE;
2606 }
2607
2608 *node = PlatformGetChild(0)->ToBrowserAccessibilityWin()->NewReference();
2609 return S_OK;
2610 }
2611
get_lastChild(ISimpleDOMNode ** node)2612 STDMETHODIMP BrowserAccessibilityWin::get_lastChild(ISimpleDOMNode** node) {
2613 if (!instance_active())
2614 return E_FAIL;
2615
2616 if (!node)
2617 return E_INVALIDARG;
2618
2619 if (PlatformChildCount() == 0) {
2620 *node = NULL;
2621 return S_FALSE;
2622 }
2623
2624 *node = PlatformGetChild(PlatformChildCount() - 1)
2625 ->ToBrowserAccessibilityWin()->NewReference();
2626 return S_OK;
2627 }
2628
get_previousSibling(ISimpleDOMNode ** node)2629 STDMETHODIMP BrowserAccessibilityWin::get_previousSibling(
2630 ISimpleDOMNode** node) {
2631 if (!instance_active())
2632 return E_FAIL;
2633
2634 if (!node)
2635 return E_INVALIDARG;
2636
2637 if (!GetParent() || GetIndexInParent() <= 0) {
2638 *node = NULL;
2639 return S_FALSE;
2640 }
2641
2642 *node = GetParent()->InternalGetChild(GetIndexInParent() - 1)->
2643 ToBrowserAccessibilityWin()->NewReference();
2644 return S_OK;
2645 }
2646
get_nextSibling(ISimpleDOMNode ** node)2647 STDMETHODIMP BrowserAccessibilityWin::get_nextSibling(ISimpleDOMNode** node) {
2648 if (!instance_active())
2649 return E_FAIL;
2650
2651 if (!node)
2652 return E_INVALIDARG;
2653
2654 if (!GetParent() ||
2655 GetIndexInParent() < 0 ||
2656 GetIndexInParent() >= static_cast<int>(
2657 GetParent()->InternalChildCount()) - 1) {
2658 *node = NULL;
2659 return S_FALSE;
2660 }
2661
2662 *node = GetParent()->InternalGetChild(GetIndexInParent() + 1)->
2663 ToBrowserAccessibilityWin()->NewReference();
2664 return S_OK;
2665 }
2666
get_childAt(unsigned int child_index,ISimpleDOMNode ** node)2667 STDMETHODIMP BrowserAccessibilityWin::get_childAt(
2668 unsigned int child_index,
2669 ISimpleDOMNode** node) {
2670 if (!instance_active())
2671 return E_FAIL;
2672
2673 if (!node)
2674 return E_INVALIDARG;
2675
2676 if (child_index >= PlatformChildCount())
2677 return E_INVALIDARG;
2678
2679 BrowserAccessibility* child = PlatformGetChild(child_index);
2680 if (!child) {
2681 *node = NULL;
2682 return S_FALSE;
2683 }
2684
2685 *node = child->ToBrowserAccessibilityWin()->NewReference();
2686 return S_OK;
2687 }
2688
2689 //
2690 // ISimpleDOMText methods.
2691 //
2692
get_domText(BSTR * dom_text)2693 STDMETHODIMP BrowserAccessibilityWin::get_domText(BSTR* dom_text) {
2694 if (!instance_active())
2695 return E_FAIL;
2696
2697 if (!dom_text)
2698 return E_INVALIDARG;
2699
2700 return GetStringAttributeAsBstr(
2701 ui::AX_ATTR_NAME, dom_text);
2702 }
2703
get_clippedSubstringBounds(unsigned int start_index,unsigned int end_index,int * out_x,int * out_y,int * out_width,int * out_height)2704 STDMETHODIMP BrowserAccessibilityWin::get_clippedSubstringBounds(
2705 unsigned int start_index,
2706 unsigned int end_index,
2707 int* out_x,
2708 int* out_y,
2709 int* out_width,
2710 int* out_height) {
2711 // TODO(dmazzoni): fully support this API by intersecting the
2712 // rect with the container's rect.
2713 return get_unclippedSubstringBounds(
2714 start_index, end_index, out_x, out_y, out_width, out_height);
2715 }
2716
get_unclippedSubstringBounds(unsigned int start_index,unsigned int end_index,int * out_x,int * out_y,int * out_width,int * out_height)2717 STDMETHODIMP BrowserAccessibilityWin::get_unclippedSubstringBounds(
2718 unsigned int start_index,
2719 unsigned int end_index,
2720 int* out_x,
2721 int* out_y,
2722 int* out_width,
2723 int* out_height) {
2724 if (!instance_active())
2725 return E_FAIL;
2726
2727 if (!out_x || !out_y || !out_width || !out_height)
2728 return E_INVALIDARG;
2729
2730 const base::string16& text_str = TextForIAccessibleText();
2731 if (start_index > text_str.size() ||
2732 end_index > text_str.size() ||
2733 start_index > end_index) {
2734 return E_INVALIDARG;
2735 }
2736
2737 gfx::Rect bounds = GetGlobalBoundsForRange(
2738 start_index, end_index - start_index);
2739 *out_x = bounds.x();
2740 *out_y = bounds.y();
2741 *out_width = bounds.width();
2742 *out_height = bounds.height();
2743 return S_OK;
2744 }
2745
scrollToSubstring(unsigned int start_index,unsigned int end_index)2746 STDMETHODIMP BrowserAccessibilityWin::scrollToSubstring(
2747 unsigned int start_index,
2748 unsigned int end_index) {
2749 if (!instance_active())
2750 return E_FAIL;
2751
2752 const base::string16& text_str = TextForIAccessibleText();
2753 if (start_index > text_str.size() ||
2754 end_index > text_str.size() ||
2755 start_index > end_index) {
2756 return E_INVALIDARG;
2757 }
2758
2759 manager()->ScrollToMakeVisible(*this, GetLocalBoundsForRange(
2760 start_index, end_index - start_index));
2761 manager()->ToBrowserAccessibilityManagerWin()->TrackScrollingObject(this);
2762
2763 return S_OK;
2764 }
2765
2766 //
2767 // IServiceProvider methods.
2768 //
2769
QueryService(REFGUID guidService,REFIID riid,void ** object)2770 STDMETHODIMP BrowserAccessibilityWin::QueryService(REFGUID guidService,
2771 REFIID riid,
2772 void** object) {
2773 if (!instance_active())
2774 return E_FAIL;
2775
2776 // The system uses IAccessible APIs for many purposes, but only
2777 // assistive technology like screen readers uses IAccessible2.
2778 // Enable full accessibility support when IAccessible2 APIs are queried.
2779 if (riid == IID_IAccessible2)
2780 BrowserAccessibilityStateImpl::GetInstance()->EnableAccessibility();
2781
2782 if (guidService == GUID_IAccessibleContentDocument) {
2783 // Special Mozilla extension: return the accessible for the root document.
2784 // Screen readers use this to distinguish between a document loaded event
2785 // on the root document vs on an iframe.
2786 return manager()->GetRoot()->ToBrowserAccessibilityWin()->QueryInterface(
2787 IID_IAccessible2, object);
2788 }
2789
2790 if (guidService == IID_IAccessible ||
2791 guidService == IID_IAccessible2 ||
2792 guidService == IID_IAccessibleAction ||
2793 guidService == IID_IAccessibleApplication ||
2794 guidService == IID_IAccessibleHyperlink ||
2795 guidService == IID_IAccessibleHypertext ||
2796 guidService == IID_IAccessibleImage ||
2797 guidService == IID_IAccessibleTable ||
2798 guidService == IID_IAccessibleTable2 ||
2799 guidService == IID_IAccessibleTableCell ||
2800 guidService == IID_IAccessibleText ||
2801 guidService == IID_IAccessibleValue ||
2802 guidService == IID_ISimpleDOMDocument ||
2803 guidService == IID_ISimpleDOMNode ||
2804 guidService == IID_ISimpleDOMText ||
2805 guidService == GUID_ISimpleDOM) {
2806 return QueryInterface(riid, object);
2807 }
2808
2809 // We only support the IAccessibleEx interface on Windows 8 and above. This
2810 // is needed for the on-screen Keyboard to show up in metro mode, when the
2811 // user taps an editable portion on the page.
2812 // All methods in the IAccessibleEx interface are unimplemented.
2813 if (riid == IID_IAccessibleEx &&
2814 base::win::GetVersion() >= base::win::VERSION_WIN8) {
2815 return QueryInterface(riid, object);
2816 }
2817
2818 *object = NULL;
2819 return E_FAIL;
2820 }
2821
GetPatternProvider(PATTERNID id,IUnknown ** provider)2822 STDMETHODIMP BrowserAccessibilityWin::GetPatternProvider(PATTERNID id,
2823 IUnknown** provider) {
2824 DVLOG(1) << "In Function: "
2825 << __FUNCTION__
2826 << " for pattern id: "
2827 << id;
2828 if (id == UIA_ValuePatternId || id == UIA_TextPatternId) {
2829 if (IsEditableText()) {
2830 DVLOG(1) << "Returning UIA text provider";
2831 base::win::UIATextProvider::CreateTextProvider(
2832 GetValueText(), true, provider);
2833 return S_OK;
2834 }
2835 }
2836 return E_NOTIMPL;
2837 }
2838
GetPropertyValue(PROPERTYID id,VARIANT * ret)2839 STDMETHODIMP BrowserAccessibilityWin::GetPropertyValue(PROPERTYID id,
2840 VARIANT* ret) {
2841 DVLOG(1) << "In Function: "
2842 << __FUNCTION__
2843 << " for property id: "
2844 << id;
2845 V_VT(ret) = VT_EMPTY;
2846 if (id == UIA_ControlTypePropertyId) {
2847 if (IsEditableText()) {
2848 V_VT(ret) = VT_I4;
2849 ret->lVal = UIA_EditControlTypeId;
2850 DVLOG(1) << "Returning Edit control type";
2851 } else {
2852 DVLOG(1) << "Returning empty control type";
2853 }
2854 }
2855 return S_OK;
2856 }
2857
2858 //
2859 // CComObjectRootEx methods.
2860 //
2861
InternalQueryInterface(void * this_ptr,const _ATL_INTMAP_ENTRY * entries,REFIID iid,void ** object)2862 HRESULT WINAPI BrowserAccessibilityWin::InternalQueryInterface(
2863 void* this_ptr,
2864 const _ATL_INTMAP_ENTRY* entries,
2865 REFIID iid,
2866 void** object) {
2867 if (iid == IID_IAccessibleImage) {
2868 if (ia_role_ != ROLE_SYSTEM_GRAPHIC) {
2869 *object = NULL;
2870 return E_NOINTERFACE;
2871 }
2872 } else if (iid == IID_IAccessibleTable || iid == IID_IAccessibleTable2) {
2873 if (ia_role_ != ROLE_SYSTEM_TABLE) {
2874 *object = NULL;
2875 return E_NOINTERFACE;
2876 }
2877 } else if (iid == IID_IAccessibleTableCell) {
2878 if (ia_role_ != ROLE_SYSTEM_CELL) {
2879 *object = NULL;
2880 return E_NOINTERFACE;
2881 }
2882 } else if (iid == IID_IAccessibleValue) {
2883 if (ia_role_ != ROLE_SYSTEM_PROGRESSBAR &&
2884 ia_role_ != ROLE_SYSTEM_SCROLLBAR &&
2885 ia_role_ != ROLE_SYSTEM_SLIDER) {
2886 *object = NULL;
2887 return E_NOINTERFACE;
2888 }
2889 } else if (iid == IID_ISimpleDOMDocument) {
2890 if (ia_role_ != ROLE_SYSTEM_DOCUMENT) {
2891 *object = NULL;
2892 return E_NOINTERFACE;
2893 }
2894 }
2895
2896 return CComObjectRootBase::InternalQueryInterface(
2897 this_ptr, entries, iid, object);
2898 }
2899
2900 //
2901 // Private methods.
2902 //
2903
2904 // Called every time this node's data changes.
OnDataChanged()2905 void BrowserAccessibilityWin::OnDataChanged() {
2906 BrowserAccessibility::OnDataChanged();
2907
2908 InitRoleAndState();
2909
2910 // Expose the "display" and "tag" attributes.
2911 StringAttributeToIA2(ui::AX_ATTR_DISPLAY, "display");
2912 StringAttributeToIA2(ui::AX_ATTR_HTML_TAG, "tag");
2913 StringAttributeToIA2(ui::AX_ATTR_ROLE, "xml-roles");
2914
2915 // Expose "level" attribute for headings, trees, etc.
2916 IntAttributeToIA2(ui::AX_ATTR_HIERARCHICAL_LEVEL, "level");
2917
2918 // Expose the set size and position in set for listbox options.
2919 if (GetRole() == ui::AX_ROLE_LIST_BOX_OPTION &&
2920 GetParent() &&
2921 GetParent()->GetRole() == ui::AX_ROLE_LIST_BOX) {
2922 ia2_attributes_.push_back(
2923 L"setsize:" + base::IntToString16(GetParent()->PlatformChildCount()));
2924 ia2_attributes_.push_back(
2925 L"setsize:" + base::IntToString16(GetIndexInParent() + 1));
2926 }
2927
2928 if (ia_role_ == ROLE_SYSTEM_CHECKBUTTON ||
2929 ia_role_ == ROLE_SYSTEM_RADIOBUTTON ||
2930 ia2_role_ == IA2_ROLE_TOGGLE_BUTTON) {
2931 ia2_attributes_.push_back(L"checkable:true");
2932 }
2933
2934 // Expose live region attributes.
2935 StringAttributeToIA2(ui::AX_ATTR_LIVE_STATUS, "live");
2936 StringAttributeToIA2(ui::AX_ATTR_LIVE_RELEVANT, "relevant");
2937 BoolAttributeToIA2(ui::AX_ATTR_LIVE_ATOMIC, "atomic");
2938 BoolAttributeToIA2(ui::AX_ATTR_LIVE_BUSY, "busy");
2939
2940 // Expose container live region attributes.
2941 StringAttributeToIA2(ui::AX_ATTR_CONTAINER_LIVE_STATUS,
2942 "container-live");
2943 StringAttributeToIA2(ui::AX_ATTR_CONTAINER_LIVE_RELEVANT,
2944 "container-relevant");
2945 BoolAttributeToIA2(ui::AX_ATTR_CONTAINER_LIVE_ATOMIC,
2946 "container-atomic");
2947 BoolAttributeToIA2(ui::AX_ATTR_CONTAINER_LIVE_BUSY,
2948 "container-busy");
2949
2950 // Expose slider value.
2951 if (ia_role_ == ROLE_SYSTEM_PROGRESSBAR ||
2952 ia_role_ == ROLE_SYSTEM_SCROLLBAR ||
2953 ia_role_ == ROLE_SYSTEM_SLIDER) {
2954 ia2_attributes_.push_back(L"valuetext:" + GetValueText());
2955 }
2956
2957 // Expose table cell index.
2958 if (ia_role_ == ROLE_SYSTEM_CELL) {
2959 BrowserAccessibility* table = GetParent();
2960 while (table && table->GetRole() != ui::AX_ROLE_TABLE)
2961 table = table->GetParent();
2962 if (table) {
2963 const std::vector<int32>& unique_cell_ids = table->GetIntListAttribute(
2964 ui::AX_ATTR_UNIQUE_CELL_IDS);
2965 for (size_t i = 0; i < unique_cell_ids.size(); ++i) {
2966 if (unique_cell_ids[i] == GetId()) {
2967 ia2_attributes_.push_back(
2968 base::string16(L"table-cell-index:") + base::IntToString16(i));
2969 }
2970 }
2971 }
2972 }
2973
2974 // The calculation of the accessible name of an element has been
2975 // standardized in the HTML to Platform Accessibility APIs Implementation
2976 // Guide (http://www.w3.org/TR/html-aapi/). In order to return the
2977 // appropriate accessible name on Windows, we need to apply some logic
2978 // to the fields we get from WebKit.
2979 //
2980 // TODO(dmazzoni): move most of this logic into WebKit.
2981 //
2982 // WebKit gives us:
2983 //
2984 // name: the default name, e.g. inner text
2985 // title ui element: a reference to a <label> element on the same
2986 // page that labels this node.
2987 // description: accessible labels that override the default name:
2988 // aria-label or aria-labelledby or aria-describedby
2989 // help: the value of the "title" attribute
2990 //
2991 // On Windows, the logic we apply lets some fields take precedence and
2992 // always returns the primary name in "name" and the secondary name,
2993 // if any, in "description".
2994
2995 int title_elem_id = GetIntAttribute(
2996 ui::AX_ATTR_TITLE_UI_ELEMENT);
2997 std::string help = GetStringAttribute(ui::AX_ATTR_HELP);
2998 std::string description = GetStringAttribute(
2999 ui::AX_ATTR_DESCRIPTION);
3000
3001 // WebKit annoyingly puts the title in the description if there's no other
3002 // description, which just confuses the rest of the logic. Put it back.
3003 // Now "help" is always the value of the "title" attribute, if present.
3004 std::string title_attr;
3005 if (GetHtmlAttribute("title", &title_attr) &&
3006 description == title_attr &&
3007 help.empty()) {
3008 help = description;
3009 description.clear();
3010 }
3011
3012 // Now implement the main logic: the descripion should become the name if
3013 // it's nonempty, and the help should become the description if
3014 // there's no description - or the name if there's no name or description.
3015 if (!description.empty()) {
3016 set_name(description);
3017 description.clear();
3018 }
3019 if (!help.empty() && description.empty()) {
3020 description = help;
3021 help.clear();
3022 }
3023 if (!description.empty() && name().empty() && !title_elem_id) {
3024 set_name(description);
3025 description.clear();
3026 }
3027
3028 // If it's a text field, also consider the placeholder.
3029 std::string placeholder;
3030 if (GetRole() == ui::AX_ROLE_TEXT_FIELD &&
3031 HasState(ui::AX_STATE_FOCUSABLE) &&
3032 GetHtmlAttribute("placeholder", &placeholder)) {
3033 if (name().empty() && !title_elem_id) {
3034 set_name(placeholder);
3035 } else if (description.empty()) {
3036 description = placeholder;
3037 }
3038 }
3039
3040 SetStringAttribute(ui::AX_ATTR_DESCRIPTION, description);
3041 SetStringAttribute(ui::AX_ATTR_HELP, help);
3042
3043 // On Windows, the value of a document should be its url.
3044 if (GetRole() == ui::AX_ROLE_ROOT_WEB_AREA ||
3045 GetRole() == ui::AX_ROLE_WEB_AREA) {
3046 set_value(GetStringAttribute(ui::AX_ATTR_DOC_URL));
3047 }
3048
3049 // For certain roles (listbox option, static text, and list marker)
3050 // WebKit stores the main accessible text in the "value" - swap it so
3051 // that it's the "name".
3052 if (name().empty() &&
3053 (GetRole() == ui::AX_ROLE_LIST_BOX_OPTION ||
3054 GetRole() == ui::AX_ROLE_STATIC_TEXT ||
3055 GetRole() == ui::AX_ROLE_LIST_MARKER)) {
3056 std::string tmp = value();
3057 set_value(name());
3058 set_name(tmp);
3059 }
3060
3061 // If this doesn't have a value and is linked then set its value to the url
3062 // attribute. This allows screen readers to read an empty link's destination.
3063 if (value().empty() && (ia_state_ & STATE_SYSTEM_LINKED))
3064 set_value(GetStringAttribute(ui::AX_ATTR_URL));
3065
3066 // Clear any old relationships between this node and other nodes.
3067 for (size_t i = 0; i < relations_.size(); ++i)
3068 relations_[i]->Release();
3069 relations_.clear();
3070
3071 // Handle title UI element.
3072 if (title_elem_id) {
3073 // Add a labelled by relationship.
3074 CComObject<BrowserAccessibilityRelation>* relation;
3075 HRESULT hr = CComObject<BrowserAccessibilityRelation>::CreateInstance(
3076 &relation);
3077 DCHECK(SUCCEEDED(hr));
3078 relation->AddRef();
3079 relation->Initialize(this, IA2_RELATION_LABELLED_BY);
3080 relation->AddTarget(title_elem_id);
3081 relations_.push_back(relation);
3082 }
3083 }
3084
OnUpdateFinished()3085 void BrowserAccessibilityWin::OnUpdateFinished() {
3086 // Construct the hypertext for this node.
3087 hyperlink_offset_to_index_.clear();
3088 hyperlinks_.clear();
3089 hypertext_.clear();
3090 for (unsigned int i = 0; i < PlatformChildCount(); ++i) {
3091 BrowserAccessibility* child = PlatformGetChild(i);
3092 if (child->GetRole() == ui::AX_ROLE_STATIC_TEXT) {
3093 hypertext_ += base::UTF8ToUTF16(child->name());
3094 } else {
3095 hyperlink_offset_to_index_[hypertext_.size()] = hyperlinks_.size();
3096 hypertext_ += kEmbeddedCharacter;
3097 hyperlinks_.push_back(i);
3098 }
3099 }
3100 DCHECK_EQ(hyperlink_offset_to_index_.size(), hyperlinks_.size());
3101
3102 // Fire an event when an alert first appears.
3103 if (GetRole() == ui::AX_ROLE_ALERT && first_time_)
3104 manager()->NotifyAccessibilityEvent(ui::AX_EVENT_ALERT, this);
3105
3106 // Fire events if text has changed.
3107 base::string16 text = TextForIAccessibleText();
3108 if (previous_text_ != text) {
3109 if (!previous_text_.empty() && !text.empty()) {
3110 manager()->NotifyAccessibilityEvent(
3111 ui::AX_EVENT_SHOW, this);
3112 }
3113
3114 // TODO(dmazzoni): Look into HIDE events, too.
3115
3116 old_text_ = previous_text_;
3117 previous_text_ = text;
3118 }
3119
3120 BrowserAccessibilityManagerWin* manager =
3121 this->manager()->ToBrowserAccessibilityManagerWin();
3122
3123 // Fire events if the state has changed.
3124 if (!first_time_ && ia_state_ != old_ia_state_) {
3125 // Normally focus events are handled elsewhere, however
3126 // focus for managed descendants is platform-specific.
3127 // Fire a focus event if the focused descendant in a multi-select
3128 // list box changes.
3129 if (GetRole() == ui::AX_ROLE_LIST_BOX_OPTION &&
3130 (ia_state_ & STATE_SYSTEM_FOCUSABLE) &&
3131 (ia_state_ & STATE_SYSTEM_SELECTABLE) &&
3132 (ia_state_ & STATE_SYSTEM_FOCUSED) &&
3133 !(old_ia_state_ & STATE_SYSTEM_FOCUSED)) {
3134 manager->MaybeCallNotifyWinEvent(EVENT_OBJECT_FOCUS, unique_id_win());
3135 }
3136
3137 if ((ia_state_ & STATE_SYSTEM_SELECTED) &&
3138 !(old_ia_state_ & STATE_SYSTEM_SELECTED)) {
3139 manager->MaybeCallNotifyWinEvent(EVENT_OBJECT_SELECTIONADD,
3140 unique_id_win());
3141 } else if (!(ia_state_ & STATE_SYSTEM_SELECTED) &&
3142 (old_ia_state_ & STATE_SYSTEM_SELECTED)) {
3143 manager->MaybeCallNotifyWinEvent(EVENT_OBJECT_SELECTIONREMOVE,
3144 unique_id_win());
3145 }
3146
3147 old_ia_state_ = ia_state_;
3148 }
3149
3150 // Fire an event if this container object has scrolled.
3151 int sx = 0;
3152 int sy = 0;
3153 if (GetIntAttribute(ui::AX_ATTR_SCROLL_X, &sx) &&
3154 GetIntAttribute(ui::AX_ATTR_SCROLL_Y, &sy)) {
3155 if (!first_time_ &&
3156 (sx != previous_scroll_x_ || sy != previous_scroll_y_)) {
3157 manager->MaybeCallNotifyWinEvent(EVENT_SYSTEM_SCROLLINGEND,
3158 unique_id_win());
3159 }
3160 previous_scroll_x_ = sx;
3161 previous_scroll_y_ = sy;
3162 }
3163
3164 first_time_ = false;
3165 }
3166
NativeAddReference()3167 void BrowserAccessibilityWin::NativeAddReference() {
3168 AddRef();
3169 }
3170
NativeReleaseReference()3171 void BrowserAccessibilityWin::NativeReleaseReference() {
3172 Release();
3173 }
3174
IsNative() const3175 bool BrowserAccessibilityWin::IsNative() const {
3176 return true;
3177 }
3178
OnLocationChanged()3179 void BrowserAccessibilityWin::OnLocationChanged() {
3180 manager()->ToBrowserAccessibilityManagerWin()->MaybeCallNotifyWinEvent(
3181 EVENT_OBJECT_LOCATIONCHANGE, unique_id_win());
3182 }
3183
NewReference()3184 BrowserAccessibilityWin* BrowserAccessibilityWin::NewReference() {
3185 AddRef();
3186 return this;
3187 }
3188
GetTargetFromChildID(const VARIANT & var_id)3189 BrowserAccessibilityWin* BrowserAccessibilityWin::GetTargetFromChildID(
3190 const VARIANT& var_id) {
3191 if (var_id.vt != VT_I4)
3192 return NULL;
3193
3194 LONG child_id = var_id.lVal;
3195 if (child_id == CHILDID_SELF)
3196 return this;
3197
3198 if (child_id >= 1 && child_id <= static_cast<LONG>(PlatformChildCount()))
3199 return PlatformGetChild(child_id - 1)->ToBrowserAccessibilityWin();
3200
3201 return manager()->ToBrowserAccessibilityManagerWin()->
3202 GetFromUniqueIdWin(child_id);
3203 }
3204
GetStringAttributeAsBstr(ui::AXStringAttribute attribute,BSTR * value_bstr)3205 HRESULT BrowserAccessibilityWin::GetStringAttributeAsBstr(
3206 ui::AXStringAttribute attribute,
3207 BSTR* value_bstr) {
3208 base::string16 str;
3209
3210 if (!GetString16Attribute(attribute, &str))
3211 return S_FALSE;
3212
3213 if (str.empty())
3214 return S_FALSE;
3215
3216 *value_bstr = SysAllocString(str.c_str());
3217 DCHECK(*value_bstr);
3218
3219 return S_OK;
3220 }
3221
StringAttributeToIA2(ui::AXStringAttribute attribute,const char * ia2_attr)3222 void BrowserAccessibilityWin::StringAttributeToIA2(
3223 ui::AXStringAttribute attribute,
3224 const char* ia2_attr) {
3225 base::string16 value;
3226 if (GetString16Attribute(attribute, &value))
3227 ia2_attributes_.push_back(base::ASCIIToUTF16(ia2_attr) + L":" + value);
3228 }
3229
BoolAttributeToIA2(ui::AXBoolAttribute attribute,const char * ia2_attr)3230 void BrowserAccessibilityWin::BoolAttributeToIA2(
3231 ui::AXBoolAttribute attribute,
3232 const char* ia2_attr) {
3233 bool value;
3234 if (GetBoolAttribute(attribute, &value)) {
3235 ia2_attributes_.push_back((base::ASCIIToUTF16(ia2_attr) + L":") +
3236 (value ? L"true" : L"false"));
3237 }
3238 }
3239
IntAttributeToIA2(ui::AXIntAttribute attribute,const char * ia2_attr)3240 void BrowserAccessibilityWin::IntAttributeToIA2(
3241 ui::AXIntAttribute attribute,
3242 const char* ia2_attr) {
3243 int value;
3244 if (GetIntAttribute(attribute, &value)) {
3245 ia2_attributes_.push_back(base::ASCIIToUTF16(ia2_attr) + L":" +
3246 base::IntToString16(value));
3247 }
3248 }
3249
GetValueText()3250 base::string16 BrowserAccessibilityWin::GetValueText() {
3251 float fval;
3252 base::string16 value = base::UTF8ToUTF16(this->value());
3253
3254 if (value.empty() &&
3255 GetFloatAttribute(ui::AX_ATTR_VALUE_FOR_RANGE, &fval)) {
3256 value = base::UTF8ToUTF16(base::DoubleToString(fval));
3257 }
3258 return value;
3259 }
3260
TextForIAccessibleText()3261 base::string16 BrowserAccessibilityWin::TextForIAccessibleText() {
3262 if (IsEditableText())
3263 return base::UTF8ToUTF16(value());
3264 return (GetRole() == ui::AX_ROLE_STATIC_TEXT) ?
3265 base::UTF8ToUTF16(name()) : hypertext_;
3266 }
3267
HandleSpecialTextOffset(const base::string16 & text,LONG * offset)3268 void BrowserAccessibilityWin::HandleSpecialTextOffset(
3269 const base::string16& text,
3270 LONG* offset) {
3271 if (*offset == IA2_TEXT_OFFSET_LENGTH)
3272 *offset = static_cast<LONG>(text.size());
3273 else if (*offset == IA2_TEXT_OFFSET_CARET)
3274 get_caretOffset(offset);
3275 }
3276
IA2TextBoundaryToTextBoundary(IA2TextBoundaryType ia2_boundary)3277 ui::TextBoundaryType BrowserAccessibilityWin::IA2TextBoundaryToTextBoundary(
3278 IA2TextBoundaryType ia2_boundary) {
3279 switch(ia2_boundary) {
3280 case IA2_TEXT_BOUNDARY_CHAR: return ui::CHAR_BOUNDARY;
3281 case IA2_TEXT_BOUNDARY_WORD: return ui::WORD_BOUNDARY;
3282 case IA2_TEXT_BOUNDARY_LINE: return ui::LINE_BOUNDARY;
3283 case IA2_TEXT_BOUNDARY_SENTENCE: return ui::SENTENCE_BOUNDARY;
3284 case IA2_TEXT_BOUNDARY_PARAGRAPH: return ui::PARAGRAPH_BOUNDARY;
3285 case IA2_TEXT_BOUNDARY_ALL: return ui::ALL_BOUNDARY;
3286 default:
3287 NOTREACHED();
3288 return ui::CHAR_BOUNDARY;
3289 }
3290 }
3291
FindBoundary(const base::string16 & text,IA2TextBoundaryType ia2_boundary,LONG start_offset,ui::TextBoundaryDirection direction)3292 LONG BrowserAccessibilityWin::FindBoundary(
3293 const base::string16& text,
3294 IA2TextBoundaryType ia2_boundary,
3295 LONG start_offset,
3296 ui::TextBoundaryDirection direction) {
3297 HandleSpecialTextOffset(text, &start_offset);
3298 ui::TextBoundaryType boundary = IA2TextBoundaryToTextBoundary(ia2_boundary);
3299 const std::vector<int32>& line_breaks = GetIntListAttribute(
3300 ui::AX_ATTR_LINE_BREAKS);
3301 return ui::FindAccessibleTextBoundary(
3302 text, line_breaks, boundary, start_offset, direction);
3303 }
3304
GetFromID(int32 id)3305 BrowserAccessibilityWin* BrowserAccessibilityWin::GetFromID(int32 id) {
3306 return manager()->GetFromID(id)->ToBrowserAccessibilityWin();
3307 }
3308
InitRoleAndState()3309 void BrowserAccessibilityWin::InitRoleAndState() {
3310 ia_state_ = 0;
3311 ia2_state_ = IA2_STATE_OPAQUE;
3312 ia2_attributes_.clear();
3313
3314 if (HasState(ui::AX_STATE_BUSY))
3315 ia_state_ |= STATE_SYSTEM_BUSY;
3316 if (HasState(ui::AX_STATE_CHECKED))
3317 ia_state_ |= STATE_SYSTEM_CHECKED;
3318 if (HasState(ui::AX_STATE_COLLAPSED))
3319 ia_state_ |= STATE_SYSTEM_COLLAPSED;
3320 if (HasState(ui::AX_STATE_EXPANDED))
3321 ia_state_ |= STATE_SYSTEM_EXPANDED;
3322 if (HasState(ui::AX_STATE_FOCUSABLE))
3323 ia_state_ |= STATE_SYSTEM_FOCUSABLE;
3324 if (HasState(ui::AX_STATE_HASPOPUP))
3325 ia_state_ |= STATE_SYSTEM_HASPOPUP;
3326 if (HasState(ui::AX_STATE_HOVERED))
3327 ia_state_ |= STATE_SYSTEM_HOTTRACKED;
3328 if (HasState(ui::AX_STATE_INDETERMINATE))
3329 ia_state_ |= STATE_SYSTEM_INDETERMINATE;
3330 if (HasState(ui::AX_STATE_INVISIBLE))
3331 ia_state_ |= STATE_SYSTEM_INVISIBLE;
3332 if (HasState(ui::AX_STATE_LINKED))
3333 ia_state_ |= STATE_SYSTEM_LINKED;
3334 if (HasState(ui::AX_STATE_MULTISELECTABLE)) {
3335 ia_state_ |= STATE_SYSTEM_EXTSELECTABLE;
3336 ia_state_ |= STATE_SYSTEM_MULTISELECTABLE;
3337 }
3338 // TODO(ctguil): Support STATE_SYSTEM_EXTSELECTABLE/accSelect.
3339 if (HasState(ui::AX_STATE_OFFSCREEN))
3340 ia_state_ |= STATE_SYSTEM_OFFSCREEN;
3341 if (HasState(ui::AX_STATE_PRESSED))
3342 ia_state_ |= STATE_SYSTEM_PRESSED;
3343 if (HasState(ui::AX_STATE_PROTECTED))
3344 ia_state_ |= STATE_SYSTEM_PROTECTED;
3345 if (HasState(ui::AX_STATE_REQUIRED))
3346 ia2_state_ |= IA2_STATE_REQUIRED;
3347 if (HasState(ui::AX_STATE_SELECTABLE))
3348 ia_state_ |= STATE_SYSTEM_SELECTABLE;
3349 if (HasState(ui::AX_STATE_SELECTED))
3350 ia_state_ |= STATE_SYSTEM_SELECTED;
3351 if (HasState(ui::AX_STATE_VISITED))
3352 ia_state_ |= STATE_SYSTEM_TRAVERSED;
3353 if (!HasState(ui::AX_STATE_ENABLED))
3354 ia_state_ |= STATE_SYSTEM_UNAVAILABLE;
3355 if (HasState(ui::AX_STATE_VERTICAL)) {
3356 ia2_state_ |= IA2_STATE_VERTICAL;
3357 } else {
3358 ia2_state_ |= IA2_STATE_HORIZONTAL;
3359 }
3360 if (HasState(ui::AX_STATE_VISITED))
3361 ia_state_ |= STATE_SYSTEM_TRAVERSED;
3362
3363 // WebKit marks everything as readonly unless it's editable text, so if it's
3364 // not readonly, mark it as editable now. The final computation of the
3365 // READONLY state for MSAA is below, after the switch.
3366 if (!HasState(ui::AX_STATE_READ_ONLY))
3367 ia2_state_ |= IA2_STATE_EDITABLE;
3368
3369 base::string16 invalid;
3370 if (GetHtmlAttribute("aria-invalid", &invalid))
3371 ia2_state_ |= IA2_STATE_INVALID_ENTRY;
3372
3373 if (GetBoolAttribute(ui::AX_ATTR_BUTTON_MIXED))
3374 ia_state_ |= STATE_SYSTEM_MIXED;
3375
3376 if (GetBoolAttribute(ui::AX_ATTR_CAN_SET_VALUE))
3377 ia2_state_ |= IA2_STATE_EDITABLE;
3378
3379 base::string16 html_tag = GetString16Attribute(
3380 ui::AX_ATTR_HTML_TAG);
3381 ia_role_ = 0;
3382 ia2_role_ = 0;
3383 switch (GetRole()) {
3384 case ui::AX_ROLE_ALERT:
3385 ia_role_ = ROLE_SYSTEM_ALERT;
3386 break;
3387 case ui::AX_ROLE_ALERT_DIALOG:
3388 ia_role_ = ROLE_SYSTEM_DIALOG;
3389 break;
3390 case ui::AX_ROLE_APPLICATION:
3391 ia_role_ = ROLE_SYSTEM_APPLICATION;
3392 break;
3393 case ui::AX_ROLE_ARTICLE:
3394 ia_role_ = ROLE_SYSTEM_DOCUMENT;
3395 ia_state_ |= STATE_SYSTEM_READONLY;
3396 break;
3397 case ui::AX_ROLE_BUSY_INDICATOR:
3398 ia_role_ = ROLE_SYSTEM_ANIMATION;
3399 ia_state_ |= STATE_SYSTEM_READONLY;
3400 break;
3401 case ui::AX_ROLE_BUTTON:
3402 ia_role_ = ROLE_SYSTEM_PUSHBUTTON;
3403 bool is_aria_pressed_defined;
3404 bool is_mixed;
3405 if (GetAriaTristate("aria-pressed", &is_aria_pressed_defined, &is_mixed))
3406 ia_state_ |= STATE_SYSTEM_PRESSED;
3407 if (is_aria_pressed_defined)
3408 ia2_role_ = IA2_ROLE_TOGGLE_BUTTON;
3409 if (is_mixed)
3410 ia_state_ |= STATE_SYSTEM_MIXED;
3411 break;
3412 case ui::AX_ROLE_CANVAS:
3413 if (GetBoolAttribute(ui::AX_ATTR_CANVAS_HAS_FALLBACK)) {
3414 role_name_ = L"canvas";
3415 ia2_role_ = IA2_ROLE_CANVAS;
3416 } else {
3417 ia_role_ = ROLE_SYSTEM_GRAPHIC;
3418 }
3419 break;
3420 case ui::AX_ROLE_CELL:
3421 ia_role_ = ROLE_SYSTEM_CELL;
3422 break;
3423 case ui::AX_ROLE_CHECK_BOX:
3424 ia_role_ = ROLE_SYSTEM_CHECKBUTTON;
3425 break;
3426 case ui::AX_ROLE_COLOR_WELL:
3427 ia_role_ = ROLE_SYSTEM_CLIENT;
3428 ia2_role_ = IA2_ROLE_COLOR_CHOOSER;
3429 break;
3430 case ui::AX_ROLE_COLUMN:
3431 ia_role_ = ROLE_SYSTEM_COLUMN;
3432 ia_state_ |= STATE_SYSTEM_READONLY;
3433 break;
3434 case ui::AX_ROLE_COLUMN_HEADER:
3435 ia_role_ = ROLE_SYSTEM_COLUMNHEADER;
3436 ia_state_ |= STATE_SYSTEM_READONLY;
3437 break;
3438 case ui::AX_ROLE_COMBO_BOX:
3439 ia_role_ = ROLE_SYSTEM_COMBOBOX;
3440 break;
3441 case ui::AX_ROLE_DIV:
3442 role_name_ = L"div";
3443 ia2_role_ = IA2_ROLE_SECTION;
3444 break;
3445 case ui::AX_ROLE_DEFINITION:
3446 role_name_ = html_tag;
3447 ia2_role_ = IA2_ROLE_PARAGRAPH;
3448 ia_state_ |= STATE_SYSTEM_READONLY;
3449 break;
3450 case ui::AX_ROLE_DESCRIPTION_LIST_DETAIL:
3451 role_name_ = html_tag;
3452 ia2_role_ = IA2_ROLE_PARAGRAPH;
3453 ia_state_ |= STATE_SYSTEM_READONLY;
3454 break;
3455 case ui::AX_ROLE_DESCRIPTION_LIST_TERM:
3456 ia_role_ = ROLE_SYSTEM_LISTITEM;
3457 ia_state_ |= STATE_SYSTEM_READONLY;
3458 break;
3459 case ui::AX_ROLE_DIALOG:
3460 ia_role_ = ROLE_SYSTEM_DIALOG;
3461 ia_state_ |= STATE_SYSTEM_READONLY;
3462 break;
3463 case ui::AX_ROLE_DISCLOSURE_TRIANGLE:
3464 ia_role_ = ROLE_SYSTEM_OUTLINEBUTTON;
3465 ia_state_ |= STATE_SYSTEM_READONLY;
3466 break;
3467 case ui::AX_ROLE_DOCUMENT:
3468 case ui::AX_ROLE_ROOT_WEB_AREA:
3469 case ui::AX_ROLE_WEB_AREA:
3470 ia_role_ = ROLE_SYSTEM_DOCUMENT;
3471 ia_state_ |= STATE_SYSTEM_READONLY;
3472 ia_state_ |= STATE_SYSTEM_FOCUSABLE;
3473 break;
3474 case ui::AX_ROLE_EDITABLE_TEXT:
3475 ia_role_ = ROLE_SYSTEM_TEXT;
3476 ia2_state_ |= IA2_STATE_SINGLE_LINE;
3477 ia2_state_ |= IA2_STATE_EDITABLE;
3478 break;
3479 case ui::AX_ROLE_FIGCAPTION:
3480 role_name_ = html_tag;
3481 ia2_role_ = IA2_ROLE_CAPTION;
3482 break;
3483 case ui::AX_ROLE_FIGURE:
3484 role_name_ = html_tag;
3485 ia_role_ = ROLE_SYSTEM_GROUPING;
3486 ia2_role_ = IA2_ROLE_SECTION;
3487 break;
3488 case ui::AX_ROLE_FORM:
3489 role_name_ = L"form";
3490 ia2_role_ = IA2_ROLE_FORM;
3491 break;
3492 case ui::AX_ROLE_FOOTER:
3493 ia_role_ = IA2_ROLE_FOOTER;
3494 ia_state_ |= STATE_SYSTEM_READONLY;
3495 break;
3496 case ui::AX_ROLE_GRID:
3497 ia_role_ = ROLE_SYSTEM_TABLE;
3498 ia_state_ |= STATE_SYSTEM_READONLY;
3499 break;
3500 case ui::AX_ROLE_GROUP: {
3501 base::string16 aria_role = GetString16Attribute(
3502 ui::AX_ATTR_ROLE);
3503 if (aria_role == L"group" || html_tag == L"fieldset") {
3504 ia_role_ = ROLE_SYSTEM_GROUPING;
3505 } else if (html_tag == L"li") {
3506 ia_role_ = ROLE_SYSTEM_LISTITEM;
3507 } else {
3508 if (html_tag.empty())
3509 role_name_ = L"div";
3510 else
3511 role_name_ = html_tag;
3512 ia2_role_ = IA2_ROLE_SECTION;
3513 }
3514 ia_state_ |= STATE_SYSTEM_READONLY;
3515 break;
3516 }
3517 case ui::AX_ROLE_GROW_AREA:
3518 ia_role_ = ROLE_SYSTEM_GRIP;
3519 ia_state_ |= STATE_SYSTEM_READONLY;
3520 break;
3521 case ui::AX_ROLE_HEADING:
3522 role_name_ = html_tag;
3523 ia2_role_ = IA2_ROLE_HEADING;
3524 ia_state_ |= STATE_SYSTEM_READONLY;
3525 break;
3526 case ui::AX_ROLE_HORIZONTAL_RULE:
3527 ia_role_ = ROLE_SYSTEM_SEPARATOR;
3528 break;
3529 case ui::AX_ROLE_IFRAME:
3530 ia_role_ = ROLE_SYSTEM_CLIENT;
3531 ia2_role_ = IA2_ROLE_INTERNAL_FRAME;
3532 break;
3533 case ui::AX_ROLE_IMAGE:
3534 ia_role_ = ROLE_SYSTEM_GRAPHIC;
3535 ia_state_ |= STATE_SYSTEM_READONLY;
3536 break;
3537 case ui::AX_ROLE_IMAGE_MAP:
3538 role_name_ = html_tag;
3539 ia2_role_ = IA2_ROLE_IMAGE_MAP;
3540 ia_state_ |= STATE_SYSTEM_READONLY;
3541 break;
3542 case ui::AX_ROLE_IMAGE_MAP_LINK:
3543 ia_role_ = ROLE_SYSTEM_LINK;
3544 ia_state_ |= STATE_SYSTEM_LINKED;
3545 ia_state_ |= STATE_SYSTEM_READONLY;
3546 break;
3547 case ui::AX_ROLE_LABEL_TEXT:
3548 ia_role_ = ROLE_SYSTEM_TEXT;
3549 ia2_role_ = IA2_ROLE_LABEL;
3550 break;
3551 case ui::AX_ROLE_MAIN:
3552 ia_role_ = ROLE_SYSTEM_GROUPING;
3553 break;
3554 case ui::AX_ROLE_BANNER:
3555 case ui::AX_ROLE_COMPLEMENTARY:
3556 case ui::AX_ROLE_CONTENT_INFO:
3557 case ui::AX_ROLE_NAVIGATION:
3558 case ui::AX_ROLE_SEARCH:
3559 ia_role_ = ROLE_SYSTEM_GROUPING;
3560 ia2_role_ = IA2_ROLE_SECTION;
3561 ia_state_ |= STATE_SYSTEM_READONLY;
3562 break;
3563 case ui::AX_ROLE_LINK:
3564 ia_role_ = ROLE_SYSTEM_LINK;
3565 ia_state_ |= STATE_SYSTEM_LINKED;
3566 break;
3567 case ui::AX_ROLE_LIST:
3568 ia_role_ = ROLE_SYSTEM_LIST;
3569 ia_state_ |= STATE_SYSTEM_READONLY;
3570 break;
3571 case ui::AX_ROLE_LIST_BOX:
3572 ia_role_ = ROLE_SYSTEM_LIST;
3573 break;
3574 case ui::AX_ROLE_LIST_BOX_OPTION:
3575 ia_role_ = ROLE_SYSTEM_LISTITEM;
3576 if (ia_state_ & STATE_SYSTEM_SELECTABLE) {
3577 ia_state_ |= STATE_SYSTEM_FOCUSABLE;
3578 if (HasState(ui::AX_STATE_FOCUSED))
3579 ia_state_ |= STATE_SYSTEM_FOCUSED;
3580 }
3581 break;
3582 case ui::AX_ROLE_LIST_ITEM:
3583 ia_role_ = ROLE_SYSTEM_LISTITEM;
3584 ia_state_ |= STATE_SYSTEM_READONLY;
3585 break;
3586 case ui::AX_ROLE_MATH_ELEMENT:
3587 ia_role_ = ROLE_SYSTEM_EQUATION;
3588 ia_state_ |= STATE_SYSTEM_READONLY;
3589 break;
3590 case ui::AX_ROLE_MENU:
3591 case ui::AX_ROLE_MENU_BUTTON:
3592 ia_role_ = ROLE_SYSTEM_MENUPOPUP;
3593 break;
3594 case ui::AX_ROLE_MENU_BAR:
3595 ia_role_ = ROLE_SYSTEM_MENUBAR;
3596 break;
3597 case ui::AX_ROLE_MENU_ITEM:
3598 ia_role_ = ROLE_SYSTEM_MENUITEM;
3599 break;
3600 case ui::AX_ROLE_MENU_LIST_POPUP:
3601 ia_role_ = ROLE_SYSTEM_CLIENT;
3602 break;
3603 case ui::AX_ROLE_MENU_LIST_OPTION:
3604 ia_role_ = ROLE_SYSTEM_LISTITEM;
3605 if (ia_state_ & STATE_SYSTEM_SELECTABLE) {
3606 ia_state_ |= STATE_SYSTEM_FOCUSABLE;
3607 if (HasState(ui::AX_STATE_FOCUSED))
3608 ia_state_ |= STATE_SYSTEM_FOCUSED;
3609 }
3610 break;
3611 case ui::AX_ROLE_NOTE:
3612 ia_role_ = ROLE_SYSTEM_GROUPING;
3613 ia2_role_ = IA2_ROLE_NOTE;
3614 ia_state_ |= STATE_SYSTEM_READONLY;
3615 break;
3616 case ui::AX_ROLE_OUTLINE:
3617 ia_role_ = ROLE_SYSTEM_OUTLINE;
3618 ia_state_ |= STATE_SYSTEM_READONLY;
3619 break;
3620 case ui::AX_ROLE_PARAGRAPH:
3621 role_name_ = L"P";
3622 ia2_role_ = IA2_ROLE_PARAGRAPH;
3623 break;
3624 case ui::AX_ROLE_POP_UP_BUTTON:
3625 if (html_tag == L"select") {
3626 ia_role_ = ROLE_SYSTEM_COMBOBOX;
3627 } else {
3628 ia_role_ = ROLE_SYSTEM_BUTTONMENU;
3629 }
3630 break;
3631 case ui::AX_ROLE_PROGRESS_INDICATOR:
3632 ia_role_ = ROLE_SYSTEM_PROGRESSBAR;
3633 ia_state_ |= STATE_SYSTEM_READONLY;
3634 break;
3635 case ui::AX_ROLE_RADIO_BUTTON:
3636 ia_role_ = ROLE_SYSTEM_RADIOBUTTON;
3637 break;
3638 case ui::AX_ROLE_RADIO_GROUP:
3639 ia_role_ = ROLE_SYSTEM_GROUPING;
3640 ia2_role_ = IA2_ROLE_SECTION;
3641 break;
3642 case ui::AX_ROLE_REGION:
3643 ia_role_ = ROLE_SYSTEM_GROUPING;
3644 ia2_role_ = IA2_ROLE_SECTION;
3645 ia_state_ |= STATE_SYSTEM_READONLY;
3646 break;
3647 case ui::AX_ROLE_ROW:
3648 ia_role_ = ROLE_SYSTEM_ROW;
3649 ia_state_ |= STATE_SYSTEM_READONLY;
3650 break;
3651 case ui::AX_ROLE_ROW_HEADER:
3652 ia_role_ = ROLE_SYSTEM_ROWHEADER;
3653 ia_state_ |= STATE_SYSTEM_READONLY;
3654 break;
3655 case ui::AX_ROLE_RULER:
3656 ia_role_ = ROLE_SYSTEM_CLIENT;
3657 ia2_role_ = IA2_ROLE_RULER;
3658 ia_state_ |= STATE_SYSTEM_READONLY;
3659 break;
3660 case ui::AX_ROLE_SCROLL_AREA:
3661 ia_role_ = ROLE_SYSTEM_CLIENT;
3662 ia2_role_ = IA2_ROLE_SCROLL_PANE;
3663 ia_state_ |= STATE_SYSTEM_READONLY;
3664 ia2_state_ &= ~(IA2_STATE_EDITABLE);
3665 break;
3666 case ui::AX_ROLE_SCROLL_BAR:
3667 ia_role_ = ROLE_SYSTEM_SCROLLBAR;
3668 break;
3669 case ui::AX_ROLE_SLIDER:
3670 ia_role_ = ROLE_SYSTEM_SLIDER;
3671 break;
3672 case ui::AX_ROLE_SPIN_BUTTON:
3673 ia_role_ = ROLE_SYSTEM_SPINBUTTON;
3674 break;
3675 case ui::AX_ROLE_SPIN_BUTTON_PART:
3676 ia_role_ = ROLE_SYSTEM_PUSHBUTTON;
3677 break;
3678 case ui::AX_ROLE_SPLIT_GROUP:
3679 ia_role_ = ROLE_SYSTEM_CLIENT;
3680 ia2_role_ = IA2_ROLE_SPLIT_PANE;
3681 ia_state_ |= STATE_SYSTEM_READONLY;
3682 break;
3683 case ui::AX_ROLE_ANNOTATION:
3684 case ui::AX_ROLE_LIST_MARKER:
3685 case ui::AX_ROLE_STATIC_TEXT:
3686 ia_role_ = ROLE_SYSTEM_STATICTEXT;
3687 break;
3688 case ui::AX_ROLE_STATUS:
3689 ia_role_ = ROLE_SYSTEM_STATUSBAR;
3690 ia_state_ |= STATE_SYSTEM_READONLY;
3691 break;
3692 case ui::AX_ROLE_SPLITTER:
3693 ia_role_ = ROLE_SYSTEM_SEPARATOR;
3694 break;
3695 case ui::AX_ROLE_SVG_ROOT:
3696 ia_role_ = ROLE_SYSTEM_GRAPHIC;
3697 break;
3698 case ui::AX_ROLE_TAB:
3699 ia_role_ = ROLE_SYSTEM_PAGETAB;
3700 break;
3701 case ui::AX_ROLE_TABLE: {
3702 base::string16 aria_role = GetString16Attribute(
3703 ui::AX_ATTR_ROLE);
3704 if (aria_role == L"treegrid") {
3705 ia_role_ = ROLE_SYSTEM_OUTLINE;
3706 } else {
3707 ia_role_ = ROLE_SYSTEM_TABLE;
3708 ia_state_ |= STATE_SYSTEM_READONLY;
3709 }
3710 break;
3711 }
3712 case ui::AX_ROLE_TABLE_HEADER_CONTAINER:
3713 ia_role_ = ROLE_SYSTEM_GROUPING;
3714 ia2_role_ = IA2_ROLE_SECTION;
3715 ia_state_ |= STATE_SYSTEM_READONLY;
3716 break;
3717 case ui::AX_ROLE_TAB_LIST:
3718 ia_role_ = ROLE_SYSTEM_PAGETABLIST;
3719 break;
3720 case ui::AX_ROLE_TAB_PANEL:
3721 ia_role_ = ROLE_SYSTEM_PROPERTYPAGE;
3722 break;
3723 case ui::AX_ROLE_TOGGLE_BUTTON:
3724 ia_role_ = ROLE_SYSTEM_PUSHBUTTON;
3725 ia2_role_ = IA2_ROLE_TOGGLE_BUTTON;
3726 break;
3727 case ui::AX_ROLE_TEXT_AREA:
3728 ia_role_ = ROLE_SYSTEM_TEXT;
3729 ia2_state_ |= IA2_STATE_MULTI_LINE;
3730 ia2_state_ |= IA2_STATE_EDITABLE;
3731 ia2_state_ |= IA2_STATE_SELECTABLE_TEXT;
3732 break;
3733 case ui::AX_ROLE_TEXT_FIELD:
3734 ia_role_ = ROLE_SYSTEM_TEXT;
3735 ia2_state_ |= IA2_STATE_SINGLE_LINE;
3736 ia2_state_ |= IA2_STATE_EDITABLE;
3737 ia2_state_ |= IA2_STATE_SELECTABLE_TEXT;
3738 break;
3739 case ui::AX_ROLE_TIMER:
3740 ia_role_ = ROLE_SYSTEM_CLOCK;
3741 ia_state_ |= STATE_SYSTEM_READONLY;
3742 break;
3743 case ui::AX_ROLE_TOOLBAR:
3744 ia_role_ = ROLE_SYSTEM_TOOLBAR;
3745 ia_state_ |= STATE_SYSTEM_READONLY;
3746 break;
3747 case ui::AX_ROLE_TOOLTIP:
3748 ia_role_ = ROLE_SYSTEM_TOOLTIP;
3749 ia_state_ |= STATE_SYSTEM_READONLY;
3750 break;
3751 case ui::AX_ROLE_TREE:
3752 ia_role_ = ROLE_SYSTEM_OUTLINE;
3753 ia_state_ |= STATE_SYSTEM_READONLY;
3754 break;
3755 case ui::AX_ROLE_TREE_GRID:
3756 ia_role_ = ROLE_SYSTEM_OUTLINE;
3757 ia_state_ |= STATE_SYSTEM_READONLY;
3758 break;
3759 case ui::AX_ROLE_TREE_ITEM:
3760 ia_role_ = ROLE_SYSTEM_OUTLINEITEM;
3761 ia_state_ |= STATE_SYSTEM_READONLY;
3762 break;
3763 case ui::AX_ROLE_WINDOW:
3764 ia_role_ = ROLE_SYSTEM_WINDOW;
3765 break;
3766
3767 // TODO(dmazzoni): figure out the proper MSAA role for all of these.
3768 case ui::AX_ROLE_BROWSER:
3769 case ui::AX_ROLE_DIRECTORY:
3770 case ui::AX_ROLE_DRAWER:
3771 case ui::AX_ROLE_HELP_TAG:
3772 case ui::AX_ROLE_IGNORED:
3773 case ui::AX_ROLE_INCREMENTOR:
3774 case ui::AX_ROLE_LOG:
3775 case ui::AX_ROLE_MARQUEE:
3776 case ui::AX_ROLE_MATTE:
3777 case ui::AX_ROLE_NONE:
3778 case ui::AX_ROLE_PRESENTATIONAL:
3779 case ui::AX_ROLE_RULER_MARKER:
3780 case ui::AX_ROLE_SHEET:
3781 case ui::AX_ROLE_SLIDER_THUMB:
3782 case ui::AX_ROLE_SYSTEM_WIDE:
3783 case ui::AX_ROLE_VALUE_INDICATOR:
3784 default:
3785 ia_role_ = ROLE_SYSTEM_CLIENT;
3786 break;
3787 }
3788
3789 // Compute the final value of READONLY for MSAA.
3790 //
3791 // We always set the READONLY state for elements that have the
3792 // aria-readonly attribute and for a few roles (in the switch above).
3793 // We clear the READONLY state on focusable controls and on a document.
3794 // Everything else, the majority of objects, do not have this state set.
3795 if (HasState(ui::AX_STATE_FOCUSABLE) &&
3796 ia_role_ != ROLE_SYSTEM_DOCUMENT) {
3797 ia_state_ &= ~(STATE_SYSTEM_READONLY);
3798 }
3799 if (!HasState(ui::AX_STATE_READ_ONLY))
3800 ia_state_ &= ~(STATE_SYSTEM_READONLY);
3801 if (GetBoolAttribute(ui::AX_ATTR_ARIA_READONLY))
3802 ia_state_ |= STATE_SYSTEM_READONLY;
3803
3804 // The role should always be set.
3805 DCHECK(!role_name_.empty() || ia_role_);
3806
3807 // If we didn't explicitly set the IAccessible2 role, make it the same
3808 // as the MSAA role.
3809 if (!ia2_role_)
3810 ia2_role_ = ia_role_;
3811 }
3812
3813 } // namespace content
3814