Forward BrowserAccessibility get_accState to AXPlatformNode.

content/browser/accessibility/browser_accessibility_com_win.cc

 // Copyright (c) 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/accessibility/browser_accessibility_com_win.h"
 
 #include <UIAutomationClient.h>
 #include <UIAutomationCoreApi.h>
 
 #include <algorithm>
@@ skipping 613 matching lines @@
 
   return AXPlatformNodeWin::get_accRole(var_id, role);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accState(VARIANT var_id,
                                                       VARIANT* state) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_STATE);
   if (!owner())
     return E_FAIL;
 
-  auto* manager = Manager();
-  if (!manager)
-    return E_FAIL;
-
-  if (!state)
-    return E_INVALIDARG;
-
-  BrowserAccessibilityComWin* target = GetTargetFromChildID(var_id);
-  if (!target)
-    return E_INVALIDARG;
-
-  state->vt = VT_I4;
-  state->lVal = target->ia_state();
-  if (manager->GetFocus() == owner())
-    state->lVal |= STATE_SYSTEM_FOCUSED;
-
-  return S_OK;
+  return AXPlatformNodeWin::get_accState(var_id, state);
 }
 
 bool BrowserAccessibilityComWin::IsRangeValueSupported() {
   switch (ia_role()) {
     case ROLE_SYSTEM_PROGRESSBAR:
     case ROLE_SYSTEM_SLIDER:
     case ROLE_SYSTEM_SPINBUTTON:
     case ROLE_SYSTEM_SCROLLBAR:
       return true;
     case ROLE_SYSTEM_SEPARATOR:
@@ skipping 1883 matching lines @@
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner() || !IsHyperlink())
     return E_FAIL;
 
   // IA2 text links can have at most one target, that is when they represent an
   // HTML hyperlink, i.e. an <a> element with a "href" attribute.
   if (index != 0 || !anchor_target)
     return E_INVALIDARG;
 
   BSTR target;
-  if (!(ia_state() & STATE_SYSTEM_LINKED) ||
+  if (!(MSAAState() & STATE_SYSTEM_LINKED) ||
       FAILED(GetStringAttributeAsBstr(ui::AX_ATTR_URL, &target))) {
     target = SysAllocString(L"");
   }
   DCHECK(target);
   anchor_target->vt = VT_BSTR;
   anchor_target->bstrVal = target;
 
   // Returning S_FALSE is not mentioned in the IA2 Spec, but it might have been
   // an oversight.
   if (!SysStringLen(target))
@@ skipping 1212 matching lines @@
     win_attributes_->ia2_attributes.push_back(L"valuetext:" + value);
   } else {
     // On Windows, the value of a document should be its url.
     if (owner()->GetRole() == ui::AX_ROLE_ROOT_WEB_AREA ||
         owner()->GetRole() == ui::AX_ROLE_WEB_AREA) {
       value = base::UTF8ToUTF16(Manager()->GetTreeData().url);
     }
     // If this doesn't have a value and is linked then set its value to the url
     // attribute. This allows screen readers to read an empty link's
     // destination.
-    if (value.empty() && (ia_state() & STATE_SYSTEM_LINKED))
+    if (value.empty() && (MSAAState() & STATE_SYSTEM_LINKED))
       value = owner()->GetString16Attribute(ui::AX_ATTR_URL);
   }
 
   win_attributes_->value = value;
 
   ClearOwnRelations();
   AddBidirectionalRelations(IA2_RELATION_CONTROLLER_FOR,
                             IA2_RELATION_CONTROLLED_BY,
                             ui::AX_ATTR_CONTROLS_IDS);
   AddBidirectionalRelations(IA2_RELATION_DESCRIBED_BY,
@@ skipping 76 matching lines @@
   // The rest of the events only fire on changes, not on new objects.
   if (old_win_attributes_->ia_role != 0 ||
       !old_win_attributes_->role_name.empty()) {
     // Fire an event if the name, description, help, or value changes.
     if (name() != old_win_attributes_->name)
       FireNativeEvent(EVENT_OBJECT_NAMECHANGE);
     if (description() != old_win_attributes_->description)
       FireNativeEvent(EVENT_OBJECT_DESCRIPTIONCHANGE);
     if (value() != old_win_attributes_->value)
       FireNativeEvent(EVENT_OBJECT_VALUECHANGE);
-    if (ia_state() != old_win_attributes_->ia_state)
+
+    // Do not fire EVENT_OBJECT_STATECHANGE if the change was due to a focus
+    // change.
+    if ((MSAAState() & ~STATE_SYSTEM_FOCUSED) !=
+        (old_win_attributes_->ia_state & ~STATE_SYSTEM_FOCUSED))
       FireNativeEvent(EVENT_OBJECT_STATECHANGE);
 
     // Handle selection being added or removed.
-    bool is_selected_now = (ia_state() & STATE_SYSTEM_SELECTED) != 0;
+    bool is_selected_now = (MSAAState() & STATE_SYSTEM_SELECTED) != 0;
     bool was_selected_before =
         (old_win_attributes_->ia_state & STATE_SYSTEM_SELECTED) != 0;
     if (is_selected_now || was_selected_before) {
       bool multiselect = false;
       if (owner()->PlatformGetParent() &&
           owner()->PlatformGetParent()->HasState(ui::AX_STATE_MULTISELECTABLE))
         multiselect = true;
 
       if (multiselect) {
         // In a multi-select box, fire SELECTIONADD and SELECTIONREMOVE events.
@@ skipping 1094 matching lines @@
 }
 
 void BrowserAccessibilityComWin::FireNativeEvent(LONG win_event_type) const {
   (new BrowserAccessibilityEventWin(BrowserAccessibilityEvent::FromTreeChange,
                                     ui::AX_EVENT_NONE, win_event_type, owner()))
       ->Fire();
 }
 
 void BrowserAccessibilityComWin::InitRoleAndState() {
   int32_t ia_role = 0;
-  int32_t ia_state = 0;
   base::string16 role_name;
   int32_t ia2_role = 0;
   int32_t ia2_state = IA2_STATE_OPAQUE;
 
-  if (owner()->HasState(ui::AX_STATE_BUSY))
-    ia_state |= STATE_SYSTEM_BUSY;
-
   const auto checked_state = static_cast<ui::AXCheckedState>(
       owner()->GetIntAttribute(ui::AX_ATTR_CHECKED_STATE));
   if (checked_state) {
     ia2_state |= IA2_STATE_CHECKABLE;
-    switch (checked_state) {
-      case ui::AX_CHECKED_STATE_TRUE:
-        ia_state |= owner()->GetRole() == ui::AX_ROLE_TOGGLE_BUTTON
-                        ? STATE_SYSTEM_PRESSED
-                        : STATE_SYSTEM_CHECKED;
-        break;
-      case ui::AX_CHECKED_STATE_MIXED:
-        ia_state |= STATE_SYSTEM_MIXED;
-        break;
-      default:
-        break;
-    }
   }
 
-  if (owner()->HasState(ui::AX_STATE_COLLAPSED))
-    ia_state |= STATE_SYSTEM_COLLAPSED;
-  if (owner()->HasState(ui::AX_STATE_EXPANDED))
-    ia_state |= STATE_SYSTEM_EXPANDED;
-  if (owner()->HasState(ui::AX_STATE_FOCUSABLE))
-    ia_state |= STATE_SYSTEM_FOCUSABLE;
-  if (owner()->HasState(ui::AX_STATE_HASPOPUP))
-    ia_state |= STATE_SYSTEM_HASPOPUP;
   if (owner()->HasIntAttribute(ui::AX_ATTR_INVALID_STATE) &&
       owner()->GetIntAttribute(ui::AX_ATTR_INVALID_STATE) !=
           ui::AX_INVALID_STATE_FALSE)
     ia2_state |= IA2_STATE_INVALID_ENTRY;
-  if (owner()->HasState(ui::AX_STATE_INVISIBLE))
-    ia_state |= STATE_SYSTEM_INVISIBLE;
-  if (owner()->HasState(ui::AX_STATE_LINKED))
-    ia_state |= STATE_SYSTEM_LINKED;
-  if (owner()->HasState(ui::AX_STATE_MULTISELECTABLE)) {
-    ia_state |= STATE_SYSTEM_EXTSELECTABLE;
-    ia_state |= STATE_SYSTEM_MULTISELECTABLE;
-  }
-  // TODO(ctguil): Support STATE_SYSTEM_EXTSELECTABLE/accSelect.
-  if (owner()->HasState(ui::AX_STATE_OFFSCREEN))
-    ia_state |= STATE_SYSTEM_OFFSCREEN;
-  if (owner()->HasState(ui::AX_STATE_PROTECTED))
-    ia_state |= STATE_SYSTEM_PROTECTED;
   if (owner()->HasState(ui::AX_STATE_REQUIRED))
     ia2_state |= IA2_STATE_REQUIRED;
-  if (owner()->HasState(ui::AX_STATE_SELECTABLE))
-    ia_state |= STATE_SYSTEM_SELECTABLE;
-  if (owner()->HasState(ui::AX_STATE_SELECTED))
-    ia_state |= STATE_SYSTEM_SELECTED;
-  if (owner()->HasState(ui::AX_STATE_VISITED))
-    ia_state |= STATE_SYSTEM_TRAVERSED;
-  if (owner()->HasState(ui::AX_STATE_DISABLED))
-    ia_state |= STATE_SYSTEM_UNAVAILABLE;
   if (owner()->HasState(ui::AX_STATE_VERTICAL))
     ia2_state |= IA2_STATE_VERTICAL;
   if (owner()->HasState(ui::AX_STATE_HORIZONTAL))
     ia2_state |= IA2_STATE_HORIZONTAL;
-  if (owner()->HasState(ui::AX_STATE_VISITED))
-    ia_state |= STATE_SYSTEM_TRAVERSED;
-
-  // Expose whether or not the mouse is over an element, but suppress
-  // this for tests because it can make the test results flaky depending
-  // on the position of the mouse.
-  BrowserAccessibilityStateImpl* accessibility_state =
-      BrowserAccessibilityStateImpl::GetInstance();
-  if (!accessibility_state->disable_hot_tracking_for_testing()) {
-    if (owner()->HasState(ui::AX_STATE_HOVERED))
-      ia_state |= STATE_SYSTEM_HOTTRACKED;
-  }
 
   if (owner()->HasState(ui::AX_STATE_EDITABLE))
     ia2_state |= IA2_STATE_EDITABLE;
 
   if (!owner()->GetStringAttribute(ui::AX_ATTR_AUTO_COMPLETE).empty())
     ia2_state |= IA2_STATE_SUPPORTS_AUTOCOMPLETION;
 
   if (owner()->GetBoolAttribute(ui::AX_ATTR_MODAL))
     ia2_state |= IA2_STATE_MODAL;
 
   base::string16 html_tag = owner()->GetString16Attribute(ui::AX_ATTR_HTML_TAG);
   switch (owner()->GetRole()) {
     case ui::AX_ROLE_ALERT:
       ia_role = ROLE_SYSTEM_ALERT;
       break;
     case ui::AX_ROLE_ALERT_DIALOG:
       ia_role = ROLE_SYSTEM_DIALOG;
       break;
     case ui::AX_ROLE_ANCHOR:
       ia_role = ROLE_SYSTEM_LINK;
       break;
     case ui::AX_ROLE_APPLICATION:
       ia_role = ROLE_SYSTEM_APPLICATION;
       break;
     case ui::AX_ROLE_ARTICLE:
       ia_role = ROLE_SYSTEM_DOCUMENT;
-      ia_state |= STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_AUDIO:
       ia_role = ROLE_SYSTEM_GROUPING;
       break;
     case ui::AX_ROLE_BANNER:
       ia_role = ROLE_SYSTEM_GROUPING;
       ia2_role = IA2_ROLE_HEADER;
       break;
     case ui::AX_ROLE_BLOCKQUOTE:
       role_name = html_tag;
       ia2_role = IA2_ROLE_SECTION;
       break;
     case ui::AX_ROLE_BUSY_INDICATOR:
       ia_role = ROLE_SYSTEM_ANIMATION;
-      ia_state |= STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_BUTTON:
       ia_role = ROLE_SYSTEM_PUSHBUTTON;
       break;
     case ui::AX_ROLE_CANVAS:
       if (owner()->GetBoolAttribute(ui::AX_ATTR_CANVAS_HAS_FALLBACK)) {
         role_name = L"canvas";
         ia2_role = IA2_ROLE_CANVAS;
       } else {
         ia_role = ROLE_SYSTEM_GRAPHIC;
@@ skipping 31 matching lines @@
       ia2_role = IA2_ROLE_PARAGRAPH;
       break;
     case ui::AX_ROLE_DATE:
     case ui::AX_ROLE_DATE_TIME:
       ia_role = ROLE_SYSTEM_DROPLIST;
       ia2_role = IA2_ROLE_DATE_EDITOR;
       break;
     case ui::AX_ROLE_DEFINITION:
       role_name = html_tag;
       ia2_role = IA2_ROLE_PARAGRAPH;
-      ia_state |= STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_DESCRIPTION_LIST_DETAIL:
       role_name = html_tag;
       ia_role = ROLE_SYSTEM_TEXT;
       ia2_role = IA2_ROLE_PARAGRAPH;
       break;
     case ui::AX_ROLE_DESCRIPTION_LIST:
       role_name = html_tag;
       ia_role = ROLE_SYSTEM_LIST;
-      ia_state |= STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_DESCRIPTION_LIST_TERM:
       ia_role = ROLE_SYSTEM_LISTITEM;
-      ia_state |= STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_DETAILS:
       role_name = html_tag;
       ia_role = ROLE_SYSTEM_GROUPING;
       break;
     case ui::AX_ROLE_DIALOG:
       ia_role = ROLE_SYSTEM_DIALOG;
       break;
     case ui::AX_ROLE_DISCLOSURE_TRIANGLE:
       ia_role = ROLE_SYSTEM_PUSHBUTTON;
       break;
     case ui::AX_ROLE_DOCUMENT:
     case ui::AX_ROLE_ROOT_WEB_AREA:
     case ui::AX_ROLE_WEB_AREA:
       ia_role = ROLE_SYSTEM_DOCUMENT;
-      ia_state |= STATE_SYSTEM_READONLY;
-      ia_state |= STATE_SYSTEM_FOCUSABLE;
       break;
     case ui::AX_ROLE_EMBEDDED_OBJECT:
       if (owner()->PlatformChildCount()) {
         // Windows screen readers assume that IA2_ROLE_EMBEDDED_OBJECT
         // doesn't have any children, but it may be something like a
         // browser plugin that has a document inside.
         ia_role = ROLE_SYSTEM_GROUPING;
       } else {
         ia_role = ROLE_SYSTEM_CLIENT;
         ia2_role = IA2_ROLE_EMBEDDED_OBJECT;
@@ skipping 17 matching lines @@
       ia_role = ROLE_SYSTEM_GROUPING;
       ia2_role = IA2_ROLE_FOOTER;
       break;
     case ui::AX_ROLE_GENERIC_CONTAINER:
       ia_role = ROLE_SYSTEM_GROUPING;
       ia2_role = IA2_ROLE_SECTION;
       role_name = html_tag.empty() ? L"div" : html_tag;
       break;
     case ui::AX_ROLE_GRID:
       ia_role = ROLE_SYSTEM_TABLE;
-      // TODO(aleventhal) this changed between ARIA 1.0 and 1.1,
-      // need to determine whether grids/treegrids should really be readonly
-      // or editable by default
-      // ia_state |= STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_GROUP:
       ia_role = ROLE_SYSTEM_GROUPING;
       break;
     case ui::AX_ROLE_HEADING:
       role_name = html_tag;
       if (html_tag.empty())
         ia_role = ROLE_SYSTEM_GROUPING;
       ia2_role = IA2_ROLE_HEADING;
       break;
     case ui::AX_ROLE_IFRAME:
       ia_role = ROLE_SYSTEM_DOCUMENT;
       ia2_role = IA2_ROLE_INTERNAL_FRAME;
-      ia_state = STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_IFRAME_PRESENTATIONAL:
       ia_role = ROLE_SYSTEM_GROUPING;
       break;
     case ui::AX_ROLE_IMAGE:
       ia_role = ROLE_SYSTEM_GRAPHIC;
-      ia_state |= STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_IMAGE_MAP:
       role_name = html_tag;
       ia2_role = IA2_ROLE_IMAGE_MAP;
-      ia_state |= STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_IMAGE_MAP_LINK:
       ia_role = ROLE_SYSTEM_LINK;
-      ia_state |= STATE_SYSTEM_LINKED;
-      ia_state |= STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_INPUT_TIME:
       ia_role = ROLE_SYSTEM_GROUPING;
       break;
     case ui::AX_ROLE_LABEL_TEXT:
     case ui::AX_ROLE_LEGEND:
       ia_role = ROLE_SYSTEM_TEXT;
       ia2_role = IA2_ROLE_LABEL;
       break;
     case ui::AX_ROLE_LINK:
       ia_role = ROLE_SYSTEM_LINK;
-      ia_state |= STATE_SYSTEM_LINKED;
       break;
     case ui::AX_ROLE_LIST:
       ia_role = ROLE_SYSTEM_LIST;
-      ia_state |= STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_LIST_BOX:
       ia_role = ROLE_SYSTEM_LIST;
       break;
     case ui::AX_ROLE_LIST_BOX_OPTION:
       ia_role = ROLE_SYSTEM_LISTITEM;
       break;
     case ui::AX_ROLE_LIST_ITEM:
       ia_role = ROLE_SYSTEM_LISTITEM;
-      ia_state |= STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_MAIN:
       ia_role = ROLE_SYSTEM_GROUPING;
       ia2_role = IA2_ROLE_PARAGRAPH;
       break;
     case ui::AX_ROLE_MARK:
       ia_role = ROLE_SYSTEM_TEXT;
       ia2_role = IA2_ROLE_TEXT_FRAME;
       break;
     case ui::AX_ROLE_MARQUEE:
@@ skipping 54 matching lines @@
         ia_role = ROLE_SYSTEM_BUTTONMENU;
       }
       break;
     case ui::AX_ROLE_PRE:
       role_name = html_tag;
       ia_role = ROLE_SYSTEM_TEXT;
       ia2_role = IA2_ROLE_PARAGRAPH;
       break;
     case ui::AX_ROLE_PROGRESS_INDICATOR:
       ia_role = ROLE_SYSTEM_PROGRESSBAR;
-      ia_state |= STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_RADIO_BUTTON:
       ia_role = ROLE_SYSTEM_RADIOBUTTON;
       break;
     case ui::AX_ROLE_RADIO_GROUP:
       ia_role = ROLE_SYSTEM_GROUPING;
       break;
     case ui::AX_ROLE_REGION:
       if (html_tag == L"section") {
         ia_role = ROLE_SYSTEM_GROUPING;
@@ skipping 12 matching lines @@
     case ui::AX_ROLE_ROW_HEADER:
       ia_role = ROLE_SYSTEM_ROWHEADER;
       break;
     case ui::AX_ROLE_RUBY:
       ia_role = ROLE_SYSTEM_TEXT;
       ia2_role = IA2_ROLE_TEXT_FRAME;
       break;
     case ui::AX_ROLE_RULER:
       ia_role = ROLE_SYSTEM_CLIENT;
       ia2_role = IA2_ROLE_RULER;
-      ia_state |= STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_SCROLL_AREA:
       ia_role = ROLE_SYSTEM_CLIENT;
       ia2_role = IA2_ROLE_SCROLL_PANE;
-      ia_state |= STATE_SYSTEM_READONLY;
       ia2_state &= ~(IA2_STATE_EDITABLE);
       break;
     case ui::AX_ROLE_SCROLL_BAR:
       ia_role = ROLE_SYSTEM_SCROLLBAR;
       break;
     case ui::AX_ROLE_SEARCH:
       ia_role = ROLE_SYSTEM_GROUPING;
       ia2_role = IA2_ROLE_SECTION;
       break;
     case ui::AX_ROLE_SLIDER:
@@ skipping 25 matching lines @@
       break;
     case ui::AX_ROLE_TAB:
       ia_role = ROLE_SYSTEM_PAGETAB;
       break;
     case ui::AX_ROLE_TABLE:
       ia_role = ROLE_SYSTEM_TABLE;
       break;
     case ui::AX_ROLE_TABLE_HEADER_CONTAINER:
       ia_role = ROLE_SYSTEM_GROUPING;
       ia2_role = IA2_ROLE_SECTION;
-      ia_state |= STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_TAB_LIST:
       ia_role = ROLE_SYSTEM_PAGETABLIST;
       break;
     case ui::AX_ROLE_TAB_PANEL:
       ia_role = ROLE_SYSTEM_PROPERTYPAGE;
       break;
     case ui::AX_ROLE_TERM:
       ia_role = ROLE_SYSTEM_LISTITEM;
-      ia_state |= STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_TOGGLE_BUTTON:
       ia_role = ROLE_SYSTEM_PUSHBUTTON;
       ia2_role = IA2_ROLE_TOGGLE_BUTTON;
       break;
     case ui::AX_ROLE_TEXT_FIELD:
     case ui::AX_ROLE_SEARCH_BOX:
       ia_role = ROLE_SYSTEM_TEXT;
       if (owner()->HasState(ui::AX_STATE_MULTILINE)) {
         ia2_state |= IA2_STATE_MULTI_LINE;
       } else {
         ia2_state |= IA2_STATE_SINGLE_LINE;
       }
-      if (owner()->HasState(ui::AX_STATE_READ_ONLY))
-        ia_state |= STATE_SYSTEM_READONLY;
       ia2_state |= IA2_STATE_SELECTABLE_TEXT;
       break;
     case ui::AX_ROLE_ABBR:
     case ui::AX_ROLE_TIME:
       role_name = html_tag;
       ia_role = ROLE_SYSTEM_TEXT;
       ia2_role = IA2_ROLE_TEXT_FRAME;
       break;
     case ui::AX_ROLE_TIMER:
       ia_role = ROLE_SYSTEM_CLOCK;
-      ia_state |= STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_TOOLBAR:
       ia_role = ROLE_SYSTEM_TOOLBAR;
-      ia_state |= STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_TOOLTIP:
       ia_role = ROLE_SYSTEM_TOOLTIP;
-      ia_state |= STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_TREE:
       ia_role = ROLE_SYSTEM_OUTLINE;
       break;
     case ui::AX_ROLE_TREE_GRID:
       ia_role = ROLE_SYSTEM_OUTLINE;
       break;
     case ui::AX_ROLE_TREE_ITEM:
       ia_role = ROLE_SYSTEM_OUTLINEITEM;
       break;
@@ skipping 12 matching lines @@
     case ui::AX_ROLE_IGNORED:
     case ui::AX_ROLE_LOG:
     case ui::AX_ROLE_NONE:
     case ui::AX_ROLE_PRESENTATIONAL:
     case ui::AX_ROLE_SLIDER_THUMB:
     default:
       ia_role = ROLE_SYSTEM_CLIENT;
       break;
   }
 
-  // Compute the final value of READONLY for MSAA.
-  //
-  // We always set the READONLY state for elements that have the
-  // aria-readonly attribute and for a few roles (in the switch above),
-  // including read-only text fields.
-  // The majority of focusable controls should not have the read-only state
-  // set.
-  if (owner()->HasState(ui::AX_STATE_FOCUSABLE) &&
-      ia_role != ROLE_SYSTEM_DOCUMENT && ia_role != ROLE_SYSTEM_TEXT) {
-    ia_state &= ~(STATE_SYSTEM_READONLY);
-  }
-  if (!owner()->HasState(ui::AX_STATE_READ_ONLY))
-    ia_state &= ~(STATE_SYSTEM_READONLY);
-  if (owner()->GetBoolAttribute(ui::AX_ATTR_ARIA_READONLY))
-    ia_state |= STATE_SYSTEM_READONLY;
-
   // The role should always be set.
   DCHECK(!role_name.empty() || ia_role);
 
   // If we didn't explicitly set the IAccessible2 role, make it the same
   // as the MSAA role.
   if (!ia2_role)
     ia2_role = ia_role;
 
   win_attributes_->ia_role = ia_role;
-  win_attributes_->ia_state = ia_state;
+  win_attributes_->ia_state = MSAAState();
   win_attributes_->role_name = role_name;
   win_attributes_->ia2_role = ia2_role;
   win_attributes_->ia2_state = ia2_state;
 }
 
 bool BrowserAccessibilityComWin::IsInTreeGrid(
     const BrowserAccessibility* item) {
   BrowserAccessibility* container = item->PlatformGetParent();
   if (container && container->GetRole() == ui::AX_ROLE_GROUP) {
     // If parent was a rowgroup, we need to look at the grandparent
     container = container->PlatformGetParent();
   }
 
   if (!container) {
     return false;
   }
 
   return container->GetRole() == ui::AX_ROLE_TREE_GRID;
 }
 
 BrowserAccessibilityComWin* ToBrowserAccessibilityComWin(
     BrowserAccessibility* obj) {
   if (!obj || !obj->IsNative())
     return nullptr;
   auto* result = static_cast<BrowserAccessibilityWin*>(obj)->GetCOM();
   return result;
 }
 
 }  // namespace content