1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
// Copyright 2020 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.
#ifndef UI_VIEWS_ACCESSIBILITY_VIEWS_AX_TREE_MANAGER_H_
#define UI_VIEWS_ACCESSIBILITY_VIEWS_AX_TREE_MANAGER_H_
#include <memory>
#include <set>
#include <string>
#include <vector>
#include "base/callback_forward.h"
#include "base/memory/weak_ptr.h"
#include "base/scoped_observation.h"
#include "ui/accessibility/ax_action_handler.h"
#include "ui/accessibility/ax_enums.mojom-forward.h"
#include "ui/accessibility/ax_event_generator.h"
#include "ui/accessibility/ax_node.h"
#include "ui/accessibility/ax_node_data.h"
#include "ui/accessibility/ax_tree.h"
#include "ui/accessibility/ax_tree_data.h"
#include "ui/accessibility/ax_tree_id.h"
#include "ui/accessibility/ax_tree_manager.h"
#include "ui/accessibility/ax_tree_serializer.h"
#include "ui/views/accessibility/ax_aura_obj_cache.h"
#include "ui/views/accessibility/ax_event_manager.h"
#include "ui/views/accessibility/ax_event_observer.h"
#include "ui/views/accessibility/ax_tree_source_views.h"
#include "ui/views/views_export.h"
#include "ui/views/widget/widget.h"
#include "ui/views/widget/widget_observer.h"
namespace ui {
struct AXActionData;
} // namespace ui
namespace views {
class AXAuraObjWrapper;
class View;
// Manages an accessibility tree that mirrors the Views tree for a particular
// widget.
//
// TODO(nektar): Enable navigating to parent and child accessibility trees for
// parent and child widgets, thereby allowing stiching the various accessibility
// trees into a unified platform tree.
//
// The Views tree is serialized into an AXTreeSource and immediately
// deserialized into an AXTree, both in the same process.
class VIEWS_EXPORT ViewsAXTreeManager : public ui::AXTreeManager,
public ui::AXActionHandler,
public AXEventObserver,
public views::WidgetObserver {
public:
using GeneratedEventCallbackForTesting = base::RepeatingCallback<
void(Widget*, ui::AXEventGenerator::Event, ui::AXNodeID)>;
// Creates an instance of this class that manages an AXTree mirroring the
// Views tree rooted at a given Widget.
//
// The provided |widget| doesn't own this class.
explicit ViewsAXTreeManager(Widget* widget);
~ViewsAXTreeManager() override;
ViewsAXTreeManager(const ViewsAXTreeManager& manager) = delete;
ViewsAXTreeManager& operator=(const ViewsAXTreeManager& manager) = delete;
// Returns a reference to the managed AXTree.
const ui::AXTree& ax_tree() const { return ax_tree_; }
// For testing only, register a function to be called when a generated event
// is fired from this ViewsAXTreeManager.
void SetGeneratedEventCallbackForTesting(
const GeneratedEventCallbackForTesting& callback);
// For testing only, unregister the function that was previously registered to
// be called when a generated event is fired from this ViewsAXTreeManager.
void UnsetGeneratedEventCallbackForTesting();
// AXTreeManager implementation.
ui::AXNode* GetNodeFromTree(const ui::AXTreeID tree_id,
const ui::AXNodeID node_id) const override;
ui::AXNode* GetNodeFromTree(const ui::AXNodeID node_id) const override;
ui::AXTreeID GetTreeID() const override;
ui::AXTreeID GetParentTreeID() const override;
ui::AXNode* GetRootAsAXNode() const override;
ui::AXNode* GetParentNodeFromParentTreeAsAXNode() const override;
std::string ToString() const override;
// AXActionHandlerBase implementation.
void PerformAction(const ui::AXActionData& data) override;
// AXEventObserver implementation.
void OnViewEvent(views::View* view, ax::mojom::Event event) override;
// WidgetObserver implementation.
void OnWidgetDestroyed(Widget* widget) override;
void OnWidgetClosing(Widget* widget) override;
private:
using ViewsAXTreeSerializer = ui::AXTreeSerializer<AXAuraObjWrapper*>;
void SerializeTreeUpdates();
void UnserializeTreeUpdates(const std::vector<ui::AXTreeUpdate>& updates);
// Determines the platform node which corresponds to the given |node| and
// fires the given |event| on it.
//
// TODO(nektar): Implement this other than for testing.
void FireGeneratedEvent(const ui::AXEventGenerator::Event& event,
const ui::AXNode& node) const;
// The Widget for which this class manages an AXTree.
//
// Weak, a Widget doesn't own this class.
Widget* widget_;
// Set to true if we are still waiting for a task to serialize all previously
// modified nodes.
bool waiting_to_serialize_ = false;
// The set of nodes in the source tree that might have been modified after an
// event has been fired on them.
std::set<ui::AXNodeID> modified_nodes_;
// The cache that maps objects in the Views tree to AXAuraObjWrapper objects
// that are used to serialize the Views tree.
AXAuraObjCache cache_;
// The ID for this AXTree.
ui::AXTreeID tree_id_;
// The AXTree that mirrors the Views tree and which is created by
// deserializing the updates from |tree_source_|.
ui::AXTree ax_tree_;
// The tree source that enables us to serialize the Views tree.
AXTreeSourceViews tree_source_;
// The serializer that serializes the Views tree into one or more
// AXTreeUpdate.
ViewsAXTreeSerializer tree_serializer_;
// For automatically generating events based on changes to |tree_|.
ui::AXEventGenerator event_generator_;
// For testing only: A function to call when a generated event is fired.
GeneratedEventCallbackForTesting generated_event_callback_for_testing_;
// To prevent any use-after-free, members below this line should be declared
// last.
base::ScopedObservation<AXEventManager, AXEventObserver>
views_event_observer_{this};
base::ScopedObservation<Widget, views::WidgetObserver> widget_observer_{this};
base::WeakPtrFactory<ViewsAXTreeManager> weak_factory_{this};
};
} // namespace views
#endif // UI_VIEWS_ACCESSIBILITY_VIEWS_AX_TREE_MANAGER_H_
|
