Move WebAXObject.cpp to core/ (WIP)

third_party/WebKit/Source/modules/accessibility/AXObjectImpl.cpp

Index: third_party/WebKit/Source/modules/accessibility/AXObjectImpl.cpp
diff --git a/third_party/WebKit/Source/modules/accessibility/AXObjectImpl.cpp b/third_party/WebKit/Source/modules/accessibility/AXObjectImpl.cpp
index bef8d97b56ab45d5616b710b737dc53bdf7f33d6..d56d8961b727de3083604288b93f805e8e7e45f1 100644
--- a/third_party/WebKit/Source/modules/accessibility/AXObjectImpl.cpp
+++ b/third_party/WebKit/Source/modules/accessibility/AXObjectImpl.cpp
@@ -849,13 +849,13 @@ String AXObjectImpl::CollapseWhitespace(const String& str) {
 
 String AXObjectImpl::ComputedName() const {
   AXNameFrom name_from;
-  AXObjectImpl::AXObjectVector name_objects;
+  AXObjectImpl::AXObjectImplVector name_objects;
   return GetName(name_from, &name_objects);
 }
 
 String AXObjectImpl::GetName(AXNameFrom& name_from,
-                             AXObjectImpl::AXObjectVector* name_objects) const {
-  HeapHashSet<Member<const AXObjectImpl>> visited;
+                             AXObject::AXObjectVector* name_objects) const {
+  HeapHashSet<Member<const AXObject>> visited;
   AXRelatedObjectVector related_objects;
   String text = TextAlternative(false, false, visited, name_from,
                                 &related_objects, nullptr);
@@ -1229,7 +1229,7 @@ bool AXObjectImpl::IsLiveRegion() const {
          EqualIgnoringASCIICase(live_region, "assertive");
 }
 
-AXObjectImpl* AXObjectImpl::LiveRegionRoot() const {
+AXObject* AXObjectImpl::LiveRegionRoot() const {
   UpdateCachedAttributeValuesIfNeeded();
   return cached_live_region_root_;
 }
@@ -1270,7 +1270,7 @@ AXObjectImpl* AXObjectImpl::ElementAccessibilityHitTest(
   return const_cast<AXObjectImpl*>(this);
 }
 
-const AXObjectImpl::AXObjectVector& AXObjectImpl::Children() {
+const AXObjectImpl::AXObjectImplVector& AXObjectImpl::Children() {
   UpdateChildrenIfNecessary();
 
   return children_;
@@ -1453,7 +1453,7 @@ void AXObjectImpl::SetScrollOffset(const IntPoint& offset) const {
 }
 
 void AXObjectImpl::GetRelativeBounds(
-    AXObjectImpl** out_container,
+    AXObject** out_container,
     FloatRect& out_bounds_in_container,
     SkMatrix44& out_container_transform) const {
   *out_container = nullptr;
@@ -1852,6 +1852,254 @@ int AXObjectImpl::LineForPosition(const VisiblePosition& position) const {
   return line_count;
 }
 
+int AXObjectImpl::AriaColumnCount() const {
+  if (IsDetached())
+    return 0;
+
+  if (!IsAXTable())
+    return 0;
+
+  return ToAXTable(this)->AriaColumnCount();
+}
+
+unsigned AXObjectImpl::AriaColumnIndex() const {
+  if (IsDetached())
+    return 0;
+
+  if (!IsTableCell())
+    return 0;
+
+  return ToAXTableCell(this)->AriaColumnIndex();
+}
+
+int AXObjectImpl::AriaRowCount() const {
+  if (IsDetached())
+    return 0;
+
+  if (!IsAXTable())
+    return 0;
+
+  return ToAXTable(this)->AriaRowCount();
+}
+
+unsigned AXObjectImpl::AriaRowIndex() const {
+  if (IsDetached())
+    return 0;
+
+  if (IsTableCell())
+    return ToAXTableCell(this)->AriaRowIndex();
+
+  if (IsTableRow())
+    return ToAXTableRow(this)->AriaRowIndex();
+
+  return 0;
+}
+
+unsigned AXObjectImpl::ColumnCount() const {
+  if (IsDetached())
+    return false;
+
+  if (!IsAXTable())
+    return 0;
+
+  return ToAXTable(this)->ColumnCount();
+}
+
+unsigned AXObjectImpl::RowCount() const {
+  if (IsDetached())
+    return 0;
+
+  if (!IsAXTable())
+    return 0;
+
+  return ToAXTable(this)->RowCount();
+}
+
+WebAXObject AXObjectImpl::CellForColumnAndRow(unsigned column,
+                                             unsigned row) const {
+  if (IsDetached())
+    return WebAXObject();
+
+  if (!IsAXTable())
+    return WebAXObject();
+
+  AXTableCell* cell = ToAXTable(this)->CellForColumnAndRow(column, row);
+  return WebAXObject(static_cast<AXObjectImpl*>(cell));
+}
+
+WebAXObject AXObjectImpl::HeaderContainerObject() const {
+  if (IsDetached())
+    return WebAXObject();
+
+  if (!IsAXTable())
+    return WebAXObject();
+
+  return WebAXObject(ToAXTable(this)->HeaderContainer());
+}
+
+WebAXObject AXObjectImpl::RowAtIndex(unsigned row_index) const {
+  if (IsDetached())
+    return WebAXObject();
+
+  if (!IsAXTable())
+    return WebAXObject();
+
+  const AXObject::AXObjectVector& rows = ToAXTable(this)->Rows();
+  if (row_index < rows.size())
+    return WebAXObject(rows[row_index]);
+
+  return WebAXObject();
+}
+
+WebAXObject AXObjectImpl::ColumnAtIndex(unsigned column_index) const {
+  if (IsDetached())
+    return WebAXObject();
+
+  if (!IsAXTable())
+    return WebAXObject();
+
+  const AXObject::AXObjectVector& columns = ToAXTable(this)->Columns();
+  if (column_index < columns.size())
+    return WebAXObject(columns[column_index]);
+
+  return WebAXObject();
+}
+
+unsigned AXObjectImpl::RowIndex() const {
+  if (IsDetached())
+    return 0;
+
+  if (!IsTableRow())
+    return 0;
+
+  return ToAXTableRow(this)->RowIndex();
+}
+
+WebAXObject AXObjectImpl::RowHeader() const {
+  if (IsDetached())
+    return WebAXObject();
+
+  if (!IsTableRow())
+    return WebAXObject();
+
+  return WebAXObject(ToAXTableRow(this)->HeaderObject());
+}
+
+void AXObjectImpl::RowHeaders(
+    WebVector<WebAXObject>& row_header_elements) const {
+  if (IsDetached())
+    return;
+
+  if (!IsAXTable())
+    return;
+
+  AXObject::AXObjectVector headers;
+  ToAXTable(this)->RowHeaders(headers);
+
+  size_t header_count = headers.size();
+  WebVector<WebAXObject> result(header_count);
+
+  for (size_t i = 0; i < header_count; i++)
+    result[i] = WebAXObject(headers[i]);
+
+  row_header_elements.Swap(result);
+}
+
+unsigned AXObjectImpl::ColumnIndex() const {
+  if (IsDetached())
+    return 0;
+
+  if (RoleValue() != kColumnRole)
+    return 0;
+
+  return ToAXTableColumn(this)->ColumnIndex();
+}
+
+WebAXObject AXObjectImpl::ColumnHeader() const {
+  if (IsDetached())
+    return WebAXObject();
+
+  if (RoleValue() != kColumnRole)
+    return WebAXObject();
+
+  return WebAXObject(ToAXTableColumn(this)->HeaderObject());
+}
+
+void AXObjectImpl::ColumnHeaders(
+    WebVector<WebAXObject>& column_header_elements) const {
+  if (IsDetached())
+    return;
+
+  if (!IsAXTable())
+    return;
+
+  AXObject::AXObjectVector headers;
+  ToAXTable(this)->ColumnHeaders(headers);
+
+  size_t header_count = headers.size();
+  WebVector<WebAXObject> result(header_count);
+
+  for (size_t i = 0; i < header_count; i++)
+    result[i] = WebAXObject(headers[i]);
+
+  column_header_elements.Swap(result);
+}
+
+unsigned AXObjectImpl::CellColumnIndex() const {
+  if (IsDetached())
+    return 0;
+
+  if (!IsTableCell())
+    return 0;
+
+  std::pair<unsigned, unsigned> column_range;
+  ToAXTableCell(this)->ColumnIndexRange(column_range);
+  return column_range.first;
+}
+
+unsigned AXObjectImpl::CellColumnSpan() const {
+  if (IsDetached())
+    return 0;
+
+  if (!IsTableCell())
+    return 0;
+
+  std::pair<unsigned, unsigned> column_range;
+  ToAXTableCell(this)->ColumnIndexRange(column_range);
+  return column_range.second;
+}
+
+unsigned AXObjectImpl::CellRowIndex() const {
+  if (IsDetached())
+    return 0;
+
+  if (!IsTableCell())
+    return 0;
+
+  std::pair<unsigned, unsigned> row_range;
+  ToAXTableCell(this)->RowIndexRange(row_range);
+  return row_range.first;
+}
+
+unsigned AXObjectImpl::CellRowSpan() const {
+  if (IsDetached())
+    return 0;
+
+  if (!IsTableCell())
+    return 0;
+
+  std::pair<unsigned, unsigned> row_range;
+  ToAXTableCell(this)->RowIndexRange(row_range);
+  return row_range.second;
+}
+
+WebAXSortDirection AXObjectImpl::SortDirection() const {
+  if (IsDetached())
+    return kWebAXSortDirectionUndefined;
+
+  return static_cast<WebAXSortDirection>(GetSortDirection());
+}
+
 bool AXObjectImpl::IsARIAControl(AccessibilityRole aria_role) {
   return IsARIAInput(aria_role) || aria_role == kButtonRole ||
          aria_role == kComboBoxRole || aria_role == kSliderRole;