Refactor: Clear m_axObjectCache when AXObject detaches

Source/modules/accessibility/AXTable.cpp

 /*
  * Copyright (C) 2008 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 30 matching lines @@
 #include "core/layout/LayoutTableCell.h"
 #include "modules/accessibility/AXObjectCacheImpl.h"
 #include "modules/accessibility/AXTableCell.h"
 #include "modules/accessibility/AXTableColumn.h"
 #include "modules/accessibility/AXTableRow.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
-AXTable::AXTable(LayoutObject* layoutObject, AXObjectCacheImpl* axObjectCache)
+AXTable::AXTable(LayoutObject* layoutObject, AXObjectCacheImpl& axObjectCache)
     : AXLayoutObject(layoutObject, axObjectCache)
     , m_headerContainer(nullptr)
     , m_isAXTable(true)
 {
 }
 
 AXTable::~AXTable()
 {
 }
 
 void AXTable::init()
 {
     AXLayoutObject::init();
     m_isAXTable = isTableExposableThroughAccessibility();
 }
 
-PassRefPtr<AXTable> AXTable::create(LayoutObject* layoutObject, AXObjectCacheImpl* axObjectCache)
+PassRefPtr<AXTable> AXTable::create(LayoutObject* layoutObject, AXObjectCacheImpl& axObjectCache)
 {
     return adoptRef(new AXTable(layoutObject, axObjectCache));
 }
 
 bool AXTable::hasARIARole() const
 {
     if (!m_layoutObject)
         return false;
 
     AccessibilityRole ariaRole = ariaRoleAttribute();
@@ skipping 285 matching lines @@
         return;
     }
 
     ASSERT(!m_haveChildren);
 
     m_haveChildren = true;
     if (!m_layoutObject || !m_layoutObject->isTable())
         return;
 
     LayoutTable* table = toLayoutTable(m_layoutObject);
-    AXObjectCacheImpl* axCache = axObjectCache();
+    AXObjectCacheImpl& axCache = axObjectCache();
 
     Node* tableNode = table->node();
     if (!isHTMLTableElement(tableNode))
         return;
 
     // Add caption
     if (HTMLTableCaptionElement* caption  = toHTMLTableElement(tableNode)->caption()) {
-        AXObject* captionObject = axCache->getOrCreate(caption);
+        AXObject* captionObject = axCache.getOrCreate(caption);
         if (captionObject && !captionObject->accessibilityIsIgnored())
             m_children.append(captionObject);
     }
 
     // Go through all the available sections to pull out the rows and add them as children.
     table->recalcSectionsIfNeeded();
     LayoutTableSection* tableSection = table->topSection();
     if (!tableSection)
         return;
 
     LayoutTableSection* initialTableSection = tableSection;
     while (tableSection) {
 
         HashSet<AXObject*> appendedRows;
         unsigned numRows = tableSection->numRows();
         for (unsigned rowIndex = 0; rowIndex < numRows; ++rowIndex) {
 
             LayoutTableRow* layoutRow = tableSection->rowLayoutObjectAt(rowIndex);
             if (!layoutRow)
                 continue;
 
-            AXObject* rowObject = axCache->getOrCreate(layoutRow);
+            AXObject* rowObject = axCache.getOrCreate(layoutRow);
             if (!rowObject || !rowObject->isTableRow())
                 continue;
 
             AXTableRow* row = toAXTableRow(rowObject);
             // We need to check every cell for a new row, because cell spans
             // can cause us to miss rows if we just check the first column.
             if (appendedRows.contains(row))
                 continue;
 
             row->setRowIndex(static_cast<int>(m_rows.size()));
             m_rows.append(row);
             if (!row->accessibilityIsIgnored())
                 m_children.append(row);
             appendedRows.add(row);
         }
 
         tableSection = table->sectionBelow(tableSection, SkipEmptySections);
     }
 
     // make the columns based on the number of columns in the first body
     unsigned length = initialTableSection->numColumns();
     for (unsigned i = 0; i < length; ++i) {
-        AXTableColumn* column = toAXTableColumn(axCache->getOrCreate(ColumnRole));
+        AXTableColumn* column = toAXTableColumn(axCache.getOrCreate(ColumnRole));
         column->setColumnIndex((int)i);
         column->setParent(this);
         m_columns.append(column);
         if (!column->accessibilityIsIgnored())
             m_children.append(column);
     }
 
     AXObject* headerContainerObject = headerContainer();
     if (headerContainerObject && !headerContainerObject->accessibilityIsIgnored())
         m_children.append(headerContainerObject);
 }
 
 AXObject* AXTable::headerContainer()
 {
     if (m_headerContainer)
         return m_headerContainer.get();
 
-    AXMockObject* tableHeader = toAXMockObject(axObjectCache()->getOrCreate(TableHeaderContainerRole));
+    AXMockObject* tableHeader = toAXMockObject(axObjectCache().getOrCreate(TableHeaderContainerRole));
     tableHeader->setParent(this);
 
     m_headerContainer = tableHeader;
     return m_headerContainer.get();
 }
 
 const AXObject::AccessibilityChildrenVector& AXTable::columns()
 {
     updateChildrenIfNecessary();
 
@@ skipping 130 matching lines @@
     }
 
     // try the standard
     if (title.isEmpty())
         title = AXLayoutObject::deprecatedTitle(mode);
 
     return title;
 }
 
 } // namespace blink