Rename AXObject to AXObjectImpl in modules/ and web/

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

 /*
  * Copyright (C) 2014, 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 14 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef AXObjectCacheImpl_h
 #define AXObjectCacheImpl_h
 
 #include <memory>
 #include "core/dom/AXObjectCache.h"
 #include "modules/ModulesExport.h"
-#include "modules/accessibility/AXObject.h"
+#include "modules/accessibility/AXObjectImpl.h"
 #include "platform/wtf/Forward.h"
 #include "platform/wtf/HashMap.h"
 #include "platform/wtf/HashSet.h"
 
 namespace blink {
 
 class AbstractInlineTextBox;
 class HTMLAreaElement;
 class FrameView;
 
 // This class should only be used from inside the accessibility directory.
 class MODULES_EXPORT AXObjectCacheImpl : public AXObjectCache {
   WTF_MAKE_NONCOPYABLE(AXObjectCacheImpl);
 
  public:
   static AXObjectCache* Create(Document&);
 
   explicit AXObjectCacheImpl(Document&);
   ~AXObjectCacheImpl();
   DECLARE_VIRTUAL_TRACE();
 
-  AXObject* FocusedObject();
+  AXObjectImpl* FocusedObject();
 
   void Dispose() override;
 
   void SelectionChanged(Node*) override;
   void ChildrenChanged(Node*) override;
   void ChildrenChanged(LayoutObject*) override;
   void CheckedStateChanged(Node*) override;
   virtual void ListboxOptionStateChanged(HTMLOptionElement*);
   virtual void ListboxSelectedChildrenChanged(HTMLSelectElement*);
   virtual void ListboxActiveIndexChanged(HTMLSelectElement*);
   virtual void RadiobuttonRemovedFromGroup(HTMLInputElement*);
 
   void Remove(LayoutObject*) override;
   void Remove(Node*) override;
   void Remove(AbstractInlineTextBox*) override;
 
   const Element* RootAXEditableElement(const Node*) override;
 
   // Called by a node when text or a text equivalent (e.g. alt) attribute is
   // changed.
   void TextChanged(LayoutObject*) override;
-  void TextChanged(AXObject*);
+  void TextChanged(AXObjectImpl*);
   // Called when a node has just been attached, so we can make sure we have the
-  // right subclass of AXObject.
+  // right subclass of AXObjectImpl.
   void UpdateCacheAfterNodeIsAttached(Node*) override;
 
   void HandleAttributeChanged(const QualifiedName& attr_name,
                               Element*) override;
   void HandleFocusedUIElementChanged(Node* old_focused_node,
                                      Node* new_focused_node) override;
   void HandleInitialFocus() override;
   void HandleTextFormControlChanged(Node*) override;
   void HandleEditableTextContentChanged(Node*) override;
   void HandleValueChanged(Node*) override;
@@ skipping 17 matching lines @@
   // Called when scroll bars are added / removed (as the view resizes).
   void HandleLayoutComplete(LayoutObject*) override;
   void HandleScrolledToAnchor(const Node* anchor_node) override;
 
   const AtomicString& ComputedRoleForNode(Node*) override;
   String ComputedNameForNode(Node*) override;
 
   void OnTouchAccessibilityHover(const IntPoint&) override;
 
   // Returns the root object for the entire document.
-  AXObject* RootObject();
+  AXObjectImpl* RootObject();
 
-  AXObject* ObjectFromAXID(AXID id) const { return objects_.at(id); }
-  AXObject* Root();
+  AXObjectImpl* ObjectFromAXID(AXID id) const { return objects_.at(id); }
+  AXObjectImpl* Root();
 
   // used for objects without backing elements
-  AXObject* GetOrCreate(AccessibilityRole);
-  AXObject* GetOrCreate(LayoutObject*);
-  AXObject* GetOrCreate(Node*);
-  AXObject* GetOrCreate(AbstractInlineTextBox*);
+  AXObjectImpl* GetOrCreate(AccessibilityRole);
+  AXObjectImpl* GetOrCreate(LayoutObject*);
+  AXObjectImpl* GetOrCreate(Node*);
+  AXObjectImpl* GetOrCreate(AbstractInlineTextBox*);
 
-  // will only return the AXObject if it already exists
-  AXObject* Get(Node*);
-  AXObject* Get(LayoutObject*);
-  AXObject* Get(AbstractInlineTextBox*);
+  // will only return the AXObjectImpl if it already exists
+  AXObjectImpl* Get(Node*);
+  AXObjectImpl* Get(LayoutObject*);
+  AXObjectImpl* Get(AbstractInlineTextBox*);
 
-  AXObject* FirstAccessibleObjectFromNode(const Node*);
+  AXObjectImpl* FirstAccessibleObjectFromNode(const Node*);
 
   void Remove(AXID);
 
-  void ChildrenChanged(AXObject*);
+  void ChildrenChanged(AXObjectImpl*);
 
   void HandleActiveDescendantChanged(Node*);
   void HandleAriaRoleChanged(Node*);
   void HandleAriaExpandedChange(Node*);
   void HandleAriaSelectedChanged(Node*);
 
   bool AccessibilityEnabled();
   bool InlineTextBoxAccessibilityEnabled();
 
-  void RemoveAXID(AXObject*);
+  void RemoveAXID(AXObjectImpl*);
 
   AXID GenerateAXID() const;
 
   // Counts the number of times the document has been modified. Some attribute
   // values are cached as long as the modification count hasn't changed.
   int ModificationCount() const { return modification_count_; }
 
   void PostNotification(LayoutObject*, AXNotification);
   void PostNotification(Node*, AXNotification);
-  void PostNotification(AXObject*, AXNotification);
+  void PostNotification(AXObjectImpl*, AXNotification);
 
   //
   // Aria-owns support.
   //
 
   // Returns true if the given object's position in the tree was due to
   // aria-owns.
-  bool IsAriaOwned(const AXObject*) const;
+  bool IsAriaOwned(const AXObjectImpl*) const;
 
   // Returns the parent of the given object due to aria-owns.
-  AXObject* GetAriaOwnedParent(const AXObject*) const;
+  AXObjectImpl* GetAriaOwnedParent(const AXObjectImpl*) const;
 
   // Given an object that has an aria-owns attributes, and a vector of ids from
   // the value of that attribute, updates the internal state to reflect the new
   // set of children owned by this object, returning the result in
   // |ownedChildren|. The result is validated - illegal, duplicate, or cyclical
   // references have been removed.
   //
   // If one or more ids aren't found, they're added to a lookup table so that if
   // an element with that id appears later, it can be added when you call
   // updateTreeIfElementIdIsAriaOwned.
-  void UpdateAriaOwns(const AXObject* owner,
+  void UpdateAriaOwns(const AXObjectImpl* owner,
                       const Vector<String>& id_vector,
-                      HeapVector<Member<AXObject>>& owned_children);
+                      HeapVector<Member<AXObjectImpl>>& owned_children);
 
   // Given an element in the DOM tree that was either just added or whose id
   // just changed, check to see if another object wants to be its parent due to
   // aria-owns. If so, update the tree by calling childrenChanged() on the
   // potential owner, possibly reparenting this element.
   void UpdateTreeIfElementIdIsAriaOwned(Element*);
 
  protected:
-  void PostPlatformNotification(AXObject*, AXNotification);
+  void PostPlatformNotification(AXObjectImpl*, AXNotification);
   void LabelChanged(Element*);
 
-  AXObject* CreateFromRenderer(LayoutObject*);
-  AXObject* CreateFromNode(Node*);
-  AXObject* CreateFromInlineTextBox(AbstractInlineTextBox*);
+  AXObjectImpl* CreateFromRenderer(LayoutObject*);
+  AXObjectImpl* CreateFromNode(Node*);
+  AXObjectImpl* CreateFromInlineTextBox(AbstractInlineTextBox*);
 
  private:
   Member<Document> document_;
-  HeapHashMap<AXID, Member<AXObject>> objects_;
+  HeapHashMap<AXID, Member<AXObjectImpl>> objects_;
   // LayoutObject and AbstractInlineTextBox are not on the Oilpan heap so we
   // do not use HeapHashMap for those mappings.
   HashMap<LayoutObject*, AXID> layout_object_mapping_;
   HeapHashMap<Member<Node>, AXID> node_object_mapping_;
   HashMap<AbstractInlineTextBox*, AXID> inline_text_box_object_mapping_;
   int modification_count_;
 
   HashSet<AXID> ids_in_use_;
 
 #if DCHECK_IS_ON()
@@ skipping 24 matching lines @@
   HashMap<AXID, HashSet<String>> aria_owner_to_ids_mapping_;
 
   // Map from an ID (the ID attribute of a DOM element) to the set of elements
   // that want to own that ID. This is *unvalidated*, it includes possible
   // duplicates.  This is used so that when an element with an ID is added to
   // the tree or changes its ID, we can quickly determine if it affects an
   // aria-owns relationship.
   HashMap<String, std::unique_ptr<HashSet<AXID>>> id_to_aria_owners_mapping_;
 
   TaskRunnerTimer<AXObjectCacheImpl> notification_post_timer_;
-  HeapVector<std::pair<Member<AXObject>, AXNotification>>
+  HeapVector<std::pair<Member<AXObjectImpl>, AXNotification>>
       notifications_to_post_;
   void NotificationPostTimerFired(TimerBase*);
 
-  AXObject* FocusedImageMapUIElement(HTMLAreaElement*);
+  AXObjectImpl* FocusedImageMapUIElement(HTMLAreaElement*);
 
-  AXID GetOrCreateAXID(AXObject*);
+  AXID GetOrCreateAXID(AXObjectImpl*);
 
   void TextChanged(Node*);
   bool NodeIsTextControl(const Node*);
 
   Settings* GetSettings();
 };
 
 // This is the only subclass of AXObjectCache.
 DEFINE_TYPE_CASTS(AXObjectCacheImpl, AXObjectCache, cache, true, true);
 
 bool NodeHasRole(Node*, const String& role);
 // This will let you know if aria-hidden was explicitly set to false.
 bool IsNodeAriaVisible(Node*);
 
 }  // namespace blink
 
 #endif