ax_tree_manager.h 4.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121
  1. // Copyright 2019 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #ifndef UI_ACCESSIBILITY_AX_TREE_MANAGER_H_
  5. #define UI_ACCESSIBILITY_AX_TREE_MANAGER_H_
  6. #include "base/scoped_observation.h"
  7. #include "ui/accessibility/ax_event_generator.h"
  8. #include "ui/accessibility/ax_export.h"
  9. #include "ui/accessibility/ax_tree.h"
  10. #include "ui/accessibility/ax_tree_observer.h"
  11. namespace ui {
  12. class AXNode;
  13. class AXTreeManagerMap;
  14. // Abstract interface for a class that owns an AXTree and manages its
  15. // connections to other AXTrees in the same page or desktop (parent and child
  16. // trees).
  17. class AX_EXPORT AXTreeManager : public AXTreeObserver {
  18. public:
  19. static AXTreeManager* FromID(AXTreeID ax_tree_id);
  20. // If the child of `parent_node` exists in a separate child tree, return the
  21. // tree manager for that child tree. Otherwise, return nullptr.
  22. static AXTreeManager* ForChildTree(const AXNode& parent_node);
  23. AXTreeManager(const AXTreeManager&) = delete;
  24. AXTreeManager& operator=(const AXTreeManager&) = delete;
  25. ~AXTreeManager() override;
  26. // Returns the AXNode with the given |node_id| from the tree that has the
  27. // given |tree_id|. This allows for callers to access nodes outside of their
  28. // own tree. Returns nullptr if |tree_id| or |node_id| is not found.
  29. // TODO(kschmi): Remove |tree_id| parameter, as it's unnecessary.
  30. virtual AXNode* GetNodeFromTree(const AXTreeID tree_id,
  31. const AXNodeID node_id) const = 0;
  32. // Returns the AXNode in the current tree that has the given |node_id|.
  33. // Returns nullptr if |node_id| is not found.
  34. virtual AXNode* GetNodeFromTree(const AXNodeID node_id) const = 0;
  35. // Returns the tree id of the tree managed by this AXTreeManager.
  36. AXTreeID GetTreeID() const;
  37. // Returns the tree id of the parent tree.
  38. // Returns AXTreeIDUnknown if this tree doesn't have a parent tree.
  39. virtual AXTreeID GetParentTreeID() const;
  40. // Returns the AXNode that is at the root of the current tree.
  41. AXNode* GetRootAsAXNode() const;
  42. // If this tree has a parent tree, returns the node in the parent tree that
  43. // hosts the current tree. Returns nullptr if this tree doesn't have a parent
  44. // tree.
  45. virtual AXNode* GetParentNodeFromParentTreeAsAXNode() const = 0;
  46. // Called when the tree manager is about to be removed from the tree map,
  47. // `AXTreeManagerMap`.
  48. void WillBeRemovedFromMap();
  49. const AXTreeID& ax_tree_id() const { return ax_tree_id_; }
  50. AXTree* ax_tree() const { return ax_tree_.get(); }
  51. const AXEventGenerator& event_generator() const { return event_generator_; }
  52. AXEventGenerator& event_generator() { return event_generator_; }
  53. // AXTreeObserver implementation.
  54. void OnTreeDataChanged(ui::AXTree* tree,
  55. const ui::AXTreeData& old_data,
  56. const ui::AXTreeData& new_data) override;
  57. void OnNodeWillBeDeleted(ui::AXTree* tree, ui::AXNode* node) override {}
  58. void OnSubtreeWillBeDeleted(ui::AXTree* tree, ui::AXNode* node) override {}
  59. void OnNodeCreated(ui::AXTree* tree, ui::AXNode* node) override {}
  60. void OnNodeDeleted(ui::AXTree* tree, int32_t node_id) override {}
  61. void OnNodeReparented(ui::AXTree* tree, ui::AXNode* node) override {}
  62. void OnRoleChanged(ui::AXTree* tree,
  63. ui::AXNode* node,
  64. ax::mojom::Role old_role,
  65. ax::mojom::Role new_role) override {}
  66. void OnAtomicUpdateFinished(
  67. ui::AXTree* tree,
  68. bool root_changed,
  69. const std::vector<ui::AXTreeObserver::Change>& changes) override {}
  70. protected:
  71. AXTreeManager();
  72. explicit AXTreeManager(std::unique_ptr<AXTree> tree);
  73. explicit AXTreeManager(const AXTreeID& tree_id, std::unique_ptr<AXTree> tree);
  74. // TODO(benjamin.beaudry): Remove this helper once we move the logic related
  75. // to the parent connection from `BrowserAccessibilityManager` to this class.
  76. // `BrowserAccessibilityManager` needs to remove the manager from the map
  77. // before calling `BrowserAccessibilityManager::ParentConnectionChanged`, so
  78. // the default removal of the manager in `~AXTreeManager` occurs too late.
  79. void RemoveFromMap();
  80. AXTreeID ax_tree_id_;
  81. std::unique_ptr<AXTree> ax_tree_;
  82. AXEventGenerator event_generator_;
  83. private:
  84. friend class TestAXTreeManager;
  85. static AXTreeManagerMap& GetMap();
  86. // Automatically stops observing notifications from the AXTree when this class
  87. // is destructed.
  88. //
  89. // This member needs to be destructed before any observed AXTrees. Since
  90. // destructors for non-static member fields are called in the reverse order of
  91. // declaration, do not move this member above other members.
  92. base::ScopedObservation<AXTree, AXTreeObserver> tree_observation_{this};
  93. };
  94. } // namespace ui
  95. #endif // UI_ACCESSIBILITY_AX_TREE_MANAGER_H_