Reland of name AXObject to AXObjectImpl in modules/ and web/

third_party/WebKit/Source/modules/accessibility/AXLayoutObject.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 309 matching lines @@
   if (layout_object_)
     layout_object_->SetHasAXObject(false);
 #endif
   layout_object_ = 0;
 }
 
 //
 // Check object role or purpose.
 //
 
-static bool IsLinkable(const AXObject& object) {
+static bool IsLinkable(const AXObjectImpl& object) {
   if (!object.GetLayoutObject())
     return false;
 
   // See https://wiki.mozilla.org/Accessibility/AT-Windows-API for the elements
   // Mozilla considers linkable.
   return object.IsLink() || object.IsImage() ||
          object.GetLayoutObject()->IsText();
 }
 
 // Requires layoutObject to be present because it relies on style
 // user-modify. Don't move this logic to AXNodeObject.
 bool AXLayoutObject::IsEditable() const {
   if (GetLayoutObject() && GetLayoutObject()->IsTextControl())
     return true;
 
   if (GetNode() && HasEditableStyle(*GetNode()))
     return true;
 
   if (IsWebArea()) {
     Document& document = GetLayoutObject()->GetDocument();
     HTMLElement* body = document.body();
     if (body && HasEditableStyle(*body)) {
-      AXObject* ax_body = AxObjectCache().GetOrCreate(body);
+      AXObjectImpl* ax_body = AxObjectCache().GetOrCreate(body);
       return ax_body && ax_body != ax_body->AriaHiddenRoot();
     }
 
     return HasEditableStyle(document);
   }
 
   return AXNodeObject::IsEditable();
 }
 
 // Requires layoutObject to be present because it relies on style
 // user-modify. Don't move this logic to AXNodeObject.
 bool AXLayoutObject::IsRichlyEditable() const {
   if (GetNode() && HasRichlyEditableStyle(*GetNode()))
     return true;
 
   if (IsWebArea()) {
     Document& document = layout_object_->GetDocument();
     HTMLElement* body = document.body();
     if (body && HasRichlyEditableStyle(*body)) {
-      AXObject* ax_body = AxObjectCache().GetOrCreate(body);
+      AXObjectImpl* ax_body = AxObjectCache().GetOrCreate(body);
       return ax_body && ax_body != ax_body->AriaHiddenRoot();
     }
 
     return HasRichlyEditableStyle(document);
   }
 
   return AXNodeObject::IsRichlyEditable();
 }
 
 bool AXLayoutObject::IsLinked() const {
@@ skipping 21 matching lines @@
   return view_rect.IsEmpty();
 }
 
 bool AXLayoutObject::IsReadOnly() const {
   DCHECK(layout_object_);
 
   if (IsWebArea()) {
     Document& document = layout_object_->GetDocument();
     HTMLElement* body = document.body();
     if (body && HasEditableStyle(*body)) {
-      AXObject* ax_body = AxObjectCache().GetOrCreate(body);
+      AXObjectImpl* ax_body = AxObjectCache().GetOrCreate(body);
       return !ax_body || ax_body == ax_body->AriaHiddenRoot();
     }
 
     return !HasEditableStyle(document);
   }
 
   return AXNodeObject::IsReadOnly();
 }
 
 bool AXLayoutObject::IsVisited() const {
   // FIXME: Is it a privacy violation to expose visited information to
   // accessibility APIs?
   return layout_object_->Style()->IsLink() &&
          layout_object_->Style()->InsideLink() ==
              EInsideLink::kInsideVisitedLink;
 }
 
 //
 // Check object state.
 //
 
 bool AXLayoutObject::IsFocused() const {
   if (!GetDocument())
     return false;
 
   Element* focused_element = GetDocument()->FocusedElement();
   if (!focused_element)
     return false;
-  AXObject* focused_object = AxObjectCache().GetOrCreate(focused_element);
+  AXObjectImpl* focused_object = AxObjectCache().GetOrCreate(focused_element);
   if (!focused_object || !focused_object->IsAXLayoutObject())
     return false;
 
   // A web area is represented by the Document node in the DOM tree, which isn't
   // focusable.  Check instead if the frame's selection controller is focused
   if (focused_object == this ||
       (RoleValue() == kWebAreaRole &&
        GetDocument()->GetFrame()->Selection().IsFocusedAndActive()))
     return true;
 
   return false;
 }
 
 bool AXLayoutObject::IsSelected() const {
   if (!GetLayoutObject() || !GetNode())
     return false;
 
   const AtomicString& aria_selected = GetAttribute(aria_selectedAttr);
   if (EqualIgnoringASCIICase(aria_selected, "true"))
     return true;
 
-  AXObject* focused_object = AxObjectCache().FocusedObject();
+  AXObjectImpl* focused_object = AxObjectCache().FocusedObject();
   if (AriaRoleAttribute() == kListBoxOptionRole && focused_object &&
       focused_object->ActiveDescendant() == this) {
     return true;
   }
 
   if (IsTabItem() && IsTabItemSelected())
     return true;
 
   return false;
 }
@@ skipping 17 matching lines @@
     // aria-hidden is meant to override visibility as the determinant in AX
     // hierarchy inclusion.
     if (EqualIgnoringASCIICase(GetAttribute(aria_hiddenAttr), "false"))
       return kDefaultBehavior;
 
     if (ignored_reasons)
       ignored_reasons->push_back(IgnoredReason(kAXNotVisible));
     return kIgnoreObject;
   }
 
-  return AXObject::DefaultObjectInclusion(ignored_reasons);
+  return AXObjectImpl::DefaultObjectInclusion(ignored_reasons);
 }
 
 bool AXLayoutObject::ComputeAccessibilityIsIgnored(
     IgnoredReasons* ignored_reasons) const {
 #if DCHECK_IS_ON()
   DCHECK(initialized_);
 #endif
 
   if (!layout_object_)
     return true;
@@ skipping 20 matching lines @@
   }
 
   if (RoleValue() == kIgnoredRole) {
     if (ignored_reasons)
       ignored_reasons->push_back(IgnoredReason(kAXUninteresting));
     return true;
   }
 
   if (HasInheritedPresentationalRole()) {
     if (ignored_reasons) {
-      const AXObject* inherits_from = InheritsPresentationalRoleFrom();
+      const AXObjectImpl* inherits_from = InheritsPresentationalRoleFrom();
       if (inherits_from == this)
         ignored_reasons->push_back(IgnoredReason(kAXPresentationalRole));
       else
         ignored_reasons->push_back(
             IgnoredReason(kAXInheritsPresentation, inherits_from));
     }
     return true;
   }
 
   // An ARIA tree can only have tree items and static text as children.
-  if (AXObject* tree_ancestor = TreeAncestorDisallowingChild()) {
+  if (AXObjectImpl* tree_ancestor = TreeAncestorDisallowingChild()) {
     if (ignored_reasons)
       ignored_reasons->push_back(
           IgnoredReason(kAXAncestorDisallowsChild, tree_ancestor));
     return true;
   }
 
   // A LayoutPart is an iframe element or embedded object element or something
   // like that. We don't want to ignore those.
   if (layout_object_->IsLayoutPart())
     return false;
 
   // Make sure renderers with layers stay in the tree.
   if (GetLayoutObject() && GetLayoutObject()->HasLayer() && GetNode() &&
       GetNode()->hasChildren())
     return false;
 
   // Find out if this element is inside of a label element.  If so, it may be
   // ignored because it's the label for a checkbox or radio button.
-  AXObject* control_object = CorrespondingControlForLabelElement();
+  AXObjectImpl* control_object = CorrespondingControlForLabelElement();
   if (control_object && control_object->IsCheckboxOrRadio() &&
       control_object->NameFromLabelElement()) {
     if (ignored_reasons) {
       HTMLLabelElement* label = LabelElementContainer();
       if (label && label != GetNode()) {
-        AXObject* label_ax_object = AxObjectCache().GetOrCreate(label);
+        AXObjectImpl* label_ax_object = AxObjectCache().GetOrCreate(label);
         ignored_reasons->push_back(
             IgnoredReason(kAXLabelContainer, label_ax_object));
       }
 
       ignored_reasons->push_back(IgnoredReason(kAXLabelFor, control_object));
     }
     return true;
   }
 
   if (layout_object_->IsBR())
     return false;
 
   if (IsLink())
     return false;
 
   if (IsInPageLinkTarget())
     return false;
 
   if (layout_object_->IsText()) {
     // Static text beneath MenuItems and MenuButtons are just reported along
     // with the menu item, so it's ignored on an individual level.
-    AXObject* parent = ParentObjectUnignored();
+    AXObjectImpl* parent = ParentObjectUnignored();
     if (parent && (parent->AriaRoleAttribute() == kMenuItemRole ||
                    parent->AriaRoleAttribute() == kMenuButtonRole)) {
       if (ignored_reasons)
         ignored_reasons->push_back(
             IgnoredReason(kAXStaticTextUsedAsNameFor, parent));
       return true;
     }
     LayoutText* layout_text = ToLayoutText(layout_object_);
     if (!layout_text->HasTextBoxes()) {
       if (ignored_reasons)
         ignored_reasons->push_back(IgnoredReason(kAXEmptyText));
       return true;
     }
 
     // Don't ignore static text in editable text controls.
-    for (AXObject* parent = ParentObject(); parent;
+    for (AXObjectImpl* parent = ParentObject(); parent;
          parent = parent->ParentObject()) {
       if (parent->RoleValue() == kTextFieldRole)
         return false;
     }
 
     // Text elements that are just empty whitespace should not be returned.
     // FIXME(dmazzoni): we probably shouldn't ignore this if the style is 'pre',
     // or similar...
     if (layout_text->GetText().Impl()->ContainsOnlyWhitespace()) {
       if (ignored_reasons)
@@ skipping 172 matching lines @@
 }
 
 RGBA32 AXLayoutObject::ComputeBackgroundColor() const {
   if (!GetLayoutObject())
     return AXNodeObject::BackgroundColor();
 
   Color blended_color = Color::kTransparent;
   // Color::blend should be called like this: background.blend(foreground).
   for (LayoutObject* layout_object = GetLayoutObject(); layout_object;
        layout_object = layout_object->Parent()) {
-    const AXObject* ax_parent = AxObjectCache().GetOrCreate(layout_object);
+    const AXObjectImpl* ax_parent = AxObjectCache().GetOrCreate(layout_object);
     if (ax_parent && ax_parent != this) {
       Color parent_color = ax_parent->BackgroundColor();
       blended_color = parent_color.Blend(blended_color);
       return blended_color.Rgb();
     }
 
     const ComputedStyle* style = layout_object->Style();
     if (!style || !style->HasBackground())
       continue;
 
@@ skipping 250 matching lines @@
     ClearChildren();
     AddInlineTextBoxChildren(true);
     return;
   }
 
   for (const auto& child : children_) {
     child->LoadInlineTextBoxes();
   }
 }
 
-AXObject* AXLayoutObject::NextOnLine() const {
+AXObjectImpl* AXLayoutObject::NextOnLine() const {
   if (!GetLayoutObject())
     return nullptr;
 
-  AXObject* result = nullptr;
+  AXObjectImpl* result = nullptr;
   if (GetLayoutObject()->IsListMarker()) {
-    AXObject* next_sibling = RawNextSibling();
+    AXObjectImpl* next_sibling = RawNextSibling();
     if (!next_sibling || !next_sibling->Children().size())
       return nullptr;
     result = next_sibling->Children()[0].Get();
   } else {
     InlineBox* inline_box = nullptr;
     if (GetLayoutObject()->IsLayoutInline())
       inline_box = ToLayoutInline(GetLayoutObject())->LastLineBox();
     else if (GetLayoutObject()->IsText())
       inline_box = ToLayoutText(GetLayoutObject())->LastTextBox();
 
@@ skipping 12 matching lines @@
 
   // A static text node might span multiple lines. Try to return the first
   // inline text box within that static text if possible.
   if (result && result->RoleValue() == kStaticTextRole &&
       result->Children().size())
     result = result->Children()[0].Get();
 
   return result;
 }
 
-AXObject* AXLayoutObject::PreviousOnLine() const {
+AXObjectImpl* AXLayoutObject::PreviousOnLine() const {
   if (!GetLayoutObject())
     return nullptr;
 
   InlineBox* inline_box = nullptr;
   if (GetLayoutObject()->IsLayoutInline())
     inline_box = ToLayoutInline(GetLayoutObject())->FirstLineBox();
   else if (GetLayoutObject()->IsText())
     inline_box = ToLayoutText(GetLayoutObject())->FirstTextBox();
 
   if (!inline_box)
     return nullptr;
 
-  AXObject* result = nullptr;
+  AXObjectImpl* result = nullptr;
   for (InlineBox* prev = inline_box->PrevOnLine(); prev;
        prev = prev->PrevOnLine()) {
     LayoutObject* layout_object =
         LineLayoutAPIShim::LayoutObjectFrom(prev->GetLineLayoutItem());
     result = AxObjectCache().GetOrCreate(layout_object);
     if (result)
       break;
   }
 
   // A static text node might span multiple lines. Try to return the last inline
@@ skipping 138 matching lines @@
     case kImageRole:
     case kProgressIndicatorRole:
     case kSpinButtonRole:
       // case SeparatorRole:
       return true;
     default:
       return false;
   }
 }
 
-AXObject* AXLayoutObject::AncestorForWhichThisIsAPresentationalChild() const {
+AXObjectImpl* AXLayoutObject::AncestorForWhichThisIsAPresentationalChild()
+    const {
   // Walk the parent chain looking for a parent that has presentational children
-  AXObject* parent = ParentObjectIfExists();
+  AXObjectImpl* parent = ParentObjectIfExists();
   while (parent) {
     if (parent->AriaRoleHasPresentationalChildren())
       break;
 
     // The descendants of a AXMenuList that are AXLayoutObjects are all
     // presentational. (The real descendants are an AXMenuListPopup and
     // AXMenuListOptions, which are not AXLayoutObjects.)
     if (parent->IsMenuList())
       break;
 
@@ skipping 83 matching lines @@
 }
 
 bool AXLayoutObject::LiveRegionBusy() const {
   return ElementAttributeValue(aria_busyAttr);
 }
 
 //
 // Hit testing.
 //
 
-AXObject* AXLayoutObject::AccessibilityHitTest(const IntPoint& point) const {
+AXObjectImpl* AXLayoutObject::AccessibilityHitTest(
+    const IntPoint& point) const {
   if (!layout_object_ || !layout_object_->HasLayer())
     return nullptr;
 
   PaintLayer* layer = ToLayoutBox(layout_object_)->Layer();
 
   HitTestRequest request(HitTestRequest::kReadOnly | HitTestRequest::kActive);
   HitTestResult hit_test_result = HitTestResult(request, point);
   layer->HitTest(hit_test_result);
 
   Node* node = hit_test_result.InnerNode();
   if (!node)
     return nullptr;
 
   if (isHTMLAreaElement(node))
     return AccessibilityImageMapHitTest(toHTMLAreaElement(node), point);
 
   if (isHTMLOptionElement(node)) {
     node = toHTMLOptionElement(*node).OwnerSelectElement();
     if (!node)
       return nullptr;
   }
 
   LayoutObject* obj = node->GetLayoutObject();
   if (!obj)
     return nullptr;
 
-  AXObject* result = AxObjectCache().GetOrCreate(obj);
+  AXObjectImpl* result = AxObjectCache().GetOrCreate(obj);
   result->UpdateChildrenIfNecessary();
 
   // Allow the element to perform any hit-testing it might need to do to reach
   // non-layout children.
   result = result->ElementAccessibilityHitTest(point);
   if (result && result->AccessibilityIsIgnored()) {
     // If this element is the label of a control, a hit test should return the
     // control.
     if (result->IsAXLayoutObject()) {
-      AXObject* control_object =
+      AXObjectImpl* control_object =
           ToAXLayoutObject(result)->CorrespondingControlForLabelElement();
       if (control_object && control_object->NameFromLabelElement())
         return control_object;
     }
 
     result = result->ParentObjectUnignored();
   }
 
   return result;
 }
 
-AXObject* AXLayoutObject::ElementAccessibilityHitTest(
+AXObjectImpl* AXLayoutObject::ElementAccessibilityHitTest(
     const IntPoint& point) const {
   if (IsSVGImage())
     return RemoteSVGElementHitTest(point);
 
-  return AXObject::ElementAccessibilityHitTest(point);
+  return AXObjectImpl::ElementAccessibilityHitTest(point);
 }
 
 //
 // High-level accessibility tree access.
 //
 
-AXObject* AXLayoutObject::ComputeParent() const {
+AXObjectImpl* AXLayoutObject::ComputeParent() const {
   DCHECK(!IsDetached());
   if (!layout_object_)
     return 0;
 
   if (AriaRoleAttribute() == kMenuBarRole)
     return AxObjectCache().GetOrCreate(layout_object_->Parent());
 
   // menuButton and its corresponding menu are DOM siblings, but Accessibility
   // needs them to be parent/child.
   if (AriaRoleAttribute() == kMenuRole) {
-    AXObject* parent = MenuButtonForMenu();
+    AXObjectImpl* parent = MenuButtonForMenu();
     if (parent)
       return parent;
   }
 
   LayoutObject* parent_obj = LayoutParentObject();
   if (parent_obj)
     return AxObjectCache().GetOrCreate(parent_obj);
 
   // A WebArea's parent should be the page popup owner, if any, otherwise null.
   if (IsWebArea()) {
     LocalFrame* frame = layout_object_->GetFrame();
     return AxObjectCache().GetOrCreate(frame->PagePopupOwner());
   }
 
   return 0;
 }
 
-AXObject* AXLayoutObject::ComputeParentIfExists() const {
+AXObjectImpl* AXLayoutObject::ComputeParentIfExists() const {
   if (!layout_object_)
     return 0;
 
   if (AriaRoleAttribute() == kMenuBarRole)
     return AxObjectCache().Get(layout_object_->Parent());
 
   // menuButton and its corresponding menu are DOM siblings, but Accessibility
   // needs them to be parent/child.
   if (AriaRoleAttribute() == kMenuRole) {
-    AXObject* parent = MenuButtonForMenu();
+    AXObjectImpl* parent = MenuButtonForMenu();
     if (parent)
       return parent;
   }
 
   LayoutObject* parent_obj = LayoutParentObject();
   if (parent_obj)
     return AxObjectCache().Get(parent_obj);
 
   // A WebArea's parent should be the page popup owner, if any, otherwise null.
   if (IsWebArea()) {
     LocalFrame* frame = layout_object_->GetFrame();
     return AxObjectCache().Get(frame->PagePopupOwner());
   }
 
   return 0;
 }
 
 //
 // Low-level accessibility tree exploration, only for use within the
 // accessibility module.
 //
 
-AXObject* AXLayoutObject::RawFirstChild() const {
+AXObjectImpl* AXLayoutObject::RawFirstChild() const {
   if (!layout_object_)
     return 0;
 
   LayoutObject* first_child = FirstChildConsideringContinuation(layout_object_);
 
   if (!first_child)
     return 0;
 
   return AxObjectCache().GetOrCreate(first_child);
 }
 
-AXObject* AXLayoutObject::RawNextSibling() const {
+AXObjectImpl* AXLayoutObject::RawNextSibling() const {
   if (!layout_object_)
     return 0;
 
   LayoutObject* next_sibling = 0;
 
   LayoutInline* inline_continuation =
       layout_object_->IsLayoutBlockFlow()
           ? ToLayoutBlockFlow(layout_object_)->InlineElementContinuation()
           : nullptr;
   if (inline_continuation) {
@@ skipping 47 matching lines @@
   // If the need to add more children in addition to existing children arises,
   // childrenChanged should have been called, leaving the object with no
   // children.
   DCHECK(!have_children_);
 
   have_children_ = true;
 
   if (!CanHaveChildren())
     return;
 
-  HeapVector<Member<AXObject>> owned_children;
+  HeapVector<Member<AXObjectImpl>> owned_children;
   ComputeAriaOwnsChildren(owned_children);
 
-  for (AXObject* obj = RawFirstChild(); obj; obj = obj->RawNextSibling()) {
+  for (AXObjectImpl* obj = RawFirstChild(); obj; obj = obj->RawNextSibling()) {
     if (!AxObjectCache().IsAriaOwned(obj)) {
       obj->SetParent(this);
       AddChild(obj);
     }
   }
 
   AddHiddenChildren();
   AddPopupChildren();
   AddImageMapChildren();
   AddTextFieldChildren();
@@ skipping 14 matching lines @@
   if (!layout_object_)
     return false;
 
   return AXNodeObject::CanHaveChildren();
 }
 
 void AXLayoutObject::UpdateChildrenIfNecessary() {
   if (NeedsToUpdateChildren())
     ClearChildren();
 
-  AXObject::UpdateChildrenIfNecessary();
+  AXObjectImpl::UpdateChildrenIfNecessary();
 }
 
 void AXLayoutObject::ClearChildren() {
-  AXObject::ClearChildren();
+  AXObjectImpl::ClearChildren();
   children_dirty_ = false;
 }
 
 //
 // Properties of the object's owning document or page.
 //
 
 double AXLayoutObject::EstimatedLoadingProgress() const {
   if (!layout_object_)
     return 0;
@@ skipping 66 matching lines @@
       return ToElement(&runner);
   }
 
   return 0;
 }
 
 //
 // Functions that retrieve the current selection.
 //
 
-AXObject::AXRange AXLayoutObject::Selection() const {
+AXObjectImpl::AXRange AXLayoutObject::Selection() const {
   AXRange text_selection = TextControlSelection();
   if (text_selection.IsValid())
     return text_selection;
 
   if (!GetLayoutObject() || !GetLayoutObject()->GetFrame())
     return AXRange();
 
   VisibleSelection selection =
       GetLayoutObject()
           ->GetFrame()
           ->Selection()
           .ComputeVisibleSelectionInDOMTreeDeprecated();
   if (selection.IsNone())
     return AXRange();
 
   VisiblePosition visible_start = selection.VisibleStart();
   Position start = visible_start.ToParentAnchoredPosition();
   TextAffinity start_affinity = visible_start.Affinity();
   VisiblePosition visible_end = selection.VisibleEnd();
   Position end = visible_end.ToParentAnchoredPosition();
   TextAffinity end_affinity = visible_end.Affinity();
 
   Node* anchor_node = start.AnchorNode();
   DCHECK(anchor_node);
 
   AXLayoutObject* anchor_object = nullptr;
-  // Find the closest node that has a corresponding AXObject.
+  // Find the closest node that has a corresponding AXObjectImpl.
   // This is because some nodes may be aria hidden or might not even have
   // a layout object if they are part of the shadow DOM.
   while (anchor_node) {
     anchor_object = GetUnignoredObjectFromNode(*anchor_node);
     if (anchor_object)
       break;
 
     if (anchor_node->nextSibling())
       anchor_node = anchor_node->nextSibling();
     else
@@ skipping 22 matching lines @@
   DCHECK_GE(anchor_offset, 0);
   int focus_offset = focus_object->IndexForVisiblePosition(visible_end);
   DCHECK_GE(focus_offset, 0);
   return AXRange(anchor_object, anchor_offset, start_affinity, focus_object,
                  focus_offset, end_affinity);
 }
 
 // Gets only the start and end offsets of the selection computed using the
 // current object as the starting point. Returns a null selection if there is
 // no selection in the subtree rooted at this object.
-AXObject::AXRange AXLayoutObject::SelectionUnderObject() const {
+AXObjectImpl::AXRange AXLayoutObject::SelectionUnderObject() const {
   AXRange text_selection = TextControlSelection();
   if (text_selection.IsValid())
     return text_selection;
 
   if (!GetNode() || !GetLayoutObject()->GetFrame())
     return AXRange();
 
   VisibleSelection selection =
       GetLayoutObject()
           ->GetFrame()
@@ skipping 13 matching lines @@
   }
 
   int start = IndexForVisiblePosition(selection.VisibleStart());
   DCHECK_GE(start, 0);
   int end = IndexForVisiblePosition(selection.VisibleEnd());
   DCHECK_GE(end, 0);
 
   return AXRange(start, end);
 }
 
-AXObject::AXRange AXLayoutObject::TextControlSelection() const {
+AXObjectImpl::AXRange AXLayoutObject::TextControlSelection() const {
   if (!GetLayoutObject())
     return AXRange();
 
   LayoutObject* layout = nullptr;
   if (GetLayoutObject()->IsTextControl()) {
     layout = GetLayoutObject();
   } else {
     Element* focused_element = GetDocument()->FocusedElement();
     if (focused_element && focused_element->GetLayoutObject() &&
         focused_element->GetLayoutObject()->IsTextControl())
       layout = focused_element->GetLayoutObject();
   }
 
   if (!layout)
     return AXRange();
 
-  AXObject* ax_object = AxObjectCache().GetOrCreate(layout);
+  AXObjectImpl* ax_object = AxObjectCache().GetOrCreate(layout);
   if (!ax_object || !ax_object->IsAXLayoutObject())
     return AXRange();
 
   VisibleSelection selection =
       layout->GetFrame()
           ->Selection()
           .ComputeVisibleSelectionInDOMTreeDeprecated();
   TextControlElement* text_control =
       ToLayoutTextControl(layout)->GetTextControlElement();
   DCHECK(text_control);
@@ skipping 24 matching lines @@
   range->setEnd(index_position, IGNORE_EXCEPTION_FOR_TESTING);
 
   return TextIterator::RangeLength(range->StartPosition(),
                                    range->EndPosition());
 }
 
 AXLayoutObject* AXLayoutObject::GetUnignoredObjectFromNode(Node& node) const {
   if (IsDetached())
     return nullptr;
 
-  AXObject* ax_object = AxObjectCache().GetOrCreate(&node);
+  AXObjectImpl* ax_object = AxObjectCache().GetOrCreate(&node);
   if (!ax_object)
     return nullptr;
 
   if (ax_object->IsAXLayoutObject() && !ax_object->AccessibilityIsIgnored())
     return ToAXLayoutObject(ax_object);
 
   return nullptr;
 }
 
 //
 // Modify or take an action on an object.
 //
 
 // Convert from an accessible object and offset to a VisiblePosition.
-static VisiblePosition ToVisiblePosition(AXObject* obj, int offset) {
+static VisiblePosition ToVisiblePosition(AXObjectImpl* obj, int offset) {
   if (!obj->GetNode())
     return VisiblePosition();
 
   Node* node = obj->GetNode();
   if (!node->IsTextNode()) {
     int child_count = obj->Children().size();
 
     // Place position immediately before the container node, if there was no
     // children.
     if (child_count == 0) {
       if (!obj->ParentObject())
         return VisiblePosition();
       return ToVisiblePosition(obj->ParentObject(), obj->IndexInParent());
     }
 
     // The offsets are child offsets over the AX tree. Note that we allow
     // for the offset to equal the number of children as |Range| does.
     if (offset < 0 || offset > child_count)
       return VisiblePosition();
 
     // Clamp to between 0 and child count - 1.
     int clamped_offset =
         static_cast<unsigned>(offset) > (obj->Children().size() - 1)
             ? offset - 1
             : offset;
-    AXObject* child_obj = obj->Children()[clamped_offset];
+    AXObjectImpl* child_obj = obj->Children()[clamped_offset];
     Node* child_node = child_obj->GetNode();
     if (!child_node || !child_node->parentNode())
       return VisiblePosition();
 
     // The index in parent.
     int adjusted_offset = child_node->NodeIndex();
 
     // If we had to clamp the offset above, the client wants to select the
     // end of the node.
     if (clamped_offset != offset)
@@ skipping 12 matching lines @@
 
   VisiblePosition node_position = blink::VisiblePositionBeforeNode(*node);
   int node_index = blink::IndexForVisiblePosition(node_position, parent);
   return blink::VisiblePositionForIndex(node_index + offset, parent);
 }
 
 void AXLayoutObject::SetSelection(const AXRange& selection) {
   if (!GetLayoutObject() || !selection.IsValid())
     return;
 
-  AXObject* anchor_object =
+  AXObjectImpl* anchor_object =
       selection.anchor_object ? selection.anchor_object.Get() : this;
-  AXObject* focus_object =
+  AXObjectImpl* focus_object =
       selection.focus_object ? selection.focus_object.Get() : this;
 
   if (!IsValidSelectionBound(anchor_object) ||
       !IsValidSelectionBound(focus_object)) {
     return;
   }
 
   // The selection offsets are offsets into the accessible value.
   if (anchor_object == focus_object &&
       anchor_object->GetLayoutObject()->IsTextControl()) {
@@ skipping 31 matching lines @@
   if (anchor_visible_position.IsNull() || focus_visible_position.IsNull())
     return;
 
   frame->Selection().SetSelection(
       SelectionInDOMTree::Builder()
           .Collapse(anchor_visible_position.ToPositionWithAffinity())
           .Extend(focus_visible_position.DeepEquivalent())
           .Build());
 }
 
-bool AXLayoutObject::IsValidSelectionBound(const AXObject* bound_object) const {
+bool AXLayoutObject::IsValidSelectionBound(
+    const AXObjectImpl* bound_object) const {
   return GetLayoutObject() && bound_object && !bound_object->IsDetached() &&
          bound_object->IsAXLayoutObject() && bound_object->GetLayoutObject() &&
          bound_object->GetLayoutObject()->GetFrame() ==
              GetLayoutObject()->GetFrame() &&
          &bound_object->AxObjectCache() == &AxObjectCache();
 }
 
 void AXLayoutObject::SetValue(const String& string) {
   if (!GetNode() || !GetNode()->IsElementNode())
     return;
@@ skipping 10 matching lines @@
 }
 
 //
 // Notifications that this object may have changed.
 //
 
 void AXLayoutObject::HandleActiveDescendantChanged() {
   if (!GetLayoutObject())
     return;
 
-  AXObject* focused_object = AxObjectCache().FocusedObject();
+  AXObjectImpl* focused_object = AxObjectCache().FocusedObject();
   if (focused_object == this && SupportsActiveDescendant()) {
     AxObjectCache().PostNotification(
         GetLayoutObject(), AXObjectCacheImpl::kAXActiveDescendantChanged);
   }
 }
 
 void AXLayoutObject::HandleAriaExpandedChanged() {
   // Find if a parent of this object should handle aria-expanded changes.
-  AXObject* container_parent = this->ParentObject();
+  AXObjectImpl* container_parent = this->ParentObject();
   while (container_parent) {
     bool found_parent = false;
 
     switch (container_parent->RoleValue()) {
       case kTreeRole:
       case kTreeGridRole:
       case kGridRole:
       case kTableRole:
         found_parent = true;
         break;
@@ skipping 99 matching lines @@
     // If a LayoutText needs layout, its inline text boxes are either
     // nonexistent or invalid, so defer until the layout happens and
     // the layoutObject calls AXObjectCacheImpl::inlineTextBoxesUpdated.
     return;
   }
 
   LayoutText* layout_text = ToLayoutText(GetLayoutObject());
   for (RefPtr<AbstractInlineTextBox> box =
            layout_text->FirstAbstractInlineTextBox();
        box.Get(); box = box->NextInlineTextBox()) {
-    AXObject* ax_object = AxObjectCache().GetOrCreate(box.Get());
+    AXObjectImpl* ax_object = AxObjectCache().GetOrCreate(box.Get());
     if (!ax_object->AccessibilityIsIgnored())
       children_.push_back(ax_object);
   }
 }
 
 void AXLayoutObject::LineBreaks(Vector<int>& line_breaks) const {
   if (!IsTextControl())
     return;
 
   VisiblePosition visible_pos = VisiblePositionForIndex(0);
@@ skipping 12 matching lines @@
     if (visible_pos.DeepEquivalent().CompareTo(
             prev_visible_pos.DeepEquivalent()) < 0)
       break;
   }
 }
 
 //
 // Private.
 //
 
-AXObject* AXLayoutObject::TreeAncestorDisallowingChild() const {
+AXObjectImpl* AXLayoutObject::TreeAncestorDisallowingChild() const {
   // Determine if this is in a tree. If so, we apply special behavior to make it
   // work like an AXOutline.
-  AXObject* ax_obj = ParentObject();
-  AXObject* tree_ancestor = 0;
+  AXObjectImpl* ax_obj = ParentObject();
+  AXObjectImpl* tree_ancestor = 0;
   while (ax_obj) {
     if (ax_obj->IsTree()) {
       tree_ancestor = ax_obj;
       break;
     }
     ax_obj = ax_obj->ParentObject();
   }
 
   // If the object is in a tree, only tree items should be exposed (and the
   // children of tree items).
   if (tree_ancestor) {
     AccessibilityRole role = RoleValue();
     if (role != kTreeItemRole && role != kStaticTextRole)
       return tree_ancestor;
   }
   return 0;
 }
 
 bool AXLayoutObject::IsTabItemSelected() const {
   if (!IsTabItem() || !GetLayoutObject())
     return false;
 
   Node* node = GetNode();
   if (!node || !node->IsElementNode())
     return false;
 
   // The ARIA spec says a tab item can also be selected if it is aria-labeled by
   // a tabpanel that has keyboard focus inside of it, or if a tabpanel in its
   // aria-controls list has KB focus inside of it.
-  AXObject* focused_element = AxObjectCache().FocusedObject();
+  AXObjectImpl* focused_element = AxObjectCache().FocusedObject();
   if (!focused_element)
     return false;
 
   HeapVector<Member<Element>> elements;
   ElementsFromAttribute(elements, aria_controlsAttr);
 
   for (const auto& element : elements) {
-    AXObject* tab_panel = AxObjectCache().GetOrCreate(element);
+    AXObjectImpl* tab_panel = AxObjectCache().GetOrCreate(element);
 
     // A tab item should only control tab panels.
     if (!tab_panel || tab_panel->RoleValue() != kTabPanelRole)
       continue;
 
-    AXObject* check_focus_element = focused_element;
+    AXObjectImpl* check_focus_element = focused_element;
     // Check if the focused element is a descendant of the element controlled by
     // the tab item.
     while (check_focus_element) {
       if (tab_panel == check_focus_element)
         return true;
       check_focus_element = check_focus_element->ParentObject();
     }
   }
 
   return false;
 }
 
-AXObject* AXLayoutObject::AccessibilityImageMapHitTest(
+AXObjectImpl* AXLayoutObject::AccessibilityImageMapHitTest(
     HTMLAreaElement* area,
     const IntPoint& point) const {
   if (!area)
     return 0;
 
-  AXObject* parent = AxObjectCache().GetOrCreate(area->ImageElement());
+  AXObjectImpl* parent = AxObjectCache().GetOrCreate(area->ImageElement());
   if (!parent)
     return 0;
 
   for (const auto& child : parent->Children()) {
     if (child->GetBoundsInFrameCoordinates().Contains(point))
       return child.Get();
   }
 
   return 0;
 }
@@ skipping 57 matching lines @@
     root->SetParent(0);
 }
 
 AXSVGRoot* AXLayoutObject::RemoteSVGRootElement() const {
   // FIXME(dmazzoni): none of this code properly handled multiple references to
   // the same remote SVG document. I'm disabling this support until it can be
   // fixed properly.
   return 0;
 }
 
-AXObject* AXLayoutObject::RemoteSVGElementHitTest(const IntPoint& point) const {
-  AXObject* remote = RemoteSVGRootElement();
+AXObjectImpl* AXLayoutObject::RemoteSVGElementHitTest(
+    const IntPoint& point) const {
+  AXObjectImpl* remote = RemoteSVGRootElement();
   if (!remote)
     return 0;
 
   IntSize offset =
       point - RoundedIntPoint(GetBoundsInFrameCoordinates().Location());
   return remote->AccessibilityHitTest(IntPoint(offset));
 }
 
 // The boundingBox for elements within the remote SVG element needs to be offset
 // by its position within the parent page, otherwise they are in relative
 // coordinates only.
 void AXLayoutObject::OffsetBoundingBoxForRemoteSVGElement(
     LayoutRect& rect) const {
-  for (AXObject* parent = ParentObject(); parent;
+  for (AXObjectImpl* parent = ParentObject(); parent;
        parent = parent->ParentObject()) {
     if (parent->IsAXSVGRoot()) {
       rect.MoveBy(
           parent->ParentObject()->GetBoundsInFrameCoordinates().Location());
       break;
     }
   }
 }
 
 // Hidden children are those that are not laid out or visible, but are
@@ skipping 18 matching lines @@
   if (!should_insert_hidden_nodes)
     return;
 
   // Iterate through all of the children, including those that may have already
   // been added, and try to insert hidden nodes in the correct place in the DOM
   // order.
   unsigned insertion_index = 0;
   for (Node& child : NodeTraversal::ChildrenOf(*node)) {
     if (child.GetLayoutObject()) {
       // Find out where the last layout sibling is located within m_children.
-      if (AXObject* child_object =
+      if (AXObjectImpl* child_object =
               AxObjectCache().Get(child.GetLayoutObject())) {
         if (child_object->AccessibilityIsIgnored()) {
           const auto& children = child_object->Children();
           child_object = children.size() ? children.back().Get() : 0;
         }
         if (child_object)
           insertion_index = children_.Find(child_object) + 1;
         continue;
       }
     }
@@ skipping 34 matching lines @@
   if (!css_box || !css_box->IsLayoutImage())
     return;
 
   HTMLMapElement* map = ToLayoutImage(css_box)->ImageMap();
   if (!map)
     return;
 
   for (HTMLAreaElement& area :
        Traversal<HTMLAreaElement>::DescendantsOf(*map)) {
     // add an <area> element for this child if it has a link
-    AXObject* obj = AxObjectCache().GetOrCreate(&area);
+    AXObjectImpl* obj = AxObjectCache().GetOrCreate(&area);
     if (obj) {
       AXImageMapLink* area_object = ToAXImageMapLink(obj);
       area_object->SetParent(this);
       DCHECK(area_object->AxObjectID() != 0);
       if (!area_object->AccessibilityIsIgnored())
         children_.push_back(area_object);
       else
         AxObjectCache().Remove(area_object->AxObjectID());
     }
   }
 }
 
 void AXLayoutObject::AddCanvasChildren() {
   if (!isHTMLCanvasElement(GetNode()))
     return;
 
   // If it's a canvas, it won't have laid out children, but it might have
   // accessible fallback content.  Clear m_haveChildren because
   // AXNodeObject::addChildren will expect it to be false.
   DCHECK(!children_.size());
   have_children_ = false;
   AXNodeObject::AddChildren();
 }
 
 void AXLayoutObject::AddPopupChildren() {
   if (!isHTMLInputElement(GetNode()))
     return;
-  if (AXObject* ax_popup = toHTMLInputElement(GetNode())->PopupRootAXObject())
+  if (AXObjectImpl* ax_popup =
+          toHTMLInputElement(GetNode())->PopupRootAXObject())
     children_.push_back(ax_popup);
 }
 
 void AXLayoutObject::AddRemoteSVGChildren() {
   AXSVGRoot* root = RemoteSVGRootElement();
   if (!root)
     return;
 
   root->SetParent(this);
 
   if (root->AccessibilityIsIgnored()) {
     for (const auto& child : root->Children())
       children_.push_back(child);
   } else {
     children_.push_back(root);
   }
 }
 
 bool AXLayoutObject::ElementAttributeValue(
     const QualifiedName& attribute_name) const {
   if (!layout_object_)
     return false;
 
   return EqualIgnoringASCIICase(GetAttribute(attribute_name), "true");
 }
 
 }  // namespace blink