Rename AXObject to AXObjectImpl in modules/ and web/

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

 /*
  * Copyright (C) 2008, 2009, 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  *     its contributors may be used to endorse or promote products derived
  *     from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "modules/accessibility/AXObject.h"
+#include "modules/accessibility/AXObjectImpl.h"
 
 #include "SkMatrix44.h"
 #include "core/InputTypeNames.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/AccessibleNode.h"
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
@@ skipping 244 matching lines @@
   for (size_t i = 0; i < WTF_ARRAY_LENGTH(kRoles); ++i)
     role_map->Set(String(kRoles[i].aria_role), kRoles[i].webcore_role);
   return role_map;
 }
 
 static Vector<AtomicString>* CreateRoleNameVector() {
   Vector<AtomicString>* role_name_vector = new Vector<AtomicString>(kNumRoles);
   for (int i = 0; i < kNumRoles; i++)
     (*role_name_vector)[i] = g_null_atom;
 
-  for (size_t i = 0; i < WTF_ARRAY_LENGTH(kRoles); ++i)
+  for (size_t i = 0; i < WTF_ARRAY_LENGTH(kRoles); ++i) {
     (*role_name_vector)[kRoles[i].webcore_role] =
         AtomicString(kRoles[i].aria_role);
+  }
 
-  for (size_t i = 0; i < WTF_ARRAY_LENGTH(kReverseRoles); ++i)
+  for (size_t i = 0; i < WTF_ARRAY_LENGTH(kReverseRoles); ++i) {
     (*role_name_vector)[kReverseRoles[i].webcore_role] =
         AtomicString(kReverseRoles[i].aria_role);
+  }
 
   return role_name_vector;
 }
 
 static Vector<AtomicString>* CreateInternalRoleNameVector() {
   Vector<AtomicString>* internal_role_name_vector =
       new Vector<AtomicString>(kNumRoles);
-  for (size_t i = 0; i < WTF_ARRAY_LENGTH(kInternalRoles); i++)
+  for (size_t i = 0; i < WTF_ARRAY_LENGTH(kInternalRoles); i++) {
     (*internal_role_name_vector)[kInternalRoles[i].webcore_role] =
         AtomicString(kInternalRoles[i].internal_role_name);
+  }
 
   return internal_role_name_vector;
 }
 
 const char* g_aria_widgets[] = {
     // From http://www.w3.org/TR/wai-aria/roles#widget_roles
     "alert", "alertdialog", "button", "checkbox", "dialog", "gridcell", "link",
     "log", "marquee", "menuitem", "menuitemcheckbox", "menuitemradio", "option",
     "progressbar", "radio", "scrollbar", "slider", "spinbutton", "status",
     "tab", "tabpanel", "textbox", "timer", "tooltip", "treeitem",
@@ skipping 16 matching lines @@
     "aria-disabled",  // If it's disabled, it can be made interactive.
     "aria-expanded",         "aria-haspopup", "aria-multiselectable",
     "aria-pressed",          "aria-required", "aria-selected"};
 
 HTMLDialogElement* GetActiveDialogElement(Node* node) {
   return node->GetDocument().ActiveModalDialog();
 }
 
 }  // namespace
 
-unsigned AXObject::number_of_live_ax_objects_ = 0;
+unsigned AXObjectImpl::number_of_live_ax_objects_ = 0;
 
-AXObject::AXObject(AXObjectCacheImpl& ax_object_cache)
+AXObjectImpl::AXObjectImpl(AXObjectCacheImpl& ax_object_cache)
     : id_(0),
       have_children_(false),
       role_(kUnknownRole),
       last_known_is_ignored_value_(kDefaultBehavior),
       explicit_container_id_(0),
       parent_(nullptr),
       last_modification_count_(-1),
       cached_is_ignored_(false),
       cached_is_inert_or_aria_hidden_(false),
       cached_is_descendant_of_leaf_node_(false),
       cached_is_descendant_of_disabled_node_(false),
       cached_has_inherited_presentational_role_(false),
       cached_is_presentational_child_(false),
       cached_ancestor_exposes_active_descendant_(false),
       cached_live_region_root_(nullptr),
       ax_object_cache_(&ax_object_cache) {
   ++number_of_live_ax_objects_;
 }
 
-AXObject::~AXObject() {
+AXObjectImpl::~AXObjectImpl() {
   DCHECK(IsDetached());
   --number_of_live_ax_objects_;
 }
 
-void AXObject::Detach() {
+void AXObjectImpl::Detach() {
   // Clear any children and call detachFromParent on them so that
   // no children are left with dangling pointers to their parent.
   ClearChildren();
 
   ax_object_cache_ = nullptr;
 }
 
-bool AXObject::IsDetached() const {
+bool AXObjectImpl::IsDetached() const {
   return !ax_object_cache_;
 }
 
-const AtomicString& AXObject::GetAOMPropertyOrARIAAttribute(
+const AtomicString& AXObjectImpl::GetAOMPropertyOrARIAAttribute(
     AOMStringProperty property) const {
   Node* node = this->GetNode();
   if (!node || !node->IsElementNode())
     return g_null_atom;
 
   return AccessibleNode::GetPropertyOrARIAAttribute(ToElement(node), property);
 }
 
-bool AXObject::IsARIATextControl() const {
+bool AXObjectImpl::IsARIATextControl() const {
   return AriaRoleAttribute() == kTextFieldRole ||
          AriaRoleAttribute() == kSearchBoxRole ||
          AriaRoleAttribute() == kComboBoxRole;
 }
 
-bool AXObject::IsButton() const {
+bool AXObjectImpl::IsButton() const {
   AccessibilityRole role = RoleValue();
 
   return role == kButtonRole || role == kPopUpButtonRole ||
          role == kToggleButtonRole;
 }
 
-bool AXObject::IsCheckable() const {
+bool AXObjectImpl::IsCheckable() const {
   switch (RoleValue()) {
     case kCheckBoxRole:
     case kMenuItemCheckBoxRole:
     case kMenuItemRadioRole:
     case kRadioButtonRole:
     case kSwitchRole:
       return true;
     default:
       return false;
   }
 }
 
 // Why this is here instead of AXNodeObject:
 // Because an AXMenuListOption (<option>) can
 // have an ARIA role of menuitemcheckbox/menuitemradio
 // yet does not inherit from AXNodeObject
-AccessibilityButtonState AXObject::CheckedState() const {
+AccessibilityButtonState AXObjectImpl::CheckedState() const {
   if (!IsCheckable())
     return kButtonStateOff;
 
   const AtomicString& checkedAttribute =
       GetAOMPropertyOrARIAAttribute(AOMStringProperty::kChecked);
   if (checkedAttribute) {
     if (EqualIgnoringASCIICase(checkedAttribute, "true"))
       return kButtonStateOn;
 
     if (EqualIgnoringASCIICase(checkedAttribute, "mixed")) {
@@ skipping 15 matching lines @@
     return kButtonStateMixed;
 
   if (isHTMLInputElement(*node) &&
       toHTMLInputElement(*node).ShouldAppearChecked()) {
     return kButtonStateOn;
   }
 
   return kButtonStateOff;
 }
 
-bool AXObject::IsNativeInputInMixedState(const Node* node) {
+bool AXObjectImpl::IsNativeInputInMixedState(const Node* node) {
   if (!isHTMLInputElement(node))
     return false;
 
   const HTMLInputElement* input = toHTMLInputElement(node);
   const auto inputType = input->type();
   if (inputType != InputTypeNames::checkbox &&
       inputType != InputTypeNames::radio)
     return false;
   return input->ShouldAppearIndeterminate();
 }
 
-bool AXObject::IsLandmarkRelated() const {
+bool AXObjectImpl::IsLandmarkRelated() const {
   switch (RoleValue()) {
     case kApplicationRole:
     case kArticleRole:
     case kBannerRole:
     case kComplementaryRole:
     case kContentInfoRole:
     case kFooterRole:
     case kFormRole:
     case kMainRole:
     case kNavigationRole:
     case kRegionRole:
     case kSearchRole:
       return true;
     default:
       return false;
   }
 }
 
-bool AXObject::IsMenuRelated() const {
+bool AXObjectImpl::IsMenuRelated() const {
   switch (RoleValue()) {
     case kMenuRole:
     case kMenuBarRole:
     case kMenuButtonRole:
     case kMenuItemRole:
     case kMenuItemCheckBoxRole:
     case kMenuItemRadioRole:
       return true;
     default:
       return false;
   }
 }
 
-bool AXObject::IsPasswordFieldAndShouldHideValue() const {
+bool AXObjectImpl::IsPasswordFieldAndShouldHideValue() const {
   Settings* settings = GetDocument()->GetSettings();
   if (!settings || settings->GetAccessibilityPasswordValuesEnabled())
     return false;
 
   return IsPasswordField();
 }
 
-bool AXObject::IsClickable() const {
+bool AXObjectImpl::IsClickable() const {
   switch (RoleValue()) {
     case kButtonRole:
     case kCheckBoxRole:
     case kColorWellRole:
     case kComboBoxRole:
     case kImageMapLinkRole:
     case kLinkRole:
     case kListBoxOptionRole:
     case kMenuButtonRole:
     case kPopUpButtonRole:
     case kRadioButtonRole:
     case kSpinButtonRole:
     case kTabRole:
     case kTextFieldRole:
     case kToggleButtonRole:
       return true;
     default:
       return false;
   }
 }
 
-bool AXObject::AccessibilityIsIgnored() const {
+bool AXObjectImpl::AccessibilityIsIgnored() const {
   UpdateCachedAttributeValuesIfNeeded();
   return cached_is_ignored_;
 }
 
-void AXObject::UpdateCachedAttributeValuesIfNeeded() const {
+void AXObjectImpl::UpdateCachedAttributeValuesIfNeeded() const {
   if (IsDetached())
     return;
 
   AXObjectCacheImpl& cache = AxObjectCache();
 
   if (cache.ModificationCount() == last_modification_count_)
     return;
 
   last_modification_count_ = cache.ModificationCount();
   cached_background_color_ = ComputeBackgroundColor();
   cached_is_inert_or_aria_hidden_ = ComputeIsInertOrAriaHidden();
   cached_is_descendant_of_leaf_node_ = (LeafNodeAncestor() != 0);
   cached_is_descendant_of_disabled_node_ = (DisabledAncestor() != 0);
   cached_has_inherited_presentational_role_ =
       (InheritsPresentationalRoleFrom() != 0);
   cached_is_presentational_child_ =
       (AncestorForWhichThisIsAPresentationalChild() != 0);
   cached_is_ignored_ = ComputeAccessibilityIsIgnored();
   cached_live_region_root_ =
       IsLiveRegion()
-          ? const_cast<AXObject*>(this)
+          ? const_cast<AXObjectImpl*>(this)
           : (ParentObjectIfExists() ? ParentObjectIfExists()->LiveRegionRoot()
                                     : 0);
   cached_ancestor_exposes_active_descendant_ =
       ComputeAncestorExposesActiveDescendant();
 }
 
-bool AXObject::AccessibilityIsIgnoredByDefault(
+bool AXObjectImpl::AccessibilityIsIgnoredByDefault(
     IgnoredReasons* ignored_reasons) const {
   return DefaultObjectInclusion(ignored_reasons) == kIgnoreObject;
 }
 
-AXObjectInclusion AXObject::AccessibilityPlatformIncludesObject() const {
+AXObjectInclusion AXObjectImpl::AccessibilityPlatformIncludesObject() const {
   if (IsMenuListPopup() || IsMenuListOption())
     return kIncludeObject;
 
   return kDefaultBehavior;
 }
 
-AXObjectInclusion AXObject::DefaultObjectInclusion(
+AXObjectInclusion AXObjectImpl::DefaultObjectInclusion(
     IgnoredReasons* ignored_reasons) const {
   if (IsInertOrAriaHidden()) {
     if (ignored_reasons)
       ComputeIsInertOrAriaHidden(ignored_reasons);
     return kIgnoreObject;
   }
 
   if (IsPresentationalChild()) {
     if (ignored_reasons) {
-      AXObject* ancestor = AncestorForWhichThisIsAPresentationalChild();
+      AXObjectImpl* ancestor = AncestorForWhichThisIsAPresentationalChild();
       ignored_reasons->push_back(
           IgnoredReason(kAXAncestorDisallowsChild, ancestor));
     }
     return kIgnoreObject;
   }
 
   return AccessibilityPlatformIncludesObject();
 }
 
-bool AXObject::IsInertOrAriaHidden() const {
+bool AXObjectImpl::IsInertOrAriaHidden() const {
   UpdateCachedAttributeValuesIfNeeded();
   return cached_is_inert_or_aria_hidden_;
 }
 
-bool AXObject::ComputeIsInertOrAriaHidden(
+bool AXObjectImpl::ComputeIsInertOrAriaHidden(
     IgnoredReasons* ignored_reasons) const {
   if (GetNode()) {
     if (GetNode()->IsInert()) {
       if (ignored_reasons) {
         HTMLDialogElement* dialog = GetActiveDialogElement(GetNode());
         if (dialog) {
-          AXObject* dialog_object = AxObjectCache().GetOrCreate(dialog);
-          if (dialog_object)
+          AXObjectImpl* dialog_object = AxObjectCache().GetOrCreate(dialog);
+          if (dialog_object) {
             ignored_reasons->push_back(
                 IgnoredReason(kAXActiveModalDialog, dialog_object));
-          else
+          } else {
             ignored_reasons->push_back(IgnoredReason(kAXInert));
+          }
         } else {
           // TODO(aboxhall): handle inert attribute if it eventuates
           ignored_reasons->push_back(IgnoredReason(kAXInert));
         }
       }
       return true;
     }
   } else {
-    AXObject* parent = ParentObject();
+    AXObjectImpl* parent = ParentObject();
     if (parent && parent->IsInertOrAriaHidden()) {
       if (ignored_reasons)
         parent->ComputeIsInertOrAriaHidden(ignored_reasons);
       return true;
     }
   }
 
-  const AXObject* hidden_root = AriaHiddenRoot();
+  const AXObjectImpl* hidden_root = AriaHiddenRoot();
   if (hidden_root) {
     if (ignored_reasons) {
-      if (hidden_root == this)
+      if (hidden_root == this) {
         ignored_reasons->push_back(IgnoredReason(kAXAriaHidden));
-      else
+      } else {
         ignored_reasons->push_back(
             IgnoredReason(kAXAriaHiddenRoot, hidden_root));
+      }
     }
     return true;
   }
 
   return false;
 }
 
-bool AXObject::IsDescendantOfLeafNode() const {
+bool AXObjectImpl::IsDescendantOfLeafNode() const {
   UpdateCachedAttributeValuesIfNeeded();
   return cached_is_descendant_of_leaf_node_;
 }
 
-AXObject* AXObject::LeafNodeAncestor() const {
-  if (AXObject* parent = ParentObject()) {
+AXObjectImpl* AXObjectImpl::LeafNodeAncestor() const {
+  if (AXObjectImpl* parent = ParentObject()) {
     if (!parent->CanHaveChildren())
       return parent;
 
     return parent->LeafNodeAncestor();
   }
 
   return 0;
 }
 
-const AXObject* AXObject::AriaHiddenRoot() const {
-  for (const AXObject* object = this; object; object = object->ParentObject()) {
+const AXObjectImpl* AXObjectImpl::AriaHiddenRoot() const {
+  for (const AXObjectImpl* object = this; object;
+       object = object->ParentObject()) {
     if (EqualIgnoringASCIICase(object->GetAttribute(aria_hiddenAttr), "true"))
       return object;
   }
 
   return 0;
 }
 
-bool AXObject::IsDescendantOfDisabledNode() const {
+bool AXObjectImpl::IsDescendantOfDisabledNode() const {
   UpdateCachedAttributeValuesIfNeeded();
   return cached_is_descendant_of_disabled_node_;
 }
 
-const AXObject* AXObject::DisabledAncestor() const {
+const AXObjectImpl* AXObjectImpl::DisabledAncestor() const {
   const AtomicString& disabled = GetAttribute(aria_disabledAttr);
   if (EqualIgnoringASCIICase(disabled, "true"))
     return this;
   if (EqualIgnoringASCIICase(disabled, "false"))
     return 0;
 
-  if (AXObject* parent = ParentObject())
+  if (AXObjectImpl* parent = ParentObject())
     return parent->DisabledAncestor();
 
   return 0;
 }
 
-bool AXObject::LastKnownIsIgnoredValue() {
-  if (last_known_is_ignored_value_ == kDefaultBehavior)
+bool AXObjectImpl::LastKnownIsIgnoredValue() {
+  if (last_known_is_ignored_value_ == kDefaultBehavior) {
     last_known_is_ignored_value_ =
         AccessibilityIsIgnored() ? kIgnoreObject : kIncludeObject;
+  }
 
   return last_known_is_ignored_value_ == kIgnoreObject;
 }
 
-void AXObject::SetLastKnownIsIgnoredValue(bool is_ignored) {
+void AXObjectImpl::SetLastKnownIsIgnoredValue(bool is_ignored) {
   last_known_is_ignored_value_ = is_ignored ? kIgnoreObject : kIncludeObject;
 }
 
-bool AXObject::HasInheritedPresentationalRole() const {
+bool AXObjectImpl::HasInheritedPresentationalRole() const {
   UpdateCachedAttributeValuesIfNeeded();
   return cached_has_inherited_presentational_role_;
 }
 
-bool AXObject::IsPresentationalChild() const {
+bool AXObjectImpl::IsPresentationalChild() const {
   UpdateCachedAttributeValuesIfNeeded();
   return cached_is_presentational_child_;
 }
 
-bool AXObject::AncestorExposesActiveDescendant() const {
+bool AXObjectImpl::AncestorExposesActiveDescendant() const {
   UpdateCachedAttributeValuesIfNeeded();
   return cached_ancestor_exposes_active_descendant_;
 }
 
-bool AXObject::ComputeAncestorExposesActiveDescendant() const {
-  const AXObject* parent = ParentObjectUnignored();
+bool AXObjectImpl::ComputeAncestorExposesActiveDescendant() const {
+  const AXObjectImpl* parent = ParentObjectUnignored();
   if (!parent)
     return false;
 
   if (parent->SupportsActiveDescendant() &&
       !parent->GetAttribute(aria_activedescendantAttr).IsEmpty()) {
     return true;
   }
 
   return parent->AncestorExposesActiveDescendant();
 }
 
 // Simplify whitespace, but preserve a single leading and trailing whitespace
 // character if it's present.
 // static
-String AXObject::CollapseWhitespace(const String& str) {
+String AXObjectImpl::CollapseWhitespace(const String& str) {
   StringBuilder result;
   if (!str.IsEmpty() && IsHTMLSpace<UChar>(str[0]))
     result.Append(' ');
   result.Append(str.SimplifyWhiteSpace(IsHTMLSpace<UChar>));
   if (!str.IsEmpty() && IsHTMLSpace<UChar>(str[str.length() - 1]))
     result.Append(' ');
   return result.ToString();
 }
 
-String AXObject::ComputedName() const {
+String AXObjectImpl::ComputedName() const {
   AXNameFrom name_from;
-  AXObject::AXObjectVector name_objects;
+  AXObjectImpl::AXObjectVector name_objects;
   return GetName(name_from, &name_objects);
 }
 
-String AXObject::GetName(AXNameFrom& name_from,
-                         AXObject::AXObjectVector* name_objects) const {
-  HeapHashSet<Member<const AXObject>> visited;
+String AXObjectImpl::GetName(AXNameFrom& name_from,
+                             AXObjectImpl::AXObjectVector* name_objects) const {
+  HeapHashSet<Member<const AXObjectImpl>> visited;
   AXRelatedObjectVector related_objects;
   String text = TextAlternative(false, false, visited, name_from,
                                 &related_objects, nullptr);
 
   AccessibilityRole role = RoleValue();
   if (!GetNode() || (!isHTMLBRElement(GetNode()) && role != kStaticTextRole &&
                      role != kInlineTextBoxRole))
     text = CollapseWhitespace(text);
 
   if (name_objects) {
     name_objects->clear();
     for (size_t i = 0; i < related_objects.size(); i++)
       name_objects->push_back(related_objects[i]->object);
   }
 
   return text;
 }
 
-String AXObject::GetName(NameSources* name_sources) const {
+String AXObjectImpl::GetName(NameSources* name_sources) const {
   AXObjectSet visited;
   AXNameFrom tmp_name_from;
   AXRelatedObjectVector tmp_related_objects;
   String text = TextAlternative(false, false, visited, tmp_name_from,
                                 &tmp_related_objects, name_sources);
   text = text.SimplifyWhiteSpace(IsHTMLSpace<UChar>);
   return text;
 }
 
-String AXObject::RecursiveTextAlternative(const AXObject& ax_obj,
-                                          bool in_aria_labelled_by_traversal,
-                                          AXObjectSet& visited) {
+String AXObjectImpl::RecursiveTextAlternative(
+    const AXObjectImpl& ax_obj,
+    bool in_aria_labelled_by_traversal,
+    AXObjectSet& visited) {
   if (visited.Contains(&ax_obj) && !in_aria_labelled_by_traversal)
     return String();
 
   AXNameFrom tmp_name_from;
   return ax_obj.TextAlternative(true, in_aria_labelled_by_traversal, visited,
                                 tmp_name_from, nullptr, nullptr);
 }
 
-bool AXObject::IsHiddenForTextAlternativeCalculation() const {
+bool AXObjectImpl::IsHiddenForTextAlternativeCalculation() const {
   if (EqualIgnoringASCIICase(GetAttribute(aria_hiddenAttr), "false"))
     return false;
 
   if (GetLayoutObject())
     return GetLayoutObject()->Style()->Visibility() != EVisibility::kVisible;
 
   // This is an obscure corner case: if a node has no LayoutObject, that means
   // it's not rendered, but we still may be exploring it as part of a text
   // alternative calculation, for example if it was explicitly referenced by
   // aria-labelledby. So we need to explicitly call the style resolver to check
   // whether it's invisible or display:none, rather than relying on the style
   // cached in the LayoutObject.
   Document* document = GetDocument();
   if (!document || !document->GetFrame())
     return false;
   if (Node* node = GetNode()) {
     if (node->isConnected() && node->IsElementNode()) {
       RefPtr<ComputedStyle> style =
           document->EnsureStyleResolver().StyleForElement(ToElement(node));
       return style->Display() == EDisplay::kNone ||
              style->Visibility() != EVisibility::kVisible;
     }
   }
   return false;
 }
 
-String AXObject::AriaTextAlternative(bool recursive,
-                                     bool in_aria_labelled_by_traversal,
-                                     AXObjectSet& visited,
-                                     AXNameFrom& name_from,
-                                     AXRelatedObjectVector* related_objects,
-                                     NameSources* name_sources,
-                                     bool* found_text_alternative) const {
+String AXObjectImpl::AriaTextAlternative(bool recursive,
+                                         bool in_aria_labelled_by_traversal,
+                                         AXObjectSet& visited,
+                                         AXNameFrom& name_from,
+                                         AXRelatedObjectVector* related_objects,
+                                         NameSources* name_sources,
+                                         bool* found_text_alternative) const {
   String text_alternative;
   bool already_visited = visited.Contains(this);
   visited.insert(this);
 
   // Step 2A from: http://www.w3.org/TR/accname-aam-1.1
   // If you change this logic, update AXNodeObject::nameFromLabelElement, too.
   if (!in_aria_labelled_by_traversal &&
       IsHiddenForTextAlternativeCalculation()) {
     *found_text_alternative = true;
     return String();
@@ skipping 59 matching lines @@
       *found_text_alternative = true;
     } else {
       *found_text_alternative = true;
       return text_alternative;
     }
   }
 
   return text_alternative;
 }
 
-String AXObject::TextFromElements(
+String AXObjectImpl::TextFromElements(
     bool in_aria_labelledby_traversal,
     AXObjectSet& visited,
     HeapVector<Member<Element>>& elements,
     AXRelatedObjectVector* related_objects) const {
   StringBuilder accumulated_text;
   bool found_valid_element = false;
   AXRelatedObjectVector local_related_objects;
 
   for (const auto& element : elements) {
-    AXObject* ax_element = AxObjectCache().GetOrCreate(element);
+    AXObjectImpl* ax_element = AxObjectCache().GetOrCreate(element);
     if (ax_element) {
       found_valid_element = true;
 
       String result = RecursiveTextAlternative(
           *ax_element, in_aria_labelledby_traversal, visited);
       local_related_objects.push_back(
           new NameSourceRelatedObject(ax_element, result));
       if (!result.IsEmpty()) {
         if (!accumulated_text.IsEmpty())
           accumulated_text.Append(' ');
         accumulated_text.Append(result);
       }
     }
   }
   if (!found_valid_element)
     return String();
   if (related_objects)
     *related_objects = local_related_objects;
   return accumulated_text.ToString();
 }
 
-void AXObject::TokenVectorFromAttribute(Vector<String>& tokens,
-                                        const QualifiedName& attribute) const {
+void AXObjectImpl::TokenVectorFromAttribute(
+    Vector<String>& tokens,
+    const QualifiedName& attribute) const {
   Node* node = this->GetNode();
   if (!node || !node->IsElementNode())
     return;
 
   String attribute_value = GetAttribute(attribute).GetString();
   if (attribute_value.IsEmpty())
     return;
 
   attribute_value.SimplifyWhiteSpace();
   attribute_value.Split(' ', tokens);
 }
 
-void AXObject::ElementsFromAttribute(HeapVector<Member<Element>>& elements,
-                                     const QualifiedName& attribute) const {
+void AXObjectImpl::ElementsFromAttribute(HeapVector<Member<Element>>& elements,
+                                         const QualifiedName& attribute) const {
   Vector<String> ids;
   TokenVectorFromAttribute(ids, attribute);
   if (ids.IsEmpty())
     return;
 
   TreeScope& scope = GetNode()->GetTreeScope();
   for (const auto& id : ids) {
     if (Element* id_element = scope.getElementById(AtomicString(id)))
       elements.push_back(id_element);
   }
 }
 
-void AXObject::AriaLabelledbyElementVector(
+void AXObjectImpl::AriaLabelledbyElementVector(
     HeapVector<Member<Element>>& elements) const {
   // Try both spellings, but prefer aria-labelledby, which is the official spec.
   ElementsFromAttribute(elements, aria_labelledbyAttr);
   if (!elements.size())
     ElementsFromAttribute(elements, aria_labeledbyAttr);
 }
 
-String AXObject::TextFromAriaLabelledby(
+String AXObjectImpl::TextFromAriaLabelledby(
     AXObjectSet& visited,
     AXRelatedObjectVector* related_objects) const {
   HeapVector<Member<Element>> elements;
   AriaLabelledbyElementVector(elements);
   return TextFromElements(true, visited, elements, related_objects);
 }
 
-String AXObject::TextFromAriaDescribedby(
+String AXObjectImpl::TextFromAriaDescribedby(
     AXRelatedObjectVector* related_objects) const {
   AXObjectSet visited;
   HeapVector<Member<Element>> elements;
   ElementsFromAttribute(elements, aria_describedbyAttr);
   return TextFromElements(true, visited, elements, related_objects);
 }
 
-RGBA32 AXObject::BackgroundColor() const {
+RGBA32 AXObjectImpl::BackgroundColor() const {
   UpdateCachedAttributeValuesIfNeeded();
   return cached_background_color_;
 }
 
-AccessibilityOrientation AXObject::Orientation() const {
+AccessibilityOrientation AXObjectImpl::Orientation() const {
   // In ARIA 1.1, the default value for aria-orientation changed from
   // horizontal to undefined.
   return kAccessibilityOrientationUndefined;
 }
 
-AXSupportedAction AXObject::Action() const {
+AXSupportedAction AXObjectImpl::Action() const {
   if (!ActionElement())
     return AXSupportedAction::kNone;
 
   switch (RoleValue()) {
     case kButtonRole:
     case kToggleButtonRole:
       return AXSupportedAction::kPress;
     case kTextFieldRole:
       return AXSupportedAction::kActivate;
     case kRadioButtonRole:
       return AXSupportedAction::kSelect;
     case kCheckBoxRole:
     case kSwitchRole:
       return CheckedState() == kButtonStateOff ? AXSupportedAction::kCheck
                                                : AXSupportedAction::kUncheck;
     case kLinkRole:
       return AXSupportedAction::kJump;
     case kPopUpButtonRole:
       return AXSupportedAction::kOpen;
     default:
       return AXSupportedAction::kClick;
   }
 }
 
-bool AXObject::IsMultiline() const {
+bool AXObjectImpl::IsMultiline() const {
   Node* node = this->GetNode();
   if (!node)
     return false;
 
   if (isHTMLTextAreaElement(*node))
     return true;
 
   if (HasEditableStyle(*node))
     return true;
 
   if (!IsNativeTextControl() && !IsNonNativeTextControl())
     return false;
 
   return EqualIgnoringASCIICase(GetAttribute(aria_multilineAttr), "true");
 }
 
-bool AXObject::AriaPressedIsPresent() const {
+bool AXObjectImpl::AriaPressedIsPresent() const {
   return !GetAttribute(aria_pressedAttr).IsEmpty();
 }
 
-bool AXObject::SupportsActiveDescendant() const {
+bool AXObjectImpl::SupportsActiveDescendant() const {
   // According to the ARIA Spec, all ARIA composite widgets, ARIA text boxes
   // and ARIA groups should be able to expose an active descendant.
   // Implicitly, <input> and <textarea> elements should also have this ability.
   switch (AriaRoleAttribute()) {
     case kComboBoxRole:
     case kGridRole:
     case kGroupRole:
     case kListBoxRole:
     case kMenuRole:
     case kMenuBarRole:
     case kRadioGroupRole:
     case kRowRole:
     case kSearchBoxRole:
     case kTabListRole:
     case kTextFieldRole:
     case kToolbarRole:
     case kTreeRole:
     case kTreeGridRole:
       return true;
     default:
       return false;
   }
 }
 
-bool AXObject::SupportsARIAAttributes() const {
+bool AXObjectImpl::SupportsARIAAttributes() const {
   return IsLiveRegion() || SupportsARIADragging() || SupportsARIADropping() ||
          SupportsARIAFlowTo() || SupportsARIAOwns() ||
          HasAttribute(aria_labelAttr);
 }
 
-bool AXObject::SupportsRangeValue() const {
+bool AXObjectImpl::SupportsRangeValue() const {
   return IsProgressIndicator() || IsMeter() || IsSlider() || IsScrollbar() ||
          IsSpinButton();
 }
 
-bool AXObject::SupportsSetSizeAndPosInSet() const {
-  AXObject* parent = ParentObject();
+bool AXObjectImpl::SupportsSetSizeAndPosInSet() const {
+  AXObjectImpl* parent = ParentObject();
   if (!parent)
     return false;
 
   int role = RoleValue();
   int parent_role = parent->RoleValue();
 
   if ((role == kListBoxOptionRole && parent_role == kListBoxRole) ||
       (role == kListItemRole && parent_role == kListRole) ||
       (role == kMenuItemRole && parent_role == kMenuRole) ||
       (role == kRadioButtonRole) ||
       (role == kTabRole && parent_role == kTabListRole) ||
       (role == kTreeItemRole && parent_role == kTreeRole) ||
       (role == kTreeItemRole && parent_role == kGroupRole)) {
     return true;
   }
 
   return false;
 }
 
-int AXObject::IndexInParent() const {
+int AXObjectImpl::IndexInParent() const {
   if (!ParentObject())
     return 0;
 
   const auto& siblings = ParentObject()->Children();
   int child_count = siblings.size();
 
   for (int index = 0; index < child_count; ++index) {
     if (siblings[index].Get() == this) {
       return index;
     }
   }
   return 0;
 }
 
-bool AXObject::IsLiveRegion() const {
+bool AXObjectImpl::IsLiveRegion() const {
   const AtomicString& live_region = LiveRegionStatus();
   return EqualIgnoringASCIICase(live_region, "polite") ||
          EqualIgnoringASCIICase(live_region, "assertive");
 }
 
-AXObject* AXObject::LiveRegionRoot() const {
+AXObjectImpl* AXObjectImpl::LiveRegionRoot() const {
   UpdateCachedAttributeValuesIfNeeded();
   return cached_live_region_root_;
 }
 
-const AtomicString& AXObject::ContainerLiveRegionStatus() const {
+const AtomicString& AXObjectImpl::ContainerLiveRegionStatus() const {
   UpdateCachedAttributeValuesIfNeeded();
   return cached_live_region_root_ ? cached_live_region_root_->LiveRegionStatus()
                                   : g_null_atom;
 }
 
-const AtomicString& AXObject::ContainerLiveRegionRelevant() const {
+const AtomicString& AXObjectImpl::ContainerLiveRegionRelevant() const {
   UpdateCachedAttributeValuesIfNeeded();
   return cached_live_region_root_
              ? cached_live_region_root_->LiveRegionRelevant()
              : g_null_atom;
 }
 
-bool AXObject::ContainerLiveRegionAtomic() const {
+bool AXObjectImpl::ContainerLiveRegionAtomic() const {
   UpdateCachedAttributeValuesIfNeeded();
   return cached_live_region_root_ &&
          cached_live_region_root_->LiveRegionAtomic();
 }
 
-bool AXObject::ContainerLiveRegionBusy() const {
+bool AXObjectImpl::ContainerLiveRegionBusy() const {
   UpdateCachedAttributeValuesIfNeeded();
   return cached_live_region_root_ && cached_live_region_root_->LiveRegionBusy();
 }
 
-AXObject* AXObject::ElementAccessibilityHitTest(const IntPoint& point) const {
+AXObjectImpl* AXObjectImpl::ElementAccessibilityHitTest(
+    const IntPoint& point) const {
   // Check if there are any mock elements that need to be handled.
   for (const auto& child : children_) {
     if (child->IsMockObject() &&
         child->GetBoundsInFrameCoordinates().Contains(point))
       return child->ElementAccessibilityHitTest(point);
   }
 
-  return const_cast<AXObject*>(this);
+  return const_cast<AXObjectImpl*>(this);
 }
 
-const AXObject::AXObjectVector& AXObject::Children() {
+const AXObjectImpl::AXObjectVector& AXObjectImpl::Children() {
   UpdateChildrenIfNecessary();
 
   return children_;
 }
 
-AXObject* AXObject::ParentObject() const {
+AXObjectImpl* AXObjectImpl::ParentObject() const {
   if (IsDetached())
     return 0;
 
   if (parent_)
     return parent_;
 
   if (AxObjectCache().IsAriaOwned(this))
     return AxObjectCache().GetAriaOwnedParent(this);
 
   return ComputeParent();
 }
 
-AXObject* AXObject::ParentObjectIfExists() const {
+AXObjectImpl* AXObjectImpl::ParentObjectIfExists() const {
   if (IsDetached())
     return 0;
 
   if (parent_)
     return parent_;
 
   return ComputeParentIfExists();
 }
 
-AXObject* AXObject::ParentObjectUnignored() const {
-  AXObject* parent;
+AXObjectImpl* AXObjectImpl::ParentObjectUnignored() const {
+  AXObjectImpl* parent;
   for (parent = ParentObject(); parent && parent->AccessibilityIsIgnored();
        parent = parent->ParentObject()) {
   }
 
   return parent;
 }
 
-void AXObject::UpdateChildrenIfNecessary() {
+void AXObjectImpl::UpdateChildrenIfNecessary() {
   if (!HasChildren())
     AddChildren();
 }
 
-void AXObject::ClearChildren() {
+void AXObjectImpl::ClearChildren() {
   // Detach all weak pointers from objects to their parents.
   for (const auto& child : children_)
     child->DetachFromParent();
 
   children_.clear();
   have_children_ = false;
 }
 
-Document* AXObject::GetDocument() const {
+Document* AXObjectImpl::GetDocument() const {
   FrameView* frame_view = DocumentFrameView();
   if (!frame_view)
     return 0;
 
   return frame_view->GetFrame().GetDocument();
 }
 
-FrameView* AXObject::DocumentFrameView() const {
-  const AXObject* object = this;
+FrameView* AXObjectImpl::DocumentFrameView() const {
+  const AXObjectImpl* object = this;
   while (object && !object->IsAXLayoutObject())
     object = object->ParentObject();
 
   if (!object)
     return 0;
 
   return object->DocumentFrameView();
 }
 
-String AXObject::Language() const {
+String AXObjectImpl::Language() const {
   const AtomicString& lang = GetAttribute(langAttr);
   if (!lang.IsEmpty())
     return lang;
 
-  AXObject* parent = ParentObject();
+  AXObjectImpl* parent = ParentObject();
 
   // As a last resort, fall back to the content language specified in the meta
   // tag.
   if (!parent) {
     Document* doc = GetDocument();
     if (doc)
       return doc->ContentLanguage();
     return g_null_atom;
   }
 
   return parent->Language();
 }
 
-bool AXObject::HasAttribute(const QualifiedName& attribute) const {
+bool AXObjectImpl::HasAttribute(const QualifiedName& attribute) const {
   Node* element_node = GetNode();
   if (!element_node)
     return false;
 
   if (!element_node->IsElementNode())
     return false;
 
   Element* element = ToElement(element_node);
   return element->FastHasAttribute(attribute);
 }
 
-const AtomicString& AXObject::GetAttribute(
+const AtomicString& AXObjectImpl::GetAttribute(
     const QualifiedName& attribute) const {
   Node* element_node = GetNode();
   if (!element_node)
     return g_null_atom;
 
   if (!element_node->IsElementNode())
     return g_null_atom;
 
   Element* element = ToElement(element_node);
   return element->FastGetAttribute(attribute);
 }
 
 //
 // Scrollable containers.
 //
 
-bool AXObject::IsScrollableContainer() const {
+bool AXObjectImpl::IsScrollableContainer() const {
   return !!GetScrollableAreaIfScrollable();
 }
 
-IntPoint AXObject::GetScrollOffset() const {
+IntPoint AXObjectImpl::GetScrollOffset() const {
   ScrollableArea* area = GetScrollableAreaIfScrollable();
   if (!area)
     return IntPoint();
 
   return IntPoint(area->ScrollOffsetInt().Width(),
                   area->ScrollOffsetInt().Height());
 }
 
-IntPoint AXObject::MinimumScrollOffset() const {
+IntPoint AXObjectImpl::MinimumScrollOffset() const {
   ScrollableArea* area = GetScrollableAreaIfScrollable();
   if (!area)
     return IntPoint();
 
   return IntPoint(area->MinimumScrollOffsetInt().Width(),
                   area->MinimumScrollOffsetInt().Height());
 }
 
-IntPoint AXObject::MaximumScrollOffset() const {
+IntPoint AXObjectImpl::MaximumScrollOffset() const {
   ScrollableArea* area = GetScrollableAreaIfScrollable();
   if (!area)
     return IntPoint();
 
   return IntPoint(area->MaximumScrollOffsetInt().Width(),
                   area->MaximumScrollOffsetInt().Height());
 }
 
-void AXObject::SetScrollOffset(const IntPoint& offset) const {
+void AXObjectImpl::SetScrollOffset(const IntPoint& offset) const {
   ScrollableArea* area = GetScrollableAreaIfScrollable();
   if (!area)
     return;
 
   // TODO(bokan): This should potentially be a UserScroll.
   area->SetScrollOffset(ScrollOffset(offset.X(), offset.Y()),
                         kProgrammaticScroll);
 }
 
-void AXObject::GetRelativeBounds(AXObject** out_container,
-                                 FloatRect& out_bounds_in_container,
-                                 SkMatrix44& out_container_transform) const {
+void AXObjectImpl::GetRelativeBounds(
+    AXObjectImpl** out_container,
+    FloatRect& out_bounds_in_container,
+    SkMatrix44& out_container_transform) const {
   *out_container = nullptr;
   out_bounds_in_container = FloatRect();
   out_container_transform.setIdentity();
 
   // First check if it has explicit bounds, for example if this element is tied
   // to a canvas path. When explicit coordinates are provided, the ID of the
   // explicit container element that the coordinates are relative to must be
   // provided too.
   if (!explicit_element_rect_.IsEmpty()) {
     *out_container = AxObjectCache().ObjectFromAXID(explicit_container_id_);
     if (*out_container) {
       out_bounds_in_container = FloatRect(explicit_element_rect_);
       return;
     }
   }
 
   LayoutObject* layout_object = LayoutObjectForRelativeBounds();
   if (!layout_object)
     return;
 
   if (IsWebArea()) {
-    if (layout_object->GetFrame()->View())
+    if (layout_object->GetFrame()->View()) {
       out_bounds_in_container.SetSize(
           FloatSize(layout_object->GetFrame()->View()->ContentsSize()));
+    }
     return;
   }
 
   // First compute the container. The container must be an ancestor in the
   // accessibility tree, and its LayoutObject must be an ancestor in the layout
   // tree. Get the first such ancestor that's either scrollable or has a paint
   // layer.
-  AXObject* container = ParentObjectUnignored();
+  AXObjectImpl* container = ParentObjectUnignored();
   LayoutObject* container_layout_object = nullptr;
   while (container) {
     container_layout_object = container->GetLayoutObject();
     if (container_layout_object &&
         container_layout_object->IsBoxModelObject() &&
         layout_object->IsDescendantOf(container_layout_object)) {
       if (container->IsScrollableContainer() ||
           container_layout_object->HasLayer())
         break;
     }
@@ skipping 21 matching lines @@
   // scaling, etc. then return the full matrix instead.
   TransformationMatrix transform = layout_object->LocalToAncestorTransform(
       ToLayoutBoxModelObject(container_layout_object));
   if (transform.IsIdentityOr2DTranslation()) {
     out_bounds_in_container.Move(transform.To2DTranslation());
   } else {
     out_container_transform = TransformationMatrix::ToSkMatrix44(transform);
   }
 }
 
-LayoutRect AXObject::GetBoundsInFrameCoordinates() const {
-  AXObject* container = nullptr;
+LayoutRect AXObjectImpl::GetBoundsInFrameCoordinates() const {
+  AXObjectImpl* container = nullptr;
   FloatRect bounds;
   SkMatrix44 transform;
   GetRelativeBounds(&container, bounds, transform);
   FloatRect computed_bounds(0, 0, bounds.Width(), bounds.Height());
   while (container && container != this) {
     computed_bounds.Move(bounds.X(), bounds.Y());
     if (!container->IsWebArea()) {
       computed_bounds.Move(-container->GetScrollOffset().X(),
                            -container->GetScrollOffset().Y());
     }
     if (!transform.isIdentity()) {
       TransformationMatrix transformation_matrix(transform);
       transformation_matrix.MapRect(computed_bounds);
     }
     container->GetRelativeBounds(&container, bounds, transform);
   }
   return LayoutRect(computed_bounds);
 }
 
 //
 // Modify or take an action on an object.
 //
 
-bool AXObject::Press() {
+bool AXObjectImpl::Press() {
   Document* document = GetDocument();
   if (!document)
     return false;
 
   UserGestureIndicator gesture_indicator(DocumentUserGestureToken::Create(
       document, UserGestureToken::kNewGesture));
   Element* action_elem = ActionElement();
   if (action_elem) {
     action_elem->AccessKeyAction(true);
     return true;
   }
 
   if (CanSetFocusAttribute()) {
     SetFocused(true);
     return true;
   }
 
   return false;
 }
 
-void AXObject::ScrollToMakeVisible() const {
+void AXObjectImpl::ScrollToMakeVisible() const {
   IntRect object_rect = PixelSnappedIntRect(GetBoundsInFrameCoordinates());
   object_rect.SetLocation(IntPoint());
   ScrollToMakeVisibleWithSubFocus(object_rect);
 }
 
 // This is a 1-dimensional scroll offset helper function that's applied
 // separately in the horizontal and vertical directions, because the
 // logic is the same. The goal is to compute the best scroll offset
 // in order to make an object visible within a viewport.
 //
@@ skipping 82 matching lines @@
 
   // Exit now if the focus is already within the viewport.
   if (object_min - current_scroll_offset >= viewport_min &&
       object_max - current_scroll_offset <= viewport_max)
     return current_scroll_offset;
 
   // Center the object in the viewport.
   return (object_min + object_max - viewport_min - viewport_max) / 2;
 }
 
-void AXObject::ScrollToMakeVisibleWithSubFocus(const IntRect& subfocus) const {
+void AXObjectImpl::ScrollToMakeVisibleWithSubFocus(
+    const IntRect& subfocus) const {
   // Search up the parent chain until we find the first one that's scrollable.
-  const AXObject* scroll_parent = ParentObject() ? ParentObject() : this;
+  const AXObjectImpl* scroll_parent = ParentObject() ? ParentObject() : this;
   ScrollableArea* scrollable_area = 0;
   while (scroll_parent) {
     scrollable_area = scroll_parent->GetScrollableAreaIfScrollable();
     if (scrollable_area)
       break;
     scroll_parent = scroll_parent->ParentObject();
   }
   if (!scroll_parent || !scrollable_area)
     return;
 
@@ skipping 27 matching lines @@
       PixelSnappedIntRect(scroll_parent->GetBoundsInFrameCoordinates());
   new_subfocus.Move(new_element_rect.X(), new_element_rect.Y());
   new_subfocus.Move(-scroll_parent_rect.X(), -scroll_parent_rect.Y());
 
   if (scroll_parent->ParentObject()) {
     // Recursively make sure the scroll parent itself is visible.
     scroll_parent->ScrollToMakeVisibleWithSubFocus(new_subfocus);
   } else {
     // To minimize the number of notifications, only fire one on the topmost
     // object that has been scrolled.
-    AxObjectCache().PostNotification(const_cast<AXObject*>(this),
+    AxObjectCache().PostNotification(const_cast<AXObjectImpl*>(this),
                                      AXObjectCacheImpl::kAXLocationChanged);
   }
 }
 
-void AXObject::ScrollToGlobalPoint(const IntPoint& global_point) const {
+void AXObjectImpl::ScrollToGlobalPoint(const IntPoint& global_point) const {
   // Search up the parent chain and create a vector of all scrollable parent
   // objects and ending with this object itself.
-  HeapVector<Member<const AXObject>> objects;
-  AXObject* parent_object;
+  HeapVector<Member<const AXObjectImpl>> objects;
+  AXObjectImpl* parent_object;
   for (parent_object = this->ParentObject(); parent_object;
        parent_object = parent_object->ParentObject()) {
     if (parent_object->GetScrollableAreaIfScrollable())
       objects.push_front(parent_object);
   }
   objects.push_back(this);
 
   // Start with the outermost scrollable (the main window) and try to scroll the
   // next innermost object to the given point.
   int offset_x = 0, offset_y = 0;
   IntPoint point = global_point;
   size_t levels = objects.size() - 1;
   for (size_t i = 0; i < levels; i++) {
-    const AXObject* outer = objects[i];
-    const AXObject* inner = objects[i + 1];
+    const AXObjectImpl* outer = objects[i];
+    const AXObjectImpl* inner = objects[i + 1];
     ScrollableArea* scrollable_area = outer->GetScrollableAreaIfScrollable();
 
     IntRect inner_rect =
         inner->IsWebArea()
             ? PixelSnappedIntRect(
                   inner->ParentObject()->GetBoundsInFrameCoordinates())
             : PixelSnappedIntRect(inner->GetBoundsInFrameCoordinates());
     IntRect object_rect = inner_rect;
     IntSize scroll_offset = scrollable_area->ScrollOffsetInt();
 
@@ skipping 28 matching lines @@
   }
 
   // To minimize the number of notifications, only fire one on the topmost
   // object that has been scrolled.
   DCHECK(objects[0]);
   // TODO(nektar): Switch to postNotification(objects[0] and remove |getNode|.
   AxObjectCache().PostNotification(objects[0]->GetNode(),
                                    AXObjectCacheImpl::kAXLocationChanged);
 }
 
-void AXObject::SetSequentialFocusNavigationStartingPoint() {
+void AXObjectImpl::SetSequentialFocusNavigationStartingPoint() {
   // Call it on the nearest ancestor that overrides this with a specific
   // implementation.
   if (ParentObject())
     ParentObject()->SetSequentialFocusNavigationStartingPoint();
 }
 
-void AXObject::NotifyIfIgnoredValueChanged() {
+void AXObjectImpl::NotifyIfIgnoredValueChanged() {
   bool is_ignored = AccessibilityIsIgnored();
   if (LastKnownIsIgnoredValue() != is_ignored) {
     AxObjectCache().ChildrenChanged(ParentObject());
     SetLastKnownIsIgnoredValue(is_ignored);
   }
 }
 
-void AXObject::SelectionChanged() {
-  if (AXObject* parent = ParentObjectIfExists())
+void AXObjectImpl::SelectionChanged() {
+  if (AXObjectImpl* parent = ParentObjectIfExists())
     parent->SelectionChanged();
 }
 
-int AXObject::LineForPosition(const VisiblePosition& position) const {
+int AXObjectImpl::LineForPosition(const VisiblePosition& position) const {
   if (position.IsNull() || !GetNode())
     return -1;
 
   // If the position is not in the same editable region as this AX object,
   // return -1.
   Node* container_node = position.DeepEquivalent().ComputeContainerNode();
   if (!container_node->IsShadowIncludingInclusiveAncestorOf(GetNode()) &&
       !GetNode()->IsShadowIncludingInclusiveAncestorOf(container_node))
     return -1;
 
   int line_count = -1;
   VisiblePosition current_position = position;
   VisiblePosition previous_position;
 
   // Move up until we get to the top.
   // FIXME: This only takes us to the top of the rootEditableElement, not the
   // top of the top document.
   do {
     previous_position = current_position;
     current_position = PreviousLinePosition(current_position, LayoutUnit(),
                                             kHasEditableAXRole);
     ++line_count;
   } while (current_position.IsNotNull() &&
            !InSameLine(current_position, previous_position));
 
   return line_count;
 }
 
-bool AXObject::IsARIAControl(AccessibilityRole aria_role) {
+bool AXObjectImpl::IsARIAControl(AccessibilityRole aria_role) {
   return IsARIAInput(aria_role) || aria_role == kButtonRole ||
          aria_role == kComboBoxRole || aria_role == kSliderRole;
 }
 
-bool AXObject::IsARIAInput(AccessibilityRole aria_role) {
+bool AXObjectImpl::IsARIAInput(AccessibilityRole aria_role) {
   return aria_role == kRadioButtonRole || aria_role == kCheckBoxRole ||
          aria_role == kTextFieldRole || aria_role == kSwitchRole ||
          aria_role == kSearchBoxRole;
 }
 
-AccessibilityRole AXObject::AriaRoleToWebCoreRole(const String& value) {
+AccessibilityRole AXObjectImpl::AriaRoleToWebCoreRole(const String& value) {
   DCHECK(!value.IsEmpty());
 
   static const ARIARoleMap* role_map = CreateARIARoleMap();
 
   Vector<String> role_vector;
   value.Split(' ', role_vector);
   AccessibilityRole role = kUnknownRole;
   for (const auto& child : role_vector) {
     role = role_map->at(child);
     if (role)
       return role;
   }
 
   return role;
 }
 
-bool AXObject::IsInsideFocusableElementOrARIAWidget(const Node& node) {
+bool AXObjectImpl::IsInsideFocusableElementOrARIAWidget(const Node& node) {
   const Node* cur_node = &node;
   do {
     if (cur_node->IsElementNode()) {
       const Element* element = ToElement(cur_node);
       if (element->IsFocusable())
         return true;
       String role = element->getAttribute("role");
-      if (!role.IsEmpty() && AXObject::IncludesARIAWidgetRole(role))
+      if (!role.IsEmpty() && AXObjectImpl::IncludesARIAWidgetRole(role))
         return true;
       if (HasInteractiveARIAAttribute(*element))
         return true;
     }
     cur_node = cur_node->parentNode();
   } while (cur_node && !isHTMLBodyElement(node));
   return false;
 }
 
-bool AXObject::HasInteractiveARIAAttribute(const Element& element) {
+bool AXObjectImpl::HasInteractiveARIAAttribute(const Element& element) {
   for (size_t i = 0; i < WTF_ARRAY_LENGTH(g_aria_interactive_widget_attributes);
        ++i) {
     const char* attribute = g_aria_interactive_widget_attributes[i];
     if (element.hasAttribute(attribute)) {
       return true;
     }
   }
   return false;
 }
 
-bool AXObject::IncludesARIAWidgetRole(const String& role) {
+bool AXObjectImpl::IncludesARIAWidgetRole(const String& role) {
   static const HashSet<String, CaseFoldingHash>* role_set =
       CreateARIARoleWidgetSet();
 
   Vector<String> role_vector;
   role.Split(' ', role_vector);
   for (const auto& child : role_vector) {
     if (role_set->Contains(child))
       return true;
   }
   return false;
 }
 
-bool AXObject::NameFromContents() const {
+bool AXObjectImpl::NameFromContents() const {
   // ARIA 1.1, section 5.2.7.5.
   switch (RoleValue()) {
     case kAnchorRole:
     case kButtonRole:
     case kCellRole:
     case kCheckBoxRole:
     case kColumnHeaderRole:
     case kDirectoryRole:
     case kDisclosureTriangleRole:
     case kHeadingRole:
@@ skipping 24 matching lines @@
         return true;
       }
       const Node* node = this->GetNode();
       return node && node->IsElementNode() && ToElement(node)->IsFocusable();
     }
     default:
       return false;
   }
 }
 
-AccessibilityRole AXObject::ButtonRoleType() const {
+AccessibilityRole AXObjectImpl::ButtonRoleType() const {
   // If aria-pressed is present, then it should be exposed as a toggle button.
   // http://www.w3.org/TR/wai-aria/states_and_properties#aria-pressed
   if (AriaPressedIsPresent())
     return kToggleButtonRole;
   if (AriaHasPopup())
     return kPopUpButtonRole;
   // We don't contemplate RadioButtonRole, as it depends on the input
   // type.
 
   return kButtonRole;
 }
 
-const AtomicString& AXObject::RoleName(AccessibilityRole role) {
+const AtomicString& AXObjectImpl::RoleName(AccessibilityRole role) {
   static const Vector<AtomicString>* role_name_vector = CreateRoleNameVector();
 
   return role_name_vector->at(role);
 }
 
-const AtomicString& AXObject::InternalRoleName(AccessibilityRole role) {
+const AtomicString& AXObjectImpl::InternalRoleName(AccessibilityRole role) {
   static const Vector<AtomicString>* internal_role_name_vector =
       CreateInternalRoleNameVector();
 
   return internal_role_name_vector->at(role);
 }
 
-DEFINE_TRACE(AXObject) {
+DEFINE_TRACE(AXObjectImpl) {
   visitor->Trace(children_);
   visitor->Trace(parent_);
   visitor->Trace(cached_live_region_root_);
   visitor->Trace(ax_object_cache_);
 }
 
 }  // namespace blink