Revert of Don't keep recreating AXMenuListPopup

Source/modules/accessibility/AXMenuListPopup.cpp

 /*
  * Copyright (C) 2010 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 53 matching lines @@
 {
     return accessibilityIsIgnoredByDefault();
 }
 
 AXMenuListOption* AXMenuListPopup::menuListOptionAXObject(HTMLElement* element) const
 {
     ASSERT(element);
     if (!isHTMLOptionElement(*element))
         return 0;
 
-    AXObject* object = axObjectCache()->getOrCreate(element);
-    if (!object)
-        return 0;
+    AXObject* object = axObjectCache()->getOrCreate(MenuListOptionRole);
+    ASSERT_WITH_SECURITY_IMPLICATION(object->isMenuListOption());
 
-    ASSERT_WITH_SECURITY_IMPLICATION(object->isMenuListOption());
-    return toAXMenuListOption(object);
+    AXMenuListOption* option = toAXMenuListOption(object);
+    option->setElement(element);
+
+    return option;
 }
 
 int AXMenuListPopup::getSelectedIndex() const
 {
-    if (!m_parent)
-        return -1;
-
     Node* selectNode = m_parent->node();
     if (!selectNode)
         return -1;
 
     HTMLSelectElement* htmlSelectElement = toHTMLSelectElement(selectNode);
     return htmlSelectElement->selectedIndex();
 }
 
 bool AXMenuListPopup::press() const
 {
     if (!m_parent)
         return false;
 
     m_parent->press();
     return true;
 }
 
 void AXMenuListPopup::addChildren()
 {
     if (!m_parent)
         return;
 
     Node* selectNode = m_parent->node();
     if (!selectNode)
         return;
 
     HTMLSelectElement* htmlSelectElement = toHTMLSelectElement(selectNode);
     m_haveChildren = true;
 
-    if (m_activeIndex == -1)
-        m_activeIndex = getSelectedIndex();
-
+    m_activeIndex = getSelectedIndex();
     const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& listItems = htmlSelectElement->listItems();
     unsigned length = listItems.size();
     for (unsigned i = 0; i < length; i++) {
         AXMenuListOption* option = menuListOptionAXObject(listItems[i]);
         if (option) {
             option->setParent(this);
             m_children.append(option);
         }
     }
 }
 
-void AXMenuListPopup::updateChildrenIfNecessary()
+void AXMenuListPopup::childrenChanged()
 {
-    if (m_haveChildren && m_parent && m_parent->needsToUpdateChildren())
-        clearChildren();
+    AXObjectCacheImpl* cache = axObjectCache();
+    if (!cache)
+        return;
+    for (size_t i = m_children.size(); i > 0 ; --i) {
+        AXObject* child = m_children[i - 1].get();
+        // FIXME: How could children end up in here that have no actionElement(), the check
+        // in menuListOptionAXObject would seem to prevent that.
+        if (child->actionElement()) {
+            child->detachFromParent();
+            cache->remove(child->axObjectID());
+        }
+    }
 
-    if (!m_haveChildren)
-        addChildren();
+    m_children.clear();
+    m_haveChildren = false;
 }
 
 void AXMenuListPopup::didUpdateActiveOption(int optionIndex)
 {
-    updateChildrenIfNecessary();
+    // We defer creation of the children until updating the active option so that we don't
+    // create AXObjects for <option> elements while they're in the middle of removal.
+    if (!m_haveChildren)
+        addChildren();
+
+    ASSERT_ARG(optionIndex, optionIndex >= 0);
+    ASSERT_ARG(optionIndex, optionIndex < static_cast<int>(m_children.size()));
 
     AXObjectCacheImpl* cache = axObjectCache();
     if (m_activeIndex != optionIndex && m_activeIndex >= 0 && m_activeIndex < static_cast<int>(m_children.size())) {
         RefPtr<AXObject> previousChild = m_children[m_activeIndex].get();
         cache->postNotification(previousChild.get(), AXObjectCacheImpl::AXMenuListItemUnselected);
     }
 
-    if (optionIndex >= 0 && optionIndex < static_cast<int>(m_children.size())) {
-        RefPtr<AXObject> child = m_children[optionIndex].get();
-        cache->postNotification(child.get(), AXObjectCacheImpl::AXFocusedUIElementChanged);
-        cache->postNotification(child.get(), AXObjectCacheImpl::AXMenuListItemSelected);
-    }
-
+    RefPtr<AXObject> child = m_children[optionIndex].get();
+    cache->postNotification(child.get(), AXObjectCacheImpl::AXFocusedUIElementChanged);
+    cache->postNotification(child.get(), AXObjectCacheImpl::AXMenuListItemSelected);
     m_activeIndex = optionIndex;
 }
 
 void AXMenuListPopup::didHide()
 {
     AXObjectCacheImpl* cache = axObjectCache();
     cache->postNotification(this, AXObjectCacheImpl::AXHide);
     if (activeChild())
         cache->postNotification(activeChild(), AXObjectCacheImpl::AXMenuListItemUnselected);
 }
@@ skipping 14 matching lines @@
 
 AXObject* AXMenuListPopup::activeChild()
 {
     if (m_activeIndex < 0 || m_activeIndex >= static_cast<int>(children().size()))
         return nullptr;
 
     return m_children[m_activeIndex].get();
 }
 
 } // namespace blink