Rename AXObject to AXObjectImpl in modules/ and web/

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

 /*
  * Copyright (C) 2008 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 369 matching lines @@
   LayoutTable* table = ToLayoutTable(layout_object_);
   AXObjectCacheImpl& ax_cache = AxObjectCache();
 
   Node* table_node = table->GetNode();
   if (!isHTMLTableElement(table_node))
     return;
 
   // Add caption
   if (HTMLTableCaptionElement* caption =
           toHTMLTableElement(table_node)->caption()) {
-    AXObject* caption_object = ax_cache.GetOrCreate(caption);
+    AXObjectImpl* caption_object = ax_cache.GetOrCreate(caption);
     if (caption_object && !caption_object->AccessibilityIsIgnored())
       children_.push_back(caption_object);
   }
 
   // Go through all the available sections to pull out the rows and add them as
   // children.
   table->RecalcSectionsIfNeeded();
   LayoutTableSection* table_section = table->TopSection();
   if (!table_section)
     return;
 
   LayoutTableSection* initial_table_section = table_section;
   while (table_section) {
-    HeapHashSet<Member<AXObject>> appended_rows;
+    HeapHashSet<Member<AXObjectImpl>> appended_rows;
     unsigned num_rows = table_section->NumRows();
     for (unsigned row_index = 0; row_index < num_rows; ++row_index) {
       LayoutTableRow* layout_row = table_section->RowLayoutObjectAt(row_index);
       if (!layout_row)
         continue;
 
-      AXObject* row_object = ax_cache.GetOrCreate(layout_row);
+      AXObjectImpl* row_object = ax_cache.GetOrCreate(layout_row);
       if (!row_object || !row_object->IsTableRow())
         continue;
 
       AXTableRow* row = ToAXTableRow(row_object);
       // We need to check every cell for a new row, because cell spans
       // can cause us to miss rows if we just check the first column.
       if (appended_rows.Contains(row))
         continue;
 
       row->SetRowIndex(static_cast<int>(rows_.size()));
@@ skipping 10 matching lines @@
   unsigned length = initial_table_section->NumEffectiveColumns();
   for (unsigned i = 0; i < length; ++i) {
     AXTableColumn* column = ToAXTableColumn(ax_cache.GetOrCreate(kColumnRole));
     column->SetColumnIndex((int)i);
     column->SetParent(this);
     columns_.push_back(column);
     if (!column->AccessibilityIsIgnored())
       children_.push_back(column);
   }
 
-  AXObject* header_container_object = HeaderContainer();
+  AXObjectImpl* header_container_object = HeaderContainer();
   if (header_container_object &&
       !header_container_object->AccessibilityIsIgnored())
     children_.push_back(header_container_object);
 }
 
-AXObject* AXTable::HeaderContainer() {
+AXObjectImpl* AXTable::HeaderContainer() {
   if (header_container_)
     return header_container_.Get();
 
   AXMockObject* table_header =
       ToAXMockObject(AxObjectCache().GetOrCreate(kTableHeaderContainerRole));
   table_header->SetParent(this);
 
   header_container_ = table_header;
   return header_container_.Get();
 }
 
-const AXObject::AXObjectVector& AXTable::Columns() {
+const AXObjectImpl::AXObjectVector& AXTable::Columns() {
   UpdateChildrenIfNecessary();
 
   return columns_;
 }
 
-const AXObject::AXObjectVector& AXTable::Rows() {
+const AXObjectImpl::AXObjectVector& AXTable::Rows() {
   UpdateChildrenIfNecessary();
 
   return rows_;
 }
 
 void AXTable::ColumnHeaders(AXObjectVector& headers) {
   if (!layout_object_)
     return;
 
   UpdateChildrenIfNecessary();
   unsigned column_count = columns_.size();
   for (unsigned c = 0; c < column_count; c++) {
-    AXObject* column = columns_[c].Get();
+    AXObjectImpl* column = columns_[c].Get();
     if (column->IsTableCol())
       ToAXTableColumn(column)->HeaderObjectsForColumn(headers);
   }
 }
 
 void AXTable::RowHeaders(AXObjectVector& headers) {
   if (!layout_object_)
     return;
 
   UpdateChildrenIfNecessary();
   unsigned row_count = rows_.size();
   for (unsigned r = 0; r < row_count; r++) {
-    AXObject* row = rows_[r].Get();
+    AXObjectImpl* row = rows_[r].Get();
     if (row->IsTableRow())
       ToAXTableRow(rows_[r].Get())->HeaderObjectsForRow(headers);
   }
 }
 
 int AXTable::AriaColumnCount() {
   if (!HasAttribute(aria_colcountAttr))
     return 0;
 
   const AtomicString& col_count_value = GetAttribute(aria_colcountAttr);
@@ skipping 55 matching lines @@
   for (unsigned row_index_counter = row + 1; row_index_counter > 0;
        --row_index_counter) {
     unsigned row_index = row_index_counter - 1;
     const auto& children = rows_[row_index]->Children();
     // Since some cells may have colspans, we have to check the actual range of
     // each cell to determine which is the right one.
     for (unsigned col_index_counter =
              std::min(static_cast<unsigned>(children.size()), column + 1);
          col_index_counter > 0; --col_index_counter) {
       unsigned col_index = col_index_counter - 1;
-      AXObject* child = children[col_index].Get();
+      AXObjectImpl* child = children[col_index].Get();
 
       if (!child->IsTableCell())
         continue;
 
       std::pair<unsigned, unsigned> column_range;
       std::pair<unsigned, unsigned> row_range;
       AXTableCell* table_cell_child = ToAXTableCell(child);
       table_cell_child->ColumnIndexRange(column_range);
       table_cell_child->RowIndexRange(row_range);
 
@@ skipping 30 matching lines @@
 }
 
 DEFINE_TRACE(AXTable) {
   visitor->Trace(rows_);
   visitor->Trace(columns_);
   visitor->Trace(header_container_);
   AXLayoutObject::Trace(visitor);
 }
 
 }  // namespace blink