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 kAXAriaHidden: | 29 case kAXAriaHiddenElement: |
30 return "ariaHidden"; | 30 return "ariaHiddenElement"; |
31 case kAXAriaHiddenRoot: | 31 case kAXAriaHiddenSubtree: |
32 return "ariaHiddenRoot"; | 32 return "ariaHiddenSubtree"; |
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 kAXInert: | 37 case kAXInertElement: |
38 return "inert"; | 38 return "inertElement"; |
| 39 case kAXInertSubtree: |
| 40 return "inertSubtree"; |
39 case kAXInheritsPresentation: | 41 case kAXInheritsPresentation: |
40 return "inheritsPresentation"; | 42 return "inheritsPresentation"; |
41 case kAXLabelContainer: | 43 case kAXLabelContainer: |
42 return "labelContainer"; | 44 return "labelContainer"; |
43 case kAXLabelFor: | 45 case kAXLabelFor: |
44 return "labelFor"; | 46 return "labelFor"; |
45 case kAXNotRendered: | 47 case kAXNotRendered: |
46 return "notRendered"; | 48 return "notRendered"; |
47 case kAXNotVisible: | 49 case kAXNotVisible: |
48 return "notVisible"; | 50 return "notVisible"; |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
90 .build(); | 92 .build(); |
91 } | 93 } |
92 | 94 |
93 std::unique_ptr<AXValue> CreateBooleanValue(bool value, const String& type) { | 95 std::unique_ptr<AXValue> CreateBooleanValue(bool value, const String& type) { |
94 return AXValue::create() | 96 return AXValue::create() |
95 .setType(type) | 97 .setType(type) |
96 .setValue(protocol::ValueConversions<bool>::toValue(value)) | 98 .setValue(protocol::ValueConversions<bool>::toValue(value)) |
97 .build(); | 99 .build(); |
98 } | 100 } |
99 | 101 |
100 std::unique_ptr<AXRelatedNode> RelatedNodeForAXObject( | 102 std::unique_ptr<AXRelatedNode> RelatedNodeForAXObjectImpl( |
101 const AXObjectImpl& ax_object, | 103 const AXObjectImpl& ax_object, |
102 String* name = nullptr) { | 104 String* name = nullptr) { |
103 Node* node = ax_object.GetNode(); | 105 Node* node = ax_object.GetNode(); |
104 if (!node) | 106 if (!node) |
105 return nullptr; | 107 return nullptr; |
106 int backend_node_id = DOMNodeIds::IdForNode(node); | 108 int backend_node_id = DOMNodeIds::IdForNode(node); |
107 if (!backend_node_id) | 109 if (!backend_node_id) |
108 return nullptr; | 110 return nullptr; |
109 std::unique_ptr<AXRelatedNode> related_node = | 111 std::unique_ptr<AXRelatedNode> related_node = |
110 AXRelatedNode::create().setBackendDOMNodeId(backend_node_id).build(); | 112 AXRelatedNode::create().setBackendDOMNodeId(backend_node_id).build(); |
111 if (!node->IsElementNode()) | 113 if (!node->IsElementNode()) |
112 return related_node; | 114 return related_node; |
113 | 115 |
114 Element* element = ToElement(node); | 116 Element* element = ToElement(node); |
115 String idref = element->GetIdAttribute(); | 117 String idref = element->GetIdAttribute(); |
116 if (!idref.IsEmpty()) | 118 if (!idref.IsEmpty()) |
117 related_node->setIdref(idref); | 119 related_node->setIdref(idref); |
118 | 120 |
119 if (name) | 121 if (name) |
120 related_node->setText(*name); | 122 related_node->setText(*name); |
121 return related_node; | 123 return related_node; |
122 } | 124 } |
123 | 125 |
124 std::unique_ptr<AXValue> CreateRelatedNodeListValue( | 126 std::unique_ptr<AXValue> CreateRelatedNodeListValue( |
125 const AXObjectImpl& ax_object, | 127 const AXObjectImpl& ax_object, |
126 String* name, | 128 String* name, |
127 const String& value_type) { | 129 const String& value_type) { |
128 std::unique_ptr<protocol::Array<AXRelatedNode>> related_nodes = | 130 std::unique_ptr<protocol::Array<AXRelatedNode>> related_nodes = |
129 protocol::Array<AXRelatedNode>::create(); | 131 protocol::Array<AXRelatedNode>::create(); |
130 related_nodes->addItem(RelatedNodeForAXObject(ax_object, name)); | 132 related_nodes->addItem(RelatedNodeForAXObjectImpl(ax_object, name)); |
131 return AXValue::create() | 133 return AXValue::create() |
132 .setType(value_type) | 134 .setType(value_type) |
133 .setRelatedNodes(std::move(related_nodes)) | 135 .setRelatedNodes(std::move(related_nodes)) |
134 .build(); | 136 .build(); |
135 } | 137 } |
136 | 138 |
137 std::unique_ptr<AXValue> CreateRelatedNodeListValue( | 139 std::unique_ptr<AXValue> CreateRelatedNodeListValue( |
138 AXRelatedObjectVector& related_objects, | 140 AXRelatedObjectVector& related_objects, |
139 const String& value_type) { | 141 const String& value_type) { |
140 std::unique_ptr<protocol::Array<AXRelatedNode>> frontend_related_nodes = | 142 std::unique_ptr<protocol::Array<AXRelatedNode>> frontend_related_nodes = |
141 protocol::Array<AXRelatedNode>::create(); | 143 protocol::Array<AXRelatedNode>::create(); |
142 for (unsigned i = 0; i < related_objects.size(); i++) { | 144 for (unsigned i = 0; i < related_objects.size(); i++) { |
143 std::unique_ptr<AXRelatedNode> frontend_related_node = | 145 std::unique_ptr<AXRelatedNode> frontend_related_node = |
144 RelatedNodeForAXObject(*(related_objects[i]->object), | 146 RelatedNodeForAXObjectImpl(*(related_objects[i]->object), |
145 &(related_objects[i]->text)); | 147 &(related_objects[i]->text)); |
146 if (frontend_related_node) | 148 if (frontend_related_node) |
147 frontend_related_nodes->addItem(std::move(frontend_related_node)); | 149 frontend_related_nodes->addItem(std::move(frontend_related_node)); |
148 } | 150 } |
149 return AXValue::create() | 151 return AXValue::create() |
150 .setType(value_type) | 152 .setType(value_type) |
151 .setRelatedNodes(std::move(frontend_related_nodes)) | 153 .setRelatedNodes(std::move(frontend_related_nodes)) |
152 .build(); | 154 .build(); |
153 } | 155 } |
154 | 156 |
155 std::unique_ptr<AXValue> CreateRelatedNodeListValue( | 157 std::unique_ptr<AXValue> CreateRelatedNodeListValue( |
156 AXObjectImpl::AXObjectVector& ax_objects, | 158 AXObjectImpl::AXObjectVector& ax_objects, |
157 const String& value_type) { | 159 const String& value_type) { |
158 std::unique_ptr<protocol::Array<AXRelatedNode>> related_nodes = | 160 std::unique_ptr<protocol::Array<AXRelatedNode>> related_nodes = |
159 protocol::Array<AXRelatedNode>::create(); | 161 protocol::Array<AXRelatedNode>::create(); |
160 for (unsigned i = 0; i < ax_objects.size(); i++) { | 162 for (unsigned i = 0; i < ax_objects.size(); i++) { |
161 std::unique_ptr<AXRelatedNode> related_node = | 163 std::unique_ptr<AXRelatedNode> related_node = |
162 RelatedNodeForAXObject(*(ax_objects[i].Get())); | 164 RelatedNodeForAXObjectImpl(*(ax_objects[i].Get())); |
163 if (related_node) | 165 if (related_node) |
164 related_nodes->addItem(std::move(related_node)); | 166 related_nodes->addItem(std::move(related_node)); |
165 } | 167 } |
166 return AXValue::create() | 168 return AXValue::create() |
167 .setType(value_type) | 169 .setType(value_type) |
168 .setRelatedNodes(std::move(related_nodes)) | 170 .setRelatedNodes(std::move(related_nodes)) |
169 .build(); | 171 .build(); |
170 } | 172 } |
171 | 173 |
172 String ValueSourceType(AXNameFrom name_from) { | 174 String ValueSourceType(AXNameFrom name_from) { |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
238 if (name_source.superseded) | 240 if (name_source.superseded) |
239 value_source->setSuperseded(true); | 241 value_source->setSuperseded(true); |
240 if (name_source.invalid) | 242 if (name_source.invalid) |
241 value_source->setInvalid(true); | 243 value_source->setInvalid(true); |
242 if (name_source.native_source != kAXTextFromNativeHTMLUninitialized) | 244 if (name_source.native_source != kAXTextFromNativeHTMLUninitialized) |
243 value_source->setNativeSource(NativeSourceType(name_source.native_source)); | 245 value_source->setNativeSource(NativeSourceType(name_source.native_source)); |
244 return value_source; | 246 return value_source; |
245 } | 247 } |
246 | 248 |
247 } // namespace blink | 249 } // namespace blink |
OLD | NEW |