Refactor: Clear m_axObjectCache when AXObject detaches

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 41 matching lines @@
 #include "core/layout/LayoutObject.h"
 #include "modules/accessibility/AXObjectCacheImpl.h"
 #include "platform/UserGestureIndicator.h"
 #include "wtf/text/StringBuilder.h"
 
 
 namespace blink {
 
 using namespace HTMLNames;
 
-AXNodeObject::AXNodeObject(Node* node, AXObjectCacheImpl* axObjectCache)
+AXNodeObject::AXNodeObject(Node* node, AXObjectCacheImpl& axObjectCache)
     : 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)
+PassRefPtr<AXNodeObject> AXNodeObject::create(Node* node, AXObjectCacheImpl& axObjectCache)
 {
     return adoptRef(new AXNodeObject(node, axObjectCache));
 }
 
 AXNodeObject::~AXNodeObject()
 {
     ASSERT(isDetached());
 }
 
 // This function implements the ARIA accessible name as described by the Mozilla
@@ skipping 43 matching lines @@
 {
     if (roleValue() != SliderRole)
         return;
 
     float value = valueForRange();
     float step = stepValueForRange();
 
     value += increase ? step : -step;
 
     setValue(String::number(value));
-    axObjectCache()->postNotification(node(), AXObjectCacheImpl::AXValueChanged);
+    axObjectCache().postNotification(node(), AXObjectCacheImpl::AXValueChanged);
 }
 
 String AXNodeObject::ariaAccessibilityDescription() const
 {
     String ariaLabeledBy = ariaLabeledByAttribute();
     if (!ariaLabeledBy.isEmpty())
         return ariaLabeledBy;
 
     const AtomicString& ariaLabel = getAttribute(aria_labelAttr);
     if (!ariaLabel.isEmpty())
@@ skipping 24 matching lines @@
             ignoredReasons->append(IgnoredReason(AXAncestorIsLeafNode, leafNodeAncestor()));
         return true;
     }
 
     // Ignore labels that are already referenced by a control's title UI element.
     AXObject* controlObject = correspondingControlForLabelElement();
     if (controlObject && !controlObject->deprecatedExposesTitleUIElement() && controlObject->isCheckboxOrRadio()) {
         if (ignoredReasons) {
             HTMLLabelElement* label = labelElementContainer();
             if (label && !label->isSameNode(node())) {
-                AXObject* labelAXObject = axObjectCache()->getOrCreate(label);
+                AXObject* labelAXObject = axObjectCache().getOrCreate(label);
                 ignoredReasons->append(IgnoredReason(AXLabelContainer, labelAXObject));
             }
 
             ignoredReasons->append(IgnoredReason(AXLabelFor, controlObject));
         }
         return true;
     }
 
     Element* element = node()->isElementNode() ? toElement(node()) : node()->parentElement();
     if (!layoutObject()
@@ skipping 375 matching lines @@
         if (Element* idElement = scope.getElementById(AtomicString(id)))
             elements.append(idElement);
     }
 }
 
 void AXNodeObject::accessibilityChildrenFromAttribute(QualifiedName attr, AccessibilityChildrenVector& children) const
 {
     WillBeHeapVector<RawPtrWillBeMember<Element>> elements;
     elementsFromAttribute(elements, attr);
 
-    AXObjectCacheImpl* cache = axObjectCache();
+    AXObjectCacheImpl& cache = axObjectCache();
     for (const auto& element : elements) {
-        if (AXObject* child = cache->getOrCreate(element))
+        if (AXObject* child = cache.getOrCreate(element))
             children.append(child);
     }
 }
 
 // This only returns true if this is the element that actually has the
 // contentEditable attribute set, unlike node->hasEditableStyle() which will
 // also return true if an ancestor is editable.
 bool AXNodeObject::hasContentEditableAttributeSet() const
 {
     if (!hasAttribute(contenteditableAttr))
@@ skipping 66 matching lines @@
 
     return Traversal<HTMLLabelElement>::firstAncestor(*element);
 }
 
 AXObject* AXNodeObject::menuButtonForMenu() const
 {
     Element* menuItem = menuItemElementForMenu();
 
     if (menuItem) {
         // ARIA just has generic menu items. AppKit needs to know if this is a top level items like MenuBarButton or MenuBarItem
-        AXObject* menuItemAX = axObjectCache()->getOrCreate(menuItem);
+        AXObject* menuItemAX = axObjectCache().getOrCreate(menuItem);
         if (menuItemAX && menuItemAX->isMenuButton())
             return menuItemAX;
     }
     return 0;
 }
 
 static Element* siblingWithAriaRole(String role, Node* node)
 {
     Node* parent = node->parentNode();
     if (!parent)
@@ skipping 594 matching lines @@
 
     return toElement(node)->innerText();
 }
 
 AXObject* AXNodeObject::deprecatedTitleUIElement() const
 {
     if (!node() || !node()->isElementNode())
         return 0;
 
     if (isFieldset())
-        return axObjectCache()->getOrCreate(toHTMLFieldSetElement(node())->legend());
+        return axObjectCache().getOrCreate(toHTMLFieldSetElement(node())->legend());
 
     HTMLLabelElement* label = labelForElement(toElement(node()));
     if (label)
-        return axObjectCache()->getOrCreate(label);
+        return axObjectCache().getOrCreate(label);
 
     return 0;
 }
 
 AccessibilityButtonState AXNodeObject::checkboxOrRadioValue() const
 {
     if (isNativeCheckboxOrRadio())
         return isChecked() ? ButtonStateOn : ButtonStateOff;
 
     return AXObject::checkboxOrRadioValue();
@@ skipping 455 matching lines @@
                 return summary;
 
             // The title attribute should be used as help text unless it is already being used as descriptive text.
             const AtomicString& title = toElement(curr)->getAttribute(titleAttr);
             if (!title.isEmpty() && description != title)
                 return title;
         }
 
         // Only take help text from an ancestor element if its a group or an unknown role. If help was
         // added to those kinds of elements, it is likely it was meant for a child element.
-        AXObject* axObj = axObjectCache()->getOrCreate(curr);
+        AXObject* axObj = axObjectCache().getOrCreate(curr);
         if (axObj) {
             AccessibilityRole role = axObj->roleValue();
             if (role != GroupRole && role != UnknownRole)
                 break;
         }
     }
 
     return String();
 }
 
@@ skipping 49 matching lines @@
     }
 
     // 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);
+            RefPtr<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 52 matching lines @@
     if (!m_explicitElementRect.isEmpty())
         return m_explicitElementRect;
 
     // FIXME: If there are a lot of elements in the canvas, it will be inefficient.
     // We can avoid the inefficient calculations by using AXComputedObjectAttributeCache.
     if (node()->parentElement()->isInCanvasSubtree()) {
         LayoutRect rect;
 
         for (Node& child : NodeTraversal::childrenOf(*node())) {
             if (child.isHTMLElement()) {
-                if (AXObject* obj = axObjectCache()->get(&child)) {
+                if (AXObject* obj = axObjectCache().get(&child)) {
                     if (rect.isEmpty())
                         rect = obj->elementRect();
                     else
                         rect.unite(obj->elementRect());
                 }
             }
         }
 
         if (!rect.isEmpty())
             return rect;
@@ skipping 30 matching lines @@
 
     if (!parentNode)
         parentNode = node->parentNode();
 
     return parentNode;
 }
 
 AXObject* AXNodeObject::computeParent() const
 {
     if (Node* parentNode = getParentNodeForComputeParent(node()))
-        return axObjectCache()->getOrCreate(parentNode);
+        return axObjectCache().getOrCreate(parentNode);
 
     return nullptr;
 }
 
 AXObject* AXNodeObject::computeParentIfExists() const
 {
     if (Node* parentNode = getParentNodeForComputeParent(node()))
-        return axObjectCache()->get(parentNode);
+        return axObjectCache().get(parentNode);
 
     return nullptr;
 }
 
 AXObject* AXNodeObject::firstChild() const
 {
     if (!node())
         return 0;
 
     Node* firstChild = node()->firstChild();
 
     if (!firstChild)
         return 0;
 
-    return axObjectCache()->getOrCreate(firstChild);
+    return axObjectCache().getOrCreate(firstChild);
 }
 
 AXObject* AXNodeObject::nextSibling() const
 {
     if (!node())
         return 0;
 
     Node* nextSibling = node()->nextSibling();
     if (!nextSibling)
         return 0;
 
-    return axObjectCache()->getOrCreate(nextSibling);
+    return axObjectCache().getOrCreate(nextSibling);
 }
 
 void AXNodeObject::addChildren()
 {
     // If the need to add more children in addition to existing children arises,
     // childrenChanged should have been called, leaving the object with no children.
     ASSERT(!m_haveChildren);
 
     if (!m_node)
         return;
 
     m_haveChildren = true;
 
     // The only time we add children from the DOM tree to a node with a layoutObject is when it's a canvas.
     if (layoutObject() && !isHTMLCanvasElement(*m_node))
         return;
 
     Vector<AXObject*> ownedChildren;
     computeAriaOwnsChildren(ownedChildren);
 
     for (Node& child : NodeTraversal::childrenOf(*m_node)) {
-        AXObject* childObj = axObjectCache()->getOrCreate(&child);
-        if (!axObjectCache()->isAriaOwned(childObj))
+        AXObject* childObj = axObjectCache().getOrCreate(&child);
+        if (!axObjectCache().isAriaOwned(childObj))
             addChild(childObj);
     }
 
     for (const auto& ownedChild : ownedChildren)
         addChild(ownedChild);
 
     for (const auto& child : m_children)
         child->setParent(this);
 }
 
@@ skipping 38 matching lines @@
     case PopUpButtonRole:
     case CheckBoxRole:
     case RadioButtonRole:
     case SwitchRole:
     case TabRole:
     case ToggleButtonRole:
     case ListBoxOptionRole:
     case ScrollBarRole:
         return false;
     case StaticTextRole:
-        if (!axObjectCache()->inlineTextBoxAccessibilityEnabled())
+        if (!axObjectCache().inlineTextBoxAccessibilityEnabled())
             return false;
     default:
         return true;
     }
 }
 
 Element* AXNodeObject::actionElement() const
 {
     Node* node = this->node();
     if (!node)
@@ skipping 36 matching lines @@
         elt = mouseButtonListener();
     return elt;
 }
 
 Element* AXNodeObject::anchorElement() const
 {
     Node* node = this->node();
     if (!node)
         return 0;
 
-    AXObjectCacheImpl* cache = axObjectCache();
+    AXObjectCacheImpl& cache = axObjectCache();
 
     // search up the DOM tree for an anchor element
     // NOTE: this assumes that any non-image with an anchor is an HTMLAnchorElement
     for ( ; node; node = node->parentNode()) {
-        if (isHTMLAnchorElement(*node) || (node->layoutObject() && cache->getOrCreate(node->layoutObject())->isAnchor()))
+        if (isHTMLAnchorElement(*node) || (node->layoutObject() && cache.getOrCreate(node->layoutObject())->isAnchor()))
             return toElement(node);
     }
 
     return 0;
 }
 
 Document* AXNodeObject::document() const
 {
     if (!node())
         return 0;
@@ skipping 13 matching lines @@
 
     HTMLElement* correspondingControl = labelElement->control();
     if (!correspondingControl)
         return 0;
 
     // Make sure the corresponding control isn't a descendant of this label
     // that's in the middle of being destroyed.
     if (correspondingControl->layoutObject() && !correspondingControl->layoutObject()->parent())
         return 0;
 
-    return axObjectCache()->getOrCreate(correspondingControl);
+    return axObjectCache().getOrCreate(correspondingControl);
 }
 
 HTMLLabelElement* AXNodeObject::labelElementContainer() const
 {
     if (!node())
         return 0;
 
     // the control element should not be considered part of the label
     if (isControl())
         return 0;
@@ skipping 49 matching lines @@
         return;
 
     // If this is not part of the accessibility tree because an ancestor
     // has only presentational children, invalidate this object's children but
     // skip sending a notification and skip walking up the ancestors.
     if (ancestorForWhichThisIsAPresentationalChild()) {
         setNeedsToUpdateChildren();
         return;
     }
 
-    axObjectCache()->postNotification(this, AXObjectCacheImpl::AXChildrenChanged);
+    axObjectCache().postNotification(this, AXObjectCacheImpl::AXChildrenChanged);
 
     // Go up the accessibility parent chain, but only if the element already exists. This method is
     // called during layout, minimal work should be done.
     // If AX elements are created now, they could interrogate the layout tree while it's in a funky state.
     // At the same time, process ARIA live region changes.
     for (AXObject* parent = this; parent; parent = parent->parentObjectIfExists()) {
         parent->setNeedsToUpdateChildren();
 
         // These notifications always need to be sent because screenreaders are reliant on them to perform.
         // In other words, they need to be sent even when the screen reader has not accessed this live region since the last update.
 
         // If this element supports ARIA live regions, then notify the AT of changes.
         if (parent->isLiveRegion())
-            axObjectCache()->postNotification(parent, AXObjectCacheImpl::AXLiveRegionChanged);
+            axObjectCache().postNotification(parent, AXObjectCacheImpl::AXLiveRegionChanged);
 
         // If this element is an ARIA text box or content editable, post a "value changed" notification on it
         // so that it behaves just like a native input element or textarea.
         if (isNonNativeTextControl())
-            axObjectCache()->postNotification(parent, AXObjectCacheImpl::AXValueChanged);
+            axObjectCache().postNotification(parent, AXObjectCacheImpl::AXValueChanged);
     }
 }
 
 void AXNodeObject::selectionChanged()
 {
     // Post the selected text changed event on the first ancestor that's
     // focused (to handle form controls, ARIA text boxes and contentEditable),
     // or the web area if the selection is just in the document somewhere.
     if (isFocused() || isWebArea())
-        axObjectCache()->postNotification(this, AXObjectCacheImpl::AXSelectedTextChanged);
+        axObjectCache().postNotification(this, AXObjectCacheImpl::AXSelectedTextChanged);
     else
         AXObject::selectionChanged(); // Calls selectionChanged on parent.
 }
 
 void AXNodeObject::textChanged()
 {
     // If this element supports ARIA live regions, or is part of a region with an ARIA editable role,
     // then notify the AT of changes.
-    AXObjectCacheImpl* cache = axObjectCache();
+    AXObjectCacheImpl& cache = axObjectCache();
     for (Node* parentNode = node(); parentNode; parentNode = parentNode->parentNode()) {
-        AXObject* parent = cache->get(parentNode);
+        AXObject* parent = cache.get(parentNode);
         if (!parent)
             continue;
 
         if (parent->isLiveRegion())
-            cache->postNotification(parentNode, AXObjectCacheImpl::AXLiveRegionChanged);
+            cache.postNotification(parentNode, AXObjectCacheImpl::AXLiveRegionChanged);
 
         // If this element is an ARIA text box or content editable, post a "value changed" notification on it
         // so that it behaves just like a native input element or textarea.
         if (parent->isNonNativeTextControl())
-            cache->postNotification(parentNode, AXObjectCacheImpl::AXValueChanged);
+            cache.postNotification(parentNode, AXObjectCacheImpl::AXValueChanged);
     }
 }
 
 void AXNodeObject::updateAccessibilityRole()
 {
     bool ignoredStatus = accessibilityIsIgnored();
     m_role = determineAccessibilityRole();
 
     // The AX hierarchy only needs to be updated if the ignored status of an element has changed.
     if (ignoredStatus != accessibilityIsIgnored())
         childrenChanged();
 }
 
 void AXNodeObject::computeAriaOwnsChildren(Vector<AXObject*>& ownedChildren)
 {
     if (!hasAttribute(aria_ownsAttr))
         return;
 
     Vector<String> idVector;
     tokenVectorFromAttribute(idVector, aria_ownsAttr);
 
-    axObjectCache()->updateAriaOwns(this, idVector, ownedChildren);
+    axObjectCache().updateAriaOwns(this, idVector, ownedChildren);
 }
 
 String AXNodeObject::alternativeTextForWebArea() const
 {
     // The WebArea description should follow this order:
     //     aria-label on the <html>
     //     title on the <html>
     //     <title> inside the <head> (of it was set through JS)
     //     name on the <html>
     // For iframes:
@@ skipping 56 matching lines @@
 }
 
 void AXNodeObject::ariaLabeledByText(Vector<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);
+            RefPtr<AXObject> axElement = axObjectCache().getOrCreate(element);
             textOrder.append(AccessibilityText(ariaLabeledBy, AlternativeText, axElement));
         }
     }
 }
 
 } // namespace blink