Rename AXObject to AXObjectImpl in modules/ and web/

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

 /*
  * Copyright (C) 2008, 2009, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nuanti Ltd.
  *
  * 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.
  */
 
-#ifndef AXObject_h
-#define AXObject_h
+#ifndef AXObjectImpl_h
+#define AXObjectImpl_h
 
+#include "core/dom/AXObject.h"
 #include "core/editing/VisiblePosition.h"
 #include "core/editing/markers/DocumentMarker.h"
 #include "core/inspector/protocol/Accessibility.h"
 #include "modules/ModulesExport.h"
 #include "platform/geometry/FloatQuad.h"
 #include "platform/geometry/LayoutRect.h"
 #include "platform/graphics/Color.h"
 #include "platform/wtf/Forward.h"
 #include "platform/wtf/Vector.h"
 
 class SkMatrix44;
 
 namespace blink {
 
-class AXObject;
+class AXObjectImpl;
 class AXObjectCacheImpl;
 class Element;
 class FrameView;
 class IntPoint;
 class Node;
 class LayoutObject;
 class ScrollableArea;
 
 enum class AOMStringProperty;
 
@@ skipping 166 matching lines @@
 class AccessibilityText final
     : public GarbageCollectedFinalized<AccessibilityText> {
   WTF_MAKE_NONCOPYABLE(AccessibilityText);
 
  public:
   DEFINE_INLINE_TRACE() { visitor->Trace(text_element_); }
 
  private:
   AccessibilityText(const String& text,
                     const AccessibilityTextSource& source,
-                    AXObject* element)
+                    AXObjectImpl* element)
       : text_(text), text_element_(element) {}
 
   String text_;
-  Member<AXObject> text_element_;
+  Member<AXObjectImpl> text_element_;
 };
 
 enum AccessibilityOrientation {
   kAccessibilityOrientationUndefined = 0,
   kAccessibilityOrientationVertical,
   kAccessibilityOrientationHorizontal,
 };
 
 enum AXObjectInclusion {
   kIncludeObject,
@@ skipping 95 matching lines @@
 enum class AXObjectVectorAttribute {
   kAriaControls,
   kAriaDetails,
   kAriaFlowTo,
 };
 
 class AXSparseAttributeClient {
  public:
   virtual void AddBoolAttribute(AXBoolAttribute, bool) = 0;
   virtual void AddStringAttribute(AXStringAttribute, const String&) = 0;
-  virtual void AddObjectAttribute(AXObjectAttribute, AXObject&) = 0;
+  virtual void AddObjectAttribute(AXObjectAttribute, AXObjectImpl&) = 0;
   virtual void AddObjectVectorAttribute(AXObjectVectorAttribute,
-                                        HeapVector<Member<AXObject>>&) = 0;
+                                        HeapVector<Member<AXObjectImpl>>&) = 0;
 };
 
 // The source of the accessible name of an element. This is needed
 // because on some platforms this determines how the accessible name
 // is exposed.
 enum AXNameFrom {
   kAXNameFromUninitialized = -1,
   kAXNameFromAttribute = 0,
   kAXNameFromAttributeExplicitlyEmpty,
   kAXNameFromCaption,
@@ skipping 46 matching lines @@
   kAXProbablyPresentational,
   kAXStaticTextUsedAsNameFor,
   kAXUninteresting
 };
 
 class IgnoredReason {
   DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 
  public:
   AXIgnoredReason reason;
-  Member<const AXObject> related_object;
+  Member<const AXObjectImpl> related_object;
 
   explicit IgnoredReason(AXIgnoredReason reason)
       : reason(reason), related_object(nullptr) {}
 
-  IgnoredReason(AXIgnoredReason r, const AXObject* obj)
+  IgnoredReason(AXIgnoredReason r, const AXObjectImpl* obj)
       : reason(r), related_object(obj) {}
 
   DEFINE_INLINE_TRACE() { visitor->Trace(related_object); }
 };
 
 class NameSourceRelatedObject
     : public GarbageCollectedFinalized<NameSourceRelatedObject> {
   WTF_MAKE_NONCOPYABLE(NameSourceRelatedObject);
 
  public:
-  WeakMember<AXObject> object;
+  WeakMember<AXObjectImpl> object;
   String text;
 
-  NameSourceRelatedObject(AXObject* object, String text)
+  NameSourceRelatedObject(AXObjectImpl* object, String text)
       : object(object), text(text) {}
 
   DEFINE_INLINE_TRACE() { visitor->Trace(object); }
 };
 
 typedef HeapVector<Member<NameSourceRelatedObject>> AXRelatedObjectVector;
 class NameSource {
   DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 
  public:
@@ skipping 38 matching lines @@
 };
 
 }  // namespace blink
 
 WTF_ALLOW_INIT_WITH_MEM_FUNCTIONS(blink::IgnoredReason);
 WTF_ALLOW_INIT_WITH_MEM_FUNCTIONS(blink::NameSource);
 WTF_ALLOW_INIT_WITH_MEM_FUNCTIONS(blink::DescriptionSource);
 
 namespace blink {
 
-class MODULES_EXPORT AXObject : public GarbageCollectedFinalized<AXObject> {
-  WTF_MAKE_NONCOPYABLE(AXObject);
+class MODULES_EXPORT AXObjectImpl
+    : public GarbageCollectedFinalized<AXObjectImpl>,
+      public AXObject {
+  WTF_MAKE_NONCOPYABLE(AXObjectImpl);
 
  public:
-  typedef HeapVector<Member<AXObject>> AXObjectVector;
+  typedef HeapVector<Member<AXObjectImpl>> AXObjectVector;
 
   struct AXRange {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
     // The deepest descendant in which the range starts.
     // (nullptr means the current object.)
-    Persistent<AXObject> anchor_object;
+    Persistent<AXObjectImpl> anchor_object;
     // The number of characters and child objects in the anchor object
     // before the range starts.
     int anchor_offset;
     // When the same character offset could correspond to two possible
     // cursor positions, upstream means it's on the previous line rather
     // than the next line.
     TextAffinity anchor_affinity;
 
     // The deepest descendant in which the range ends.
     // (nullptr means the current object.)
-    Persistent<AXObject> focus_object;
+    Persistent<AXObjectImpl> focus_object;
     // The number of characters and child objects in the focus object
     // before the range ends.
     int focus_offset;
     // When the same character offset could correspond to two possible
     // cursor positions, upstream means it's on the previous line rather
     // than the next line.
     TextAffinity focus_affinity;
 
     AXRange()
         : anchor_object(nullptr),
           anchor_offset(-1),
           anchor_affinity(TextAffinity::kUpstream),
           focus_object(nullptr),
           focus_offset(-1),
           focus_affinity(TextAffinity::kDownstream) {}
 
     AXRange(int start_offset, int end_offset)
         : anchor_object(nullptr),
           anchor_offset(start_offset),
           anchor_affinity(TextAffinity::kUpstream),
           focus_object(nullptr),
           focus_offset(end_offset),
           focus_affinity(TextAffinity::kDownstream) {}
 
-    AXRange(AXObject* anchor_object,
+    AXRange(AXObjectImpl* anchor_object,
             int anchor_offset,
             TextAffinity anchor_affinity,
-            AXObject* focus_object,
+            AXObjectImpl* focus_object,
             int focus_offset,
             TextAffinity focus_affinity)
         : anchor_object(anchor_object),
           anchor_offset(anchor_offset),
           anchor_affinity(anchor_affinity),
           focus_object(focus_object),
           focus_offset(focus_offset),
           focus_affinity(focus_affinity) {}
 
     bool IsValid() const {
       return ((anchor_object && focus_object) ||
               (!anchor_object && !focus_object)) &&
              anchor_offset >= 0 && focus_offset >= 0;
     }
 
     // Determines if the range only refers to text offsets under the current
     // object.
     bool IsSimple() const {
       return anchor_object == focus_object || !anchor_object || !focus_object;
     }
   };
 
  protected:
-  AXObject(AXObjectCacheImpl&);
+  AXObjectImpl(AXObjectCacheImpl&);
 
  public:
-  virtual ~AXObject();
+  virtual ~AXObjectImpl();
   DECLARE_VIRTUAL_TRACE();
 
   static unsigned NumberOfLiveAXObjects() { return number_of_live_ax_objects_; }
 
-  // After constructing an AXObject, it must be given a
+  // After constructing an AXObjectImpl, it must be given a
   // unique ID, then added to AXObjectCacheImpl, and finally init() must
   // be called last.
   void SetAXObjectID(AXID ax_object_id) { id_ = ax_object_id; }
   virtual void Init() {}
 
-  // When the corresponding WebCore object that this AXObject
+  // When the corresponding WebCore object that this AXObjectImpl
   // wraps is deleted, it must be detached.
   virtual void Detach();
   virtual bool IsDetached() const;
 
   // If the parent of this object is known, this can be faster than using
   // computeParent().
-  virtual void SetParent(AXObject* parent) { parent_ = parent; }
+  virtual void SetParent(AXObjectImpl* parent) { parent_ = parent; }
 
   // The AXObjectCacheImpl that owns this object, and its unique ID within this
   // cache.
   AXObjectCacheImpl& AxObjectCache() const {
     DCHECK(ax_object_cache_);
     return *ax_object_cache_;
   }
 
   AXID AxObjectID() const { return id_; }
 
@@ skipping 109 matching lines @@
   bool AccessibilityIsIgnored() const;
   typedef HeapVector<IgnoredReason> IgnoredReasons;
   virtual bool ComputeAccessibilityIsIgnored(IgnoredReasons* = nullptr) const {
     return true;
   }
   bool AccessibilityIsIgnoredByDefault(IgnoredReasons* = nullptr) const;
   AXObjectInclusion AccessibilityPlatformIncludesObject() const;
   virtual AXObjectInclusion DefaultObjectInclusion(
       IgnoredReasons* = nullptr) const;
   bool IsInertOrAriaHidden() const;
-  const AXObject* AriaHiddenRoot() const;
+  const AXObjectImpl* AriaHiddenRoot() const;
   bool ComputeIsInertOrAriaHidden(IgnoredReasons* = nullptr) const;
   bool IsDescendantOfLeafNode() const;
-  AXObject* LeafNodeAncestor() const;
+  AXObjectImpl* LeafNodeAncestor() const;
   bool IsDescendantOfDisabledNode() const;
-  const AXObject* DisabledAncestor() const;
+  const AXObjectImpl* DisabledAncestor() const;
   bool LastKnownIsIgnoredValue();
   void SetLastKnownIsIgnoredValue(bool);
   bool HasInheritedPresentationalRole() const;
   bool IsPresentationalChild() const;
   bool AncestorExposesActiveDescendant() const;
   bool ComputeAncestorExposesActiveDescendant() const;
 
   //
   // Accessible name calculation
   //
@@ skipping 27 matching lines @@
                              AXRelatedObjectVector*) const {
     return String();
   }
 
   // Takes the result of nameFrom and descriptionFrom from calling |name| and
   // |description|, above, and retrieves the placeholder of the object, if
   // present and if it wasn't already exposed by one of the two functions above.
   virtual String Placeholder(AXNameFrom) const { return String(); }
 
   // Internal functions used by name and description, above.
-  typedef HeapHashSet<Member<const AXObject>> AXObjectSet;
+  typedef HeapHashSet<Member<const AXObjectImpl>> AXObjectSet;
   virtual String TextAlternative(bool recursive,
                                  bool in_aria_labelled_by_traversal,
                                  AXObjectSet& visited,
                                  AXNameFrom& name_from,
                                  AXRelatedObjectVector* related_objects,
                                  NameSources* name_sources) const {
     return String();
   }
   virtual String TextFromDescendants(AXObjectSet& visited,
                                      bool recursive) const {
@@ skipping 28 matching lines @@
   // Value should be 1-based. 0 means not supported.
   virtual int HeadingLevel() const { return 0; }
   // Value should be 1-based. 0 means not supported.
   virtual unsigned HierarchicalLevel() const { return 0; }
   // Return the content of an image or canvas as an image data url in
   // PNG format. If |maxSize| is not empty and if the image is larger than
   // those dimensions, the image will be resized proportionally first to fit.
   virtual String ImageDataUrl(const IntSize& max_size) const {
     return g_null_atom;
   }
-  virtual AXObject* InPageLinkTarget() const { return nullptr; }
+  virtual AXObjectImpl* InPageLinkTarget() const { return nullptr; }
   virtual AccessibilityOrientation Orientation() const;
   virtual String GetText() const { return String(); }
   virtual AccessibilityTextDirection GetTextDirection() const {
     return kAccessibilityTextDirectionLTR;
   }
   virtual int TextLength() const { return 0; }
   virtual TextStyle GetTextStyle() const { return kTextStyleNone; }
   virtual AXObjectVector RadioButtonsInGroup() const {
     return AXObjectVector();
   }
   virtual KURL Url() const { return KURL(); }
 
   // Load inline text boxes for just this node, even if
   // settings->inlineTextBoxAccessibilityEnabled() is false.
   virtual void LoadInlineTextBoxes() {}
 
   // Walk the AXObjects on the same line. This is supported on any
   // object type but primarily intended to be used for inline text boxes.
-  virtual AXObject* NextOnLine() const { return nullptr; }
-  virtual AXObject* PreviousOnLine() const { return nullptr; }
+  virtual AXObjectImpl* NextOnLine() const { return nullptr; }
+  virtual AXObjectImpl* PreviousOnLine() const { return nullptr; }
 
   // For all node objects. The start and end character offset of each
   // marker, such as spelling or grammar error.
   virtual void Markers(Vector<DocumentMarker::MarkerType>&,
                        Vector<AXRange>&) const {}
   // For an inline text box.
   // The integer horizontal pixel offset of each character in the string;
   // negative values for RTL.
   virtual void TextCharacterOffsets(Vector<int>&) const {}
   // The start and end character offset of each word in the object's text.
@@ skipping 10 matching lines @@
   }
   // Only used when invalidState() returns InvalidStateOther.
   virtual String AriaInvalidValue() const { return String(); }
   virtual String ValueDescription() const { return String(); }
   virtual float ValueForRange() const { return 0.0f; }
   virtual float MaxValueForRange() const { return 0.0f; }
   virtual float MinValueForRange() const { return 0.0f; }
   virtual String StringValue() const { return String(); }
 
   // ARIA attributes.
-  virtual AXObject* ActiveDescendant() { return nullptr; }
+  virtual AXObjectImpl* ActiveDescendant() { return nullptr; }
   virtual String AriaAutoComplete() const { return String(); }
   virtual void AriaOwnsElements(AXObjectVector& owns) const {}
   virtual void AriaDescribedbyElements(AXObjectVector&) const {}
   virtual void AriaLabelledbyElements(AXObjectVector&) const {}
   virtual bool AriaHasPopup() const { return false; }
   virtual bool IsEditable() const { return false; }
   bool IsMultiline() const;
   virtual bool IsRichlyEditable() const { return false; }
   bool AriaPressedIsPresent() const;
   virtual AccessibilityRole AriaRoleAttribute() const { return kUnknownRole; }
   virtual bool AriaRoleHasPresentationalChildren() const { return false; }
-  virtual AXObject* AncestorForWhichThisIsAPresentationalChild() const {
+  virtual AXObjectImpl* AncestorForWhichThisIsAPresentationalChild() const {
     return 0;
   }
   bool SupportsActiveDescendant() const;
   bool SupportsARIAAttributes() const;
   virtual bool SupportsARIADragging() const { return false; }
   virtual bool SupportsARIADropping() const { return false; }
   virtual bool SupportsARIAFlowTo() const { return false; }
   virtual bool SupportsARIAOwns() const { return false; }
   bool SupportsRangeValue() const;
   virtual SortDirection GetSortDirection() const {
     return kSortDirectionUndefined;
   }
 
   // Returns 0-based index.
   int IndexInParent() const;
 
   // Value should be 1-based. 0 means not supported.
   virtual int PosInSet() const { return 0; }
   virtual int SetSize() const { return 0; }
   bool SupportsSetSizeAndPosInSet() const;
 
   // ARIA live-region features.
   bool IsLiveRegion() const;
-  AXObject* LiveRegionRoot() const;
+  AXObjectImpl* LiveRegionRoot() const;
   virtual const AtomicString& LiveRegionStatus() const { return g_null_atom; }
   virtual const AtomicString& LiveRegionRelevant() const { return g_null_atom; }
   virtual bool LiveRegionAtomic() const { return false; }
   virtual bool LiveRegionBusy() const { return false; }
 
   const AtomicString& ContainerLiveRegionStatus() const;
   const AtomicString& ContainerLiveRegionRelevant() const;
   bool ContainerLiveRegionAtomic() const;
   bool ContainerLiveRegionBusy() const;
 
   // Every object's bounding box is returned relative to a
   // container object (which is guaranteed to be an ancestor) and
   // optionally a transformation matrix that needs to be applied too.
   // To compute the absolute bounding box of an element, start with its
   // boundsInContainer and apply the transform. Then as long as its container is
   // not null, walk up to its container and offset by the container's offset
   // from origin, the container's scroll position if any, and apply the
   // container's transform.  Do this until you reach the root of the tree.
-  virtual void GetRelativeBounds(AXObject** out_container,
+  virtual void GetRelativeBounds(AXObjectImpl** out_container,
                                  FloatRect& out_bounds_in_container,
                                  SkMatrix44& out_container_transform) const;
 
   // Get the bounds in frame-relative coordinates as a LayoutRect.
   LayoutRect GetBoundsInFrameCoordinates() const;
 
   // Explicitly set an object's bounding rect and offset container.
-  void SetElementRect(LayoutRect r, AXObject* container) {
+  void SetElementRect(LayoutRect r, AXObjectImpl* container) {
     explicit_element_rect_ = r;
     explicit_container_id_ = container->AxObjectID();
   }
 
   // Hit testing.
   // Called on the root AX object to return the deepest available element.
-  virtual AXObject* AccessibilityHitTest(const IntPoint&) const { return 0; }
+  virtual AXObjectImpl* AccessibilityHitTest(const IntPoint&) const {
+    return 0;
+  }
   // Called on the AX object after the layout tree determines which is the right
   // AXLayoutObject.
-  virtual AXObject* ElementAccessibilityHitTest(const IntPoint&) const;
+  virtual AXObjectImpl* ElementAccessibilityHitTest(const IntPoint&) const;
 
   // High-level accessibility tree access. Other modules should only use these
   // functions.
   const AXObjectVector& Children();
-  AXObject* ParentObject() const;
-  AXObject* ParentObjectIfExists() const;
-  virtual AXObject* ComputeParent() const = 0;
-  virtual AXObject* ComputeParentIfExists() const { return 0; }
-  AXObject* CachedParentObject() const { return parent_; }
-  AXObject* ParentObjectUnignored() const;
+  AXObjectImpl* ParentObject() const;
+  AXObjectImpl* ParentObjectIfExists() const;
+  virtual AXObjectImpl* ComputeParent() const = 0;
+  virtual AXObjectImpl* ComputeParentIfExists() const { return 0; }
+  AXObjectImpl* CachedParentObject() const { return parent_; }
+  AXObjectImpl* ParentObjectUnignored() const;
 
   // Low-level accessibility tree exploration, only for use within the
   // accessibility module.
-  virtual AXObject* RawFirstChild() const { return 0; }
-  virtual AXObject* RawNextSibling() const { return 0; }
+  virtual AXObjectImpl* RawFirstChild() const { return 0; }
+  virtual AXObjectImpl* RawNextSibling() const { return 0; }
   virtual void AddChildren() {}
   virtual bool CanHaveChildren() const { return true; }
   bool HasChildren() const { return have_children_; }
   virtual void UpdateChildrenIfNecessary();
   virtual bool NeedsToUpdateChildren() const { return false; }
   virtual void SetNeedsToUpdateChildren() {}
   virtual void ClearChildren();
   virtual void DetachFromParent() { parent_ = 0; }
-  virtual AXObject* ScrollBar(AccessibilityOrientation) { return 0; }
+  virtual AXObjectImpl* ScrollBar(AccessibilityOrientation) { return 0; }
 
   // Properties of the object's owning document or page.
   virtual double EstimatedLoadingProgress() const { return 0; }
 
   // DOM and layout tree access.
   virtual Node* GetNode() const { return 0; }
   virtual LayoutObject* GetLayoutObject() const { return 0; }
   virtual Document* GetDocument() const;
   virtual FrameView* DocumentFrameView() const;
   virtual Element* AnchorElement() const { return 0; }
@@ skipping 71 matching lines @@
   AXID id_;
   AXObjectVector children_;
   mutable bool have_children_;
   AccessibilityRole role_;
   AXObjectInclusion last_known_is_ignored_value_;
   LayoutRect explicit_element_rect_;
   AXID explicit_container_id_;
 
   // Used only inside textAlternative():
   static String CollapseWhitespace(const String&);
-  static String RecursiveTextAlternative(const AXObject&,
+  static String RecursiveTextAlternative(const AXObjectImpl&,
                                          bool in_aria_labelled_by_traversal,
                                          AXObjectSet& visited);
   bool IsHiddenForTextAlternativeCalculation() const;
   String AriaTextAlternative(bool recursive,
                              bool in_aria_labelled_by_traversal,
                              AXObjectSet& visited,
                              AXNameFrom&,
                              AXRelatedObjectVector*,
                              NameSources*,
                              bool* found_text_alternative) const;
   String TextFromElements(bool in_aria_labelled_by_traversal,
                           AXObjectSet& visited,
                           HeapVector<Member<Element>>& elements,
                           AXRelatedObjectVector* related_objects) const;
   void TokenVectorFromAttribute(Vector<String>&, const QualifiedName&) const;
   void ElementsFromAttribute(HeapVector<Member<Element>>& elements,
                              const QualifiedName&) const;
   void AriaLabelledbyElementVector(HeapVector<Member<Element>>& elements) const;
   String TextFromAriaLabelledby(AXObjectSet& visited,
                                 AXRelatedObjectVector* related_objects) const;
   String TextFromAriaDescribedby(AXRelatedObjectVector* related_objects) const;
 
-  virtual const AXObject* InheritsPresentationalRoleFrom() const { return 0; }
+  virtual const AXObjectImpl* InheritsPresentationalRoleFrom() const {
+    return 0;
+  }
 
   virtual bool NameFromContents() const;
 
   AccessibilityRole ButtonRoleType() const;
 
   virtual LayoutObject* LayoutObjectForRelativeBounds() const {
     return nullptr;
   }
 
-  mutable Member<AXObject> parent_;
+  mutable Member<AXObjectImpl> parent_;
 
   // The following cached attribute values (the ones starting with m_cached*)
   // are only valid if m_lastModificationCount matches
   // AXObjectCacheImpl::modificationCount().
   mutable int last_modification_count_;
   mutable RGBA32 cached_background_color_;
   mutable bool cached_is_ignored_ : 1;
   mutable bool cached_is_inert_or_aria_hidden_ : 1;
   mutable bool cached_is_descendant_of_leaf_node_ : 1;
   mutable bool cached_is_descendant_of_disabled_node_ : 1;
   mutable bool cached_has_inherited_presentational_role_ : 1;
   mutable bool cached_is_presentational_child_ : 1;
   mutable bool cached_ancestor_exposes_active_descendant_ : 1;
-  mutable Member<AXObject> cached_live_region_root_;
+  mutable Member<AXObjectImpl> cached_live_region_root_;
 
   Member<AXObjectCacheImpl> ax_object_cache_;
 
   // Updates the cached attribute values. This may be recursive, so to prevent
   // deadlocks,
   // functions called here may only search up the tree (ancestors), not down.
   void UpdateCachedAttributeValuesIfNeeded() const;
 
  private:
   static bool IsNativeInputInMixedState(const Node*);
   static bool IncludesARIAWidgetRole(const String&);
   static bool HasInteractiveARIAAttribute(const Element&);
 
   static unsigned number_of_live_ax_objects_;
 };
 
-#define DEFINE_AX_OBJECT_TYPE_CASTS(thisType, predicate)           \
-  DEFINE_TYPE_CASTS(thisType, AXObject, object, object->predicate, \
+// TODO(sashab): Remove this once callers in web/ can use AXObject directly.

[sashab, 2017/05/08 23:58:34]

aboxhall - wdyt of this comment?

[aboxhall, 2017/05/09 02:01:02]

We may not want or need to remove the ability to cast, per the other example you
called out. Once web/ no longer depends on modules/ it won't be able to call
this cast anyway. So I don't think the comment is necessary.

Also, I think we can use the DEFINE_TYPE_CASTS macro here, like in
AXObjectCache:

DEFINE_TYPE_CASTS(AXObjectImpl, AXObject, cache, true, true);

[sashab, 2017/05/10 04:24:43]

Thanks; removed the comment and changed to use the macro :)

+inline AXObjectImpl* ToAXObjectImpl(AXObject* argument) {
+  return static_cast<AXObjectImpl*>(argument);
+}
+
+#define DEFINE_AX_OBJECT_TYPE_CASTS(thisType, predicate)               \
+  DEFINE_TYPE_CASTS(thisType, AXObjectImpl, object, object->predicate, \
                     object.predicate)
 
 }  // namespace blink
 
-#endif  // AXObject_h
+#endif  // AXObjectImpl_h