Get rid of postToElement argument for accessibility notifications.

Source/modules/accessibility/AXObjectCacheImpl.cpp

 /*
  * Copyright (C) 2014, 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 629 matching lines @@
     textChanged(getOrCreate(layoutObject));
 }
 
 void AXObjectCacheImpl::textChanged(AXObject* obj)
 {
     if (!obj)
         return;
 
     bool parentAlreadyExists = obj->parentObjectIfExists();
     obj->textChanged();
-    postNotification(obj, AXObjectCacheImpl::AXTextChanged, true);
+    postNotification(obj, AXObjectCacheImpl::AXTextChanged);
     if (parentAlreadyExists)
         obj->notifyIfIgnoredValueChanged();
 }
 
 void AXObjectCacheImpl::updateCacheAfterNodeIsAttached(Node* node)
 {
     // Calling get() will update the AX object if we had an AXNodeObject but now we need
     // an AXLayoutObject, because it was reparented to a location outside of a canvas.
     get(node);
 }
@@ skipping 45 matching lines @@
         AXNotification notification = m_notificationsToPost[i].second;
         postPlatformNotification(obj, notification);
 
         if (notification == AXChildrenChanged && obj->parentObjectIfExists() && obj->lastKnownIsIgnoredValue() != obj->accessibilityIsIgnored())
             childrenChanged(obj->parentObject());
     }
 
     m_notificationsToPost.clear();
 }
 
-void AXObjectCacheImpl::postNotification(LayoutObject* layoutObject, AXNotification notification, bool postToElement)
+void AXObjectCacheImpl::postNotification(LayoutObject* layoutObject, AXNotification notification)
 {
     if (!layoutObject)
         return;
 
     m_modificationCount++;
-    postNotification(get(layoutObject), notification, postToElement);
+    postNotification(get(layoutObject), notification);
 }
 
-void AXObjectCacheImpl::postNotification(Node* node, AXNotification notification, bool postToElement)
+void AXObjectCacheImpl::postNotification(Node* node, AXNotification notification)
 {
     if (!node)
         return;
 
     m_modificationCount++;
-    postNotification(get(node), notification, postToElement);
+    postNotification(get(node), notification);
 }
 
-void AXObjectCacheImpl::postNotification(AXObject* object, AXNotification notification, bool postToElement)
+void AXObjectCacheImpl::postNotification(AXObject* object, AXNotification notification)
 {
     m_modificationCount++;
-
-    if (object && !postToElement)
-        object = object->observableObject();
-
     if (!object)
         return;
 
     m_notificationsToPost.append(std::make_pair(object, notification));
     if (!m_notificationPostTimer.isActive())
         m_notificationPostTimer.startOneShot(0, FROM_HERE);
 }
 
 void AXObjectCacheImpl::checkedStateChanged(Node* node)
 {
-    postNotification(node, AXObjectCacheImpl::AXCheckedStateChanged, true);
+    postNotification(node, AXObjectCacheImpl::AXCheckedStateChanged);
 }
 
 void AXObjectCacheImpl::selectedChildrenChanged(Node* node)
 {
-    // postToElement is false so that you can pass in any child of an element and it will go up the parent tree
-    // to find the container which should send out the notification.
-    postNotification(node, AXSelectedChildrenChanged, false);
+    selectedChildrenChanged(get(node));
 }
 
 void AXObjectCacheImpl::selectedChildrenChanged(LayoutObject* layoutObject)
 {
-    // postToElement is false so that you can pass in any child of an element and it will go up the parent tree
-    // to find the container which should send out the notification.
-    postNotification(layoutObject, AXSelectedChildrenChanged, false);
+    selectedChildrenChanged(get(layoutObject));
+}
+
+void AXObjectCacheImpl::selectedChildrenChanged(AXObject* obj)
+{
+    while (obj && obj->roleValue() != ListBoxRole)
+        obj = obj->parentObject();
+    postNotification(obj, AXSelectedChildrenChanged);
 }
 
 void AXObjectCacheImpl::handleScrollbarUpdate(FrameView* view)
 {
     if (!view)
         return;
 
     // We don't want to create a scroll view from this method, only update an existing one.
     if (AXObject* scrollViewObject = get(view)) {
         m_modificationCount++;
         scrollViewObject->updateChildrenIfNecessary();
     }
 }
 
 void AXObjectCacheImpl::handleLayoutComplete(LayoutObject* layoutObject)
 {
     if (!layoutObject)
         return;
 
     m_modificationCount++;
 
     // Create the AXObject if it didn't yet exist - that's always safe at the end of a layout, and it
     // allows an AX notification to be sent when a page has its first layout, rather than when the
     // document first loads.
     if (AXObject* obj = getOrCreate(layoutObject))
-        postNotification(obj, AXLayoutComplete, true);
+        postNotification(obj, AXLayoutComplete);
 }
 
 void AXObjectCacheImpl::handleAriaExpandedChange(Node* node)
 {
     if (AXObject* obj = getOrCreate(node))
         obj->handleAriaExpandedChanged();
 }
 
 void AXObjectCacheImpl::handleActiveDescendantChanged(Node* node)
 {
@@ skipping 18 matching lines @@
         textChanged(element);
     else if (attrName == forAttr && isHTMLLabelElement(*element))
         labelChanged(element);
 
     if (!attrName.localName().startsWith("aria-"))
         return;
 
     if (attrName == aria_activedescendantAttr)
         handleActiveDescendantChanged(element);
     else if (attrName == aria_valuenowAttr || attrName == aria_valuetextAttr)
-        postNotification(element, AXObjectCacheImpl::AXValueChanged, true);
+        postNotification(element, AXObjectCacheImpl::AXValueChanged);
     else if (attrName == aria_labelAttr || attrName == aria_labeledbyAttr || attrName == aria_labelledbyAttr)
         textChanged(element);
     else if (attrName == aria_checkedAttr)
         checkedStateChanged(element);
     else if (attrName == aria_selectedAttr)
         selectedChildrenChanged(element);
     else if (attrName == aria_expandedAttr)
         handleAriaExpandedChange(element);
     else if (attrName == aria_hiddenAttr)
         childrenChanged(element->parentNode());
     else if (attrName == aria_invalidAttr)
-        postNotification(element, AXObjectCacheImpl::AXInvalidStatusChanged, true);
+        postNotification(element, AXObjectCacheImpl::AXInvalidStatusChanged);
     else
-        postNotification(element, AXObjectCacheImpl::AXAriaAttributeChanged, true);
+        postNotification(element, AXObjectCacheImpl::AXAriaAttributeChanged);
 }
 
 void AXObjectCacheImpl::labelChanged(Element* element)
 {
     textChanged(toHTMLLabelElement(element)->control());
 }
 
 void AXObjectCacheImpl::recomputeIsIgnored(LayoutObject* layoutObject)
 {
     if (AXObject* obj = get(layoutObject))
         obj->notifyIfIgnoredValueChanged();
 }
 
 void AXObjectCacheImpl::inlineTextBoxesUpdated(LayoutObject* layoutObject)
 {
     if (!inlineTextBoxAccessibilityEnabled())
         return;
 
     // Only update if the accessibility object already exists and it's
     // not already marked as dirty.
     if (AXObject* obj = get(layoutObject)) {
         if (!obj->needsToUpdateChildren()) {
             obj->setNeedsToUpdateChildren();
-            postNotification(layoutObject, AXChildrenChanged, true);
+            postNotification(layoutObject, AXChildrenChanged);
         }
     }
 }
 
 Settings* AXObjectCacheImpl::settings()
 {
     return m_document.settings();
 }
 
 bool AXObjectCacheImpl::accessibilityEnabled()
@@ skipping 106 matching lines @@
 
     AXObject* focusedObject = focusedUIElementForPage(page);
     if (!focusedObject)
         return;
 
     postPlatformNotification(focusedObject, AXFocusedUIElementChanged);
 }
 
 void AXObjectCacheImpl::handleInitialFocus()
 {
-    postNotification(&m_document, AXObjectCache::AXFocusedUIElementChanged, true);
+    postNotification(&m_document, AXObjectCache::AXFocusedUIElementChanged);
 }
 
 void AXObjectCacheImpl::handleEditableTextContentChanged(Node* node)
 {
-    postNotification(node, AXObjectCache::AXValueChanged, false);
+    AXObject* obj = get(node);
+    while (obj && !obj->isNativeTextControl() && !obj->isNonNativeTextControl())
+        obj = obj->parentObject();
+    postNotification(obj, AXObjectCache::AXValueChanged);
 }
 
 void AXObjectCacheImpl::handleTextFormControlChanged(Node* node)
 {
-    postNotification(node, AXObjectCache::AXValueChanged, false);
+    handleEditableTextContentChanged(node);
 }
 
 void AXObjectCacheImpl::handleValueChanged(Node* node)
 {
-    postNotification(node, AXObjectCache::AXValueChanged, true);
+    postNotification(node, AXObjectCache::AXValueChanged);
 }
 
 void AXObjectCacheImpl::handleUpdateActiveMenuOption(LayoutMenuList* menuList, int optionIndex)
 {
     if (AXMenuList* axMenuList = static_cast<AXMenuList*>(get(menuList)))
         axMenuList->didUpdateActiveOption(optionIndex);
 }
 
 void AXObjectCacheImpl::handleLoadComplete(Document* document)
 {
-    postNotification(getOrCreate(document), AXObjectCache::AXLoadComplete, true);
+    postNotification(getOrCreate(document), AXObjectCache::AXLoadComplete);
 }
 
 void AXObjectCacheImpl::handleLayoutComplete(Document* document)
 {
-    postNotification(getOrCreate(document), AXObjectCache::AXLayoutComplete, true);
+    postNotification(getOrCreate(document), AXObjectCache::AXLayoutComplete);
 }
 
 void AXObjectCacheImpl::handleScrolledToAnchor(const Node* anchorNode)
 {
     // The anchor node may not be accessible. Post the notification for the
     // first accessible object.
     postPlatformNotification(firstAccessibleObjectFromNode(anchorNode), AXScrolledToAnchor);
 }
 
 void AXObjectCacheImpl::handleScrollPositionChanged(FrameView* frameView)
@@ skipping 57 matching lines @@
 void AXObjectCacheImpl::setCanvasObjectBounds(Element* element, const LayoutRect& rect)
 {
     AXObject* obj = getOrCreate(element);
     if (!obj)
         return;
 
     obj->setElementRect(rect);
 }
 
 } // namespace blink