Oilpan: Prepare moving AXObject to heap

Source/modules/accessibility/AXObject.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.
@@ skipping 202 matching lines @@
     AXVerticalState,
     AXVisitedState
 };
 
 class AccessibilityText final : public NoBaseWillBeGarbageCollectedFinalized<AccessibilityText> {
 public:
     static PassOwnPtrWillBeRawPtr<AccessibilityText> create(const String& text, const AccessibilityTextSource& source)
     {
         return adoptPtrWillBeNoop(new AccessibilityText(text, source, nullptr));
     }
-    static PassOwnPtrWillBeRawPtr<AccessibilityText> create(const String& text, const AccessibilityTextSource& source, const RefPtr<AXObject> element)
+    static PassOwnPtrWillBeRawPtr<AccessibilityText> create(const String& text, const AccessibilityTextSource& source, const RefPtrWillBeRawPtr<AXObject> element)
     {
         return adoptPtrWillBeNoop(new AccessibilityText(text, source, nullptr));
     }
 
     String text() const { return m_text; }
     AccessibilityTextSource textSource() const { return m_textSource; }
     AXObject* textElement() const { return m_textElement.get(); }
 
-    DEFINE_INLINE_TRACE() { }
+    DEFINE_INLINE_TRACE()
+    {
+        visitor->trace(m_textElement);
+    }
 
 private:
-    AccessibilityText(const String& text, const AccessibilityTextSource& source, const PassRefPtr<AXObject> element)
+    AccessibilityText(const String& text, const AccessibilityTextSource& source, const RefPtrWillBeRawPtr<AXObject> element)
     : m_text(text)
     , m_textSource(source)
     , m_textElement(element)
     { }
 
     String m_text;
     AccessibilityTextSource m_textSource;
-    RefPtr<AXObject> m_textElement;
+    RefPtrWillBeMember<AXObject> m_textElement;
 };
 
 enum AccessibilityOrientation {
     AccessibilityOrientationUndefined = 0,
     AccessibilityOrientationVertical,
     AccessibilityOrientationHorizontal,
 };
 
 enum AXObjectInclusion {
     IncludeObject,
@@ skipping 102 matching lines @@
         : reason(reason)
         , relatedObject(nullptr)
     { }
 
     IgnoredReason(AXIgnoredReason r, const AXObject* obj)
         : reason(r)
         , relatedObject(obj)
     { }
 };
 
-class MODULES_EXPORT AXObject : public RefCounted<AXObject> {
+class MODULES_EXPORT AXObject : public RefCountedWillBeGarbageCollectedFinalized<AXObject> {
 public:
-    typedef Vector<RefPtr<AXObject>> AccessibilityChildrenVector;
+    typedef WillBeHeapVector<RefPtrWillBeMember<AXObject>> AccessibilityChildrenVector;
 
     struct PlainTextRange {
 
         unsigned start;
         unsigned length;
 
         PlainTextRange()
             : start(0)
             , length(0)
         { }
 
         PlainTextRange(unsigned s, unsigned l)
             : start(s)
             , length(l)
         { }
 
         bool isNull() const { return !start && !length; }
     };
 
 protected:
     AXObject(AXObjectCacheImpl&);
 
 public:
     virtual ~AXObject();
+    DECLARE_VIRTUAL_TRACE();
 
     // After constructing an AXObject, it must be given a
     // unique ID, then added to AXObjectCacheImpl, and finally init() must
     // be called last.
     void setAXObjectID(AXID axObjectID) { m_id = axObjectID; }
     virtual void init() { }
 
     // When the corresponding WebCore object that this AXObject
     // wraps is deleted, it must be detached.
     virtual void detach();
@@ skipping 134 matching lines @@
     virtual String deprecatedTitle(TextUnderElementMode mode = TextUnderElementAll) const { return String(); }
     virtual String deprecatedHelpText() const { return String(); }
     virtual String deprecatedTextUnderElement(TextUnderElementMode mode = TextUnderElementAll) const { return String(); }
 
     //
     // New text alternative calculation API (under development).
     //
 
     // Retrieves the accessible name of the object, an enum indicating where the name
     // was derived from, and a list of objects that were used to derive the name, if any.
-    virtual String name(AXNameFrom&, Vector<AXObject*>& nameObjects);
+    virtual String name(AXNameFrom&, WillBeHeapVector<RawPtrWillBeMember<AXObject>>& nameObjects);
 
     // Takes the result of nameFrom from calling |name|, above, and retrieves the
     // accessible description of the object, which is secondary to |name|, an enum indicating
     // where the description was derived from, and a list of objects that were used to
     // derive the description, if any.
-    virtual String description(AXNameFrom, AXDescriptionFrom&, Vector<AXObject*>& descriptionObjects) { return String(); }
+    virtual String description(AXNameFrom, AXDescriptionFrom&, WillBeHeapVector<RawPtrWillBeMember<AXObject>>& descriptionObjects) { 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, AXDescriptionFrom) { return String(); }
 
     // Internal function used by name and description, above.
-    virtual String textAlternative(bool recursive, bool inAriaLabelledByTraversal, HashSet<AXObject*>& visited, AXNameFrom*, Vector<AXObject*>* nameObjects) { return String(); }
+    virtual String textAlternative(bool recursive, bool inAriaLabelledByTraversal, WillBeHeapHashSet<RawPtrWillBeMember<AXObject>>& visited, AXNameFrom*, WillBeHeapVector<RawPtrWillBeMember<AXObject>>* nameObjects) { return String(); }
 
     // Returns result of Accessible Name Calculation algorithm.
     // This is a simpler high-level interface to |name| used by Inspector.
     virtual String computedName() const { return String(); }
 
     //
     // Properties of static elements.
     //
 
     virtual const AtomicString& accessKey() const { return nullAtom; }
@@ skipping 205 matching lines @@
     LayoutRect m_explicitElementRect;
 
     virtual const AXObject* inheritsPresentationalRoleFrom() const { return 0; }
 
     bool nameFromContents() const;
 
     AccessibilityRole buttonRoleType() const;
 
     unsigned getLengthForTextRange() const { return text().length(); }
 
-    mutable AXObject* m_parent;
+    bool m_detached;
+
+    mutable RawPtrWillBeMember<AXObject> m_parent;
 
     // The following cached attribute values (the ones starting with m_cached*)
     // are only valid if m_lastModificationCount matches AXObjectCacheImpl::modificationCount().
     mutable int m_lastModificationCount;
     mutable bool m_cachedIsIgnored : 1;
     mutable bool m_cachedIsInertOrAriaHidden : 1;
     mutable bool m_cachedIsDescendantOfLeafNode : 1;
     mutable bool m_cachedIsDescendantOfDisabledNode : 1;
     mutable bool m_cachedHasInheritedPresentationalRole : 1;
     mutable bool m_cachedIsPresentationalChild : 1;
-    mutable const AXObject* m_cachedLiveRegionRoot;
+    mutable RawPtrWillBeMember<const AXObject> m_cachedLiveRegionRoot;
 
-    AXObjectCacheImpl* m_axObjectCache;
+    RawPtrWillBeMember<AXObjectCacheImpl> m_axObjectCache;
 
     // 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 includesARIAWidgetRole(const String&);
     static bool hasInteractiveARIAAttribute(const Element&);
 };
 
 #define DEFINE_AX_OBJECT_TYPE_CASTS(thisType, predicate) \
     DEFINE_TYPE_CASTS(thisType, AXObject, object, object->predicate, object.predicate)
 
 } // namespace blink
 
 #endif // AXObject_h