Use Blink accessibility enums in Chromium

content/browser/accessibility/browser_accessibility_win.cc

 // Copyright (c) 2012 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_win.h"
 
 #include <UIAutomationClient.h>
 #include <UIAutomationCoreApi.h>
 
 #include "base/strings/string_number_conversions.h"
@@ skipping 580 matching lines @@
 STDMETHODIMP BrowserAccessibilityWin::get_accHelpTopic(BSTR* help_file,
                                                        VARIANT var_id,
                                                        LONG* topic_id) {
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_accSelection(VARIANT* selected) {
   if (!instance_active_)
     return E_FAIL;
 
-  if (role_ != AccessibilityNodeData::ROLE_LISTBOX)
+  if (role_ != WebKit::WebAXRoleListBox)
     return E_NOTIMPL;
 
   unsigned long selected_count = 0;
   for (size_t i = 0; i < children_.size(); ++i) {
-    if (children_[i]->HasState(AccessibilityNodeData::STATE_SELECTED))
+    if (children_[i]->HasState(WebKit::WebAXStateSelected))
       ++selected_count;
   }
 
   if (selected_count == 0) {
     selected->vt = VT_EMPTY;
     return S_OK;
   }
 
   if (selected_count == 1) {
     for (size_t i = 0; i < children_.size(); ++i) {
-      if (children_[i]->HasState(AccessibilityNodeData::STATE_SELECTED)) {
+      if (children_[i]->HasState(WebKit::WebAXStateSelected)) {
         selected->vt = VT_DISPATCH;
         selected->pdispVal =
             children_[i]->ToBrowserAccessibilityWin()->NewReference();
         return S_OK;
       }
     }
   }
 
   // Multiple items are selected.
   base::win::EnumVariant* enum_variant =
       new base::win::EnumVariant(selected_count);
   enum_variant->AddRef();
   unsigned long index = 0;
   for (size_t i = 0; i < children_.size(); ++i) {
-    if (children_[i]->HasState(AccessibilityNodeData::STATE_SELECTED)) {
+    if (children_[i]->HasState(WebKit::WebAXStateSelected)) {
       enum_variant->ItemAt(index)->vt = VT_DISPATCH;
       enum_variant->ItemAt(index)->pdispVal =
         children_[i]->ToBrowserAccessibilityWin()->NewReference();
       ++index;
     }
   }
   selected->vt = VT_UNKNOWN;
   selected->punkVal = static_cast<IUnknown*>(
       static_cast<base::win::IUnknownImpl*>(enum_variant));
   return S_OK;
@@ skipping 220 matching lines @@
 STDMETHODIMP BrowserAccessibilityWin::get_groupPosition(
     LONG* group_level,
     LONG* similar_items_in_group,
     LONG* position_in_group) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!group_level || !similar_items_in_group || !position_in_group)
     return E_INVALIDARG;
 
-  if (role_ == AccessibilityNodeData::ROLE_LISTBOX_OPTION &&
+  if (role_ == WebKit::WebAXRoleListBoxOption &&
       parent_ &&
-      parent_->role() == AccessibilityNodeData::ROLE_LISTBOX) {
+      parent_->role() == WebKit::WebAXRoleListBox) {
     *group_level = 0;
     *similar_items_in_group = parent_->child_count();
     *position_in_group = index_in_parent_ + 1;
     return S_OK;
   }
 
   return E_NOTIMPL;
 }
 
 //
@@ skipping 238 matching lines @@
 
   if (column < 0 || column >= columns)
     return E_INVALIDARG;
 
   const std::vector<int32>& cell_ids = GetIntListAttribute(
       AccessibilityNodeData::ATTR_CELL_IDS);
   for (int i = 0; i < rows; ++i) {
     int cell_id = cell_ids[i * columns + column];
     BrowserAccessibilityWin* cell = static_cast<BrowserAccessibilityWin*>(
         manager_->GetFromRendererID(cell_id));
-    if (cell && cell->role_ == AccessibilityNodeData::ROLE_COLUMN_HEADER) {
+    if (cell && cell->role_ == WebKit::WebAXRoleColumnHeader) {
       string16 cell_name = cell->GetString16Attribute(
           AccessibilityNodeData::ATTR_NAME);
       if (cell_name.size() > 0) {
         *description = SysAllocString(cell_name.c_str());
         return S_OK;
       }
 
       return cell->GetStringAttributeAsBstr(
           AccessibilityNodeData::ATTR_DESCRIPTION, description);
     }
@@ skipping 166 matching lines @@
 
   if (row < 0 || row >= rows)
     return E_INVALIDARG;
 
   const std::vector<int32>& cell_ids = GetIntListAttribute(
       AccessibilityNodeData::ATTR_CELL_IDS);
   for (int i = 0; i < columns; ++i) {
     int cell_id = cell_ids[row * columns + i];
     BrowserAccessibilityWin* cell =
         manager_->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
-    if (cell && cell->role_ == AccessibilityNodeData::ROLE_ROW_HEADER) {
+    if (cell && cell->role_ == WebKit::WebAXRoleRowHeader) {
       string16 cell_name = cell->GetString16Attribute(
           AccessibilityNodeData::ATTR_NAME);
       if (cell_name.size() > 0) {
         *description = SysAllocString(cell_name.c_str());
         return S_OK;
       }
 
       return cell->GetStringAttributeAsBstr(
           AccessibilityNodeData::ATTR_DESCRIPTION, description);
     }
@@ skipping 302 matching lines @@
 
   *n_column_header_cells = 0;
 
   int column;
   if (!GetIntAttribute(
           AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_INDEX, &column)) {
     return S_FALSE;
   }
 
   BrowserAccessibility* table = parent();
-  while (table && table->role() != AccessibilityNodeData::ROLE_TABLE)
+  while (table && table->role() != WebKit::WebAXRoleTable)
     table = table->parent();
   if (!table) {
     NOTREACHED();
     return S_FALSE;
   }
 
   int columns;
   int rows;
   if (!table->GetIntAttribute(
           AccessibilityNodeData::ATTR_TABLE_COLUMN_COUNT, &columns) ||
       !table->GetIntAttribute(
           AccessibilityNodeData::ATTR_TABLE_ROW_COUNT, &rows)) {
     return S_FALSE;
   }
   if (columns <= 0 || rows <= 0 || column < 0 || column >= columns)
     return S_FALSE;
 
   const std::vector<int32>& cell_ids = table->GetIntListAttribute(
       AccessibilityNodeData::ATTR_CELL_IDS);
 
   for (int i = 0; i < rows; ++i) {
     int cell_id = cell_ids[i * columns + column];
     BrowserAccessibilityWin* cell =
         manager_->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
-    if (cell && cell->role_ == AccessibilityNodeData::ROLE_COLUMN_HEADER)
+    if (cell && cell->role_ == WebKit::WebAXRoleColumnHeader)
       (*n_column_header_cells)++;
   }
 
   *cell_accessibles = static_cast<IUnknown**>(CoTaskMemAlloc(
       (*n_column_header_cells) * sizeof(cell_accessibles[0])));
   int index = 0;
   for (int i = 0; i < rows; ++i) {
     int cell_id = cell_ids[i * columns + column];
     BrowserAccessibilityWin* cell =
         manager_->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
-    if (cell && cell->role_ == AccessibilityNodeData::ROLE_COLUMN_HEADER) {
+    if (cell && cell->role_ == WebKit::WebAXRoleColumnHeader) {
       (*cell_accessibles)[index] =
           static_cast<IAccessible*>(cell->NewReference());
       ++index;
     }
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_columnIndex(long* column_index) {
@@ skipping 42 matching lines @@
 
   *n_row_header_cells = 0;
 
   int row;
   if (!GetIntAttribute(
           AccessibilityNodeData::ATTR_TABLE_CELL_ROW_INDEX, &row)) {
     return S_FALSE;
   }
 
   BrowserAccessibility* table = parent();
-  while (table && table->role() != AccessibilityNodeData::ROLE_TABLE)
+  while (table && table->role() != WebKit::WebAXRoleTable)
     table = table->parent();
   if (!table) {
     NOTREACHED();
     return S_FALSE;
   }
 
   int columns;
   int rows;
   if (!table->GetIntAttribute(
           AccessibilityNodeData::ATTR_TABLE_COLUMN_COUNT, &columns) ||
       !table->GetIntAttribute(
           AccessibilityNodeData::ATTR_TABLE_ROW_COUNT, &rows)) {
     return S_FALSE;
   }
   if (columns <= 0 || rows <= 0 || row < 0 || row >= rows)
     return S_FALSE;
 
   const std::vector<int32>& cell_ids = table->GetIntListAttribute(
       AccessibilityNodeData::ATTR_CELL_IDS);
 
   for (int i = 0; i < columns; ++i) {
     int cell_id = cell_ids[row * columns + i];
     BrowserAccessibilityWin* cell =
         manager_->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
-    if (cell && cell->role_ == AccessibilityNodeData::ROLE_ROW_HEADER)
+    if (cell && cell->role_ == WebKit::WebAXRoleRowHeader)
       (*n_row_header_cells)++;
   }
 
   *cell_accessibles = static_cast<IUnknown**>(CoTaskMemAlloc(
       (*n_row_header_cells) * sizeof(cell_accessibles[0])));
   int index = 0;
   for (int i = 0; i < columns; ++i) {
     int cell_id = cell_ids[row * columns + i];
     BrowserAccessibilityWin* cell =
         manager_->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
-    if (cell && cell->role_ == AccessibilityNodeData::ROLE_ROW_HEADER) {
+    if (cell && cell->role_ == WebKit::WebAXRoleRowHeader) {
       (*cell_accessibles)[index] =
           static_cast<IAccessible*>(cell->NewReference());
       ++index;
     }
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_rowIndex(long* row_index) {
@@ skipping 68 matching lines @@
   if (!table)
     return E_INVALIDARG;
 
 
   int row;
   int column;
   GetIntAttribute(AccessibilityNodeData::ATTR_TABLE_CELL_ROW_INDEX, &row);
   GetIntAttribute(AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_INDEX, &column);
 
   BrowserAccessibility* find_table = parent();
-  while (find_table && find_table->role() != AccessibilityNodeData::ROLE_TABLE)
+  while (find_table && find_table->role() != WebKit::WebAXRoleTable)
     find_table = find_table->parent();
   if (!find_table) {
     NOTREACHED();
     return S_FALSE;
   }
 
   *table = static_cast<IAccessibleTable*>(
       find_table->ToBrowserAccessibilityWin()->NewReference());
 
   return S_OK;
@@ skipping 15 matching lines @@
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_caretOffset(LONG* offset) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!offset)
     return E_INVALIDARG;
 
   *offset = 0;
-  if (role_ == AccessibilityNodeData::ROLE_TEXT_FIELD ||
-      role_ == AccessibilityNodeData::ROLE_TEXTAREA) {
+  if (role_ == WebKit::WebAXRoleTextField ||
+      role_ == WebKit::WebAXRoleTextArea) {
     int sel_start = 0;
     if (GetIntAttribute(AccessibilityNodeData::ATTR_TEXT_SEL_START,
                         &sel_start))
       *offset = sel_start;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_nSelections(LONG* n_selections) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!n_selections)
     return E_INVALIDARG;
 
   *n_selections = 0;
-  if (role_ == AccessibilityNodeData::ROLE_TEXT_FIELD ||
-      role_ == AccessibilityNodeData::ROLE_TEXTAREA) {
+  if (role_ == WebKit::WebAXRoleTextField ||
+      role_ == WebKit::WebAXRoleTextArea) {
     int sel_start = 0;
     int sel_end = 0;
     if (GetIntAttribute(AccessibilityNodeData::ATTR_TEXT_SEL_START,
                         &sel_start) &&
         GetIntAttribute(AccessibilityNodeData::ATTR_TEXT_SEL_END, &sel_end) &&
         sel_start != sel_end)
       *n_selections = 1;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_selection(LONG selection_index,
                                                     LONG* start_offset,
                                                     LONG* end_offset) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!start_offset || !end_offset || selection_index != 0)
     return E_INVALIDARG;
 
   *start_offset = 0;
   *end_offset = 0;
-  if (role_ == AccessibilityNodeData::ROLE_TEXT_FIELD ||
-      role_ == AccessibilityNodeData::ROLE_TEXTAREA) {
+  if (role_ == WebKit::WebAXRoleTextField ||
+      role_ == WebKit::WebAXRoleTextArea) {
     int sel_start = 0;
     int sel_end = 0;
     if (GetIntAttribute(
             AccessibilityNodeData::ATTR_TEXT_SEL_START, &sel_start) &&
         GetIntAttribute(AccessibilityNodeData::ATTR_TEXT_SEL_END, &sel_end)) {
       *start_offset = sel_start;
       *end_offset = sel_end;
     }
   }
 
@@ skipping 825 matching lines @@
 
   // Expose the "display" and "tag" attributes.
   StringAttributeToIA2(AccessibilityNodeData::ATTR_DISPLAY, "display");
   StringAttributeToIA2(AccessibilityNodeData::ATTR_HTML_TAG, "tag");
   StringAttributeToIA2(AccessibilityNodeData::ATTR_ROLE, "xml-roles");
 
   // Expose "level" attribute for headings, trees, etc.
   IntAttributeToIA2(AccessibilityNodeData::ATTR_HIERARCHICAL_LEVEL, "level");
 
   // Expose the set size and position in set for listbox options.
-  if (role_ == AccessibilityNodeData::ROLE_LISTBOX_OPTION &&
+  if (role_ == WebKit::WebAXRoleListBoxOption &&
       parent_ &&
-      parent_->role() == AccessibilityNodeData::ROLE_LISTBOX) {
+      parent_->role() == WebKit::WebAXRoleListBox) {
     ia2_attributes_.push_back(
         L"setsize:" + base::IntToString16(parent_->child_count()));
     ia2_attributes_.push_back(
         L"setsize:" + base::IntToString16(index_in_parent_ + 1));
   }
 
   if (ia_role_ == ROLE_SYSTEM_CHECKBUTTON ||
       ia_role_ == ROLE_SYSTEM_RADIOBUTTON ||
       ia2_role_ == IA2_ROLE_TOGGLE_BUTTON) {
     ia2_attributes_.push_back(L"checkable:true");
@@ skipping 18 matching lines @@
   // Expose slider value.
   if (ia_role_ == ROLE_SYSTEM_PROGRESSBAR ||
       ia_role_ == ROLE_SYSTEM_SCROLLBAR ||
       ia_role_ == ROLE_SYSTEM_SLIDER) {
     ia2_attributes_.push_back(L"valuetext:" + GetValueText());
   }
 
   // Expose table cell index.
   if (ia_role_ == ROLE_SYSTEM_CELL) {
     BrowserAccessibility* table = parent();
-    while (table && table->role() != AccessibilityNodeData::ROLE_TABLE)
+    while (table && table->role() != WebKit::WebAXRoleTable)
       table = table->parent();
     if (table) {
       const std::vector<int32>& unique_cell_ids = table->GetIntListAttribute(
           AccessibilityNodeData::ATTR_UNIQUE_CELL_IDS);
       for (size_t i = 0; i < unique_cell_ids.size(); ++i) {
         if (unique_cell_ids[i] == renderer_id_) {
           ia2_attributes_.push_back(
               string16(L"table-cell-index:") + base::IntToString16(i));
         }
       }
@@ skipping 49 matching lines @@
     description = help;
     help.clear();
   }
   if (!description.empty() && name_.empty() && !title_elem_id) {
     name_ = description;
     description.clear();
   }
 
   // If it's a text field, also consider the placeholder.
   std::string placeholder;
-  if (role_ == AccessibilityNodeData::ROLE_TEXT_FIELD &&
-      HasState(AccessibilityNodeData::STATE_FOCUSABLE) &&
+  if (role_ == WebKit::WebAXRoleTextField &&
+      HasState(WebKit::WebAXStateFocusable) &&
       GetHtmlAttribute("placeholder", &placeholder)) {
     if (name_.empty() && !title_elem_id) {
       name_ = placeholder;
     } else if (description.empty()) {
       description = placeholder;
     }
   }
 
   SetStringAttribute(AccessibilityNodeData::ATTR_DESCRIPTION, description);
   SetStringAttribute(AccessibilityNodeData::ATTR_HELP, help);
 
   // On Windows, the value of a document should be its url.
-  if (role_ == AccessibilityNodeData::ROLE_ROOT_WEB_AREA ||
-      role_ == AccessibilityNodeData::ROLE_WEB_AREA) {
+  if (role_ == WebKit::WebAXRoleRootWebArea ||
+      role_ == WebKit::WebAXRoleWebArea) {
     GetStringAttribute(AccessibilityNodeData::ATTR_DOC_URL, &value_);
   }
 
   // For certain roles (listbox option, static text, and list marker)
   // WebKit stores the main accessible text in the "value" - swap it so
   // that it's the "name".
   if (name_.empty() &&
-      (role_ == AccessibilityNodeData::ROLE_LISTBOX_OPTION ||
-       role_ == AccessibilityNodeData::ROLE_STATIC_TEXT ||
-       role_ == AccessibilityNodeData::ROLE_LIST_MARKER)) {
+      (role_ == WebKit::WebAXRoleListBoxOption ||
+       role_ == WebKit::WebAXRoleStaticText ||
+       role_ == WebKit::WebAXRoleListMarker)) {
     name_.swap(value_);
   }
 
   // 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))
     GetStringAttribute(AccessibilityNodeData::ATTR_URL, &value_);
 
   // Clear any old relationships between this node and other nodes.
   for (size_t i = 0; i < relations_.size(); ++i)
@@ skipping 16 matching lines @@
 
 void BrowserAccessibilityWin::PostInitialize() {
   BrowserAccessibility::PostInitialize();
 
   // Construct the hypertext for this node.
   hyperlink_offset_to_index_.clear();
   hyperlinks_.clear();
   hypertext_.clear();
   for (unsigned int i = 0; i < children().size(); ++i) {
     BrowserAccessibility* child = children()[i];
-    if (child->role() == AccessibilityNodeData::ROLE_STATIC_TEXT) {
+    if (child->role() == WebKit::WebAXRoleStaticText) {
       hypertext_ += UTF8ToUTF16(child->name());
     } else {
       hyperlink_offset_to_index_[hypertext_.size()] = hyperlinks_.size();
       hypertext_ += kEmbeddedCharacter;
       hyperlinks_.push_back(i);
     }
   }
   DCHECK_EQ(hyperlink_offset_to_index_.size(), hyperlinks_.size());
 
   // Fire an event when an alert first appears.
-  if (role_ == AccessibilityNodeData::ROLE_ALERT && first_time_)
-    manager_->NotifyAccessibilityEvent(AccessibilityNotificationAlert, this);
+  if (role_ == WebKit::WebAXRoleAlert && first_time_)
+    manager_->NotifyAccessibilityEvent(WebKit::WebAXEventAlert, this);
 
   // Fire events if text has changed.
   string16 text = TextForIAccessibleText();
   if (previous_text_ != text) {
     if (!previous_text_.empty() && !text.empty()) {
       manager_->NotifyAccessibilityEvent(
-          AccessibilityNotificationObjectShow, this);
+          WebKit::WebAXEventShow, this);
     }
 
     // TODO(dmazzoni): Look into HIDE events, too.
 
     old_text_ = previous_text_;
     previous_text_ = text;
   }
 
   // Fire events if the state has changed.
   if (!first_time_ && ia_state_ != old_ia_state_) {
     BrowserAccessibilityManagerWin* manager =
         manager_->ToBrowserAccessibilityManagerWin();
 
     // Normally focus events are handled elsewhere, however
     // focus for managed descendants is platform-specific.
     // Fire a focus event if the focused descendant in a multi-select
     // list box changes.
-    if (role_ == AccessibilityNodeData::ROLE_LISTBOX_OPTION &&
+    if (role_ == WebKit::WebAXRoleListBoxOption &&
         (ia_state_ & STATE_SYSTEM_FOCUSABLE) &&
         (ia_state_ & STATE_SYSTEM_SELECTABLE) &&
         (ia_state_ & STATE_SYSTEM_FOCUSED) &&
         !(old_ia_state_ & STATE_SYSTEM_FOCUSED)) {
       manager->MaybeCallNotifyWinEvent(EVENT_OBJECT_FOCUS, unique_id_win());
     }
 
     if ((ia_state_ & STATE_SYSTEM_SELECTED) &&
         !(old_ia_state_ & STATE_SYSTEM_SELECTED)) {
       manager->MaybeCallNotifyWinEvent(EVENT_OBJECT_SELECTIONADD,
@@ skipping 100 matching lines @@
   if (value.empty() &&
       GetFloatAttribute(AccessibilityNodeData::ATTR_VALUE_FOR_RANGE, &fval)) {
     value = UTF8ToUTF16(base::DoubleToString(fval));
   }
   return value;
 }
 
 string16 BrowserAccessibilityWin::TextForIAccessibleText() {
   if (IsEditableText())
     return UTF8ToUTF16(value_);
-  return (role_ == AccessibilityNodeData::ROLE_STATIC_TEXT) ?
+  return (role_ == WebKit::WebAXRoleStaticText) ?
       UTF8ToUTF16(name_) : hypertext_;
 }
 
 void BrowserAccessibilityWin::HandleSpecialTextOffset(const string16& text,
                                                       LONG* offset) {
   if (*offset == IA2_TEXT_OFFSET_LENGTH)
     *offset = static_cast<LONG>(text.size());
   else if (*offset == IA2_TEXT_OFFSET_CARET)
     get_caretOffset(offset);
 }
@@ skipping 29 matching lines @@
 BrowserAccessibilityWin* BrowserAccessibilityWin::GetFromRendererID(
     int32 renderer_id) {
   return manager_->GetFromRendererID(renderer_id)->ToBrowserAccessibilityWin();
 }
 
 void BrowserAccessibilityWin::InitRoleAndState() {
   ia_state_ = 0;
   ia2_state_ = IA2_STATE_OPAQUE;
   ia2_attributes_.clear();
 
-  if (HasState(AccessibilityNodeData::STATE_BUSY))
+  if (HasState(WebKit::WebAXStateBusy))
     ia_state_ |= STATE_SYSTEM_BUSY;
-  if (HasState(AccessibilityNodeData::STATE_CHECKED))
+  if (HasState(WebKit::WebAXStateChecked))
     ia_state_ |= STATE_SYSTEM_CHECKED;
-  if (HasState(AccessibilityNodeData::STATE_COLLAPSED))
+  if (HasState(WebKit::WebAXStateCollapsed))
     ia_state_ |= STATE_SYSTEM_COLLAPSED;
-  if (HasState(AccessibilityNodeData::STATE_EXPANDED))
+  if (HasState(WebKit::WebAXStateExpanded))
     ia_state_ |= STATE_SYSTEM_EXPANDED;
-  if (HasState(AccessibilityNodeData::STATE_FOCUSABLE))
+  if (HasState(WebKit::WebAXStateFocusable))
     ia_state_ |= STATE_SYSTEM_FOCUSABLE;
-  if (HasState(AccessibilityNodeData::STATE_HASPOPUP))
+  if (HasState(WebKit::WebAXStateHaspopup))
     ia_state_ |= STATE_SYSTEM_HASPOPUP;
-  if (HasState(AccessibilityNodeData::STATE_HOTTRACKED))
+  if (HasState(WebKit::WebAXStateHovered))
     ia_state_ |= STATE_SYSTEM_HOTTRACKED;
-  if (HasState(AccessibilityNodeData::STATE_INDETERMINATE))
+  if (HasState(WebKit::WebAXStateIndeterminate))
     ia_state_ |= STATE_SYSTEM_INDETERMINATE;
-  if (HasState(AccessibilityNodeData::STATE_INVISIBLE))
+  if (HasState(WebKit::WebAXStateInvisible))
     ia_state_ |= STATE_SYSTEM_INVISIBLE;
-  if (HasState(AccessibilityNodeData::STATE_LINKED))
+  if (HasState(WebKit::WebAXStateLinked))
     ia_state_ |= STATE_SYSTEM_LINKED;
-  if (HasState(AccessibilityNodeData::STATE_MULTISELECTABLE)) {
+  if (HasState(WebKit::WebAXStateMultiselectable)) {
     ia_state_ |= STATE_SYSTEM_EXTSELECTABLE;
     ia_state_ |= STATE_SYSTEM_MULTISELECTABLE;
   }
   // TODO(ctguil): Support STATE_SYSTEM_EXTSELECTABLE/accSelect.
-  if (HasState(AccessibilityNodeData::STATE_OFFSCREEN))
+  if (HasState(WebKit::WebAXStateOffscreen))
     ia_state_ |= STATE_SYSTEM_OFFSCREEN;
-  if (HasState(AccessibilityNodeData::STATE_PRESSED))
+  if (HasState(WebKit::WebAXStatePressed))
     ia_state_ |= STATE_SYSTEM_PRESSED;
-  if (HasState(AccessibilityNodeData::STATE_PROTECTED))
+  if (HasState(WebKit::WebAXStateProtected))
     ia_state_ |= STATE_SYSTEM_PROTECTED;
-  if (HasState(AccessibilityNodeData::STATE_REQUIRED))
+  if (HasState(WebKit::WebAXStateRequired))
     ia2_state_ |= IA2_STATE_REQUIRED;
-  if (HasState(AccessibilityNodeData::STATE_SELECTABLE))
+  if (HasState(WebKit::WebAXStateSelectable))
     ia_state_ |= STATE_SYSTEM_SELECTABLE;
-  if (HasState(AccessibilityNodeData::STATE_SELECTED))
+  if (HasState(WebKit::WebAXStateSelected))
     ia_state_ |= STATE_SYSTEM_SELECTED;
-  if (HasState(AccessibilityNodeData::STATE_TRAVERSED))
+  if (HasState(WebKit::WebAXStateVisited))
     ia_state_ |= STATE_SYSTEM_TRAVERSED;
-  if (HasState(AccessibilityNodeData::STATE_UNAVAILABLE))
+  if (!HasState(WebKit::WebAXStateEnabled))
     ia_state_ |= STATE_SYSTEM_UNAVAILABLE;
-  if (HasState(AccessibilityNodeData::STATE_VERTICAL)) {
+  if (HasState(WebKit::WebAXStateVertical)) {
     ia2_state_ |= IA2_STATE_VERTICAL;
   } else {
     ia2_state_ |= IA2_STATE_HORIZONTAL;
   }
-  if (HasState(AccessibilityNodeData::STATE_VISITED))
+  if (HasState(WebKit::WebAXStateVisited))
     ia_state_ |= STATE_SYSTEM_TRAVERSED;
 
   // WebKit marks everything as readonly unless it's editable text, so if it's
   // not readonly, mark it as editable now. The final computation of the
   // READONLY state for MSAA is below, after the switch.
-  if (!HasState(AccessibilityNodeData::STATE_READONLY))
+  if (!HasState(WebKit::WebAXStateReadonly))
     ia2_state_ |= IA2_STATE_EDITABLE;
 
   string16 invalid;
   if (GetHtmlAttribute("aria-invalid", &invalid))
     ia2_state_ |= IA2_STATE_INVALID_ENTRY;
 
   if (GetBoolAttribute(AccessibilityNodeData::ATTR_BUTTON_MIXED))
     ia_state_ |= STATE_SYSTEM_MIXED;
 
   if (GetBoolAttribute(AccessibilityNodeData::ATTR_CAN_SET_VALUE))
     ia2_state_ |= IA2_STATE_EDITABLE;
 
   string16 html_tag = GetString16Attribute(
       AccessibilityNodeData::ATTR_HTML_TAG);
   ia_role_ = 0;
   ia2_role_ = 0;
   switch (role_) {
-    case AccessibilityNodeData::ROLE_ALERT:
+    case WebKit::WebAXRoleAlert:
       ia_role_ = ROLE_SYSTEM_ALERT;
       break;
-    case AccessibilityNodeData::ROLE_ALERT_DIALOG:
+    case WebKit::WebAXRoleAlertDialog:
       ia_role_ = ROLE_SYSTEM_DIALOG;
       break;
-    case AccessibilityNodeData::ROLE_APPLICATION:
+    case WebKit::WebAXRoleApplication:
       ia_role_ = ROLE_SYSTEM_APPLICATION;
       break;
-    case AccessibilityNodeData::ROLE_ARTICLE:
+    case WebKit::WebAXRoleArticle:
       ia_role_ = ROLE_SYSTEM_GROUPING;
       ia2_role_ = IA2_ROLE_SECTION;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_BUSY_INDICATOR:
+    case WebKit::WebAXRoleBusyIndicator:
       ia_role_ = ROLE_SYSTEM_ANIMATION;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_BUTTON:
+    case WebKit::WebAXRoleButton:
       ia_role_ = ROLE_SYSTEM_PUSHBUTTON;
       bool is_aria_pressed_defined;
       bool is_mixed;
       if (GetAriaTristate("aria-pressed", &is_aria_pressed_defined, &is_mixed))
         ia_state_ |= STATE_SYSTEM_PRESSED;
       if (is_aria_pressed_defined)
         ia2_role_ = IA2_ROLE_TOGGLE_BUTTON;
       if (is_mixed)
         ia_state_ |= STATE_SYSTEM_MIXED;
       break;
-    case AccessibilityNodeData::ROLE_CANVAS:
-      ia_role_ = ROLE_SYSTEM_GRAPHIC;
+    case WebKit::WebAXRoleCanvas:
+      if (GetBoolAttribute(AccessibilityNodeData::ATTR_CANVAS_HAS_FALLBACK)) {
+        role_name_ = L"canvas";
+        ia2_role_ = IA2_ROLE_CANVAS;
+      } else {
+        ia_role_ = ROLE_SYSTEM_GRAPHIC;
+      }
       break;
-    case AccessibilityNodeData::ROLE_CANVAS_WITH_FALLBACK_CONTENT:
-      role_name_ = L"canvas";
-      ia2_role_ = IA2_ROLE_CANVAS;
-      break;
-    case AccessibilityNodeData::ROLE_CELL:
+    case WebKit::WebAXRoleCell:
       ia_role_ = ROLE_SYSTEM_CELL;
       break;
-    case AccessibilityNodeData::ROLE_CHECKBOX:
+    case WebKit::WebAXRoleCheckBox:
       ia_role_ = ROLE_SYSTEM_CHECKBUTTON;
       break;
-    case AccessibilityNodeData::ROLE_COLOR_WELL:
+    case WebKit::WebAXRoleColorWell:
       ia_role_ = ROLE_SYSTEM_CLIENT;
       ia2_role_ = IA2_ROLE_COLOR_CHOOSER;
       break;
-    case AccessibilityNodeData::ROLE_COLUMN:
+    case WebKit::WebAXRoleColumn:
       ia_role_ = ROLE_SYSTEM_COLUMN;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_COLUMN_HEADER:
+    case WebKit::WebAXRoleColumnHeader:
       ia_role_ = ROLE_SYSTEM_COLUMNHEADER;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_COMBO_BOX:
+    case WebKit::WebAXRoleComboBox:
       ia_role_ = ROLE_SYSTEM_COMBOBOX;
       break;
-    case AccessibilityNodeData::ROLE_DIV:
+    case WebKit::WebAXRoleDiv:
       role_name_ = L"div";
       ia2_role_ = IA2_ROLE_SECTION;
       break;
-    case AccessibilityNodeData::ROLE_DEFINITION:
+    case WebKit::WebAXRoleDefinition:
       role_name_ = html_tag;
       ia2_role_ = IA2_ROLE_PARAGRAPH;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_DESCRIPTION_LIST_DETAIL:
+    case WebKit::WebAXRoleDescriptionListDetail:
       role_name_ = html_tag;
       ia2_role_ = IA2_ROLE_PARAGRAPH;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_DESCRIPTION_LIST_TERM:
+    case WebKit::WebAXRoleDescriptionListTerm:
       ia_role_ = ROLE_SYSTEM_LISTITEM;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_DIALOG:
+    case WebKit::WebAXRoleDialog:
       ia_role_ = ROLE_SYSTEM_DIALOG;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_DISCLOSURE_TRIANGLE:
+    case WebKit::WebAXRoleDisclosureTriangle:
       ia_role_ = ROLE_SYSTEM_OUTLINEBUTTON;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_DOCUMENT:
-    case AccessibilityNodeData::ROLE_ROOT_WEB_AREA:
-    case AccessibilityNodeData::ROLE_WEB_AREA:
+    case WebKit::WebAXRoleDocument:
+    case WebKit::WebAXRoleRootWebArea:
+    case WebKit::WebAXRoleWebArea:
       ia_role_ = ROLE_SYSTEM_DOCUMENT;
       ia_state_ |= STATE_SYSTEM_READONLY;
       ia_state_ |= STATE_SYSTEM_FOCUSABLE;
       break;
-    case AccessibilityNodeData::ROLE_EDITABLE_TEXT:
+    case WebKit::WebAXRoleEditableText:
       ia_role_ = ROLE_SYSTEM_TEXT;
       ia2_state_ |= IA2_STATE_SINGLE_LINE;
       ia2_state_ |= IA2_STATE_EDITABLE;
       break;
-    case AccessibilityNodeData::ROLE_FORM:
+    case WebKit::WebAXRoleForm:
       role_name_ = L"form";
       ia2_role_ = IA2_ROLE_FORM;
       break;
-    case AccessibilityNodeData::ROLE_FOOTER:
+    case WebKit::WebAXRoleFooter:
       ia_role_ = IA2_ROLE_FOOTER;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_GRID:
+    case WebKit::WebAXRoleGrid:
       ia_role_ = ROLE_SYSTEM_TABLE;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_GROUP: {
+    case WebKit::WebAXRoleGroup: {
       string16 aria_role = GetString16Attribute(
           AccessibilityNodeData::ATTR_ROLE);
       if (aria_role == L"group" || html_tag == L"fieldset") {
         ia_role_ = ROLE_SYSTEM_GROUPING;
       } else if (html_tag == L"li") {
         ia_role_ = ROLE_SYSTEM_LISTITEM;
       } else {
         if (html_tag.empty())
           role_name_ = L"div";
         else
           role_name_ = html_tag;
         ia2_role_ = IA2_ROLE_SECTION;
       }
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
     }
-    case AccessibilityNodeData::ROLE_GROW_AREA:
+    case WebKit::WebAXRoleGrowArea:
       ia_role_ = ROLE_SYSTEM_GRIP;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_HEADING:
+    case WebKit::WebAXRoleHeading:
       role_name_ = html_tag;
       ia2_role_ = IA2_ROLE_HEADING;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_HORIZONTAL_RULE:
+    case WebKit::WebAXRoleHorizontalRule:
       ia_role_ = ROLE_SYSTEM_SEPARATOR;
       break;
-    case AccessibilityNodeData::ROLE_IMAGE:
+    case WebKit::WebAXRoleImage:
       ia_role_ = ROLE_SYSTEM_GRAPHIC;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_IMAGE_MAP:
+    case WebKit::WebAXRoleImageMap:
       role_name_ = html_tag;
       ia2_role_ = IA2_ROLE_IMAGE_MAP;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_IMAGE_MAP_LINK:
+    case WebKit::WebAXRoleImageMapLink:
       ia_role_ = ROLE_SYSTEM_LINK;
       ia_state_ |= STATE_SYSTEM_LINKED;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_LABEL:
+    case WebKit::WebAXRoleLabel:
       ia_role_ = ROLE_SYSTEM_TEXT;
       ia2_role_ = IA2_ROLE_LABEL;
       break;
-    case AccessibilityNodeData::ROLE_LANDMARK_APPLICATION:
-    case AccessibilityNodeData::ROLE_LANDMARK_BANNER:
-    case AccessibilityNodeData::ROLE_LANDMARK_COMPLEMENTARY:
-    case AccessibilityNodeData::ROLE_LANDMARK_CONTENTINFO:
-    case AccessibilityNodeData::ROLE_LANDMARK_MAIN:
-    case AccessibilityNodeData::ROLE_LANDMARK_NAVIGATION:
-    case AccessibilityNodeData::ROLE_LANDMARK_SEARCH:
+    case WebKit::WebAXRoleBanner:
+    case WebKit::WebAXRoleComplementary:
+    case WebKit::WebAXRoleContentInfo:
+    case WebKit::WebAXRoleMain:
+    case WebKit::WebAXRoleNavigation:
+    case WebKit::WebAXRoleSearch:
       ia_role_ = ROLE_SYSTEM_GROUPING;
       ia2_role_ = IA2_ROLE_SECTION;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_LINK:
-    case AccessibilityNodeData::ROLE_WEBCORE_LINK:
+    case WebKit::WebAXRoleLink:
       ia_role_ = ROLE_SYSTEM_LINK;
       ia_state_ |= STATE_SYSTEM_LINKED;
       break;
-    case AccessibilityNodeData::ROLE_LIST:
+    case WebKit::WebAXRoleList:
       ia_role_ = ROLE_SYSTEM_LIST;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_LISTBOX:
+    case WebKit::WebAXRoleListBox:
       ia_role_ = ROLE_SYSTEM_LIST;
       break;
-    case AccessibilityNodeData::ROLE_LISTBOX_OPTION:
+    case WebKit::WebAXRoleListBoxOption:
       ia_role_ = ROLE_SYSTEM_LISTITEM;
       if (ia_state_ & STATE_SYSTEM_SELECTABLE) {
         ia_state_ |= STATE_SYSTEM_FOCUSABLE;
-        if (HasState(AccessibilityNodeData::STATE_FOCUSED))
+        if (HasState(WebKit::WebAXStateFocused))
           ia_state_ |= STATE_SYSTEM_FOCUSED;
       }
       break;
-    case AccessibilityNodeData::ROLE_LIST_ITEM:
+    case WebKit::WebAXRoleListItem:
       ia_role_ = ROLE_SYSTEM_LISTITEM;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_LIST_MARKER:
+    case WebKit::WebAXRoleListMarker:
       ia_role_ = ROLE_SYSTEM_TEXT;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_MATH:
+    case WebKit::WebAXRoleMath:
       ia_role_ = ROLE_SYSTEM_EQUATION;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_MENU:
-    case AccessibilityNodeData::ROLE_MENU_BUTTON:
+    case WebKit::WebAXRoleMenu:
+    case WebKit::WebAXRoleMenuButton:
       ia_role_ = ROLE_SYSTEM_MENUPOPUP;
       break;
-    case AccessibilityNodeData::ROLE_MENU_BAR:
+    case WebKit::WebAXRoleMenuBar:
       ia_role_ = ROLE_SYSTEM_MENUBAR;
       break;
-    case AccessibilityNodeData::ROLE_MENU_ITEM:
+    case WebKit::WebAXRoleMenuItem:
       ia_role_ = ROLE_SYSTEM_MENUITEM;
       break;
-    case AccessibilityNodeData::ROLE_MENU_LIST_POPUP:
+    case WebKit::WebAXRoleMenuListPopup:
       ia_role_ = ROLE_SYSTEM_CLIENT;
       break;
-    case AccessibilityNodeData::ROLE_MENU_LIST_OPTION:
+    case WebKit::WebAXRoleMenuListOption:
       ia_role_ = ROLE_SYSTEM_LISTITEM;
       if (ia_state_ & STATE_SYSTEM_SELECTABLE) {
         ia_state_ |= STATE_SYSTEM_FOCUSABLE;
-        if (HasState(AccessibilityNodeData::STATE_FOCUSED))
+        if (HasState(WebKit::WebAXStateFocused))
           ia_state_ |= STATE_SYSTEM_FOCUSED;
       }
       break;
-    case AccessibilityNodeData::ROLE_NOTE:
+    case WebKit::WebAXRoleNote:
       ia_role_ = ROLE_SYSTEM_GROUPING;
       ia2_role_ = IA2_ROLE_NOTE;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_OUTLINE:
+    case WebKit::WebAXRoleOutline:
       ia_role_ = ROLE_SYSTEM_OUTLINE;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_PARAGRAPH:
+    case WebKit::WebAXRoleParagraph:
       role_name_ = L"P";
       ia2_role_ = IA2_ROLE_PARAGRAPH;
       break;
-    case AccessibilityNodeData::ROLE_POPUP_BUTTON:
+    case WebKit::WebAXRolePopUpButton:
       if (html_tag == L"select") {
         ia_role_ = ROLE_SYSTEM_COMBOBOX;
       } else {
         ia_role_ = ROLE_SYSTEM_BUTTONMENU;
       }
       break;
-    case AccessibilityNodeData::ROLE_PROGRESS_INDICATOR:
+    case WebKit::WebAXRoleProgressIndicator:
       ia_role_ = ROLE_SYSTEM_PROGRESSBAR;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_RADIO_BUTTON:
+    case WebKit::WebAXRoleRadioButton:
       ia_role_ = ROLE_SYSTEM_RADIOBUTTON;
       break;
-    case AccessibilityNodeData::ROLE_RADIO_GROUP:
+    case WebKit::WebAXRoleRadioGroup:
       ia_role_ = ROLE_SYSTEM_GROUPING;
       ia2_role_ = IA2_ROLE_SECTION;
       break;
-    case AccessibilityNodeData::ROLE_REGION:
+    case WebKit::WebAXRoleRegion:
       ia_role_ = ROLE_SYSTEM_GROUPING;
       ia2_role_ = IA2_ROLE_SECTION;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_ROW:
+    case WebKit::WebAXRoleRow:
       ia_role_ = ROLE_SYSTEM_ROW;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_ROW_HEADER:
+    case WebKit::WebAXRoleRowHeader:
       ia_role_ = ROLE_SYSTEM_ROWHEADER;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_RULER:
+    case WebKit::WebAXRoleRuler:
       ia_role_ = ROLE_SYSTEM_CLIENT;
       ia2_role_ = IA2_ROLE_RULER;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_SCROLLAREA:
+    case WebKit::WebAXRoleScrollArea:
       ia_role_ = ROLE_SYSTEM_CLIENT;
       ia2_role_ = IA2_ROLE_SCROLL_PANE;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_SCROLLBAR:
+    case WebKit::WebAXRoleScrollBar:
       ia_role_ = ROLE_SYSTEM_SCROLLBAR;
       break;
-    case AccessibilityNodeData::ROLE_SLIDER:
+    case WebKit::WebAXRoleSlider:
       ia_role_ = ROLE_SYSTEM_SLIDER;
       break;
-    case AccessibilityNodeData::ROLE_SPIN_BUTTON:
+    case WebKit::WebAXRoleSpinButton:
       ia_role_ = ROLE_SYSTEM_SPINBUTTON;
       break;
-    case AccessibilityNodeData::ROLE_SPIN_BUTTON_PART:
+    case WebKit::WebAXRoleSpinButtonPart:
       ia_role_ = ROLE_SYSTEM_PUSHBUTTON;
       break;
-    case AccessibilityNodeData::ROLE_SPLIT_GROUP:
+    case WebKit::WebAXRoleSplitGroup:
       ia_role_ = ROLE_SYSTEM_CLIENT;
       ia2_role_ = IA2_ROLE_SPLIT_PANE;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_ANNOTATION:
-    case AccessibilityNodeData::ROLE_STATIC_TEXT:
+    case WebKit::WebAXRoleAnnotation:
+    case WebKit::WebAXRoleStaticText:
       ia_role_ = ROLE_SYSTEM_TEXT;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_STATUS:
+    case WebKit::WebAXRoleStatus:
       ia_role_ = ROLE_SYSTEM_STATUSBAR;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_SPLITTER:
+    case WebKit::WebAXRoleSplitter:
       ia_role_ = ROLE_SYSTEM_SEPARATOR;
       break;
-    case AccessibilityNodeData::ROLE_SVG_ROOT:
+    case WebKit::WebAXRoleSVGRoot:
       ia_role_ = ROLE_SYSTEM_GRAPHIC;
       break;
-    case AccessibilityNodeData::ROLE_TAB:
+    case WebKit::WebAXRoleTab:
       ia_role_ = ROLE_SYSTEM_PAGETAB;
       break;
-    case AccessibilityNodeData::ROLE_TABLE: {
+    case WebKit::WebAXRoleTable: {
       string16 aria_role = GetString16Attribute(
           AccessibilityNodeData::ATTR_ROLE);
       if (aria_role == L"treegrid") {
         ia_role_ = ROLE_SYSTEM_OUTLINE;
       } else {
         ia_role_ = ROLE_SYSTEM_TABLE;
         ia_state_ |= STATE_SYSTEM_READONLY;
       }
       break;
     }
-    case AccessibilityNodeData::ROLE_TABLE_HEADER_CONTAINER:
+    case WebKit::WebAXRoleTableHeaderContainer:
       ia_role_ = ROLE_SYSTEM_GROUPING;
       ia2_role_ = IA2_ROLE_SECTION;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_TAB_GROUP_UNUSED:
-      NOTREACHED();
+    case WebKit::WebAXRoleTabList:
       ia_role_ = ROLE_SYSTEM_PAGETABLIST;
       break;
-    case AccessibilityNodeData::ROLE_TAB_LIST:
-      ia_role_ = ROLE_SYSTEM_PAGETABLIST;
-      break;
-    case AccessibilityNodeData::ROLE_TAB_PANEL:
+    case WebKit::WebAXRoleTabPanel:
       ia_role_ = ROLE_SYSTEM_PROPERTYPAGE;
       break;
-    case AccessibilityNodeData::ROLE_TOGGLE_BUTTON:
+    case WebKit::WebAXRoleToggleButton:
       ia_role_ = ROLE_SYSTEM_PUSHBUTTON;
       ia2_role_ = IA2_ROLE_TOGGLE_BUTTON;
       break;
-    case AccessibilityNodeData::ROLE_TEXTAREA:
+    case WebKit::WebAXRoleTextArea:
       ia_role_ = ROLE_SYSTEM_TEXT;
       ia2_state_ |= IA2_STATE_MULTI_LINE;
       ia2_state_ |= IA2_STATE_EDITABLE;
       ia2_state_ |= IA2_STATE_SELECTABLE_TEXT;
       break;
-    case AccessibilityNodeData::ROLE_TEXT_FIELD:
+    case WebKit::WebAXRoleTextField:
       ia_role_ = ROLE_SYSTEM_TEXT;
       ia2_state_ |= IA2_STATE_SINGLE_LINE;
       ia2_state_ |= IA2_STATE_EDITABLE;
       ia2_state_ |= IA2_STATE_SELECTABLE_TEXT;
       break;
-    case AccessibilityNodeData::ROLE_TIMER:
+    case WebKit::WebAXRoleTimer:
       ia_role_ = ROLE_SYSTEM_CLOCK;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_TOOLBAR:
+    case WebKit::WebAXRoleToolbar:
       ia_role_ = ROLE_SYSTEM_TOOLBAR;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_TOOLTIP:
+    case WebKit::WebAXRoleUserInterfaceTooltip:
       ia_role_ = ROLE_SYSTEM_TOOLTIP;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_TREE:
+    case WebKit::WebAXRoleTree:
       ia_role_ = ROLE_SYSTEM_OUTLINE;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_TREE_GRID:
+    case WebKit::WebAXRoleTreeGrid:
       ia_role_ = ROLE_SYSTEM_OUTLINE;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_TREE_ITEM:
+    case WebKit::WebAXRoleTreeItem:
       ia_role_ = ROLE_SYSTEM_OUTLINEITEM;
       ia_state_ |= STATE_SYSTEM_READONLY;
       break;
-    case AccessibilityNodeData::ROLE_WINDOW:
+    case WebKit::WebAXRoleWindow:
       ia_role_ = ROLE_SYSTEM_WINDOW;
       break;
 
     // TODO(dmazzoni): figure out the proper MSAA role for all of these.
-    case AccessibilityNodeData::ROLE_BROWSER:
-    case AccessibilityNodeData::ROLE_DIRECTORY:
-    case AccessibilityNodeData::ROLE_DRAWER:
-    case AccessibilityNodeData::ROLE_HELP_TAG:
-    case AccessibilityNodeData::ROLE_IGNORED:
-    case AccessibilityNodeData::ROLE_INCREMENTOR:
-    case AccessibilityNodeData::ROLE_LOG:
-    case AccessibilityNodeData::ROLE_MARQUEE:
-    case AccessibilityNodeData::ROLE_MATTE:
-    case AccessibilityNodeData::ROLE_PRESENTATIONAL:
-    case AccessibilityNodeData::ROLE_RULER_MARKER:
-    case AccessibilityNodeData::ROLE_SHEET:
-    case AccessibilityNodeData::ROLE_SLIDER_THUMB:
-    case AccessibilityNodeData::ROLE_SYSTEM_WIDE:
-    case AccessibilityNodeData::ROLE_VALUE_INDICATOR:
+    case WebKit::WebAXRoleBrowser:
+    case WebKit::WebAXRoleDirectory:
+    case WebKit::WebAXRoleDrawer:
+    case WebKit::WebAXRoleHelpTag:
+    case WebKit::WebAXRoleIgnored:
+    case WebKit::WebAXRoleIncrementor:
+    case WebKit::WebAXRoleLog:
+    case WebKit::WebAXRoleMarquee:
+    case WebKit::WebAXRoleMatte:
+    case WebKit::WebAXRolePresentational:
+    case WebKit::WebAXRoleRulerMarker:
+    case WebKit::WebAXRoleSheet:
+    case WebKit::WebAXRoleSliderThumb:
+    case WebKit::WebAXRoleSystemWide:
+    case WebKit::WebAXRoleValueIndicator:
     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).
   // We clear the READONLY state on focusable controls and on a document.
   // Everything else, the majority of objects, do not have this state set.
-  if (HasState(AccessibilityNodeData::STATE_FOCUSABLE) &&
+  if (HasState(WebKit::WebAXStateFocusable) &&
       ia_role_ != ROLE_SYSTEM_DOCUMENT) {
     ia_state_ &= ~(STATE_SYSTEM_READONLY);
   }
-  if (!HasState(AccessibilityNodeData::STATE_READONLY))
+  if (!HasState(WebKit::WebAXStateReadonly))
     ia_state_ &= ~(STATE_SYSTEM_READONLY);
   if (GetBoolAttribute(AccessibilityNodeData::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_;
 }
 
 }  // namespace content