OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "modules/accessibility/InspectorTypeBuilderHelper.h" | 5 #include "modules/accessibility/InspectorTypeBuilderHelper.h" |
6 | 6 |
7 #include "core/dom/DOMNodeIds.h" | 7 #include "core/dom/DOMNodeIds.h" |
8 #include "modules/accessibility/AXObjectCacheImpl.h" | 8 #include "modules/accessibility/AXObjectCacheImpl.h" |
9 #include "modules/accessibility/AXObjectImpl.h" | 9 #include "modules/accessibility/AXObjectImpl.h" |
10 | 10 |
11 namespace blink { | 11 namespace blink { |
12 | 12 |
13 using namespace HTMLNames; | 13 using namespace HTMLNames; |
14 using namespace protocol::Accessibility; | 14 using namespace protocol::Accessibility; |
15 | 15 |
16 std::unique_ptr<AXProperty> CreateProperty(const String& name, | 16 std::unique_ptr<AXProperty> CreateProperty(const String& name, |
17 std::unique_ptr<AXValue> value) { | 17 std::unique_ptr<AXValue> value) { |
18 return AXProperty::create().setName(name).setValue(std::move(value)).build(); | 18 return AXProperty::create().setName(name).setValue(std::move(value)).build(); |
19 } | 19 } |
20 | 20 |
21 String IgnoredReasonName(AXIgnoredReason reason) { | 21 String IgnoredReasonName(AXIgnoredReason reason) { |
22 switch (reason) { | 22 switch (reason) { |
23 case kAXActiveModalDialog: | 23 case kAXActiveModalDialog: |
24 return "activeModalDialog"; | 24 return "activeModalDialog"; |
25 case kAXAncestorDisallowsChild: | 25 case kAXAncestorDisallowsChild: |
26 return "ancestorDisallowsChild"; | 26 return "ancestorDisallowsChild"; |
27 case kAXAncestorIsLeafNode: | 27 case kAXAncestorIsLeafNode: |
28 return "ancestorIsLeafNode"; | 28 return "ancestorIsLeafNode"; |
29 case kAXAriaHiddenElement: | 29 case kAXAriaHidden: |
30 return "ariaHiddenElement"; | 30 return "ariaHidden"; |
31 case kAXAriaHiddenSubtree: | 31 case kAXAriaHiddenRoot: |
32 return "ariaHiddenSubtree"; | 32 return "ariaHiddenRoot"; |
33 case kAXEmptyAlt: | 33 case kAXEmptyAlt: |
34 return "emptyAlt"; | 34 return "emptyAlt"; |
35 case kAXEmptyText: | 35 case kAXEmptyText: |
36 return "emptyText"; | 36 return "emptyText"; |
37 case kAXInertElement: | 37 case kAXInert: |
38 return "inertElement"; | 38 return "inert"; |
39 case kAXInertSubtree: | |
40 return "inertSubtree"; | |
41 case kAXInheritsPresentation: | 39 case kAXInheritsPresentation: |
42 return "inheritsPresentation"; | 40 return "inheritsPresentation"; |
43 case kAXLabelContainer: | 41 case kAXLabelContainer: |
44 return "labelContainer"; | 42 return "labelContainer"; |
45 case kAXLabelFor: | 43 case kAXLabelFor: |
46 return "labelFor"; | 44 return "labelFor"; |
47 case kAXNotRendered: | 45 case kAXNotRendered: |
48 return "notRendered"; | 46 return "notRendered"; |
49 case kAXNotVisible: | 47 case kAXNotVisible: |
50 return "notVisible"; | 48 return "notVisible"; |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
92 .build(); | 90 .build(); |
93 } | 91 } |
94 | 92 |
95 std::unique_ptr<AXValue> CreateBooleanValue(bool value, const String& type) { | 93 std::unique_ptr<AXValue> CreateBooleanValue(bool value, const String& type) { |
96 return AXValue::create() | 94 return AXValue::create() |
97 .setType(type) | 95 .setType(type) |
98 .setValue(protocol::ValueConversions<bool>::toValue(value)) | 96 .setValue(protocol::ValueConversions<bool>::toValue(value)) |
99 .build(); | 97 .build(); |
100 } | 98 } |
101 | 99 |
102 std::unique_ptr<AXRelatedNode> RelatedNodeForAXObjectImpl( | 100 std::unique_ptr<AXRelatedNode> RelatedNodeForAXObject( |
103 const AXObjectImpl& ax_object, | 101 const AXObjectImpl& ax_object, |
104 String* name = nullptr) { | 102 String* name = nullptr) { |
105 Node* node = ax_object.GetNode(); | 103 Node* node = ax_object.GetNode(); |
106 if (!node) | 104 if (!node) |
107 return nullptr; | 105 return nullptr; |
108 int backend_node_id = DOMNodeIds::IdForNode(node); | 106 int backend_node_id = DOMNodeIds::IdForNode(node); |
109 if (!backend_node_id) | 107 if (!backend_node_id) |
110 return nullptr; | 108 return nullptr; |
111 std::unique_ptr<AXRelatedNode> related_node = | 109 std::unique_ptr<AXRelatedNode> related_node = |
112 AXRelatedNode::create().setBackendDOMNodeId(backend_node_id).build(); | 110 AXRelatedNode::create().setBackendDOMNodeId(backend_node_id).build(); |
113 if (!node->IsElementNode()) | 111 if (!node->IsElementNode()) |
114 return related_node; | 112 return related_node; |
115 | 113 |
116 Element* element = ToElement(node); | 114 Element* element = ToElement(node); |
117 String idref = element->GetIdAttribute(); | 115 String idref = element->GetIdAttribute(); |
118 if (!idref.IsEmpty()) | 116 if (!idref.IsEmpty()) |
119 related_node->setIdref(idref); | 117 related_node->setIdref(idref); |
120 | 118 |
121 if (name) | 119 if (name) |
122 related_node->setText(*name); | 120 related_node->setText(*name); |
123 return related_node; | 121 return related_node; |
124 } | 122 } |
125 | 123 |
126 std::unique_ptr<AXValue> CreateRelatedNodeListValue( | 124 std::unique_ptr<AXValue> CreateRelatedNodeListValue( |
127 const AXObjectImpl& ax_object, | 125 const AXObjectImpl& ax_object, |
128 String* name, | 126 String* name, |
129 const String& value_type) { | 127 const String& value_type) { |
130 std::unique_ptr<protocol::Array<AXRelatedNode>> related_nodes = | 128 std::unique_ptr<protocol::Array<AXRelatedNode>> related_nodes = |
131 protocol::Array<AXRelatedNode>::create(); | 129 protocol::Array<AXRelatedNode>::create(); |
132 related_nodes->addItem(RelatedNodeForAXObjectImpl(ax_object, name)); | 130 related_nodes->addItem(RelatedNodeForAXObject(ax_object, name)); |
133 return AXValue::create() | 131 return AXValue::create() |
134 .setType(value_type) | 132 .setType(value_type) |
135 .setRelatedNodes(std::move(related_nodes)) | 133 .setRelatedNodes(std::move(related_nodes)) |
136 .build(); | 134 .build(); |
137 } | 135 } |
138 | 136 |
139 std::unique_ptr<AXValue> CreateRelatedNodeListValue( | 137 std::unique_ptr<AXValue> CreateRelatedNodeListValue( |
140 AXRelatedObjectVector& related_objects, | 138 AXRelatedObjectVector& related_objects, |
141 const String& value_type) { | 139 const String& value_type) { |
142 std::unique_ptr<protocol::Array<AXRelatedNode>> frontend_related_nodes = | 140 std::unique_ptr<protocol::Array<AXRelatedNode>> frontend_related_nodes = |
143 protocol::Array<AXRelatedNode>::create(); | 141 protocol::Array<AXRelatedNode>::create(); |
144 for (unsigned i = 0; i < related_objects.size(); i++) { | 142 for (unsigned i = 0; i < related_objects.size(); i++) { |
145 std::unique_ptr<AXRelatedNode> frontend_related_node = | 143 std::unique_ptr<AXRelatedNode> frontend_related_node = |
146 RelatedNodeForAXObjectImpl(*(related_objects[i]->object), | 144 RelatedNodeForAXObject(*(related_objects[i]->object), |
147 &(related_objects[i]->text)); | 145 &(related_objects[i]->text)); |
148 if (frontend_related_node) | 146 if (frontend_related_node) |
149 frontend_related_nodes->addItem(std::move(frontend_related_node)); | 147 frontend_related_nodes->addItem(std::move(frontend_related_node)); |
150 } | 148 } |
151 return AXValue::create() | 149 return AXValue::create() |
152 .setType(value_type) | 150 .setType(value_type) |
153 .setRelatedNodes(std::move(frontend_related_nodes)) | 151 .setRelatedNodes(std::move(frontend_related_nodes)) |
154 .build(); | 152 .build(); |
155 } | 153 } |
156 | 154 |
157 std::unique_ptr<AXValue> CreateRelatedNodeListValue( | 155 std::unique_ptr<AXValue> CreateRelatedNodeListValue( |
158 AXObjectImpl::AXObjectVector& ax_objects, | 156 AXObjectImpl::AXObjectVector& ax_objects, |
159 const String& value_type) { | 157 const String& value_type) { |
160 std::unique_ptr<protocol::Array<AXRelatedNode>> related_nodes = | 158 std::unique_ptr<protocol::Array<AXRelatedNode>> related_nodes = |
161 protocol::Array<AXRelatedNode>::create(); | 159 protocol::Array<AXRelatedNode>::create(); |
162 for (unsigned i = 0; i < ax_objects.size(); i++) { | 160 for (unsigned i = 0; i < ax_objects.size(); i++) { |
163 std::unique_ptr<AXRelatedNode> related_node = | 161 std::unique_ptr<AXRelatedNode> related_node = |
164 RelatedNodeForAXObjectImpl(*(ax_objects[i].Get())); | 162 RelatedNodeForAXObject(*(ax_objects[i].Get())); |
165 if (related_node) | 163 if (related_node) |
166 related_nodes->addItem(std::move(related_node)); | 164 related_nodes->addItem(std::move(related_node)); |
167 } | 165 } |
168 return AXValue::create() | 166 return AXValue::create() |
169 .setType(value_type) | 167 .setType(value_type) |
170 .setRelatedNodes(std::move(related_nodes)) | 168 .setRelatedNodes(std::move(related_nodes)) |
171 .build(); | 169 .build(); |
172 } | 170 } |
173 | 171 |
174 String ValueSourceType(AXNameFrom name_from) { | 172 String ValueSourceType(AXNameFrom name_from) { |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
240 if (name_source.superseded) | 238 if (name_source.superseded) |
241 value_source->setSuperseded(true); | 239 value_source->setSuperseded(true); |
242 if (name_source.invalid) | 240 if (name_source.invalid) |
243 value_source->setInvalid(true); | 241 value_source->setInvalid(true); |
244 if (name_source.native_source != kAXTextFromNativeHTMLUninitialized) | 242 if (name_source.native_source != kAXTextFromNativeHTMLUninitialized) |
245 value_source->setNativeSource(NativeSourceType(name_source.native_source)); | 243 value_source->setNativeSource(NativeSourceType(name_source.native_source)); |
246 return value_source; | 244 return value_source; |
247 } | 245 } |
248 | 246 |
249 } // namespace blink | 247 } // namespace blink |
OLD | NEW |