Rename AXObject to AXObjectImpl in modules/ and web/

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

Index: third_party/WebKit/Source/modules/accessibility/AXObjectCacheImpl.cpp
diff --git a/third_party/WebKit/Source/modules/accessibility/AXObjectCacheImpl.cpp b/third_party/WebKit/Source/modules/accessibility/AXObjectCacheImpl.cpp
index 4f14f3e06d7d086d7831e67c7dd784f6ffde375d..1278b64ec79be70410791fb5960d36ef69e539c4 100644
--- a/third_party/WebKit/Source/modules/accessibility/AXObjectCacheImpl.cpp
+++ b/third_party/WebKit/Source/modules/accessibility/AXObjectCacheImpl.cpp
@@ -109,7 +109,7 @@ void AXObjectCacheImpl::Dispose() {
   notification_post_timer_.Stop();
 
   for (auto& entry : objects_) {
-    AXObject* obj = entry.value;
+    AXObjectImpl* obj = entry.value;
     obj->Detach();
     RemoveAXID(obj);
   }
@@ -119,11 +119,11 @@ void AXObjectCacheImpl::Dispose() {
 #endif
 }
 
-AXObject* AXObjectCacheImpl::Root() {
+AXObjectImpl* AXObjectCacheImpl::Root() {
   return GetOrCreate(document_);
 }
 
-AXObject* AXObjectCacheImpl::FocusedImageMapUIElement(
+AXObjectImpl* AXObjectCacheImpl::FocusedImageMapUIElement(
     HTMLAreaElement* area_element) {
   // Find the corresponding accessibility object for the HTMLAreaElement. This
   // should be in the list of children for its corresponding image.
@@ -134,14 +134,15 @@ AXObject* AXObjectCacheImpl::FocusedImageMapUIElement(
   if (!image_element)
     return 0;
 
-  AXObject* ax_layout_image = GetOrCreate(image_element);
+  AXObjectImpl* ax_layout_image = GetOrCreate(image_element);
   if (!ax_layout_image)
     return 0;
 
-  const AXObject::AXObjectVector& image_children = ax_layout_image->Children();
+  const AXObjectImpl::AXObjectVector& image_children =
+      ax_layout_image->Children();
   unsigned count = image_children.size();
   for (unsigned k = 0; k < count; ++k) {
-    AXObject* child = image_children[k];
+    AXObjectImpl* child = image_children[k];
     if (!child->IsImageMapLink())
       continue;
 
@@ -152,7 +153,7 @@ AXObject* AXObjectCacheImpl::FocusedImageMapUIElement(
   return 0;
 }
 
-AXObject* AXObjectCacheImpl::FocusedObject() {
+AXObjectImpl* AXObjectCacheImpl::FocusedObject() {
   if (!AccessibilityEnabled())
     return nullptr;
 
@@ -170,12 +171,12 @@ AXObject* AXObjectCacheImpl::FocusedObject() {
     if (AXObject* ax_popup =
             toHTMLInputElement(adjusted_focused_element)->PopupRootAXObject()) {
       if (Element* focused_element_in_popup =
-              ax_popup->GetDocument()->FocusedElement())
+              ToAXObjectImpl(ax_popup)->GetDocument()->FocusedElement())
         focused_node = focused_element_in_popup;
     }
   }
 
-  AXObject* obj = GetOrCreate(focused_node);
+  AXObjectImpl* obj = GetOrCreate(focused_node);
   if (!obj)
     return nullptr;
 
@@ -187,7 +188,7 @@ AXObject* AXObjectCacheImpl::FocusedObject() {
   return obj;
 }
 
-AXObject* AXObjectCacheImpl::Get(LayoutObject* layout_object) {
+AXObjectImpl* AXObjectCacheImpl::Get(LayoutObject* layout_object) {
   if (!layout_object)
     return 0;
 
@@ -211,7 +212,7 @@ static bool IsMenuListOption(Node* node) {
   return layout_object && layout_object->IsMenuList();
 }
 
-AXObject* AXObjectCacheImpl::Get(Node* node) {
+AXObjectImpl* AXObjectCacheImpl::Get(Node* node) {
   if (!node)
     return 0;
 
@@ -244,7 +245,7 @@ AXObject* AXObjectCacheImpl::Get(Node* node) {
   return objects_.at(node_id);
 }
 
-AXObject* AXObjectCacheImpl::Get(AbstractInlineTextBox* inline_text_box) {
+AXObjectImpl* AXObjectCacheImpl::Get(AbstractInlineTextBox* inline_text_box) {
   if (!inline_text_box)
     return 0;
 
@@ -265,7 +266,8 @@ bool NodeHasRole(Node* node, const String& role) {
   return EqualIgnoringASCIICase(ToElement(node)->getAttribute(roleAttr), role);
 }
 
-AXObject* AXObjectCacheImpl::CreateFromRenderer(LayoutObject* layout_object) {
+AXObjectImpl* AXObjectCacheImpl::CreateFromRenderer(
+    LayoutObject* layout_object) {
   // FIXME: How could layoutObject->node() ever not be an Element?
   Node* node = layout_object->GetNode();
 
@@ -327,7 +329,7 @@ AXObject* AXObjectCacheImpl::CreateFromRenderer(LayoutObject* layout_object) {
   return AXLayoutObject::Create(layout_object, *this);
 }
 
-AXObject* AXObjectCacheImpl::CreateFromNode(Node* node) {
+AXObjectImpl* AXObjectCacheImpl::CreateFromNode(Node* node) {
   if (IsMenuListOption(node))
     return AXMenuListOption::Create(toHTMLOptionElement(node), *this);
 
@@ -337,21 +339,21 @@ AXObject* AXObjectCacheImpl::CreateFromNode(Node* node) {
   return AXNodeObject::Create(node, *this);
 }
 
-AXObject* AXObjectCacheImpl::CreateFromInlineTextBox(
+AXObjectImpl* AXObjectCacheImpl::CreateFromInlineTextBox(
     AbstractInlineTextBox* inline_text_box) {
   return AXInlineTextBox::Create(inline_text_box, *this);
 }
 
-AXObject* AXObjectCacheImpl::GetOrCreate(Node* node) {
+AXObjectImpl* AXObjectCacheImpl::GetOrCreate(Node* node) {
   if (!node)
     return 0;
 
-  if (AXObject* obj = Get(node))
+  if (AXObjectImpl* obj = Get(node))
     return obj;
 
   // If the node has a layout object, prefer using that as the primary key for
-  // the AXObject, with the exception of an HTMLAreaElement, which is created
-  // based on its node.
+  // the AXObjectImpl, with the exception of an HTMLAreaElement, which is
+  // created based on its node.
   if (node->GetLayoutObject() && !isHTMLAreaElement(node))
     return GetOrCreate(node->GetLayoutObject());
 
@@ -361,7 +363,7 @@ AXObject* AXObjectCacheImpl::GetOrCreate(Node* node) {
   if (isHTMLHeadElement(node))
     return 0;
 
-  AXObject* new_obj = CreateFromNode(node);
+  AXObjectImpl* new_obj = CreateFromNode(node);
 
   // Will crash later if we have two objects for the same node.
   DCHECK(!Get(node));
@@ -378,14 +380,14 @@ AXObject* AXObjectCacheImpl::GetOrCreate(Node* node) {
   return new_obj;
 }
 
-AXObject* AXObjectCacheImpl::GetOrCreate(LayoutObject* layout_object) {
+AXObjectImpl* AXObjectCacheImpl::GetOrCreate(LayoutObject* layout_object) {
   if (!layout_object)
     return 0;
 
-  if (AXObject* obj = Get(layout_object))
+  if (AXObjectImpl* obj = Get(layout_object))
     return obj;
 
-  AXObject* new_obj = CreateFromRenderer(layout_object);
+  AXObjectImpl* new_obj = CreateFromRenderer(layout_object);
 
   // Will crash later if we have two objects for the same layoutObject.
   DCHECK(!Get(layout_object));
@@ -399,15 +401,15 @@ AXObject* AXObjectCacheImpl::GetOrCreate(LayoutObject* layout_object) {
   return new_obj;
 }
 
-AXObject* AXObjectCacheImpl::GetOrCreate(
+AXObjectImpl* AXObjectCacheImpl::GetOrCreate(
     AbstractInlineTextBox* inline_text_box) {
   if (!inline_text_box)
     return 0;
 
-  if (AXObject* obj = Get(inline_text_box))
+  if (AXObjectImpl* obj = Get(inline_text_box))
     return obj;
 
-  AXObject* new_obj = CreateFromInlineTextBox(inline_text_box);
+  AXObjectImpl* new_obj = CreateFromInlineTextBox(inline_text_box);
 
   // Will crash later if we have two objects for the same inlineTextBox.
   DCHECK(!Get(inline_text_box));
@@ -421,8 +423,8 @@ AXObject* AXObjectCacheImpl::GetOrCreate(
   return new_obj;
 }
 
-AXObject* AXObjectCacheImpl::GetOrCreate(AccessibilityRole role) {
-  AXObject* obj = nullptr;
+AXObjectImpl* AXObjectCacheImpl::GetOrCreate(AccessibilityRole role) {
+  AXObjectImpl* obj = nullptr;
 
   // will be filled in...
   switch (role) {
@@ -462,7 +464,7 @@ void AXObjectCacheImpl::Remove(AXID ax_id) {
     return;
 
   // first fetch object to operate some cleanup functions on it
-  AXObject* obj = objects_.at(ax_id);
+  AXObjectImpl* obj = objects_.at(ax_id);
   if (!obj)
     return;
 
@@ -524,7 +526,7 @@ AXID AXObjectCacheImpl::GenerateAXID() const {
   return obj_id;
 }
 
-AXID AXObjectCacheImpl::GetOrCreateAXID(AXObject* obj) {
+AXID AXObjectCacheImpl::GetOrCreateAXID(AXObjectImpl* obj) {
   // check for already-assigned ID
   const AXID existing_axid = obj->AxObjectID();
   if (existing_axid) {
@@ -541,7 +543,7 @@ AXID AXObjectCacheImpl::GetOrCreateAXID(AXObject* obj) {
   return new_axid;
 }
 
-void AXObjectCacheImpl::RemoveAXID(AXObject* object) {
+void AXObjectCacheImpl::RemoveAXID(AXObjectImpl* object) {
   if (!object)
     return;
 
@@ -568,7 +570,7 @@ void AXObjectCacheImpl::SelectionChanged(Node* node) {
   // Find the nearest ancestor that already has an accessibility object, since
   // we might be in the middle of a layout.
   while (node) {
-    if (AXObject* obj = Get(node)) {
+    if (AXObjectImpl* obj = Get(node)) {
       obj->SelectionChanged();
       return;
     }
@@ -584,7 +586,7 @@ void AXObjectCacheImpl::TextChanged(LayoutObject* layout_object) {
   TextChanged(GetOrCreate(layout_object));
 }
 
-void AXObjectCacheImpl::TextChanged(AXObject* obj) {
+void AXObjectCacheImpl::TextChanged(AXObjectImpl* obj) {
   if (!obj)
     return;
 
@@ -612,7 +614,7 @@ void AXObjectCacheImpl::ChildrenChanged(LayoutObject* layout_object) {
   ChildrenChanged(Get(layout_object));
 }
 
-void AXObjectCacheImpl::ChildrenChanged(AXObject* obj) {
+void AXObjectCacheImpl::ChildrenChanged(AXObjectImpl* obj) {
   if (!obj)
     return;
 
@@ -624,7 +626,7 @@ void AXObjectCacheImpl::NotificationPostTimerFired(TimerBase*) {
 
   unsigned i = 0, count = notifications_to_post_.size();
   for (i = 0; i < count; ++i) {
-    AXObject* obj = notifications_to_post_[i].first;
+    AXObjectImpl* obj = notifications_to_post_[i].first;
 
     if (!obj->AxObjectID())
       continue;
@@ -668,7 +670,7 @@ void AXObjectCacheImpl::PostNotification(Node* node,
   PostNotification(Get(node), notification);
 }
 
-void AXObjectCacheImpl::PostNotification(AXObject* object,
+void AXObjectCacheImpl::PostNotification(AXObjectImpl* object,
                                          AXNotification notification) {
   if (!object)
     return;
@@ -679,19 +681,20 @@ void AXObjectCacheImpl::PostNotification(AXObject* object,
     notification_post_timer_.StartOneShot(0, BLINK_FROM_HERE);
 }
 
-bool AXObjectCacheImpl::IsAriaOwned(const AXObject* child) const {
+bool AXObjectCacheImpl::IsAriaOwned(const AXObjectImpl* child) const {
   return aria_owned_child_to_owner_mapping_.Contains(child->AxObjectID());
 }
 
-AXObject* AXObjectCacheImpl::GetAriaOwnedParent(const AXObject* child) const {
+AXObjectImpl* AXObjectCacheImpl::GetAriaOwnedParent(
+    const AXObjectImpl* child) const {
   return ObjectFromAXID(
       aria_owned_child_to_owner_mapping_.at(child->AxObjectID()));
 }
 
 void AXObjectCacheImpl::UpdateAriaOwns(
-    const AXObject* owner,
+    const AXObjectImpl* owner,
     const Vector<String>& id_vector,
-    HeapVector<Member<AXObject>>& owned_children) {
+    HeapVector<Member<AXObjectImpl>>& owned_children) {
   //
   // Update the map from the AXID of this element to the ids of the owned
   // children, and the reverse map from ids to possible AXID owners.
@@ -741,7 +744,7 @@ void AXObjectCacheImpl::UpdateAriaOwns(
     if (!element)
       continue;
 
-    AXObject* child = GetOrCreate(element);
+    AXObjectImpl* child = GetOrCreate(element);
     if (!child)
       continue;
 
@@ -759,7 +762,7 @@ void AXObjectCacheImpl::UpdateAriaOwns(
     // Walk up the parents of the owner object, make sure that this child
     // doesn't appear there, as that would create a cycle.
     bool found_cycle = false;
-    for (AXObject* parent = owner->ParentObject(); parent && !found_cycle;
+    for (AXObjectImpl* parent = owner->ParentObject(); parent && !found_cycle;
          parent = parent->ParentObject()) {
       if (parent == child)
         found_cycle = true;
@@ -791,9 +794,9 @@ void AXObjectCacheImpl::UpdateAriaOwns(
   // to be safe and handle all cases we remove all of the current owned children
   // and add the new list of owned children.
   for (size_t i = 0; i < current_child_axi_ds.size(); ++i) {
-    // Find the AXObject for the child that this owner no longer owns.
+    // Find the AXObjectImpl for the child that this owner no longer owns.
     AXID removed_child_id = current_child_axi_ds[i];
-    AXObject* removed_child = ObjectFromAXID(removed_child_id);
+    AXObjectImpl* removed_child = ObjectFromAXID(removed_child_id);
 
     // It's possible that this child has already been owned by some other owner,
     // in which case we don't need to do anything.
@@ -811,7 +814,7 @@ void AXObjectCacheImpl::UpdateAriaOwns(
       removed_child->DetachFromParent();
       AXID real_parent_id =
           aria_owned_child_to_real_parent_mapping_.at(removed_child_id);
-      AXObject* real_parent = ObjectFromAXID(real_parent_id);
+      AXObjectImpl* real_parent = ObjectFromAXID(real_parent_id);
       ChildrenChanged(real_parent);
     }
 
@@ -821,9 +824,10 @@ void AXObjectCacheImpl::UpdateAriaOwns(
   }
 
   for (size_t i = 0; i < new_child_axi_ds.size(); ++i) {
-    // Find the AXObject for the child that will now be a child of this owner.
+    // Find the AXObjectImpl for the child that will now be a child of this
+    // owner.
     AXID added_child_id = new_child_axi_ds[i];
-    AXObject* added_child = ObjectFromAXID(added_child_id);
+    AXObjectImpl* added_child = ObjectFromAXID(added_child_id);
 
     // Add this child to the mapping from child to owner.
     aria_owned_child_to_owner_mapping_.Set(added_child_id, owner->AxObjectID());
@@ -831,7 +835,7 @@ void AXObjectCacheImpl::UpdateAriaOwns(
     // Add its parent object to a mapping from child to real parent. If later
     // this owner doesn't own this child anymore, we need to return it to its
     // original parent.
-    AXObject* original_parent = added_child->ParentObject();
+    AXObjectImpl* original_parent = added_child->ParentObject();
     aria_owned_child_to_real_parent_mapping_.Set(added_child_id,
                                                  original_parent->AxObjectID());
 
@@ -854,14 +858,14 @@ void AXObjectCacheImpl::UpdateTreeIfElementIdIsAriaOwned(Element* element) {
   if (!owners)
     return;
 
-  AXObject* ax_element = GetOrCreate(element);
+  AXObjectImpl* ax_element = GetOrCreate(element);
   if (!ax_element)
     return;
 
   // If it's already owned, call childrenChanged on the owner to make sure it's
   // still an owner.
   if (IsAriaOwned(ax_element)) {
-    AXObject* owned_parent = GetAriaOwnedParent(ax_element);
+    AXObjectImpl* owned_parent = GetAriaOwnedParent(ax_element);
     DCHECK(owned_parent);
     ChildrenChanged(owned_parent);
     return;
@@ -870,7 +874,7 @@ void AXObjectCacheImpl::UpdateTreeIfElementIdIsAriaOwned(Element* element) {
   // If it's not already owned, check the possible owners based on our mapping
   // from ids to elements that have that id listed in their aria-owns attribute.
   for (const auto& ax_id : *owners) {
-    AXObject* owner = ObjectFromAXID(ax_id);
+    AXObjectImpl* owner = ObjectFromAXID(ax_id);
     if (owner)
       ChildrenChanged(owner);
   }
@@ -890,7 +894,7 @@ void AXObjectCacheImpl::ListboxSelectedChildrenChanged(
 }
 
 void AXObjectCacheImpl::ListboxActiveIndexChanged(HTMLSelectElement* select) {
-  AXObject* obj = Get(select);
+  AXObjectImpl* obj = Get(select);
   if (!obj || !obj->IsAXListBox())
     return;
 
@@ -899,7 +903,7 @@ void AXObjectCacheImpl::ListboxActiveIndexChanged(HTMLSelectElement* select) {
 
 void AXObjectCacheImpl::RadiobuttonRemovedFromGroup(
     HTMLInputElement* group_member) {
-  AXObject* obj = Get(group_member);
+  AXObjectImpl* obj = Get(group_member);
   if (!obj || !obj->IsAXRadioInput())
     return;
 
@@ -907,7 +911,7 @@ void AXObjectCacheImpl::RadiobuttonRemovedFromGroup(
   // node, as the removed node is already detached from tree.
   HTMLInputElement* first_radio =
       ToAXRadioInput(obj)->FindFirstRadioButtonInGroup(group_member);
-  AXObject* first_obj = Get(first_radio);
+  AXObjectImpl* first_obj = Get(first_radio);
   if (!first_obj || !first_obj->IsAXRadioInput())
     return;
 
@@ -922,31 +926,31 @@ void AXObjectCacheImpl::HandleLayoutComplete(LayoutObject* layout_object) {
 
   modification_count_++;
 
-  // Create the AXObject if it didn't yet exist - that's always safe at the end
-  // of a layout, and it allows an AX notification to be sent when a page has
-  // its first layout, rather than when the document first loads.
-  if (AXObject* obj = GetOrCreate(layout_object))
+  // Create the AXObjectImpl if it didn't yet exist - that's always safe at the
+  // end of a layout, and it allows an AX notification to be sent when a page
+  // has its first layout, rather than when the document first loads.
+  if (AXObjectImpl* obj = GetOrCreate(layout_object))
     PostNotification(obj, kAXLayoutComplete);
 }
 
 void AXObjectCacheImpl::HandleClicked(Node* node) {
-  if (AXObject* obj = GetOrCreate(node))
+  if (AXObjectImpl* obj = GetOrCreate(node))
     PostNotification(obj, kAXClicked);
 }
 
 void AXObjectCacheImpl::HandleAriaExpandedChange(Node* node) {
-  if (AXObject* obj = GetOrCreate(node))
+  if (AXObjectImpl* obj = GetOrCreate(node))
     obj->HandleAriaExpandedChanged();
 }
 
 void AXObjectCacheImpl::HandleAriaSelectedChanged(Node* node) {
-  AXObject* obj = Get(node);
+  AXObjectImpl* obj = Get(node);
   if (!obj)
     return;
 
   PostNotification(obj, kAXCheckedStateChanged);
 
-  AXObject* listbox = obj->ParentObjectUnignored();
+  AXObjectImpl* listbox = obj->ParentObjectUnignored();
   if (listbox && listbox->RoleValue() == kListBoxRole)
     PostNotification(listbox, kAXSelectedChildrenChanged);
 }
@@ -957,12 +961,12 @@ void AXObjectCacheImpl::HandleActiveDescendantChanged(Node* node) {
   // it can affect what's focusable or not.
   modification_count_++;
 
-  if (AXObject* obj = GetOrCreate(node))
+  if (AXObjectImpl* obj = GetOrCreate(node))
     obj->HandleActiveDescendantChanged();
 }
 
 void AXObjectCacheImpl::HandleAriaRoleChanged(Node* node) {
-  if (AXObject* obj = GetOrCreate(node)) {
+  if (AXObjectImpl* obj = GetOrCreate(node)) {
     obj->UpdateAccessibilityRole();
     modification_count_++;
     obj->NotifyIfIgnoredValueChanged();
@@ -1020,7 +1024,7 @@ void AXObjectCacheImpl::InlineTextBoxesUpdated(
 
   // Only update if the accessibility object already exists and it's
   // not already marked as dirty.
-  if (AXObject* obj = Get(layout_object)) {
+  if (AXObjectImpl* obj = Get(layout_object)) {
     if (!obj->NeedsToUpdateChildren()) {
       obj->SetNeedsToUpdateChildren();
       PostNotification(layout_object, kAXChildrenChanged);
@@ -1059,11 +1063,12 @@ const Element* AXObjectCacheImpl::RootAXEditableElement(const Node* node) {
   return result;
 }
 
-AXObject* AXObjectCacheImpl::FirstAccessibleObjectFromNode(const Node* node) {
+AXObjectImpl* AXObjectCacheImpl::FirstAccessibleObjectFromNode(
+    const Node* node) {
   if (!node)
     return 0;
 
-  AXObject* accessible_object = GetOrCreate(node->GetLayoutObject());
+  AXObjectImpl* accessible_object = GetOrCreate(node->GetLayoutObject());
   while (accessible_object && accessible_object->AccessibilityIsIgnored()) {
     node = NodeTraversal::Next(*node);
 
@@ -1083,7 +1088,7 @@ bool AXObjectCacheImpl::NodeIsTextControl(const Node* node) {
   if (!node)
     return false;
 
-  const AXObject* ax_object = GetOrCreate(const_cast<Node*>(node));
+  const AXObjectImpl* ax_object = GetOrCreate(const_cast<Node*>(node));
   return ax_object && ax_object->IsTextControl();
 }
 
@@ -1098,7 +1103,7 @@ bool IsNodeAriaVisible(Node* node) {
                                 "false");
 }
 
-void AXObjectCacheImpl::PostPlatformNotification(AXObject* obj,
+void AXObjectCacheImpl::PostPlatformNotification(AXObjectImpl* obj,
                                                  AXNotification notification) {
   if (!obj || !obj->GetDocument() || !obj->DocumentFrameView() ||
       !obj->DocumentFrameView()->GetFrame().GetPage())
@@ -1118,11 +1123,11 @@ void AXObjectCacheImpl::HandleFocusedUIElementChanged(Node* old_focused_node,
   if (!page)
     return;
 
-  AXObject* focused_object = this->FocusedObject();
+  AXObjectImpl* focused_object = this->FocusedObject();
   if (!focused_object)
     return;
 
-  AXObject* old_focused_object = Get(old_focused_node);
+  AXObjectImpl* old_focused_object = Get(old_focused_node);
 
   PostPlatformNotification(old_focused_object, kAXBlur);
   PostPlatformNotification(focused_object, kAXFocusedUIElementChanged);
@@ -1133,7 +1138,7 @@ void AXObjectCacheImpl::HandleInitialFocus() {
 }
 
 void AXObjectCacheImpl::HandleEditableTextContentChanged(Node* node) {
-  AXObject* obj = Get(node);
+  AXObjectImpl* obj = Get(node);
   while (obj && !obj->IsNativeTextControl() && !obj->IsNonNativeTextControl())
     obj = obj->ParentObject();
   PostNotification(obj, AXObjectCache::kAXValueChanged);
@@ -1149,7 +1154,7 @@ void AXObjectCacheImpl::HandleValueChanged(Node* node) {
 
 void AXObjectCacheImpl::HandleUpdateActiveMenuOption(LayoutMenuList* menu_list,
                                                      int option_index) {
-  AXObject* obj = Get(menu_list);
+  AXObjectImpl* obj = Get(menu_list);
   if (!obj || !obj->IsMenuList())
     return;
 
@@ -1157,7 +1162,7 @@ void AXObjectCacheImpl::HandleUpdateActiveMenuOption(LayoutMenuList* menu_list,
 }
 
 void AXObjectCacheImpl::DidShowMenuListPopup(LayoutMenuList* menu_list) {
-  AXObject* obj = Get(menu_list);
+  AXObjectImpl* obj = Get(menu_list);
   if (!obj || !obj->IsMenuList())
     return;
 
@@ -1165,7 +1170,7 @@ void AXObjectCacheImpl::DidShowMenuListPopup(LayoutMenuList* menu_list) {
 }
 
 void AXObjectCacheImpl::DidHideMenuListPopup(LayoutMenuList* menu_list) {
-  AXObject* obj = Get(menu_list);
+  AXObjectImpl* obj = Get(menu_list);
   if (!obj || !obj->IsMenuList())
     return;
 
@@ -1183,7 +1188,7 @@ void AXObjectCacheImpl::HandleLayoutComplete(Document* document) {
 void AXObjectCacheImpl::HandleScrolledToAnchor(const Node* anchor_node) {
   if (!anchor_node)
     return;
-  AXObject* obj = GetOrCreate(anchor_node->GetLayoutObject());
+  AXObjectImpl* obj = GetOrCreate(anchor_node->GetLayoutObject());
   if (!obj)
     return;
   if (obj->AccessibilityIsIgnored())
@@ -1192,7 +1197,7 @@ void AXObjectCacheImpl::HandleScrolledToAnchor(const Node* anchor_node) {
 }
 
 void AXObjectCacheImpl::HandleScrollPositionChanged(FrameView* frame_view) {
-  AXObject* target_ax_object =
+  AXObjectImpl* target_ax_object =
       GetOrCreate(frame_view->GetFrame().GetDocument());
   PostPlatformNotification(target_ax_object, kAXScrollPositionChanged);
 }
@@ -1204,14 +1209,14 @@ void AXObjectCacheImpl::HandleScrollPositionChanged(
 }
 
 const AtomicString& AXObjectCacheImpl::ComputedRoleForNode(Node* node) {
-  AXObject* obj = GetOrCreate(node);
+  AXObjectImpl* obj = GetOrCreate(node);
   if (!obj)
-    return AXObject::RoleName(kUnknownRole);
-  return AXObject::RoleName(obj->RoleValue());
+    return AXObjectImpl::RoleName(kUnknownRole);
+  return AXObjectImpl::RoleName(obj->RoleValue());
 }
 
 String AXObjectCacheImpl::ComputedNameForNode(Node* node) {
-  AXObject* obj = GetOrCreate(node);
+  AXObjectImpl* obj = GetOrCreate(node);
   if (!obj)
     return "";
 
@@ -1219,7 +1224,7 @@ String AXObjectCacheImpl::ComputedNameForNode(Node* node) {
 }
 
 void AXObjectCacheImpl::OnTouchAccessibilityHover(const IntPoint& location) {
-  AXObject* hit = Root()->AccessibilityHitTest(location);
+  AXObjectImpl* hit = Root()->AccessibilityHitTest(location);
   if (hit) {
     // Ignore events on a frame or plug-in, because the touch events
     // will be re-targeted there and we don't want to fire duplicate
@@ -1234,11 +1239,11 @@ void AXObjectCacheImpl::OnTouchAccessibilityHover(const IntPoint& location) {
 void AXObjectCacheImpl::SetCanvasObjectBounds(HTMLCanvasElement* canvas,
                                               Element* element,
                                               const LayoutRect& rect) {
-  AXObject* obj = GetOrCreate(element);
+  AXObjectImpl* obj = GetOrCreate(element);
   if (!obj)
     return;
 
-  AXObject* ax_canvas = GetOrCreate(canvas);
+  AXObjectImpl* ax_canvas = GetOrCreate(canvas);
   if (!ax_canvas)
     return;