Revert of Rename AXObject to AXObjectImpl in modules/ and web/ (patchset #9 id:160001 of https://co…

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

 /*
  * Copyright (C) 2012, Google 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 62 matching lines @@
 #include "platform/wtf/text/StringBuilder.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 class SparseAttributeSetter {
   USING_FAST_MALLOC(SparseAttributeSetter);
 
  public:
-  virtual void Run(const AXObjectImpl&,
+  virtual void Run(const AXObject&,
                    AXSparseAttributeClient&,
                    const AtomicString& value) = 0;
 };
 
 class BoolAttributeSetter : public SparseAttributeSetter {
  public:
   BoolAttributeSetter(AXBoolAttribute attribute) : attribute_(attribute) {}
 
  private:
   AXBoolAttribute attribute_;
 
-  void Run(const AXObjectImpl& obj,
+  void Run(const AXObject& obj,
            AXSparseAttributeClient& attribute_map,
            const AtomicString& value) override {
     attribute_map.AddBoolAttribute(attribute_,
                                    EqualIgnoringASCIICase(value, "true"));
   }
 };
 
 class StringAttributeSetter : public SparseAttributeSetter {
  public:
   StringAttributeSetter(AXStringAttribute attribute) : attribute_(attribute) {}
 
  private:
   AXStringAttribute attribute_;
 
-  void Run(const AXObjectImpl& obj,
+  void Run(const AXObject& obj,
            AXSparseAttributeClient& attribute_map,
            const AtomicString& value) override {
     attribute_map.AddStringAttribute(attribute_, value);
   }
 };
 
 class ObjectAttributeSetter : public SparseAttributeSetter {
  public:
   ObjectAttributeSetter(AXObjectAttribute attribute) : attribute_(attribute) {}
 
  private:
   AXObjectAttribute attribute_;
 
-  void Run(const AXObjectImpl& obj,
+  void Run(const AXObject& obj,
            AXSparseAttributeClient& attribute_map,
            const AtomicString& value) override {
     if (value.IsNull() || value.IsEmpty())
       return;
 
     Node* node = obj.GetNode();
     if (!node || !node->IsElementNode())
       return;
     Element* target = ToElement(node)->GetTreeScope().getElementById(value);
     if (!target)
       return;
-    AXObjectImpl* ax_target = obj.AxObjectCache().GetOrCreate(target);
+    AXObject* ax_target = obj.AxObjectCache().GetOrCreate(target);
     if (ax_target)
       attribute_map.AddObjectAttribute(attribute_, *ax_target);
   }
 };
 
 class ObjectVectorAttributeSetter : public SparseAttributeSetter {
  public:
   ObjectVectorAttributeSetter(AXObjectVectorAttribute attribute)
       : attribute_(attribute) {}
 
  private:
   AXObjectVectorAttribute attribute_;
 
-  void Run(const AXObjectImpl& obj,
+  void Run(const AXObject& obj,
            AXSparseAttributeClient& attribute_map,
            const AtomicString& value) override {
     Node* node = obj.GetNode();
     if (!node || !node->IsElementNode())
       return;
 
     String attribute_value = value.GetString();
     if (attribute_value.IsEmpty())
       return;
 
     attribute_value.SimplifyWhiteSpace();
     Vector<String> ids;
     attribute_value.Split(' ', ids);
     if (ids.IsEmpty())
       return;
 
-    HeapVector<Member<AXObjectImpl>> objects;
+    HeapVector<Member<AXObject>> objects;
     TreeScope& scope = node->GetTreeScope();
     for (const auto& id : ids) {
       if (Element* id_element = scope.getElementById(AtomicString(id))) {
-        AXObjectImpl* ax_id_element =
-            obj.AxObjectCache().GetOrCreate(id_element);
+        AXObject* ax_id_element = obj.AxObjectCache().GetOrCreate(id_element);
         if (ax_id_element && !ax_id_element->AccessibilityIsIgnored())
           objects.push_back(ax_id_element);
       }
     }
 
     attribute_map.AddObjectVectorAttribute(attribute_, objects);
   }
 };
 
 using AXSparseAttributeSetterMap =
@@ skipping 26 matching lines @@
         aria_keyshortcutsAttr,
         new StringAttributeSetter(AXStringAttribute::kAriaKeyShortcuts));
     ax_sparse_attribute_setter_map.Set(
         aria_roledescriptionAttr,
         new StringAttributeSetter(AXStringAttribute::kAriaRoleDescription));
   }
   return ax_sparse_attribute_setter_map;
 }
 
 AXNodeObject::AXNodeObject(Node* node, AXObjectCacheImpl& ax_object_cache)
-    : AXObjectImpl(ax_object_cache),
+    : AXObject(ax_object_cache),
       aria_role_(kUnknownRole),
       children_dirty_(false),
       node_(node) {}
 
 AXNodeObject* AXNodeObject::Create(Node* node,
                                    AXObjectCacheImpl& ax_object_cache) {
   return new AXNodeObject(node, ax_object_cache);
 }
 
 AXNodeObject::~AXNodeObject() {
   DCHECK(!node_);
 }
 
 void AXNodeObject::AlterSliderValue(bool increase) {
   if (RoleValue() != kSliderRole)
     return;
 
   float value = ValueForRange();
   float step = StepValueForRange();
 
   value += increase ? step : -step;
 
   SetValue(String::Number(value));
   AxObjectCache().PostNotification(GetNode(),
                                    AXObjectCacheImpl::kAXValueChanged);
 }
 
-AXObjectImpl* AXNodeObject::ActiveDescendant() {
+AXObject* AXNodeObject::ActiveDescendant() {
   if (!node_ || !node_->IsElementNode())
     return nullptr;
 
   const AtomicString& active_descendant_attr =
       GetAttribute(aria_activedescendantAttr);
   if (active_descendant_attr.IsNull() || active_descendant_attr.IsEmpty())
     return nullptr;
 
   Element* element = ToElement(GetNode());
   Element* descendant =
       element->GetTreeScope().getElementById(active_descendant_attr);
   if (!descendant)
     return nullptr;
 
-  AXObjectImpl* ax_descendant = AxObjectCache().GetOrCreate(descendant);
+  AXObject* ax_descendant = AxObjectCache().GetOrCreate(descendant);
   return ax_descendant;
 }
 
 bool AXNodeObject::ComputeAccessibilityIsIgnored(
     IgnoredReasons* ignored_reasons) const {
 #if DCHECK_IS_ON()
-  // Double-check that an AXObjectImpl is never accessed before
+  // Double-check that an AXObject is never accessed before
   // it's been initialized.
   DCHECK(initialized_);
 #endif
 
   // If this element is within a parent that cannot have children, it should not
   // be exposed.
   if (IsDescendantOfLeafNode()) {
     if (ignored_reasons)
       ignored_reasons->push_back(
           IgnoredReason(kAXAncestorIsLeafNode, LeafNodeAncestor()));
     return true;
   }
 
   // Ignore labels that are already referenced by a control.
-  AXObjectImpl* control_object = CorrespondingControlForLabelElement();
+  AXObject* control_object = CorrespondingControlForLabelElement();
   if (control_object && control_object->IsCheckboxOrRadio() &&
       control_object->NameFromLabelElement()) {
     if (ignored_reasons) {
       HTMLLabelElement* label = LabelElementContainer();
       if (label && label != GetNode()) {
-        AXObjectImpl* label_ax_object = AxObjectCache().GetOrCreate(label);
+        AXObject* 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;
   }
 
   Element* element = GetNode()->IsElementNode() ? ToElement(GetNode())
@@ skipping 11 matching lines @@
     return true;
   }
   return false;
 }
 
 static bool IsListElement(Node* node) {
   return isHTMLUListElement(*node) || isHTMLOListElement(*node) ||
          isHTMLDListElement(*node);
 }
 
-static bool IsPresentationalInTable(AXObjectImpl* parent,
+static bool IsPresentationalInTable(AXObject* parent,
                                     HTMLElement* current_element) {
   if (!current_element)
     return false;
 
   Node* parent_node = parent->GetNode();
   if (!parent_node || !parent_node->IsHTMLElement())
     return false;
 
   // AXTable determines the role as checking isTableXXX.
   // If Table has explicit role including presentation, AXTable doesn't assign
   // implicit Role to a whole Table. That's why we should check it based on
   // node.
   // Normal Table Tree is that
   // cell(its role)-> tr(tr role)-> tfoot, tbody, thead(ignored role) ->
   //     table(table role).
   // If table has presentation role, it will be like
   // cell(group)-> tr(unknown) -> tfoot, tbody, thead(ignored) ->
   //     table(presentation).
   if (IsHTMLTableCellElement(*current_element) &&
       isHTMLTableRowElement(*parent_node))
     return parent->HasInheritedPresentationalRole();
 
   if (isHTMLTableRowElement(*current_element) &&
       IsHTMLTableSectionElement(ToHTMLElement(*parent_node))) {
     // Because TableSections have ignored role, presentation should be checked
     // with its parent node.
-    AXObjectImpl* table_object = parent->ParentObject();
+    AXObject* table_object = parent->ParentObject();
     Node* table_node = table_object ? table_object->GetNode() : 0;
     return isHTMLTableElement(table_node) &&
            table_object->HasInheritedPresentationalRole();
   }
   return false;
 }
 
-static bool IsRequiredOwnedElement(AXObjectImpl* parent,
+static bool IsRequiredOwnedElement(AXObject* parent,
                                    AccessibilityRole current_role,
                                    HTMLElement* current_element) {
   Node* parent_node = parent->GetNode();
   if (!parent_node || !parent_node->IsHTMLElement())
     return false;
 
   if (current_role == kListItemRole)
     return IsListElement(parent_node);
   if (current_role == kListMarkerRole)
     return isHTMLLIElement(*parent_node);
   if (current_role == kMenuItemCheckBoxRole || current_role == kMenuItemRole ||
       current_role == kMenuItemRadioRole)
     return isHTMLMenuElement(*parent_node);
 
   if (!current_element)
     return false;
   if (IsHTMLTableCellElement(*current_element))
     return isHTMLTableRowElement(*parent_node);
   if (isHTMLTableRowElement(*current_element))
     return IsHTMLTableSectionElement(ToHTMLElement(*parent_node));
 
   // In case of ListboxRole and its child, ListBoxOptionRole, inheritance of
   // presentation role is handled in AXListBoxOption because ListBoxOption Role
   // doesn't have any child.
   // If it's just ignored because of presentation, we can't see any AX tree
   // related to ListBoxOption.
   return false;
 }
 
-const AXObjectImpl* AXNodeObject::InheritsPresentationalRoleFrom() const {
+const AXObject* AXNodeObject::InheritsPresentationalRoleFrom() const {
   // ARIA states if an item can get focus, it should not be presentational.
   if (CanSetFocusAttribute())
     return 0;
 
   if (IsPresentational())
     return this;
 
   // http://www.w3.org/TR/wai-aria/complete#presentation
   // ARIA spec says that the user agent MUST apply an inherited role of
   // presentation
   // to any owned elements that do not have an explicit role defined.
   if (AriaRoleAttribute() != kUnknownRole)
     return 0;
 
-  AXObjectImpl* parent = ParentObject();
+  AXObject* parent = ParentObject();
   if (!parent)
     return 0;
 
   HTMLElement* element = nullptr;
   if (GetNode() && GetNode()->IsHTMLElement())
     element = ToHTMLElement(GetNode());
   if (!parent->HasInheritedPresentationalRole()) {
     if (!GetLayoutObject() || !GetLayoutObject()->IsBoxModelObject())
       return 0;
 
@@ skipping 304 matching lines @@
   role = RemapAriaRoleDueToParent(role);
 
   if (role)
     return role;
 
   return kUnknownRole;
 }
 
 void AXNodeObject::AccessibilityChildrenFromAttribute(
     QualifiedName attr,
-    AXObjectImpl::AXObjectVector& children) const {
+    AXObject::AXObjectVector& children) const {
   HeapVector<Member<Element>> elements;
   ElementsFromAttribute(elements, attr);
 
   AXObjectCacheImpl& cache = AxObjectCache();
   for (const auto& element : elements) {
-    if (AXObjectImpl* child = cache.GetOrCreate(element)) {
+    if (AXObject* child = cache.GetOrCreate(element)) {
       // Only aria-labelledby and aria-describedby can target hidden elements.
       if (child->AccessibilityIsIgnored() && attr != aria_labelledbyAttr &&
           attr != aria_labeledbyAttr && attr != aria_describedbyAttr) {
         continue;
       }
       children.push_back(child);
     }
   }
 }
 
@@ skipping 53 matching lines @@
 
   // An SVG root is focusable by default, but it's probably not interactive, so
   // don't include it. It can still be made accessible by giving it an ARIA
   // role.
   if (RoleValue() == kSVGRootRole)
     return false;
 
   return true;
 }
 
-AXObjectImpl* AXNodeObject::MenuButtonForMenu() const {
+AXObject* AXNodeObject::MenuButtonForMenu() const {
   Element* menu_item = MenuItemElementForMenu();
 
   if (menu_item) {
     // ARIA just has generic menu items. AppKit needs to know if this is a top
     // level items like MenuBarButton or MenuBarItem
-    AXObjectImpl* menu_item_ax = AxObjectCache().GetOrCreate(menu_item);
+    AXObject* menu_item_ax = AxObjectCache().GetOrCreate(menu_item);
     if (menu_item_ax && menu_item_ax->IsMenuButton())
       return menu_item_ax;
   }
   return 0;
 }
 
 static Element* SiblingWithAriaRole(String role, Node* node) {
   Node* parent = node->parentNode();
   if (!parent)
     return 0;
@@ skipping 49 matching lines @@
     AccessibilityRole role) const {
   // Some objects change their role based on their parent.
   // However, asking for the unignoredParent calls accessibilityIsIgnored(),
   // which can trigger a loop.  While inside the call stack of creating an
   // element, we need to avoid accessibilityIsIgnored().
   // https://bugs.webkit.org/show_bug.cgi?id=65174
 
   if (role != kListBoxOptionRole && role != kMenuItemRole)
     return role;
 
-  for (AXObjectImpl* parent = ParentObject();
+  for (AXObject* parent = ParentObject();
        parent && !parent->AccessibilityIsIgnored();
        parent = parent->ParentObject()) {
     AccessibilityRole parent_aria_role = parent->AriaRoleAttribute();
 
     // Selects and listboxes both have options as child roles, but they map to
     // different roles within WebCore.
     if (role == kListBoxOptionRole && parent_aria_role == kMenuRole)
       return kMenuItemRole;
     // An aria "menuitem" may map to MenuButton or MenuItem depending on its
     // parent.
@@ skipping 11 matching lines @@
 
 void AXNodeObject::Init() {
 #if DCHECK_IS_ON()
   DCHECK(!initialized_);
   initialized_ = true;
 #endif
   role_ = DetermineAccessibilityRole();
 }
 
 void AXNodeObject::Detach() {
-  AXObjectImpl::Detach();
+  AXObject::Detach();
   node_ = nullptr;
 }
 
 void AXNodeObject::GetSparseAXAttributes(
     AXSparseAttributeClient& sparse_attribute_client) const {
   Node* node = this->GetNode();
   if (!node || !node->IsElementNode())
     return;
 
   AXSparseAttributeSetterMap& ax_sparse_attribute_setter_map =
@@ skipping 27 matching lines @@
 bool AXNodeObject::IsAnchor() const {
   return !IsNativeImage() && IsLink();
 }
 
 bool AXNodeObject::IsControl() const {
   Node* node = this->GetNode();
   if (!node)
     return false;
 
   return ((node->IsElementNode() && ToElement(node)->IsFormControlElement()) ||
-          AXObjectImpl::IsARIAControl(AriaRoleAttribute()));
+          AXObject::IsARIAControl(AriaRoleAttribute()));
 }
 
 bool AXNodeObject::IsControllingVideoElement() const {
   Node* node = this->GetNode();
   if (!node)
     return true;
 
   return isHTMLVideoElement(ToParentMediaElement(node));
 }
 
@@ skipping 180 matching lines @@
 
     // Note: we can't call getNode()->willRespondToMouseClickEvents() because
     // that triggers a style recalc and can delete this.
     if (GetNode()->HasEventListeners(EventTypeNames::mouseup) ||
         GetNode()->HasEventListeners(EventTypeNames::mousedown) ||
         GetNode()->HasEventListeners(EventTypeNames::click) ||
         GetNode()->HasEventListeners(EventTypeNames::DOMActivate))
       return true;
   }
 
-  return AXObjectImpl::IsClickable();
+  return AXObject::IsClickable();
 }
 
 bool AXNodeObject::IsEnabled() const {
   if (IsDescendantOfDisabledNode())
     return false;
 
   Node* node = this->GetNode();
   if (!node || !node->IsElementNode())
     return true;
 
@@ skipping 122 matching lines @@
   // for this information for all elements.
   return !IsReadOnly();
 }
 
 bool AXNodeObject::CanSetSelectedAttribute() const {
   // ARIA list box options can be selected if they are children of an element
   // with an aria-activedescendant attribute.
   if (AriaRoleAttribute() == kListBoxOptionRole &&
       AncestorExposesActiveDescendant())
     return true;
-  return AXObjectImpl::CanSetSelectedAttribute();
+  return AXObject::CanSetSelectedAttribute();
 }
 
 bool AXNodeObject::CanvasHasFallbackContent() const {
   Node* node = this->GetNode();
   if (!isHTMLCanvasElement(node))
     return false;
 
   // If it has any children that are elements, we'll assume it might be fallback
   // content. If it has no children or its only children are not elements
   // (e.g. just text nodes), it doesn't have fallback content.
@@ skipping 55 matching lines @@
     return 1;
   }
 
   // Only tree item will calculate its level through the DOM currently.
   if (RoleValue() != kTreeItemRole)
     return 0;
 
   // Hierarchy leveling starts at 1, to match the aria-level spec.
   // We measure tree hierarchy by the number of groups that the item is within.
   unsigned level = 1;
-  for (AXObjectImpl* parent = ParentObject(); parent;
+  for (AXObject* parent = ParentObject(); parent;
        parent = parent->ParentObject()) {
     AccessibilityRole parent_role = parent->RoleValue();
     if (parent_role == kGroupRole)
       level++;
     else if (parent_role == kTreeRole)
       break;
   }
 
   return level;
 }
@@ skipping 30 matching lines @@
         marker_ranges.push_back(
             AXRange(marker->StartOffset(), marker->EndOffset()));
         break;
       case DocumentMarker::kComposition:
         // No need for accessibility to know about these marker types.
         break;
     }
   }
 }
 
-AXObjectImpl* AXNodeObject::InPageLinkTarget() const {
+AXObject* AXNodeObject::InPageLinkTarget() const {
   if (!node_ || !isHTMLAnchorElement(node_) || !GetDocument())
-    return AXObjectImpl::InPageLinkTarget();
+    return AXObject::InPageLinkTarget();
 
   HTMLAnchorElement* anchor = toHTMLAnchorElement(node_);
   DCHECK(anchor);
   KURL link_url = anchor->Href();
   if (!link_url.IsValid())
-    return AXObjectImpl::InPageLinkTarget();
+    return AXObject::InPageLinkTarget();
   String fragment = link_url.FragmentIdentifier();
   if (fragment.IsEmpty())
-    return AXObjectImpl::InPageLinkTarget();
+    return AXObject::InPageLinkTarget();
 
   KURL document_url = GetDocument()->Url();
   if (!document_url.IsValid() ||
       !EqualIgnoringFragmentIdentifier(document_url, link_url)) {
-    return AXObjectImpl::InPageLinkTarget();
+    return AXObject::InPageLinkTarget();
   }
 
   TreeScope& tree_scope = anchor->GetTreeScope();
   Element* target = tree_scope.FindAnchor(fragment);
   if (!target)
-    return AXObjectImpl::InPageLinkTarget();
+    return AXObject::InPageLinkTarget();
   // If the target is not in the accessibility tree, get the first unignored
   // sibling.
   return AxObjectCache().FirstAccessibleObjectFromNode(target);
 }
 
 AccessibilityOrientation AXNodeObject::Orientation() const {
   const AtomicString& aria_orientation =
       GetAOMPropertyOrARIAAttribute(AOMStringProperty::kOrientation);
   AccessibilityOrientation orientation = kAccessibilityOrientationUndefined;
   if (EqualIgnoringASCIICase(aria_orientation, "horizontal"))
@@ skipping 17 matching lines @@
     case kTabListRole:
     case kToolbarRole:
       if (orientation == kAccessibilityOrientationUndefined)
         orientation = kAccessibilityOrientationHorizontal;
 
       return orientation;
     case kRadioGroupRole:
     case kTreeGridRole:
       return orientation;
     default:
-      return AXObjectImpl::Orientation();
+      return AXObject::Orientation();
   }
 }
 
-AXObjectImpl::AXObjectVector AXNodeObject::RadioButtonsInGroup() const {
+AXObject::AXObjectVector AXNodeObject::RadioButtonsInGroup() const {
   AXObjectVector radio_buttons;
   if (!node_ || RoleValue() != kRadioButtonRole)
     return radio_buttons;
 
   if (isHTMLInputElement(node_)) {
     HTMLInputElement* radio_button = toHTMLInputElement(node_);
     HeapVector<Member<HTMLInputElement>> html_radio_buttons =
         FindAllRadioButtonsWithSameName(radio_button);
     for (size_t i = 0; i < html_radio_buttons.size(); ++i) {
-      AXObjectImpl* ax_radio_button =
+      AXObject* ax_radio_button =
           AxObjectCache().GetOrCreate(html_radio_buttons[i]);
       if (ax_radio_button)
         radio_buttons.push_back(ax_radio_button);
     }
     return radio_buttons;
   }
 
   // If the immediate parent is a radio group, return all its children that are
   // radio buttons.
-  AXObjectImpl* parent = ParentObject();
+  AXObject* parent = ParentObject();
   if (parent && parent->RoleValue() == kRadioGroupRole) {
     for (size_t i = 0; i < parent->Children().size(); ++i) {
-      AXObjectImpl* child = parent->Children()[i];
+      AXObject* child = parent->Children()[i];
       DCHECK(child);
       if (child->RoleValue() == kRadioButtonRole &&
           !child->AccessibilityIsIgnored()) {
         radio_buttons.push_back(child);
       }
     }
   }
 
   return radio_buttons;
 }
@@ skipping 41 matching lines @@
     return ToTextControlElement(*node).value();
 
   if (!node->IsElementNode())
     return String();
 
   return ToElement(node)->innerText();
 }
 
 RGBA32 AXNodeObject::ColorValue() const {
   if (!isHTMLInputElement(GetNode()) || !IsColorWell())
-    return AXObjectImpl::ColorValue();
+    return AXObject::ColorValue();
 
   HTMLInputElement* input = toHTMLInputElement(GetNode());
   const AtomicString& type = input->getAttribute(typeAttr);
   if (!EqualIgnoringASCIICase(type, "color"))
-    return AXObjectImpl::ColorValue();
+    return AXObject::ColorValue();
 
   // HTMLInputElement::value always returns a string parseable by Color.
   Color color;
   bool success = color.SetFromString(input->value());
   DCHECK(success);
   return color.Rgb();
 }
 
 AriaCurrentState AXNodeObject::GetAriaCurrentState() const {
   const AtomicString& attribute_value =
@@ skipping 12 matching lines @@
   if (EqualIgnoringASCIICase(attribute_value, "location"))
     return kAriaCurrentStateLocation;
   if (EqualIgnoringASCIICase(attribute_value, "date"))
     return kAriaCurrentStateDate;
   if (EqualIgnoringASCIICase(attribute_value, "time"))
     return kAriaCurrentStateTime;
   // An unknown value should return true.
   if (!attribute_value.IsEmpty())
     return kAriaCurrentStateTrue;
 
-  return AXObjectImpl::GetAriaCurrentState();
+  return AXObject::GetAriaCurrentState();
 }
 
 InvalidState AXNodeObject::GetInvalidState() const {
   const AtomicString& attribute_value =
       GetAOMPropertyOrARIAAttribute(AOMStringProperty::kInvalid);
   if (EqualIgnoringASCIICase(attribute_value, "false"))
     return kInvalidStateFalse;
   if (EqualIgnoringASCIICase(attribute_value, "true"))
     return kInvalidStateTrue;
   if (EqualIgnoringASCIICase(attribute_value, "spelling"))
     return kInvalidStateSpelling;
   if (EqualIgnoringASCIICase(attribute_value, "grammar"))
     return kInvalidStateGrammar;
   // A yet unknown value.
   if (!attribute_value.IsEmpty())
     return kInvalidStateOther;
 
   if (GetNode() && GetNode()->IsElementNode() &&
       ToElement(GetNode())->IsFormControlElement()) {
     HTMLFormControlElement* element = ToHTMLFormControlElement(GetNode());
     HeapVector<Member<HTMLFormControlElement>> invalid_controls;
     bool is_invalid = !element->checkValidity(&invalid_controls,
                                               kCheckValidityDispatchNoEvent);
     return is_invalid ? kInvalidStateTrue : kInvalidStateFalse;
   }
 
-  return AXObjectImpl::GetInvalidState();
+  return AXObject::GetInvalidState();
 }
 
 int AXNodeObject::PosInSet() const {
   if (SupportsSetSizeAndPosInSet()) {
     String pos_in_set_str = GetAttribute(aria_posinsetAttr);
     if (!pos_in_set_str.IsEmpty()) {
       int pos_in_set = pos_in_set_str.ToInt();
       if (pos_in_set > 0)
         return pos_in_set;
       return 1;
     }
 
-    return AXObjectImpl::IndexInParent() + 1;
+    return AXObject::IndexInParent() + 1;
   }
 
   return 0;
 }
 
 int AXNodeObject::SetSize() const {
   if (SupportsSetSizeAndPosInSet()) {
     String set_size_str = GetAttribute(aria_setsizeAttr);
     if (!set_size_str.IsEmpty()) {
       int set_size = set_size_str.ToInt();
@@ skipping 258 matching lines @@
 
   return String();
 }
 
 String AXNodeObject::TextFromDescendants(AXObjectSet& visited,
                                          bool recursive) const {
   if (!CanHaveChildren() && recursive)
     return String();
 
   StringBuilder accumulated_text;
-  AXObjectImpl* previous = nullptr;
+  AXObject* previous = nullptr;
 
   AXObjectVector children;
 
-  HeapVector<Member<AXObjectImpl>> owned_children;
+  HeapVector<Member<AXObject>> owned_children;
   ComputeAriaOwnsChildren(owned_children);
-  for (AXObjectImpl* obj = RawFirstChild(); obj; obj = obj->RawNextSibling()) {
+  for (AXObject* obj = RawFirstChild(); obj; obj = obj->RawNextSibling()) {
     if (!AxObjectCache().IsAriaOwned(obj))
       children.push_back(obj);
   }
   for (const auto& owned_child : owned_children)
     children.push_back(owned_child);
 
-  for (AXObjectImpl* child : children) {
+  for (AXObject* child : children) {
     // Don't recurse into children that are explicitly marked as aria-hidden.
     // Note that we don't call isInertOrAriaHidden because that would return
     // true if any ancestor is hidden, but we need to be able to compute the
     // accessible name of object inside hidden subtrees (for example, if
     // aria-labelledby points to an object that's hidden).
     if (EqualIgnoringASCIICase(child->GetAttribute(aria_hiddenAttr), "true"))
       continue;
 
     // If we're going between two layoutObjects that are in separate
     // LayoutBoxes, add whitespace if it wasn't there already. Intuitively if
@@ skipping 56 matching lines @@
         ToLabelableElement(html_element)->labels()->length() > 0)
       return true;
   }
 
   return false;
 }
 
 bool AXNodeObject::NameFromContents() const {
   Node* node = GetNode();
   if (!node || !node->IsElementNode())
-    return AXObjectImpl::NameFromContents();
-  // AXObjectImpl::nameFromContents determines whether an element should take
-  // its name from its descendant contents based on role. However, <select> is a
+    return AXObject::NameFromContents();
+  // AXObject::nameFromContents determines whether an element should take its
+  // name from its descendant contents based on role. However, <select> is a
   // special case, as unlike a typical pop-up button it contains its own pop-up
   // menu's contents, which should not be used as the name.
   if (isHTMLSelectElement(node))
     return false;
-  return AXObjectImpl::NameFromContents();
+  return AXObject::NameFromContents();
 }
 
 void AXNodeObject::GetRelativeBounds(
-    AXObjectImpl** out_container,
+    AXObject** out_container,
     FloatRect& out_bounds_in_container,
     SkMatrix44& out_container_transform) const {
   if (LayoutObjectForRelativeBounds()) {
-    AXObjectImpl::GetRelativeBounds(out_container, out_bounds_in_container,
-                                    out_container_transform);
+    AXObject::GetRelativeBounds(out_container, out_bounds_in_container,
+                                out_container_transform);
     return;
   }
 
   *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.
   if (!explicit_element_rect_.IsEmpty()) {
     *out_container = AxObjectCache().ObjectFromAXID(explicit_container_id_);
     if (*out_container) {
       out_bounds_in_container = FloatRect(explicit_element_rect_);
       return;
     }
   }
 
   // If it's in a canvas but doesn't have an explicit rect, get the bounding
   // rect of its children.
   if (GetNode()->parentElement()->IsInCanvasSubtree()) {
     Vector<FloatRect> rects;
     for (Node& child : NodeTraversal::ChildrenOf(*GetNode())) {
       if (child.IsHTMLElement()) {
-        if (AXObjectImpl* obj = AxObjectCache().Get(&child)) {
-          AXObjectImpl* container;
+        if (AXObject* obj = AxObjectCache().Get(&child)) {
+          AXObject* container;
           FloatRect bounds;
           obj->GetRelativeBounds(&container, bounds, out_container_transform);
           if (container) {
             *out_container = container;
             rects.push_back(bounds);
           }
         }
       }
     }
 
     if (*out_container) {
       out_bounds_in_container = UnionRect(rects);
       return;
     }
   }
 
   // If this object doesn't have an explicit element rect or computable from its
   // children, for now, let's return the position of the ancestor that does have
   // a position, and make it the width of that parent, and about the height of a
   // line of text, so that it's clear the object is a child of the parent.
-  for (AXObjectImpl* position_provider = ParentObject(); position_provider;
+  for (AXObject* position_provider = ParentObject(); position_provider;
        position_provider = position_provider->ParentObject()) {
     if (position_provider->IsAXLayoutObject()) {
       position_provider->GetRelativeBounds(
           out_container, out_bounds_in_container, out_container_transform);
       if (*out_container)
         out_bounds_in_container.SetSize(
             FloatSize(out_bounds_in_container.Width(),
                       std::min(10.0f, out_bounds_in_container.Height())));
       break;
     }
@@ skipping 10 matching lines @@
   // <option>.
   if (isHTMLOptionElement(node))
     parent_node = toHTMLOptionElement(node)->OwnerSelectElement();
 
   if (!parent_node)
     parent_node = node->parentNode();
 
   return parent_node;
 }
 
-AXObjectImpl* AXNodeObject::ComputeParent() const {
+AXObject* AXNodeObject::ComputeParent() const {
   DCHECK(!IsDetached());
   if (Node* parent_node = GetParentNodeForComputeParent(GetNode()))
     return AxObjectCache().GetOrCreate(parent_node);
 
   return nullptr;
 }
 
-AXObjectImpl* AXNodeObject::ComputeParentIfExists() const {
+AXObject* AXNodeObject::ComputeParentIfExists() const {
   if (Node* parent_node = GetParentNodeForComputeParent(GetNode()))
     return AxObjectCache().Get(parent_node);
 
   return nullptr;
 }
 
-AXObjectImpl* AXNodeObject::RawFirstChild() const {
+AXObject* AXNodeObject::RawFirstChild() const {
   if (!GetNode())
     return 0;
 
   Node* first_child = GetNode()->firstChild();
 
   if (!first_child)
     return 0;
 
   return AxObjectCache().GetOrCreate(first_child);
 }
 
-AXObjectImpl* AXNodeObject::RawNextSibling() const {
+AXObject* AXNodeObject::RawNextSibling() const {
   if (!GetNode())
     return 0;
 
   Node* next_sibling = GetNode()->nextSibling();
   if (!next_sibling)
     return 0;
 
   return AxObjectCache().GetOrCreate(next_sibling);
 }
 
 void AXNodeObject::AddChildren() {
   DCHECK(!IsDetached());
   // 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_);
 
   if (!node_)
     return;
 
   have_children_ = true;
 
   // The only time we add children from the DOM tree to a node with a
   // layoutObject is when it's a canvas.
   if (GetLayoutObject() && !isHTMLCanvasElement(*node_))
     return;
 
-  HeapVector<Member<AXObjectImpl>> owned_children;
+  HeapVector<Member<AXObject>> owned_children;
   ComputeAriaOwnsChildren(owned_children);
 
   for (Node& child : NodeTraversal::ChildrenOf(*node_)) {
-    AXObjectImpl* child_obj = AxObjectCache().GetOrCreate(&child);
+    AXObject* child_obj = AxObjectCache().GetOrCreate(&child);
     if (child_obj && !AxObjectCache().IsAriaOwned(child_obj))
       AddChild(child_obj);
   }
 
   for (const auto& owned_child : owned_children)
     AddChild(owned_child);
 
   for (const auto& child : children_)
     child->SetParent(this);
 }
 
-void AXNodeObject::AddChild(AXObjectImpl* child) {
+void AXNodeObject::AddChild(AXObject* child) {
   InsertChild(child, children_.size());
 }
 
-void AXNodeObject::InsertChild(AXObjectImpl* child, unsigned index) {
+void AXNodeObject::InsertChild(AXObject* child, unsigned index) {
   if (!child)
     return;
 
   // If the parent is asking for this child's children, then either it's the
   // first time (and clearing is a no-op), or its visibility has changed. In the
   // latter case, this child may have a stale child cached.  This can prevent
   // aria-hidden changes from working correctly. Hence, whenever a parent is
   // getting children, ensure data is not stale.
   child->ClearChildren();
 
@@ skipping 55 matching lines @@
   if (isHTMLInputElement(*node)) {
     HTMLInputElement& input = toHTMLInputElement(*node);
     if (!input.IsDisabledFormControl() &&
         (IsCheckboxOrRadio() || input.IsTextButton() ||
          input.type() == InputTypeNames::file))
       return &input;
   } else if (isHTMLButtonElement(*node)) {
     return ToElement(node);
   }
 
-  if (AXObjectImpl::IsARIAInput(AriaRoleAttribute()))
+  if (AXObject::IsARIAInput(AriaRoleAttribute()))
     return ToElement(node);
 
   if (IsImageButton())
     return ToElement(node);
 
   if (isHTMLSelectElement(*node))
     return ToElement(node);
 
   switch (RoleValue()) {
     case kButtonRole:
@@ skipping 38 matching lines @@
 Document* AXNodeObject::GetDocument() const {
   if (!GetNode())
     return 0;
   return &GetNode()->GetDocument();
 }
 
 void AXNodeObject::SetNode(Node* node) {
   node_ = node;
 }
 
-AXObjectImpl* AXNodeObject::CorrespondingControlForLabelElement() const {
+AXObject* AXNodeObject::CorrespondingControlForLabelElement() const {
   HTMLLabelElement* label_element = LabelElementContainer();
   if (!label_element)
     return 0;
 
   HTMLElement* corresponding_control = label_element->control();
   if (!corresponding_control)
     return 0;
 
   // Make sure the corresponding control isn't a descendant of this label
   // that's in the middle of being destroyed.
@@ skipping 78 matching lines @@
     return;
   }
 
   AxObjectCache().PostNotification(this, AXObjectCacheImpl::kAXChildrenChanged);
 
   // Go up the accessibility parent chain, but only if the element already
   // exists. This method is called during layout, minimal work should be done.
   // If AX elements are created now, they could interrogate the layout tree
   // while it's in a funky state.  At the same time, process ARIA live region
   // changes.
-  for (AXObjectImpl* parent = this; parent;
+  for (AXObject* parent = this; parent;
        parent = parent->ParentObjectIfExists()) {
     parent->SetNeedsToUpdateChildren();
 
     // These notifications always need to be sent because screenreaders are
     // reliant on them to perform.  In other words, they need to be sent even
     // when the screen reader has not accessed this live region since the last
     // update.
 
     // If this element supports ARIA live regions, then notify the AT of
     // changes.
@@ skipping 11 matching lines @@
 }
 
 void AXNodeObject::SelectionChanged() {
   // Post the selected text changed event on the first ancestor that's
   // focused (to handle form controls, ARIA text boxes and contentEditable),
   // or the web area if the selection is just in the document somewhere.
   if (IsFocused() || IsWebArea()) {
     AxObjectCache().PostNotification(this,
                                      AXObjectCacheImpl::kAXSelectedTextChanged);
     if (GetDocument()) {
-      AXObjectImpl* document_object =
-          AxObjectCache().GetOrCreate(GetDocument());
+      AXObject* document_object = AxObjectCache().GetOrCreate(GetDocument());
       AxObjectCache().PostNotification(
           document_object, AXObjectCacheImpl::kAXDocumentSelectionChanged);
     }
   } else {
-    AXObjectImpl::SelectionChanged();  // Calls selectionChanged on parent.
+    AXObject::SelectionChanged();  // Calls selectionChanged on parent.
   }
 }
 
 void AXNodeObject::TextChanged() {
   // If this element supports ARIA live regions, or is part of a region with an
   // ARIA editable role, then notify the AT of changes.
   AXObjectCacheImpl& cache = AxObjectCache();
   for (Node* parent_node = GetNode(); parent_node;
        parent_node = parent_node->parentNode()) {
-    AXObjectImpl* parent = cache.Get(parent_node);
+    AXObject* parent = cache.Get(parent_node);
     if (!parent)
       continue;
 
     if (parent->IsLiveRegion())
       cache.PostNotification(parent_node,
                              AXObjectCacheImpl::kAXLiveRegionChanged);
 
     // If this element is an ARIA text box or content editable, post a "value
     // changed" notification on it so that it behaves just like a native input
     // element or textarea.
     if (parent->IsNonNativeTextControl())
       cache.PostNotification(parent_node, AXObjectCacheImpl::kAXValueChanged);
   }
 }
 
 void AXNodeObject::UpdateAccessibilityRole() {
   role_ = DetermineAccessibilityRole();
   bool ignored_status = AccessibilityIsIgnored();
 
   // The AX hierarchy only needs to be updated if the ignored status of an
   // element has changed.
   if (ignored_status != AccessibilityIsIgnored())
     ChildrenChanged();
 }
 
 void AXNodeObject::ComputeAriaOwnsChildren(
-    HeapVector<Member<AXObjectImpl>>& owned_children) const {
+    HeapVector<Member<AXObject>>& owned_children) const {
   if (!HasAttribute(aria_ownsAttr))
     return;
 
   Vector<String> id_vector;
   if (CanHaveChildren() && !IsNativeTextControl() &&
       !HasContentEditableAttributeSet())
     TokenVectorFromAttribute(id_vector, aria_ownsAttr);
 
   AxObjectCache().UpdateAriaOwns(this, id_vector, owned_children);
 }
@@ skipping 231 matching lines @@
       name_sources->back().native_source = kAXTextFromNativeHTMLFigcaption;
     }
     Element* figcaption = nullptr;
     for (Element& element : ElementTraversal::DescendantsOf(*(GetNode()))) {
       if (element.HasTagName(figcaptionTag)) {
         figcaption = &element;
         break;
       }
     }
     if (figcaption) {
-      AXObjectImpl* figcaption_ax_object =
-          AxObjectCache().GetOrCreate(figcaption);
+      AXObject* figcaption_ax_object = AxObjectCache().GetOrCreate(figcaption);
       if (figcaption_ax_object) {
         text_alternative =
             RecursiveTextAlternative(*figcaption_ax_object, false, visited);
 
         if (related_objects) {
           local_related_objects.push_back(new NameSourceRelatedObject(
               figcaption_ax_object, text_alternative));
           *related_objects = local_related_objects;
           local_related_objects.clear();
         }
@@ skipping 43 matching lines @@
 
     // caption
     name_from = kAXNameFromCaption;
     if (name_sources) {
       name_sources->push_back(NameSource(*found_text_alternative));
       name_sources->back().type = name_from;
       name_sources->back().native_source = kAXTextFromNativeHTMLTableCaption;
     }
     HTMLTableCaptionElement* caption = table_element->caption();
     if (caption) {
-      AXObjectImpl* caption_ax_object = AxObjectCache().GetOrCreate(caption);
+      AXObject* caption_ax_object = AxObjectCache().GetOrCreate(caption);
       if (caption_ax_object) {
         text_alternative =
             RecursiveTextAlternative(*caption_ax_object, false, visited);
         if (related_objects) {
           local_related_objects.push_back(
               new NameSourceRelatedObject(caption_ax_object, text_alternative));
           *related_objects = local_related_objects;
           local_related_objects.clear();
         }
 
@@ skipping 36 matching lines @@
     if (name_sources) {
       name_sources->push_back(NameSource(*found_text_alternative));
       name_sources->back().type = name_from;
       name_sources->back().native_source = kAXTextFromNativeHTMLTitleElement;
     }
     DCHECK(GetNode()->IsContainerNode());
     Element* title = ElementTraversal::FirstChild(
         ToContainerNode(*(GetNode())), HasTagName(SVGNames::titleTag));
 
     if (title) {
-      AXObjectImpl* title_ax_object = AxObjectCache().GetOrCreate(title);
+      AXObject* title_ax_object = AxObjectCache().GetOrCreate(title);
       if (title_ax_object && !visited.Contains(title_ax_object)) {
         text_alternative =
             RecursiveTextAlternative(*title_ax_object, false, visited);
         if (related_objects) {
           local_related_objects.push_back(
               new NameSourceRelatedObject(title_ax_object, text_alternative));
           *related_objects = local_related_objects;
           local_related_objects.clear();
         }
       }
@@ skipping 11 matching lines @@
   // Fieldset / legend.
   if (isHTMLFieldSetElement(GetNode())) {
     name_from = kAXNameFromRelatedElement;
     if (name_sources) {
       name_sources->push_back(NameSource(*found_text_alternative));
       name_sources->back().type = name_from;
       name_sources->back().native_source = kAXTextFromNativeHTMLLegend;
     }
     HTMLElement* legend = toHTMLFieldSetElement(GetNode())->Legend();
     if (legend) {
-      AXObjectImpl* legend_ax_object = AxObjectCache().GetOrCreate(legend);
+      AXObject* legend_ax_object = AxObjectCache().GetOrCreate(legend);
       // Avoid an infinite loop
       if (legend_ax_object && !visited.Contains(legend_ax_object)) {
         text_alternative =
             RecursiveTextAlternative(*legend_ax_object, false, visited);
 
         if (related_objects) {
           local_related_objects.push_back(
               new NameSourceRelatedObject(legend_ax_object, text_alternative));
           *related_objects = local_related_objects;
           local_related_objects.clear();
@@ skipping 41 matching lines @@
       name_from = kAXNameFromRelatedElement;
       if (name_sources) {
         name_sources->push_back(NameSource(*found_text_alternative));
         name_sources->back().type = name_from;
         name_sources->back().native_source = kAXTextFromNativeHTMLTitleElement;
       }
 
       text_alternative = document->title();
 
       Element* title_element = document->TitleElement();
-      AXObjectImpl* title_ax_object =
-          AxObjectCache().GetOrCreate(title_element);
+      AXObject* title_ax_object = AxObjectCache().GetOrCreate(title_element);
       if (title_ax_object) {
         if (related_objects) {
           local_related_objects.push_back(
               new NameSourceRelatedObject(title_ax_object, text_alternative));
           *related_objects = local_related_objects;
           local_related_objects.clear();
         }
 
         if (name_sources) {
           NameSource& source = name_sources->back();
@@ skipping 106 matching lines @@
 
     description_from = kAXDescriptionFromRelatedElement;
     if (description_sources) {
       description_sources->push_back(DescriptionSource(found_description));
       description_sources->back().type = description_from;
       description_sources->back().native_source =
           kAXTextFromNativeHTMLTableCaption;
     }
     HTMLTableCaptionElement* caption = table_element->caption();
     if (caption) {
-      AXObjectImpl* caption_ax_object = AxObjectCache().GetOrCreate(caption);
+      AXObject* caption_ax_object = AxObjectCache().GetOrCreate(caption);
       if (caption_ax_object) {
         AXObjectSet visited;
         description =
             RecursiveTextAlternative(*caption_ax_object, false, visited);
         if (related_objects)
           related_objects->push_back(
               new NameSourceRelatedObject(caption_ax_object, description));
 
         if (description_sources) {
           DescriptionSource& source = description_sources->back();
@@ skipping 110 matching lines @@
 
 String AXNodeObject::PlaceholderFromNativeAttribute() const {
   Node* node = GetNode();
   if (!node || !IsTextControlElement(node))
     return String();
   return ToTextControlElement(node)->StrippedPlaceholder();
 }
 
 DEFINE_TRACE(AXNodeObject) {
   visitor->Trace(node_);
-  AXObjectImpl::Trace(visitor);
+  AXObject::Trace(visitor);
 }
 
 }  // namespace blink