[a11y] Use the new update semantics embedder API (#39)

Author: swift-kim

flutter/shell/platform/common/accessibility_bridge.cc

@@ -7,6 +7,7 @@
 #include <functional>
 #include <utility>
 
+#include "flutter/third_party/accessibility/ax/ax_tree_manager_map.h"
 #include "flutter/third_party/accessibility/ax/ax_tree_update.h"
 #include "flutter/third_party/accessibility/base/logging.h"
 
@@ -19,24 +20,30 @@ constexpr int kHasScrollingAction =
     FlutterSemanticsAction::kFlutterSemanticsActionScrollDown;
 
 // AccessibilityBridge
-AccessibilityBridge::AccessibilityBridge() {
-  event_generator_.SetTree(&tree_);
-  tree_.AddObserver(static_cast<ui::AXTreeObserver*>(this));
+AccessibilityBridge::AccessibilityBridge()
+    : tree_(std::make_unique<ui::AXTree>()) {
+  event_generator_.SetTree(tree_.get());
+  tree_->AddObserver(static_cast<ui::AXTreeObserver*>(this));
+  ui::AXTreeData data = tree_->data();
+  data.tree_id = ui::AXTreeID::CreateNewAXTreeID();
+  tree_->UpdateData(data);
+  ui::AXTreeManagerMap::GetInstance().AddTreeManager(tree_->GetAXTreeID(),
+                                                     this);
 }
 
 AccessibilityBridge::~AccessibilityBridge() {
   event_generator_.ReleaseTree();
-  tree_.RemoveObserver(static_cast<ui::AXTreeObserver*>(this));
+  tree_->RemoveObserver(static_cast<ui::AXTreeObserver*>(this));
 }
 
 void AccessibilityBridge::AddFlutterSemanticsNodeUpdate(
-    const FlutterSemanticsNode* node) {
-  pending_semantics_node_updates_[node->id] = FromFlutterSemanticsNode(node);
+    const FlutterSemanticsNode2& node) {
+  pending_semantics_node_updates_[node.id] = FromFlutterSemanticsNode(node);
 }
 
 void AccessibilityBridge::AddFlutterSemanticsCustomActionUpdate(
-    const FlutterSemanticsCustomAction* action) {
-  pending_semantics_custom_action_updates_[action->id] =
+    const FlutterSemanticsCustomAction2& action) {
+  pending_semantics_custom_action_updates_[action.id] =
       FromFlutterSemanticsCustomAction(action);
 }
 
@@ -51,9 +58,9 @@ void AccessibilityBridge::CommitUpdates() {
   std::optional<ui::AXTreeUpdate> remove_reparented =
       CreateRemoveReparentedNodesUpdate();
   if (remove_reparented.has_value()) {
-    tree_.Unserialize(remove_reparented.value());
+    tree_->Unserialize(remove_reparented.value());
 
-    std::string error = tree_.error();
+    std::string error = tree_->error();
     if (!error.empty()) {
       FML_LOG(ERROR) << "Failed to update ui::AXTree, error: " << error;
       assert(false);
@@ -63,15 +70,16 @@ void AccessibilityBridge::CommitUpdates() {
 
   // Second, apply the pending node updates. This also moves reparented nodes to
   // their new parents if needed.
-  ui::AXTreeUpdate update{.tree_data = tree_.data()};
+  ui::AXTreeUpdate update{.tree_data = tree_->data()};
 
   // Figure out update order, ui::AXTree only accepts update in tree order,
   // where parent node must come before the child node in
   // ui::AXTreeUpdate.nodes. We start with picking a random node and turn the
   // entire subtree into a list. We pick another node from the remaining update,
   // and keep doing so until the update map is empty. We then concatenate the
   // lists in the reversed order, this guarantees parent updates always come
-  // before child updates.
+  // before child updates. If the root is in the update, it is guaranteed to
+  // be the first node of the last list.
   std::vector<std::vector<SemanticsNode>> results;
   while (!pending_semantics_node_updates_.empty()) {
     auto begin = pending_semantics_node_updates_.begin();
@@ -88,11 +96,20 @@ void AccessibilityBridge::CommitUpdates() {
     }
   }
 
-  tree_.Unserialize(update);
+  // The first update must set the tree's root, which is guaranteed to be the
+  // last list's first node. A tree's root node never changes, though it can be
+  // modified.
+  if (!results.empty() && GetRootAsAXNode()->id() == ui::AXNode::kInvalidAXID) {
+    FML_DCHECK(!results.back().empty());
+
+    update.root_id = results.back().front().id;
+  }
+
+  tree_->Unserialize(update);
   pending_semantics_node_updates_.clear();
   pending_semantics_custom_action_updates_.clear();
 
-  std::string error = tree_.error();
+  std::string error = tree_->error();
   if (!error.empty()) {
     FML_LOG(ERROR) << "Failed to update ui::AXTree, error: " << error;
     return;
@@ -122,7 +139,7 @@ AccessibilityBridge::GetFlutterPlatformNodeDelegateFromID(
 }
 
 const ui::AXTreeData& AccessibilityBridge::GetAXTreeData() const {
-  return tree_.data();
+  return tree_->data();
 }
 
 const std::vector<ui::AXEventGenerator::TargetedEvent>
@@ -201,7 +218,7 @@ AccessibilityBridge::CreateRemoveReparentedNodesUpdate() {
   for (auto node_update : pending_semantics_node_updates_) {
     for (int32_t child_id : node_update.second.children_in_traversal_order) {
       // Skip nodes that don't exist or have a parent in the current tree.
-      ui::AXNode* child = tree_.GetFromId(child_id);
+      ui::AXNode* child = tree_->GetFromId(child_id);
       if (!child) {
         continue;
       }
@@ -222,7 +239,7 @@ AccessibilityBridge::CreateRemoveReparentedNodesUpdate() {
       // Create an update to remove the child from its previous parent.
       int32_t parent_id = child->parent()->id();
       if (updates.find(parent_id) == updates.end()) {
-        updates[parent_id] = tree_.GetFromId(parent_id)->data();
+        updates[parent_id] = tree_->GetFromId(parent_id)->data();
       }
 
       ui::AXNodeData* parent = &updates[parent_id];
@@ -239,7 +256,7 @@ AccessibilityBridge::CreateRemoveReparentedNodesUpdate() {
   }
 
   ui::AXTreeUpdate update{
-      .tree_data = tree_.data(),
+      .tree_data = tree_->data(),
       .nodes = std::vector<ui::AXNodeData>(),
   };
 
@@ -428,6 +445,12 @@ void AccessibilityBridge::SetBooleanAttributesFromFlutterUpdate(
       ax::mojom::BoolAttribute::kEditableRoot,
       flags & FlutterSemanticsFlag::kFlutterSemanticsFlagIsTextField &&
           (flags & FlutterSemanticsFlag::kFlutterSemanticsFlagIsReadOnly) == 0);
+  // Mark nodes as line breaking so that screen readers don't
+  // merge all consecutive objects into one.
+  // TODO(schectman): When should a node have this attribute set?
+  // https://github.com/flutter/flutter/issues/118184
+  node_data.AddBoolAttribute(ax::mojom::BoolAttribute::kIsLineBreakingObject,
+                             true);
 }
 
 void AccessibilityBridge::SetIntAttributesFromFlutterUpdate(
@@ -520,11 +543,12 @@ void AccessibilityBridge::SetTooltipFromFlutterUpdate(
 void AccessibilityBridge::SetTreeData(const SemanticsNode& node,
                                       ui::AXTreeUpdate& tree_update) {
   FlutterSemanticsFlag flags = node.flags;
-  // Set selection if:
+  // Set selection of the focused node if:
   // 1. this text field has a valid selection
   // 2. this text field doesn't have a valid selection but had selection stored
   //    in the tree.
-  if (flags & FlutterSemanticsFlag::kFlutterSemanticsFlagIsTextField) {
+  if (flags & FlutterSemanticsFlag::kFlutterSemanticsFlagIsTextField &&
+      flags & FlutterSemanticsFlag::kFlutterSemanticsFlagIsFocused) {
     if (node.text_selection_base != -1) {
       tree_update.tree_data.sel_anchor_object_id = node.id;
       tree_update.tree_data.sel_anchor_offset = node.text_selection_base;
@@ -554,66 +578,66 @@ void AccessibilityBridge::SetTreeData(const SemanticsNode& node,
 
 AccessibilityBridge::SemanticsNode
 AccessibilityBridge::FromFlutterSemanticsNode(
-    const FlutterSemanticsNode* flutter_node) {
+    const FlutterSemanticsNode2& flutter_node) {
   SemanticsNode result;
-  result.id = flutter_node->id;
-  result.flags = flutter_node->flags;
-  result.actions = flutter_node->actions;
-  result.text_selection_base = flutter_node->text_selection_base;
-  result.text_selection_extent = flutter_node->text_selection_extent;
-  result.scroll_child_count = flutter_node->scroll_child_count;
-  result.scroll_index = flutter_node->scroll_index;
-  result.scroll_position = flutter_node->scroll_position;
-  result.scroll_extent_max = flutter_node->scroll_extent_max;
-  result.scroll_extent_min = flutter_node->scroll_extent_min;
-  result.elevation = flutter_node->elevation;
-  result.thickness = flutter_node->thickness;
-  if (flutter_node->label) {
-    result.label = std::string(flutter_node->label);
-  }
-  if (flutter_node->hint) {
-    result.hint = std::string(flutter_node->hint);
-  }
-  if (flutter_node->value) {
-    result.value = std::string(flutter_node->value);
-  }
-  if (flutter_node->increased_value) {
-    result.increased_value = std::string(flutter_node->increased_value);
-  }
-  if (flutter_node->decreased_value) {
-    result.decreased_value = std::string(flutter_node->decreased_value);
-  }
-  if (flutter_node->tooltip) {
-    result.tooltip = std::string(flutter_node->tooltip);
-  }
-  result.text_direction = flutter_node->text_direction;
-  result.rect = flutter_node->rect;
-  result.transform = flutter_node->transform;
-  if (flutter_node->child_count > 0) {
+  result.id = flutter_node.id;
+  result.flags = flutter_node.flags;
+  result.actions = flutter_node.actions;
+  result.text_selection_base = flutter_node.text_selection_base;
+  result.text_selection_extent = flutter_node.text_selection_extent;
+  result.scroll_child_count = flutter_node.scroll_child_count;
+  result.scroll_index = flutter_node.scroll_index;
+  result.scroll_position = flutter_node.scroll_position;
+  result.scroll_extent_max = flutter_node.scroll_extent_max;
+  result.scroll_extent_min = flutter_node.scroll_extent_min;
+  result.elevation = flutter_node.elevation;
+  result.thickness = flutter_node.thickness;
+  if (flutter_node.label) {
+    result.label = std::string(flutter_node.label);
+  }
+  if (flutter_node.hint) {
+    result.hint = std::string(flutter_node.hint);
+  }
+  if (flutter_node.value) {
+    result.value = std::string(flutter_node.value);
+  }
+  if (flutter_node.increased_value) {
+    result.increased_value = std::string(flutter_node.increased_value);
+  }
+  if (flutter_node.decreased_value) {
+    result.decreased_value = std::string(flutter_node.decreased_value);
+  }
+  if (flutter_node.tooltip) {
+    result.tooltip = std::string(flutter_node.tooltip);
+  }
+  result.text_direction = flutter_node.text_direction;
+  result.rect = flutter_node.rect;
+  result.transform = flutter_node.transform;
+  if (flutter_node.child_count > 0) {
     result.children_in_traversal_order = std::vector<int32_t>(
-        flutter_node->children_in_traversal_order,
-        flutter_node->children_in_traversal_order + flutter_node->child_count);
+        flutter_node.children_in_traversal_order,
+        flutter_node.children_in_traversal_order + flutter_node.child_count);
   }
-  if (flutter_node->custom_accessibility_actions_count > 0) {
+  if (flutter_node.custom_accessibility_actions_count > 0) {
     result.custom_accessibility_actions = std::vector<int32_t>(
-        flutter_node->custom_accessibility_actions,
-        flutter_node->custom_accessibility_actions +
-            flutter_node->custom_accessibility_actions_count);
+        flutter_node.custom_accessibility_actions,
+        flutter_node.custom_accessibility_actions +
+            flutter_node.custom_accessibility_actions_count);
   }
   return result;
 }
 
 AccessibilityBridge::SemanticsCustomAction
 AccessibilityBridge::FromFlutterSemanticsCustomAction(
-    const FlutterSemanticsCustomAction* flutter_custom_action) {
+    const FlutterSemanticsCustomAction2& flutter_custom_action) {
   SemanticsCustomAction result;
-  result.id = flutter_custom_action->id;
-  result.override_action = flutter_custom_action->override_action;
-  if (flutter_custom_action->label) {
-    result.label = std::string(flutter_custom_action->label);
+  result.id = flutter_custom_action.id;
+  result.override_action = flutter_custom_action.override_action;
+  if (flutter_custom_action.label) {
+    result.label = std::string(flutter_custom_action.label);
   }
-  if (flutter_custom_action->hint) {
-    result.hint = std::string(flutter_custom_action->hint);
+  if (flutter_custom_action.hint) {
+    result.hint = std::string(flutter_custom_action.hint);
   }
   return result;
 }
@@ -649,8 +673,60 @@ gfx::NativeViewAccessible AccessibilityBridge::GetNativeAccessibleFromId(
 gfx::RectF AccessibilityBridge::RelativeToGlobalBounds(const ui::AXNode* node,
                                                        bool& offscreen,
                                                        bool clip_bounds) {
-  return tree_.RelativeToTreeBounds(node, gfx::RectF(), &offscreen,
-                                    clip_bounds);
+  return tree_->RelativeToTreeBounds(node, gfx::RectF(), &offscreen,
+                                     clip_bounds);
+}
+
+ui::AXNode* AccessibilityBridge::GetNodeFromTree(
+    ui::AXTreeID tree_id,
+    ui::AXNode::AXID node_id) const {
+  return GetNodeFromTree(node_id);
+}
+
+ui::AXNode* AccessibilityBridge::GetNodeFromTree(
+    ui::AXNode::AXID node_id) const {
+  return tree_->GetFromId(node_id);
+}
+
+ui::AXTreeID AccessibilityBridge::GetTreeID() const {
+  return tree_->GetAXTreeID();
+}
+
+ui::AXTreeID AccessibilityBridge::GetParentTreeID() const {
+  return ui::AXTreeIDUnknown();
+}
+
+ui::AXNode* AccessibilityBridge::GetRootAsAXNode() const {
+  return tree_->root();
+}
+
+ui::AXNode* AccessibilityBridge::GetParentNodeFromParentTreeAsAXNode() const {
+  return nullptr;
+}
+
+ui::AXTree* AccessibilityBridge::GetTree() const {
+  return tree_.get();
+}
+
+ui::AXPlatformNode* AccessibilityBridge::GetPlatformNodeFromTree(
+    const ui::AXNode::AXID node_id) const {
+  auto platform_delegate_weak = GetFlutterPlatformNodeDelegateFromID(node_id);
+  auto platform_delegate = platform_delegate_weak.lock();
+  if (!platform_delegate) {
+    return nullptr;
+  }
+  return platform_delegate->GetPlatformNode();
+}
+
+ui::AXPlatformNode* AccessibilityBridge::GetPlatformNodeFromTree(
+    const ui::AXNode& node) const {
+  return GetPlatformNodeFromTree(node.id());
+}
+
+ui::AXPlatformNodeDelegate* AccessibilityBridge::RootDelegate() const {
+  return GetFlutterPlatformNodeDelegateFromID(GetRootAsAXNode()->id())
+      .lock()
+      .get();
 }
 
 }  // namespace flutter