Automatically fire AX events on Win based on tree changes

content/browser/accessibility/browser_accessibility_manager_win.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_win.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/windows_version.h"
 #include "content/browser/accessibility/browser_accessibility_event_win.h"
 #include "content/browser/accessibility/browser_accessibility_state_impl.h"
 #include "content/browser/accessibility/browser_accessibility_win.h"
 #include "content/browser/renderer_host/legacy_render_widget_host_win.h"
 #include "content/common/accessibility_messages.h"
 #include "ui/base/win/atl_module.h"
 
 namespace content {
 
+namespace {
+
+bool IsContainerWithSelectableChildrenRole(ui::AXRole role) {
+  switch (role) {
+    case ui::AX_ROLE_COMBO_BOX:
+    case ui::AX_ROLE_GRID:
+    case ui::AX_ROLE_LIST_BOX:
+    case ui::AX_ROLE_MENU:
+    case ui::AX_ROLE_MENU_BAR:
+    case ui::AX_ROLE_RADIO_GROUP:
+    case ui::AX_ROLE_TAB_LIST:
+    case ui::AX_ROLE_TOOLBAR:
+    case ui::AX_ROLE_TREE:
+    case ui::AX_ROLE_TREE_GRID:
+      return true;
+    default:
+      return false;
+  }
+}
+
+}  // namespace
+
 // static
 BrowserAccessibilityManager* BrowserAccessibilityManager::Create(
     const ui::AXTreeUpdate& initial_tree,
     BrowserAccessibilityDelegate* delegate,
     BrowserAccessibilityFactory* factory) {
   return new BrowserAccessibilityManagerWin(initial_tree, delegate, factory);
 }
 
 BrowserAccessibilityManagerWin*
 BrowserAccessibilityManager::ToBrowserAccessibilityManagerWin() {
@@ skipping 202 matching lines @@
   BrowserAccessibilityDelegate* delegate = GetDelegateFromRootManager();
   if (delegate) {
     gfx::Rect bounds = delegate->AccessibilityGetViewBounds();
     if (device_scale_factor() > 0.0 && device_scale_factor() != 1.0)
       bounds = ScaleToEnclosingRect(bounds, device_scale_factor());
     return bounds;
   }
   return gfx::Rect();
 }
 
+void BrowserAccessibilityManagerWin::OnTreeDataChanged(
+    ui::AXTree* tree,
+    const ui::AXTreeData& old_tree_data,
+    const ui::AXTreeData& new_tree_data) {
+  BrowserAccessibilityManager::OnTreeDataChanged(tree, old_tree_data,
+                                                 new_tree_data);
+  if (new_tree_data.loaded && !old_tree_data.loaded)
+    tree_events_[tree->root()->id()].insert(ui::AX_EVENT_LOAD_COMPLETE);
+  if (new_tree_data.sel_anchor_object_id !=
+          old_tree_data.sel_anchor_object_id ||
+      new_tree_data.sel_anchor_offset != old_tree_data.sel_anchor_offset ||
+      new_tree_data.sel_anchor_affinity != old_tree_data.sel_anchor_affinity ||
+      new_tree_data.sel_focus_object_id != old_tree_data.sel_focus_object_id ||
+      new_tree_data.sel_focus_offset != old_tree_data.sel_focus_offset ||
+      new_tree_data.sel_focus_affinity != old_tree_data.sel_focus_affinity) {
+    tree_events_[tree->root()->id()].insert(
+        ui::AX_EVENT_DOCUMENT_SELECTION_CHANGED);
+  }
+}
+
 void BrowserAccessibilityManagerWin::OnNodeCreated(ui::AXTree* tree,
                                                    ui::AXNode* node) {
   DCHECK(node);
   BrowserAccessibilityManager::OnNodeCreated(tree, node);
   BrowserAccessibility* obj = GetFromAXNode(node);
   if (!obj)
     return;
   if (!obj->IsNative())
     return;
 }
 
+void BrowserAccessibilityManagerWin::OnNodeDataWillChange(
+    ui::AXTree* tree,
+    const ui::AXNodeData& old_node_data,
+    const ui::AXNodeData& new_node_data) {
+  if (new_node_data.child_ids != old_node_data.child_ids &&
+      new_node_data.role != ui::AX_ROLE_STATIC_TEXT) {
+    tree_events_[new_node_data.id].insert(ui::AX_EVENT_CHILDREN_CHANGED);
+  }
+}
+
+void BrowserAccessibilityManagerWin::OnStateChanged(ui::AXTree* tree,
+                                                    ui::AXNode* node,
+                                                    ui::AXState state,
+                                                    bool new_value) {
+  if (state == ui::AX_STATE_SELECTED) {
+    ui::AXNode* container = node;
+    while (container &&
+           !IsContainerWithSelectableChildrenRole(container->data().role))
+      container = container->parent();
+    if (container) {
+      tree_events_[container->id()].insert(
+          ui::AX_EVENT_SELECTED_CHILDREN_CHANGED);
+    }
+  }
+}
+
+void BrowserAccessibilityManagerWin::OnIntAttributeChanged(
+    ui::AXTree* tree,
+    ui::AXNode* node,
+    ui::AXIntAttribute attr,
+    int32_t old_value,
+    int32_t new_value) {
+  BrowserAccessibilityManager::OnIntAttributeChanged(tree, node, attr,
+                                                     old_value, new_value);
+  switch (attr) {
+    case ui::AX_ATTR_ACTIVEDESCENDANT_ID:
+      tree_events_[node->id()].insert(ui::AX_EVENT_ACTIVEDESCENDANTCHANGED);
+      break;
+    case ui::AX_ATTR_SCROLL_X:
+    case ui::AX_ATTR_SCROLL_Y:
+      tree_events_[node->id()].insert(ui::AX_EVENT_SCROLL_POSITION_CHANGED);
+      break;
+    default:
+      break;
+  }
+}
+
 void BrowserAccessibilityManagerWin::OnAtomicUpdateFinished(
     ui::AXTree* tree,
     bool root_changed,
     const std::vector<ui::AXTreeDelegate::Change>& changes) {
   BrowserAccessibilityManager::OnAtomicUpdateFinished(
       tree, root_changed, changes);
 
+  if (root_changed && tree->data().loaded)
+    tree_events_[tree->root()->id()].insert(ui::AX_EVENT_LOAD_COMPLETE);
+
+  // Handle live region changes.
+  for (size_t i = 0; i < changes.size(); ++i) {
+    const ui::AXNode* node = changes[i].node;
+    DCHECK(node);
+    if (node->data().HasStringAttribute(ui::AX_ATTR_CONTAINER_LIVE_STATUS)) {
+      const ui::AXNode* container = node;
+      while (container &&
+             !container->data().HasStringAttribute(ui::AX_ATTR_LIVE_STATUS)) {
+        container = container->parent();
+      }
+      if (container)
+        tree_events_[container->id()].insert(ui::AX_EVENT_LIVE_REGION_CHANGED);
+    }
+  }
+
   // Do a sequence of Windows-specific updates on each node. Each one is
   // done in a single pass that must complete before the next step starts.
   // The first step moves win_attributes_ to old_win_attributes_ and then
   // recomputes all of win_attributes_ other than IAccessibleText.
   for (size_t i = 0; i < changes.size(); ++i) {
     const ui::AXNode* changed_node = changes[i].node;
     DCHECK(changed_node);
     BrowserAccessibility* obj = GetFromAXNode(changed_node);
     if (obj && obj->IsNative() && !obj->PlatformIsChildOfLeaf())
       ToBrowserAccessibilityWin(obj)
@@ skipping 25 matching lines @@
     DCHECK(changed_node);
     BrowserAccessibility* obj = GetFromAXNode(changed_node);
     if (obj && obj->IsNative() && !obj->PlatformIsChildOfLeaf()) {
       ToBrowserAccessibilityWin(obj)->GetCOM()->UpdateStep3FireEvents(
           changes[i].type == AXTreeDelegate::SUBTREE_CREATED);
     }
   }
 }
 
 }  // namespace content