Move WebAXObject.cpp to core/ (WIP)

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

 /*
  * Copyright (C) 2008, 2009, 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 831 matching lines @@
   if (!str.IsEmpty() && IsHTMLSpace<UChar>(str[0]))
     result.Append(' ');
   result.Append(str.SimplifyWhiteSpace(IsHTMLSpace<UChar>));
   if (!str.IsEmpty() && IsHTMLSpace<UChar>(str[str.length() - 1]))
     result.Append(' ');
   return result.ToString();
 }
 
 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);
 
   AccessibilityRole role = RoleValue();
   if (!GetNode() || (!isHTMLBRElement(GetNode()) && role != kStaticTextRole &&
                      role != kInlineTextBoxRole))
     text = CollapseWhitespace(text);
 
   if (name_objects) {
@@ skipping 353 matching lines @@
   }
   return 0;
 }
 
 bool AXObjectImpl::IsLiveRegion() const {
   const AtomicString& live_region = LiveRegionStatus();
   return EqualIgnoringASCIICase(live_region, "polite") ||
          EqualIgnoringASCIICase(live_region, "assertive");
 }
 
-AXObjectImpl* AXObjectImpl::LiveRegionRoot() const {
+AXObject* AXObjectImpl::LiveRegionRoot() const {
   UpdateCachedAttributeValuesIfNeeded();
   return cached_live_region_root_;
 }
 
 const AtomicString& AXObjectImpl::ContainerLiveRegionStatus() const {
   UpdateCachedAttributeValuesIfNeeded();
   return cached_live_region_root_ ? cached_live_region_root_->LiveRegionStatus()
                                   : g_null_atom;
 }
 
@@ skipping 20 matching lines @@
   // Check if there are any mock elements that need to be handled.
   for (const auto& child : children_) {
     if (child->IsMockObject() &&
         child->GetBoundsInFrameCoordinates().Contains(point))
       return child->ElementAccessibilityHitTest(point);
   }
 
   return const_cast<AXObjectImpl*>(this);
 }
 
-const AXObjectImpl::AXObjectVector& AXObjectImpl::Children() {
+const AXObjectImpl::AXObjectImplVector& AXObjectImpl::Children() {
   UpdateChildrenIfNecessary();
 
   return children_;
 }
 
 AXObjectImpl* AXObjectImpl::ParentObject() const {
   if (IsDetached())
     return 0;
 
   if (parent_)
@@ skipping 162 matching lines @@
   ScrollableArea* area = GetScrollableAreaIfScrollable();
   if (!area)
     return;
 
   // TODO(bokan): This should potentially be a UserScroll.
   area->SetScrollOffset(ScrollOffset(offset.X(), offset.Y()),
                         kProgrammaticScroll);
 }
 
 void AXObjectImpl::GetRelativeBounds(
-    AXObjectImpl** out_container,
+    AXObject** out_container,
     FloatRect& out_bounds_in_container,
     SkMatrix44& out_container_transform) const {
   *out_container = nullptr;
   out_bounds_in_container = FloatRect();
   out_container_transform.setIdentity();
 
   // First check if it has explicit bounds, for example if this element is tied
   // to a canvas path. When explicit coordinates are provided, the ID of the
   // explicit container element that the coordinates are relative to must be
   // provided too.
@@ skipping 378 matching lines @@
     previous_position = current_position;
     current_position = PreviousLinePosition(current_position, LayoutUnit(),
                                             kHasEditableAXRole);
     ++line_count;
   } while (current_position.IsNotNull() &&
            !InSameLine(current_position, previous_position));
 
   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;
 }
 
 bool AXObjectImpl::IsARIAInput(AccessibilityRole aria_role) {
   return aria_role == kRadioButtonRole || aria_role == kCheckBoxRole ||
          aria_role == kTextFieldRole || aria_role == kSwitchRole ||
          aria_role == kSearchBoxRole;
 }
@@ skipping 201 matching lines @@
 }
 
 DEFINE_TRACE(AXObjectImpl) {
   visitor->Trace(children_);
   visitor->Trace(parent_);
   visitor->Trace(cached_live_region_root_);
   visitor->Trace(ax_object_cache_);
 }
 
 }  // namespace blink