Move AX Role predicates into ax_role_properties.h.

content/browser/accessibility/browser_accessibility.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.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 724 matching lines @@
   return GetData().GetHtmlAttribute(html_attr, value);
 }
 
 bool BrowserAccessibility::GetHtmlAttribute(
     const char* html_attr, base::string16* value) const {
   return GetData().GetHtmlAttribute(html_attr, value);
 }
 
 BrowserAccessibility* BrowserAccessibility::GetTable() const {
   BrowserAccessibility* table = const_cast<BrowserAccessibility*>(this);
-  while (table && !table->IsTableLikeRole())
+  while (table && !ui::IsTableLikeRole(table->GetRole()))
     table = table->PlatformGetParent();
   return table;
 }
 
 BrowserAccessibility* BrowserAccessibility::GetTableCell(int index) const {
-  if (!IsTableLikeRole() && !IsCellOrTableHeaderRole())
+  if (!ui::IsTableLikeRole(GetRole()) &&
+      !ui::IsCellOrTableHeaderRole(GetRole()))
     return nullptr;
 
   BrowserAccessibility* table = GetTable();
   if (!table)
     return nullptr;
   const std::vector<int32_t>& unique_cell_ids =
       table->GetIntListAttribute(ui::AX_ATTR_UNIQUE_CELL_IDS);
   if (index < 0 || index >= static_cast<int>(unique_cell_ids.size()))
     return nullptr;
   return table->manager_->GetFromID(unique_cell_ids[index]);
 }
 
 BrowserAccessibility* BrowserAccessibility::GetTableCell(int row,
                                                          int column) const {
-  if (!IsTableLikeRole() && !IsCellOrTableHeaderRole())
+  if (!ui::IsTableLikeRole(GetRole()) &&
+      !ui::IsCellOrTableHeaderRole(GetRole()))
     return nullptr;
   if (row < 0 || row >= GetTableRowCount() || column < 0 ||
       column >= GetTableColumnCount()) {
     return nullptr;
   }
 
   BrowserAccessibility* table = GetTable();
   if (!table)
     return nullptr;
 
   // In contrast to unique cell IDs, these are duplicated whenever a cell spans
   // multiple columns or rows.
   const std::vector<int32_t>& cell_ids =
       table->GetIntListAttribute(ui::AX_ATTR_CELL_IDS);
   DCHECK_EQ(GetTableRowCount() * GetTableColumnCount(),
             static_cast<int>(cell_ids.size()));
   int position = row * GetTableColumnCount() + column;
   if (position < 0 || position >= static_cast<int>(cell_ids.size()))
     return nullptr;
   return table->manager_->GetFromID(cell_ids[position]);
 }
 
 int BrowserAccessibility::GetTableCellIndex() const {
-  if (!IsCellOrTableHeaderRole())
+  if (!ui::IsCellOrTableHeaderRole(GetRole()))
     return -1;
 
   BrowserAccessibility* table = GetTable();
   if (!table)
     return -1;
 
   const std::vector<int32_t>& unique_cell_ids =
       table->GetIntListAttribute(ui::AX_ATTR_UNIQUE_CELL_IDS);
   auto iter =
       std::find(unique_cell_ids.begin(), unique_cell_ids.end(), GetId());
   if (iter == unique_cell_ids.end())
     return -1;
 
   return std::distance(unique_cell_ids.begin(), iter);
 }
 
 int BrowserAccessibility::GetTableColumn() const {
   return GetIntAttribute(ui::AX_ATTR_TABLE_CELL_COLUMN_INDEX);
 }
 
 int BrowserAccessibility::GetTableColumnCount() const {
   BrowserAccessibility* table = GetTable();
   if (!table)
     return 0;
 
   return table->GetIntAttribute(ui::AX_ATTR_TABLE_COLUMN_COUNT);
 }
 
 int BrowserAccessibility::GetTableColumnSpan() const {
-  if (!IsCellOrTableHeaderRole())
+  if (!ui::IsCellOrTableHeaderRole(GetRole()))
     return 0;
 
   int column_span;
   if (GetIntAttribute(ui::AX_ATTR_TABLE_CELL_COLUMN_SPAN, &column_span))
     return column_span;
   return 1;
 }
 
 int BrowserAccessibility::GetTableRow() const {
   return GetIntAttribute(ui::AX_ATTR_TABLE_CELL_ROW_INDEX);
 }
 
 int BrowserAccessibility::GetTableRowCount() const {
   BrowserAccessibility* table = GetTable();
   if (!table)
     return 0;
 
   return table->GetIntAttribute(ui::AX_ATTR_TABLE_ROW_COUNT);
 }
 
 int BrowserAccessibility::GetTableRowSpan() const {
-  if (!IsCellOrTableHeaderRole())
+  if (!ui::IsCellOrTableHeaderRole(GetRole()))
     return 0;
 
   int row_span;
   if (GetIntAttribute(ui::AX_ATTR_TABLE_CELL_ROW_SPAN, &row_span))
     return row_span;
   return 1;
 }
 
 base::string16 BrowserAccessibility::GetText() const {
   return GetInnerText();
 }
 
 bool BrowserAccessibility::HasState(ui::AXState state_enum) const {
   return GetData().HasState(state_enum);
 }
 
 bool BrowserAccessibility::HasAction(ui::AXAction action_enum) const {
   return GetData().HasAction(action_enum);
 }
 
-bool BrowserAccessibility::IsCellOrTableHeaderRole() const {
-  return (GetRole() == ui::AX_ROLE_CELL ||
-          GetRole() == ui::AX_ROLE_COLUMN_HEADER ||
-          GetRole() == ui::AX_ROLE_ROW_HEADER);
-}
-
-bool BrowserAccessibility::IsTableLikeRole() const {
-  return (GetRole() == ui::AX_ROLE_TABLE ||
-          GetRole() == ui::AX_ROLE_GRID ||
-          GetRole() == ui::AX_ROLE_TREE_GRID);
-}
-
 bool BrowserAccessibility::HasCaret() const {
   if (IsSimpleTextControl() && HasIntAttribute(ui::AX_ATTR_TEXT_SEL_START) &&
       HasIntAttribute(ui::AX_ATTR_TEXT_SEL_END)) {
     return true;
   }
 
   // The caret is always at the focus of the selection.
   int32_t focus_id = manager()->GetTreeData().sel_focus_object_id;
   BrowserAccessibility* focus_object = manager()->GetFromID(focus_id);
   if (!focus_object)
@@ skipping 275 matching lines @@
 
   if (data.action == ui::AX_ACTION_FOCUS) {
     manager_->SetFocus(*this);
     return true;
   }
 
   return false;
 }
 
 }  // namespace content