Automatically fire AX events on Mac based on tree changes

content/browser/accessibility/browser_accessibility_manager.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 372 matching lines @@
           BrowserAccessibilityEvent::FromChildFrameLoading,
           ui::AX_EVENT_CHILDREN_CHANGED,
           parent);
       connected_to_parent_tree_node_ = true;
     }
   } else {
     connected_to_parent_tree_node_ = false;
   }
 
   // Fire any events related to changes to the tree.
-  for (auto& event : tree_events_) {
-    BrowserAccessibility* event_target = GetFromID(event.second);
+  for (auto& entry : tree_events_) {
+    BrowserAccessibility* event_target = GetFromID(entry.first);
     if (!event_target)
       continue;
-    NotifyAccessibilityEvent(BrowserAccessibilityEvent::FromTreeChange,
-                             event.first, event_target);
+    std::set<ui::AXEvent>& events = entry.second;
+    if (events.find(ui::AX_EVENT_LIVE_REGION_CREATED) != events.end() ||
+        events.find(ui::AX_EVENT_ALERT) != events.end()) {
+      events.erase(ui::AX_EVENT_LIVE_REGION_CHANGED);
+    }
+    for (auto event : events) {
+      NotifyAccessibilityEvent(BrowserAccessibilityEvent::FromTreeChange, event,
+                               event_target);
+    }
   }
   tree_events_.clear();
 
-  // Based on the changes to the tree, first fire focus events if needed.
+  // Based on the changes to the tree, fire focus events if needed.
   // Screen readers might not do the right thing if they're not aware of what
   // has focus, so always try that first. Nothing will be fired if the window
   // itself isn't focused or if focus hasn't changed.
   GetRootManager()->FireFocusEventsIfNeeded(
       BrowserAccessibilityEvent::FromBlink);
 
-  // Now iterate over the events from the renderer and fire the events
-  // other than focus events.
+  // We are in the process of inferring all native events from tree changes.
+  // Mac OS X no longer needs to iterate over the specific events coming from
+  // the renderer, all needed events were fired above by iterating over
+  // tree_events_.
+  //
+  // When all platforms have switched to inferring all events, we can delete
+  // the following code, which iterates over the non-focus events from the
+  // renderer and fires native events based on them.
+  //
+  // See http://crbug.com/699438 for details.
   for (uint32_t index = 0; index < details.size(); index++) {
     const AXEventNotificationDetails& detail = details[index];
 
     // Find the node corresponding to the id that's the target of the
     // event (which may not be the root of the update tree).
     ui::AXNode* node = tree_->GetFromId(detail.id);
     if (!node)
       continue;
 
     ui::AXEvent event_type = detail.event_type;
+
+#if defined(OS_MACOSX)
+    if (event_type != ui::AX_EVENT_HOVER)
+      continue;
+#endif  // !defined(OS_MACOSX)
+
     if (event_type == ui::AX_EVENT_FOCUS ||
         event_type == ui::AX_EVENT_BLUR) {
       if (osk_state_ != OSK_DISALLOWED_BECAUSE_TAB_HIDDEN &&
           osk_state_ != OSK_DISALLOWED_BECAUSE_TAB_JUST_APPEARED) {
         osk_state_ = OSK_ALLOWED;
       }
 
       // We already handled all focus events above.
       continue;
     }
@@ skipping 662 matching lines @@
   } while (current);
 
   return result;
 }
 
 void BrowserAccessibilityManager::OnNodeDataWillChange(
     ui::AXTree* tree,
     const ui::AXNodeData& old_node_data,
     const ui::AXNodeData& new_node_data) {}
 
-void BrowserAccessibilityManager::OnTreeDataChanged(ui::AXTree* tree) {
-}
+void BrowserAccessibilityManager::OnTreeDataChanged(
+    ui::AXTree* tree,
+    const ui::AXTreeData& old_tree_data,
+    const ui::AXTreeData& new_tree_data) {}
 
 void BrowserAccessibilityManager::OnNodeWillBeDeleted(ui::AXTree* tree,
                                                       ui::AXNode* node) {
   DCHECK(node);
   if (id_wrapper_map_.find(node->id()) == id_wrapper_map_.end())
     return;
   GetFromAXNode(node)->Destroy();
   id_wrapper_map_.erase(node->id());
 }
 
@@ skipping 75 matching lines @@
   for (auto& change : changes) {
     if (change.type != NODE_CREATED && change.type != SUBTREE_CREATED)
       continue;
 
     const ui::AXNode* created_node = change.node;
     DCHECK(created_node);
     BrowserAccessibility* object = GetFromAXNode(created_node);
     if (object && object->HasStringAttribute(ui::AX_ATTR_LIVE_STATUS)) {
       int32_t id = object->GetId();
       if (object->GetRole() == ui::AX_ROLE_ALERT) {
-        tree_events_.push_back(std::make_pair(ui::AX_EVENT_ALERT, id));
+        tree_events_[id].insert(ui::AX_EVENT_ALERT);
       } else {
-        tree_events_.push_back(
-            std::make_pair(ui::AX_EVENT_LIVE_REGION_CREATED, id));
+        tree_events_[id].insert(ui::AX_EVENT_LIVE_REGION_CREATED);
       }
     }
   }
 }
 
 BrowserAccessibilityManager* BrowserAccessibilityManager::GetRootManager() {
   BrowserAccessibility* parent = GetParentNodeFromParentTree();
   if (!parent)
     return this;
 
@@ skipping 76 matching lines @@
       hit_test_result = parent;
     parent = parent->PlatformGetParent();
   }
 
   last_hover_ax_tree_id_ = hit_test_result->manager()->ax_tree_id();
   last_hover_node_id_ = hit_test_result->GetId();
   last_hover_bounds_ = hit_test_result->GetScreenBoundsRect();
 }
 
 }  // namespace content