Oilpan: Prepare moving AXObject to heap

Source/modules/accessibility/AXNodeObject.cpp

 /*
 * Copyright (C) 2012, 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 52 matching lines @@
     : AXObject(axObjectCache)
     , m_ariaRole(UnknownRole)
     , m_childrenDirty(false)
 #if ENABLE(ASSERT)
     , m_initialized(false)
 #endif
     , m_node(node)
 {
 }
 
-PassRefPtr<AXNodeObject> AXNodeObject::create(Node* node, AXObjectCacheImpl& axObjectCache)
+PassRefPtrWillBeRawPtr<AXNodeObject> AXNodeObject::create(Node* node, AXObjectCacheImpl& axObjectCache)
 {
-    return adoptRef(new AXNodeObject(node, axObjectCache));
+    return adoptRefWillBeNoop(new AXNodeObject(node, axObjectCache));
 }
 
 AXNodeObject::~AXNodeObject()
 {
-    ASSERT(isDetached());
+    ASSERT(!m_node);
 }
 
 // This function implements the ARIA accessible name as described by the Mozilla
 // ARIA Implementer's Guide.
 static String accessibleNameForNode(Node* node)
 {
     if (!node)
         return String();
 
     if (node->isTextNode())
@@ skipping 657 matching lines @@
 {
 #if ENABLE(ASSERT)
     ASSERT(!m_initialized);
     m_initialized = true;
 #endif
     m_role = determineAccessibilityRole();
 }
 
 void AXNodeObject::detach()
 {
-    clearChildren();
     AXObject::detach();
-    m_node = 0;
+    m_node = nullptr;
 }
 
 bool AXNodeObject::isAnchor() const
 {
     return !isNativeImage() && isLink();
 }
 
 bool AXNodeObject::isControl() const
 {
     Node* node = this->node();
@@ skipping 999 matching lines @@
             return placeholder;
     }
 
     return String();
 }
 
 //
 // New AX name calculation.
 //
 
-String AXNodeObject::textAlternative(bool recursive, bool inAriaLabelledByTraversal, HashSet<AXObject*>& visited, AXNameFrom* nameFrom, Vector<AXObject*>* nameObjects)
+String AXNodeObject::textAlternative(bool recursive, bool inAriaLabelledByTraversal, WillBeHeapHashSet<RawPtrWillBeMember<AXObject>>& visited, AXNameFrom* nameFrom, WillBeHeapVector<RawPtrWillBeMember<AXObject>>* nameObjects)
 {
     bool alreadyVisited = visited.contains(this);
     visited.add(this);
 
     if (!node() && !layoutObject())
         return String();
 
     // Step 2A from: http://www.w3.org/TR/accname-aam-1.1
     if (!recursive && layoutObject()
         && layoutObject()->style()->visibility() != VISIBLE
         && !equalIgnoringCase(getAttribute(aria_hiddenAttr), "false")) {
         return String();
     }
 
     // Step 2B from: http://www.w3.org/TR/accname-aam-1.1
     if (!inAriaLabelledByTraversal && hasAttribute(aria_labelledbyAttr) && !alreadyVisited) {
         if (nameFrom)
             *nameFrom = AXNameFromRelatedElement;
         WillBeHeapVector<RawPtrWillBeMember<Element>> elements;
         ariaLabeledByElements(elements);
         StringBuilder accumulatedText;
         for (const auto& element : elements) {
-            RefPtr<AXObject> axElement = axObjectCache().getOrCreate(element);
+            RefPtrWillBeRawPtr<AXObject> axElement = axObjectCache().getOrCreate(element);
             if (axElement) {
                 if (nameObjects)
                     nameObjects->append(axElement.get());
                 String result = axElement->textAlternative(true, true, visited, nullptr, nullptr);
                 if (!result.isEmpty()) {
                     if (!accumulatedText.isEmpty())
                         accumulatedText.append(" ");
                     accumulatedText.append(result);
                 }
             }
@@ skipping 535 matching lines @@
 }
 
 void AXNodeObject::ariaLabeledByText(WillBeHeapVector<OwnPtrWillBeMember<AccessibilityText>>& textOrder) const
 {
     String ariaLabeledBy = ariaLabeledByAttribute();
     if (!ariaLabeledBy.isEmpty()) {
         WillBeHeapVector<RawPtrWillBeMember<Element>> elements;
         ariaLabeledByElements(elements);
 
         for (const auto& element : elements) {
-            RefPtr<AXObject> axElement = axObjectCache().getOrCreate(element);
+            RefPtrWillBeRawPtr<AXObject> axElement = axObjectCache().getOrCreate(element);
             textOrder.append(AccessibilityText::create(ariaLabeledBy, AlternativeText, axElement));
         }
     }
 }
 
+DEFINE_TRACE(AXNodeObject)
+{
+    visitor->trace(m_node);
+    AXObject::trace(visitor);
+}
+
 } // namespace blink