Converts accNavigate over to the AXPlatformNode code.

ui/accessibility/platform/ax_platform_node_base.cc

 // Copyright 2014 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 "ui/accessibility/platform/ax_platform_node_base.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "ui/accessibility/ax_action_data.h"
 #include "ui/accessibility/ax_node_data.h"
+#include "ui/accessibility/ax_role_properties.h"
 #include "ui/accessibility/platform/ax_platform_node_delegate.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace ui {
 
 void AXPlatformNodeBase::Init(AXPlatformNodeDelegate* delegate) {
   delegate_ = delegate;
 }
 
 const AXNodeData& AXPlatformNodeBase::GetData() const {
@@ skipping 162 matching lines @@
   return GetData().GetString16Attribute(attribute);
 }
 
 bool AXPlatformNodeBase::GetString16Attribute(
     ui::AXStringAttribute attribute,
     base::string16* value) const {
   CHECK(delegate_);
   return GetData().GetString16Attribute(attribute, value);
 }
 
+bool AXPlatformNodeBase::HasIntListAttribute(
+    ui::AXIntListAttribute attribute) const {
+  return GetData().HasIntListAttribute(attribute);
+}
+
+const std::vector<int32_t>& AXPlatformNodeBase::GetIntListAttribute(
+    ui::AXIntListAttribute attribute) const {
+  return GetData().GetIntListAttribute(attribute);
+}
+
+bool AXPlatformNodeBase::GetIntListAttribute(
+    ui::AXIntListAttribute attribute,
+    std::vector<int32_t>* value) const {
+  return GetData().GetIntListAttribute(attribute, value);
+}
+
 AXPlatformNodeBase::AXPlatformNodeBase() {
 }
 
 AXPlatformNodeBase::~AXPlatformNodeBase() {
   CHECK(!delegate_);
 }
 
 // static
 AXPlatformNodeBase* AXPlatformNodeBase::FromNativeViewAccessible(
     gfx::NativeViewAccessible accessible) {
@@ skipping 79 matching lines @@
     case ui::AX_ROLE_SPIN_BUTTON:
     case ui::AX_ROLE_SCROLL_BAR:
       return true;
     case ui::AX_ROLE_SPLITTER:
       return GetData().HasState(ui::AX_STATE_FOCUSABLE);
     default:
       return false;
   }
 }
 
+AXPlatformNodeBase* AXPlatformNodeBase::GetTable() const {
+  AXPlatformNodeBase* table = const_cast<AXPlatformNodeBase*>(this);
+  while (table && !ui::IsTableLikeRole(table->GetData().role)) {
+    gfx::NativeViewAccessible parent_accessible = table->GetParent();
+    AXPlatformNodeBase* parent = FromNativeViewAccessible(parent_accessible);
+
+    table = parent;
+  }
+  return table;
+}
+
+AXPlatformNodeBase* AXPlatformNodeBase::GetTableCell(int index) const {
+  DCHECK(delegate_);
+
+  if (!ui::IsTableLikeRole(GetData().role) &&
+      !ui::IsCellOrTableHeaderRole(GetData().role))
+    return nullptr;
+
+  AXPlatformNodeBase* 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 static_cast<AXPlatformNodeBase*>(
+      table->delegate_->GetFromNodeID(unique_cell_ids[index]));
+}
+
+AXPlatformNodeBase* AXPlatformNodeBase::GetTableCell(int row,
+                                                     int column) const {
+  if (!ui::IsTableLikeRole(GetData().role) &&
+      !ui::IsCellOrTableHeaderRole(GetData().role))
+    return nullptr;
+
+  if (row < 0 || row >= GetTableRowCount() || column < 0 ||
+      column >= GetTableColumnCount()) {
+    return nullptr;
+  }
+
+  AXPlatformNodeBase* 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 static_cast<AXPlatformNodeBase*>(
+      table->delegate_->GetFromNodeID(cell_ids[position]));
+}
+
+int AXPlatformNodeBase::GetTableCellIndex() const {
+  if (!ui::IsCellOrTableHeaderRole(GetData().role))
+    return -1;
+
+  AXPlatformNodeBase* 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(), GetData().id);
+  if (iter == unique_cell_ids.end())
+    return -1;
+
+  return std::distance(unique_cell_ids.begin(), iter);
+}
+
+int AXPlatformNodeBase::GetTableColumn() const {
+  return GetIntAttribute(ui::AX_ATTR_TABLE_CELL_COLUMN_INDEX);
+}
+
+int AXPlatformNodeBase::GetTableColumnCount() const {
+  AXPlatformNodeBase* table = GetTable();
+  if (!table)
+    return 0;
+
+  return table->GetIntAttribute(ui::AX_ATTR_TABLE_COLUMN_COUNT);
+}
+
+int AXPlatformNodeBase::GetTableColumnSpan() const {
+  if (!ui::IsCellOrTableHeaderRole(GetData().role))
+    return 0;
+
+  int column_span;
+  if (GetIntAttribute(ui::AX_ATTR_TABLE_CELL_COLUMN_SPAN, &column_span))
+    return column_span;
+  return 1;
+}
+
+int AXPlatformNodeBase::GetTableRow() const {
+  return GetIntAttribute(ui::AX_ATTR_TABLE_CELL_ROW_INDEX);
+}
+
+int AXPlatformNodeBase::GetTableRowCount() const {
+  AXPlatformNodeBase* table = GetTable();
+  if (!table)
+    return 0;
+
+  return table->GetIntAttribute(ui::AX_ATTR_TABLE_ROW_COUNT);
+}
+
+int AXPlatformNodeBase::GetTableRowSpan() const {
+  if (!ui::IsCellOrTableHeaderRole(GetData().role))
+    return 0;
+
+  int row_span;
+  if (GetIntAttribute(ui::AX_ATTR_TABLE_CELL_ROW_SPAN, &row_span))
+    return row_span;
+  return 1;
+}
+
 }  // namespace ui