src/content/browser/accessibility/browser_accessibility_win.cc

   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)
  55     COM_INTERFACE_ENTRY(IAccessibleRelation)
  56   END_COM_MAP()
  57
  58   CONTENT_EXPORT 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.
  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
  84 void BrowserAccessibilityRelation::Initialize(BrowserAccessibilityWin* owner,
  85                                               const base::string16& type) {
  86   owner_ = owner;
  87   type_ = type;
  88 }
  89
  90 void BrowserAccessibilityRelation::AddTarget(int target_id) {
  91   target_ids_.push_back(target_id);
  92 }
  93
  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
 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
 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
 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
 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
 190 BrowserAccessibilityWin* BrowserAccessibility::ToBrowserAccessibilityWin() {
 191   return static_cast<BrowserAccessibilityWin*>(this);
 192 }
 193
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 606 STDMETHODIMP BrowserAccessibilityWin::get_accHelpTopic(BSTR* help_file,
 607                                                        VARIANT var_id,
 608                                                        LONG* topic_id) {
 609   return E_NOTIMPL;
 610 }
 611
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
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
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
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
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
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
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
1209 STDMETHODIMP BrowserAccessibilityWin::get_columnHeader(
1210     IAccessibleTable** accessible_table,
1211     long* starting_row_index) {
1212   // TODO(dmazzoni): implement
1213   return E_NOTIMPL;
1214 }
1215
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
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
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
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
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
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
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
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
1395 STDMETHODIMP BrowserAccessibilityWin::get_rowHeader(
1396     IAccessibleTable** accessible_table,
1397     long* starting_column_index) {
1398   // TODO(dmazzoni): implement
1399   return E_NOTIMPL;
1400 }
1401
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
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
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
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
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
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
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
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
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
1571 STDMETHODIMP BrowserAccessibilityWin::get_cellAt(long row,
1572                                                  long column,
1573                                                  IUnknown** cell) {
1574   return get_accessibleAt(row, column, cell);
1575 }
1576
1577 STDMETHODIMP BrowserAccessibilityWin::get_nSelectedCells(long* cell_count) {
1578   return get_nSelectedChildren(cell_count);
1579 }
1580
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
2375 STDMETHODIMP BrowserAccessibilityWin::setCurrentValue(VARIANT new_value) {
2376   // TODO(dmazzoni): Implement this.
2377   return E_NOTIMPL;
2378 }
2379
2380 //
2381 // ISimpleDOMDocument methods.
2382 //
2383
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
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
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
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
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
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
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
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
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
2580 STDMETHODIMP BrowserAccessibilityWin::scrollTo(boolean placeTopLeft) {
2581   return scrollTo(placeTopLeft ?
2582       IA2_SCROLL_TYPE_TOP_LEFT : IA2_SCROLL_TYPE_ANYWHERE);
2583 }
2584
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
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
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
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
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
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
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
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
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
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
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
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
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
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.
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
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
3167 void BrowserAccessibilityWin::NativeAddReference() {
3168   AddRef();
3169 }
3170
3171 void BrowserAccessibilityWin::NativeReleaseReference() {
3172   Release();
3173 }
3174
3175 bool BrowserAccessibilityWin::IsNative() const {
3176   return true;
3177 }
3178
3179 void BrowserAccessibilityWin::OnLocationChanged() {
3180   manager()->ToBrowserAccessibilityManagerWin()->MaybeCallNotifyWinEvent(
3181       EVENT_OBJECT_LOCATIONCHANGE, unique_id_win());
3182 }
3183
3184 BrowserAccessibilityWin* BrowserAccessibilityWin::NewReference() {
3185   AddRef();
3186   return this;
3187 }
3188
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
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
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
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
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
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
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
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
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
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
3305 BrowserAccessibilityWin* BrowserAccessibilityWin::GetFromID(int32 id) {
3306   return manager()->GetFromID(id)->ToBrowserAccessibilityWin();
3307 }
3308
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