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 193 matching lines @@
     AXPressedState,
     AXProtectedState,
     AXReadonlyState,
     AXRequiredState,
     AXSelectableState,
     AXSelectedState,
     AXVerticalState,
     AXVisitedState
 };
 
-struct AccessibilityText {
-    String text;
-    AccessibilityTextSource textSource;
-    RefPtr<AXObject> textElement;
+class AccessibilityText : public NoBaseWillBeGarbageCollectedFinalized<AccessibilityText> {
+public:
+    static PassOwnPtrWillBeRawPtr<AccessibilityText> create(const String& t, const AccessibilityTextSource& s)
+    {
+        return adoptPtrWillBeNoop<AccessibilityText>(new AccessibilityText(t, s, nullptr));
+    }
+    static PassOwnPtrWillBeRawPtr<AccessibilityText> create(const String& t, const AccessibilityTextSource& s, const RefPtrWillBeRawPtr<AXObject> element)
+    {
+        return adoptPtrWillBeNoop<AccessibilityText>(new AccessibilityText(t, s, nullptr));
+    }
 
-    AccessibilityText(const String& t, const AccessibilityTextSource& s)
-    : text(t)
-    , textSource(s)
+    String text() { return m_text; }
+    AccessibilityTextSource textSource() { return m_textSource; }
+    AXObject* textElement() { return m_textElement.get(); }
+
+    DEFINE_INLINE_TRACE()
+    {
+        visitor->trace(m_textElement);
+    }
+
+private:
+    AccessibilityText(const String& t, const AccessibilityTextSource& s, const RefPtrWillBeRawPtr<AXObject> element)
+    : m_text(t)
+    , m_textSource(s)
+    , m_textElement(element)
     { }
 
-    AccessibilityText(const String& t, const AccessibilityTextSource& s, const RefPtr<AXObject> element)
-    : text(t)
-    , textSource(s)
-    , textElement(element)
-    { }
+    String m_text;
+    AccessibilityTextSource m_textSource;
+    RefPtrWillBeMember<AXObject> m_textElement;
 };
 
 enum AccessibilityOrientation {
     AccessibilityOrientationUndefined = 0,
     AccessibilityOrientationVertical,
     AccessibilityOrientationHorizontal,
 };
 
 enum AXObjectInclusion {
     IncludeObject,
@@ skipping 92 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 130 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) { return String(); }
+    virtual String name(AXNameFrom&, WillBeHeapVector<RawPtrWillBeMember<AXObject>>& nameObjects) { return String(); }
 
     // 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(); }
 
     // 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(); }
 
@@ skipping 195 matching lines @@
     // If this object itself scrolls, return its ScrollableArea.
     virtual ScrollableArea* getScrollableAreaIfScrollable() const { return 0; }
     virtual void scrollTo(const IntPoint&) const { }
 
     AccessibilityRole buttonRoleType() const;
 
     unsigned getLengthForTextRange() const { return text().length(); }
 
     bool m_detached;
 
-    mutable AXObject* m_parent;
+    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;
+    RawPtrWillBeWeakMember<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