Refactor: Clear m_axObjectCache when AXObject detaches

Source/modules/accessibility/AXObject.cpp

 /*
  * Copyright (C) 2008, 2009, 2011 Apple 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 352 matching lines @@
 };
 
 
 HTMLDialogElement* getActiveDialogElement(Node* node)
 {
     return node->document().activeModalDialog();
 }
 
 } // namespace
 
-AXObject::AXObject(AXObjectCacheImpl* axObjectCache)
+AXObject::AXObject(AXObjectCacheImpl& axObjectCache)
     : m_id(0)
     , m_haveChildren(false)
     , m_role(UnknownRole)
     , m_lastKnownIsIgnoredValue(DefaultBehavior)
-    , m_detached(false)
     , m_parent(0)
     , m_lastModificationCount(-1)
     , m_cachedIsIgnored(false)
     , m_cachedIsInertOrAriaHidden(false)
     , m_cachedIsDescendantOfLeafNode(false)
     , m_cachedIsDescendantOfDisabledNode(false)
     , m_cachedHasInheritedPresentationalRole(false)
     , m_cachedIsPresentationalChild(false)
     , m_cachedLiveRegionRoot(0)
-    , m_axObjectCache(axObjectCache)
+    , m_axObjectCache(&axObjectCache)
 {
 }
 
 AXObject::~AXObject()
 {
     ASSERT(isDetached());
 }
 
 void AXObject::detach()
 {
     // Clear any children and call detachFromParent on them so that
     // no children are left with dangling pointers to their parent.
     clearChildren();
 
-    m_detached = true;
+    m_axObjectCache = nullptr;
 }
 
 bool AXObject::isDetached() const
 {
-    return m_detached;
+    return !m_axObjectCache;
 }
 
 bool AXObject::isARIATextControl() const
 {
     return ariaRoleAttribute() == TextFieldRole || ariaRoleAttribute() == SearchBoxRole;
 }
 
 bool AXObject::isButton() const
 {
     AccessibilityRole role = roleValue();
@@ skipping 69 matching lines @@
 }
 
 bool AXObject::accessibilityIsIgnored() const
 {
     updateCachedAttributeValuesIfNeeded();
     return m_cachedIsIgnored;
 }
 
 void AXObject::updateCachedAttributeValuesIfNeeded() const
 {
-    AXObjectCacheImpl* cache = axObjectCache();
-    if (!cache)
+    if (isDetached())
         return;
 
-    if (cache->modificationCount() == m_lastModificationCount)
+    AXObjectCacheImpl& cache = axObjectCache();
+
+    if (cache.modificationCount() == m_lastModificationCount)
         return;
 
-    m_lastModificationCount = cache->modificationCount();
+    m_lastModificationCount = cache.modificationCount();
     m_cachedIsInertOrAriaHidden = computeIsInertOrAriaHidden();
     m_cachedIsDescendantOfLeafNode = (leafNodeAncestor() != 0);
     m_cachedIsDescendantOfDisabledNode = (disabledAncestor() != 0);
     m_cachedHasInheritedPresentationalRole = (inheritsPresentationalRoleFrom() != 0);
     m_cachedIsPresentationalChild = (ancestorForWhichThisIsAPresentationalChild() != 0);
     m_cachedIsIgnored = computeAccessibilityIsIgnored();
     m_cachedLiveRegionRoot = isLiveRegion() ?
         this :
         (parentObjectIfExists() ? parentObjectIfExists()->liveRegionRoot() : 0);
 }
@@ skipping 36 matching lines @@
     return m_cachedIsInertOrAriaHidden;
 }
 
 bool AXObject::computeIsInertOrAriaHidden(IgnoredReasons* ignoredReasons) const
 {
     if (node()) {
         if (node()->isInert()) {
             if (ignoredReasons) {
                 HTMLDialogElement* dialog = getActiveDialogElement(node());
                 if (dialog) {
-                    AXObject* dialogObject = axObjectCache()->getOrCreate(dialog);
+                    AXObject* dialogObject = axObjectCache().getOrCreate(dialog);
                     if (dialogObject)
                         ignoredReasons->append(IgnoredReason(AXActiveModalDialog, dialogObject));
                     else
                         ignoredReasons->append(IgnoredReason(AXInert));
                 } else {
                     // TODO(aboxhall): handle inert attribute if it eventuates
                     ignoredReasons->append(IgnoredReason(AXInert));
                 }
             }
             return true;
@@ skipping 318 matching lines @@
     return result;
 }
 
 AXObject* AXObject::elementAccessibilityHitTest(const IntPoint& point) const
 {
     // Send the hit test back into the sub-frame if necessary.
     if (isAttachment()) {
         Widget* widget = widgetForAttachmentView();
         // Normalize the point for the widget's bounds.
         if (widget && widget->isFrameView())
-            return axObjectCache()->getOrCreate(widget)->accessibilityHitTest(IntPoint(point - widget->frameRect().location()));
+            return axObjectCache().getOrCreate(widget)->accessibilityHitTest(IntPoint(point - widget->frameRect().location()));
     }
 
     // Check if there are any mock elements that need to be handled.
     for (const auto& child : m_children) {
         if (child->isMockObject() && child->elementRect().contains(point))
             return child->elementAccessibilityHitTest(point);
     }
 
     return const_cast<AXObject*>(this);
 }
 
 const AXObject::AccessibilityChildrenVector& AXObject::children()
 {
     updateChildrenIfNecessary();
 
     return m_children;
 }
 
 AXObject* AXObject::parentObject() const
 {
-    if (m_detached)
+    if (isDetached())
         return 0;
 
     if (m_parent)
         return m_parent;
 
-    if (axObjectCache()->isAriaOwned(this))
-        return axObjectCache()->getAriaOwnedParent(this);
+    if (axObjectCache().isAriaOwned(this))
+        return axObjectCache().getAriaOwnedParent(this);
 
     return computeParent();
 }
 
 AXObject* AXObject::parentObjectIfExists() const
 {
-    if (m_detached)
+    if (isDetached())
         return 0;
 
     if (m_parent)
         return m_parent;
 
     return computeParentIfExists();
 }
 
 AXObject* AXObject::parentObjectUnignored() const
 {
@@ skipping 23 matching lines @@
 AXObject* AXObject::focusedUIElement() const
 {
     Document* doc = document();
     if (!doc)
         return 0;
 
     Page* page = doc->page();
     if (!page)
         return 0;
 
-    return axObjectCache()->focusedUIElementForPage(page);
+    return axObjectCache().focusedUIElementForPage(page);
 }
 
 Document* AXObject::document() const
 {
     FrameView* frameView = documentFrameView();
     if (!frameView)
         return 0;
 
     return frameView->frame().document();
 }
@@ skipping 318 matching lines @@
             offsetX = 0;
             offsetY = 0;
         }
     }
 }
 
 void AXObject::notifyIfIgnoredValueChanged()
 {
     bool isIgnored = accessibilityIsIgnored();
     if (lastKnownIsIgnoredValue() != isIgnored) {
-        axObjectCache()->childrenChanged(parentObject());
+        axObjectCache().childrenChanged(parentObject());
         setLastKnownIsIgnoredValue(isIgnored);
     }
 }
 
 void AXObject::selectionChanged()
 {
     if (AXObject* parent = parentObjectIfExists())
         parent->selectionChanged();
 }
 
@@ skipping 144 matching lines @@
 }
 
 const AtomicString& AXObject::internalRoleName(AccessibilityRole role)
 {
     static const Vector<AtomicString>* internalRoleNameVector = createInternalRoleNameVector();
 
     return internalRoleNameVector->at(role);
 }
 
 } // namespace blink