| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright 2014 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 |
| 5 // TODO(dcarney): Remove this when UnsafePersistent is removed. |
| 6 #define V8_ALLOW_ACCESS_TO_RAW_HANDLE_CONSTRUCTOR |
| 7 |
| 8 #include "content/shell/renderer/test_runner/web_ax_object_proxy.h" |
| 9 |
| 10 #include "gin/handle.h" |
| 11 #include "third_party/WebKit/public/platform/WebPoint.h" |
| 12 #include "third_party/WebKit/public/platform/WebRect.h" |
| 13 #include "third_party/WebKit/public/platform/WebString.h" |
| 14 #include "third_party/WebKit/public/web/WebFrame.h" |
| 15 #include "third_party/WebKit/public/web/WebKit.h" |
| 16 |
| 17 namespace content { |
| 18 |
| 19 namespace { |
| 20 |
| 21 // Map role value to string, matching Safari/Mac platform implementation to |
| 22 // avoid rebaselining layout tests. |
| 23 std::string RoleToString(blink::WebAXRole role) |
| 24 { |
| 25 std::string result = "AXRole: AX"; |
| 26 switch (role) { |
| 27 case blink::WebAXRoleAlertDialog: |
| 28 return result.append("AlertDialog"); |
| 29 case blink::WebAXRoleAlert: |
| 30 return result.append("Alert"); |
| 31 case blink::WebAXRoleAnnotation: |
| 32 return result.append("Annotation"); |
| 33 case blink::WebAXRoleApplication: |
| 34 return result.append("Application"); |
| 35 case blink::WebAXRoleArticle: |
| 36 return result.append("Article"); |
| 37 case blink::WebAXRoleBanner: |
| 38 return result.append("Banner"); |
| 39 case blink::WebAXRoleBrowser: |
| 40 return result.append("Browser"); |
| 41 case blink::WebAXRoleBusyIndicator: |
| 42 return result.append("BusyIndicator"); |
| 43 case blink::WebAXRoleButton: |
| 44 return result.append("Button"); |
| 45 case blink::WebAXRoleCanvas: |
| 46 return result.append("Canvas"); |
| 47 case blink::WebAXRoleCell: |
| 48 return result.append("Cell"); |
| 49 case blink::WebAXRoleCheckBox: |
| 50 return result.append("CheckBox"); |
| 51 case blink::WebAXRoleColorWell: |
| 52 return result.append("ColorWell"); |
| 53 case blink::WebAXRoleColumnHeader: |
| 54 return result.append("ColumnHeader"); |
| 55 case blink::WebAXRoleColumn: |
| 56 return result.append("Column"); |
| 57 case blink::WebAXRoleComboBox: |
| 58 return result.append("ComboBox"); |
| 59 case blink::WebAXRoleComplementary: |
| 60 return result.append("Complementary"); |
| 61 case blink::WebAXRoleContentInfo: |
| 62 return result.append("ContentInfo"); |
| 63 case blink::WebAXRoleDefinition: |
| 64 return result.append("Definition"); |
| 65 case blink::WebAXRoleDescriptionListDetail: |
| 66 return result.append("DescriptionListDetail"); |
| 67 case blink::WebAXRoleDescriptionListTerm: |
| 68 return result.append("DescriptionListTerm"); |
| 69 case blink::WebAXRoleDialog: |
| 70 return result.append("Dialog"); |
| 71 case blink::WebAXRoleDirectory: |
| 72 return result.append("Directory"); |
| 73 case blink::WebAXRoleDisclosureTriangle: |
| 74 return result.append("DisclosureTriangle"); |
| 75 case blink::WebAXRoleDiv: |
| 76 return result.append("Div"); |
| 77 case blink::WebAXRoleDocument: |
| 78 return result.append("Document"); |
| 79 case blink::WebAXRoleDrawer: |
| 80 return result.append("Drawer"); |
| 81 case blink::WebAXRoleEditableText: |
| 82 return result.append("EditableText"); |
| 83 case blink::WebAXRoleFooter: |
| 84 return result.append("Footer"); |
| 85 case blink::WebAXRoleForm: |
| 86 return result.append("Form"); |
| 87 case blink::WebAXRoleGrid: |
| 88 return result.append("Grid"); |
| 89 case blink::WebAXRoleGroup: |
| 90 return result.append("Group"); |
| 91 case blink::WebAXRoleGrowArea: |
| 92 return result.append("GrowArea"); |
| 93 case blink::WebAXRoleHeading: |
| 94 return result.append("Heading"); |
| 95 case blink::WebAXRoleHelpTag: |
| 96 return result.append("HelpTag"); |
| 97 case blink::WebAXRoleHorizontalRule: |
| 98 return result.append("HorizontalRule"); |
| 99 case blink::WebAXRoleIgnored: |
| 100 return result.append("Ignored"); |
| 101 case blink::WebAXRoleImageMapLink: |
| 102 return result.append("ImageMapLink"); |
| 103 case blink::WebAXRoleImageMap: |
| 104 return result.append("ImageMap"); |
| 105 case blink::WebAXRoleImage: |
| 106 return result.append("Image"); |
| 107 case blink::WebAXRoleIncrementor: |
| 108 return result.append("Incrementor"); |
| 109 case blink::WebAXRoleInlineTextBox: |
| 110 return result.append("InlineTextBox"); |
| 111 case blink::WebAXRoleLabel: |
| 112 return result.append("Label"); |
| 113 case blink::WebAXRoleLegend: |
| 114 return result.append("Legend"); |
| 115 case blink::WebAXRoleLink: |
| 116 return result.append("Link"); |
| 117 case blink::WebAXRoleListBoxOption: |
| 118 return result.append("ListBoxOption"); |
| 119 case blink::WebAXRoleListBox: |
| 120 return result.append("ListBox"); |
| 121 case blink::WebAXRoleListItem: |
| 122 return result.append("ListItem"); |
| 123 case blink::WebAXRoleListMarker: |
| 124 return result.append("ListMarker"); |
| 125 case blink::WebAXRoleList: |
| 126 return result.append("List"); |
| 127 case blink::WebAXRoleLog: |
| 128 return result.append("Log"); |
| 129 case blink::WebAXRoleMain: |
| 130 return result.append("Main"); |
| 131 case blink::WebAXRoleMarquee: |
| 132 return result.append("Marquee"); |
| 133 case blink::WebAXRoleMathElement: |
| 134 return result.append("MathElement"); |
| 135 case blink::WebAXRoleMath: |
| 136 return result.append("Math"); |
| 137 case blink::WebAXRoleMatte: |
| 138 return result.append("Matte"); |
| 139 case blink::WebAXRoleMenuBar: |
| 140 return result.append("MenuBar"); |
| 141 case blink::WebAXRoleMenuButton: |
| 142 return result.append("MenuButton"); |
| 143 case blink::WebAXRoleMenuItem: |
| 144 return result.append("MenuItem"); |
| 145 case blink::WebAXRoleMenuListOption: |
| 146 return result.append("MenuListOption"); |
| 147 case blink::WebAXRoleMenuListPopup: |
| 148 return result.append("MenuListPopup"); |
| 149 case blink::WebAXRoleMenu: |
| 150 return result.append("Menu"); |
| 151 case blink::WebAXRoleNavigation: |
| 152 return result.append("Navigation"); |
| 153 case blink::WebAXRoleNote: |
| 154 return result.append("Note"); |
| 155 case blink::WebAXRoleOutline: |
| 156 return result.append("Outline"); |
| 157 case blink::WebAXRoleParagraph: |
| 158 return result.append("Paragraph"); |
| 159 case blink::WebAXRolePopUpButton: |
| 160 return result.append("PopUpButton"); |
| 161 case blink::WebAXRolePresentational: |
| 162 return result.append("Presentational"); |
| 163 case blink::WebAXRoleProgressIndicator: |
| 164 return result.append("ProgressIndicator"); |
| 165 case blink::WebAXRoleRadioButton: |
| 166 return result.append("RadioButton"); |
| 167 case blink::WebAXRoleRadioGroup: |
| 168 return result.append("RadioGroup"); |
| 169 case blink::WebAXRoleRegion: |
| 170 return result.append("Region"); |
| 171 case blink::WebAXRoleRootWebArea: |
| 172 return result.append("RootWebArea"); |
| 173 case blink::WebAXRoleRowHeader: |
| 174 return result.append("RowHeader"); |
| 175 case blink::WebAXRoleRow: |
| 176 return result.append("Row"); |
| 177 case blink::WebAXRoleRulerMarker: |
| 178 return result.append("RulerMarker"); |
| 179 case blink::WebAXRoleRuler: |
| 180 return result.append("Ruler"); |
| 181 case blink::WebAXRoleSVGRoot: |
| 182 return result.append("SVGRoot"); |
| 183 case blink::WebAXRoleScrollArea: |
| 184 return result.append("ScrollArea"); |
| 185 case blink::WebAXRoleScrollBar: |
| 186 return result.append("ScrollBar"); |
| 187 case blink::WebAXRoleSeamlessWebArea: |
| 188 return result.append("SeamlessWebArea"); |
| 189 case blink::WebAXRoleSearch: |
| 190 return result.append("Search"); |
| 191 case blink::WebAXRoleSheet: |
| 192 return result.append("Sheet"); |
| 193 case blink::WebAXRoleSlider: |
| 194 return result.append("Slider"); |
| 195 case blink::WebAXRoleSliderThumb: |
| 196 return result.append("SliderThumb"); |
| 197 case blink::WebAXRoleSpinButtonPart: |
| 198 return result.append("SpinButtonPart"); |
| 199 case blink::WebAXRoleSpinButton: |
| 200 return result.append("SpinButton"); |
| 201 case blink::WebAXRoleSplitGroup: |
| 202 return result.append("SplitGroup"); |
| 203 case blink::WebAXRoleSplitter: |
| 204 return result.append("Splitter"); |
| 205 case blink::WebAXRoleStaticText: |
| 206 return result.append("StaticText"); |
| 207 case blink::WebAXRoleStatus: |
| 208 return result.append("Status"); |
| 209 case blink::WebAXRoleSystemWide: |
| 210 return result.append("SystemWide"); |
| 211 case blink::WebAXRoleTabGroup: |
| 212 return result.append("TabGroup"); |
| 213 case blink::WebAXRoleTabList: |
| 214 return result.append("TabList"); |
| 215 case blink::WebAXRoleTabPanel: |
| 216 return result.append("TabPanel"); |
| 217 case blink::WebAXRoleTab: |
| 218 return result.append("Tab"); |
| 219 case blink::WebAXRoleTableHeaderContainer: |
| 220 return result.append("TableHeaderContainer"); |
| 221 case blink::WebAXRoleTable: |
| 222 return result.append("Table"); |
| 223 case blink::WebAXRoleTextArea: |
| 224 return result.append("TextArea"); |
| 225 case blink::WebAXRoleTextField: |
| 226 return result.append("TextField"); |
| 227 case blink::WebAXRoleTimer: |
| 228 return result.append("Timer"); |
| 229 case blink::WebAXRoleToggleButton: |
| 230 return result.append("ToggleButton"); |
| 231 case blink::WebAXRoleToolbar: |
| 232 return result.append("Toolbar"); |
| 233 case blink::WebAXRoleTreeGrid: |
| 234 return result.append("TreeGrid"); |
| 235 case blink::WebAXRoleTreeItem: |
| 236 return result.append("TreeItem"); |
| 237 case blink::WebAXRoleTree: |
| 238 return result.append("Tree"); |
| 239 case blink::WebAXRoleUnknown: |
| 240 return result.append("Unknown"); |
| 241 case blink::WebAXRoleUserInterfaceTooltip: |
| 242 return result.append("UserInterfaceTooltip"); |
| 243 case blink::WebAXRoleValueIndicator: |
| 244 return result.append("ValueIndicator"); |
| 245 case blink::WebAXRoleWebArea: |
| 246 return result.append("WebArea"); |
| 247 case blink::WebAXRoleWindow: |
| 248 return result.append("Window"); |
| 249 default: |
| 250 return result.append("Unknown"); |
| 251 } |
| 252 } |
| 253 |
| 254 std::string GetDescription(const blink::WebAXObject& object) { |
| 255 std::string description = object.accessibilityDescription().utf8(); |
| 256 return description.insert(0, "AXDescription: "); |
| 257 } |
| 258 |
| 259 std::string GetHelpText(const blink::WebAXObject& object) { |
| 260 std::string help_text = object.helpText().utf8(); |
| 261 return help_text.insert(0, "AXHelp: "); |
| 262 } |
| 263 |
| 264 std::string GetStringValue(const blink::WebAXObject& object) { |
| 265 std::string value; |
| 266 if (object.role() == blink::WebAXRoleColorWell) { |
| 267 int r, g, b; |
| 268 char buffer[100]; |
| 269 object.colorValue(r, g, b); |
| 270 snprintf(buffer, sizeof(buffer), "rgb %7.5f %7.5f %7.5f 1", |
| 271 r / 255., g / 255., b / 255.); |
| 272 value = buffer; |
| 273 } else { |
| 274 value = object.stringValue().utf8(); |
| 275 } |
| 276 return value.insert(0, "AXValue: "); |
| 277 } |
| 278 |
| 279 std::string GetRole(const blink::WebAXObject& object) { |
| 280 std::string role_string = RoleToString(object.role()); |
| 281 |
| 282 // Special-case canvas with fallback content because Chromium wants to treat |
| 283 // this as essentially a separate role that it can map differently depending |
| 284 // on the platform. |
| 285 if (object.role() == blink::WebAXRoleCanvas && |
| 286 object.canvasHasFallbackContent()) { |
| 287 role_string += "WithFallbackContent"; |
| 288 } |
| 289 |
| 290 return role_string; |
| 291 } |
| 292 |
| 293 std::string GetTitle(const blink::WebAXObject& object) { |
| 294 std::string title = object.title().utf8(); |
| 295 return title.insert(0, "AXTitle: "); |
| 296 } |
| 297 |
| 298 std::string GetOrientation(const blink::WebAXObject& object) { |
| 299 if (object.isVertical()) |
| 300 return "AXOrientation: AXVerticalOrientation"; |
| 301 |
| 302 return "AXOrientation: AXHorizontalOrientation"; |
| 303 } |
| 304 |
| 305 std::string GetValueDescription(const blink::WebAXObject& object) { |
| 306 std::string value_description = object.valueDescription().utf8(); |
| 307 return value_description.insert(0, "AXValueDescription: "); |
| 308 } |
| 309 |
| 310 std::string GetAttributes(const blink::WebAXObject& object) { |
| 311 // FIXME: Concatenate all attributes of the AXObject. |
| 312 std::string attributes(GetTitle(object)); |
| 313 attributes.append("\n"); |
| 314 attributes.append(GetRole(object)); |
| 315 attributes.append("\n"); |
| 316 attributes.append(GetDescription(object)); |
| 317 return attributes; |
| 318 } |
| 319 |
| 320 blink::WebRect BoundsForCharacter(const blink::WebAXObject& object, |
| 321 int characterIndex) { |
| 322 DCHECK_EQ(object.role(), blink::WebAXRoleStaticText); |
| 323 int end = 0; |
| 324 for (unsigned i = 0; i < object.childCount(); i++) { |
| 325 blink::WebAXObject inline_text_box = object.childAt(i); |
| 326 DCHECK_EQ(inline_text_box.role(), blink::WebAXRoleInlineTextBox); |
| 327 int start = end; |
| 328 end += inline_text_box.stringValue().length(); |
| 329 if (end <= characterIndex) |
| 330 continue; |
| 331 blink::WebRect inline_text_box_rect = inline_text_box.boundingBoxRect(); |
| 332 int localIndex = characterIndex - start; |
| 333 blink::WebVector<int> character_offsets; |
| 334 inline_text_box.characterOffsets(character_offsets); |
| 335 DCHECK(character_offsets.size() > 0 && |
| 336 character_offsets.size() == inline_text_box.stringValue().length()); |
| 337 switch (inline_text_box.textDirection()) { |
| 338 case blink::WebAXTextDirectionLR: { |
| 339 if (localIndex) { |
| 340 int left = inline_text_box_rect.x + character_offsets[localIndex - 1]; |
| 341 int width = character_offsets[localIndex] - |
| 342 character_offsets[localIndex - 1]; |
| 343 return blink::WebRect(left, inline_text_box_rect.y, |
| 344 width, inline_text_box_rect.height); |
| 345 } |
| 346 return blink::WebRect( |
| 347 inline_text_box_rect.x, inline_text_box_rect.y, |
| 348 character_offsets[0], inline_text_box_rect.height); |
| 349 } |
| 350 case blink::WebAXTextDirectionRL: { |
| 351 int right = inline_text_box_rect.x + inline_text_box_rect.width; |
| 352 |
| 353 if (localIndex) { |
| 354 int left = right - character_offsets[localIndex]; |
| 355 int width = character_offsets[localIndex] - |
| 356 character_offsets[localIndex - 1]; |
| 357 return blink::WebRect(left, inline_text_box_rect.y, |
| 358 width, inline_text_box_rect.height); |
| 359 } |
| 360 int left = right - character_offsets[0]; |
| 361 return blink::WebRect( |
| 362 left, inline_text_box_rect.y, |
| 363 character_offsets[0], inline_text_box_rect.height); |
| 364 } |
| 365 case blink::WebAXTextDirectionTB: { |
| 366 if (localIndex) { |
| 367 int top = inline_text_box_rect.y + character_offsets[localIndex - 1]; |
| 368 int height = character_offsets[localIndex] - |
| 369 character_offsets[localIndex - 1]; |
| 370 return blink::WebRect(inline_text_box_rect.x, top, |
| 371 inline_text_box_rect.width, height); |
| 372 } |
| 373 return blink::WebRect(inline_text_box_rect.x, inline_text_box_rect.y, |
| 374 inline_text_box_rect.width, character_offsets[0]); |
| 375 } |
| 376 case blink::WebAXTextDirectionBT: { |
| 377 int bottom = inline_text_box_rect.y + inline_text_box_rect.height; |
| 378 |
| 379 if (localIndex) { |
| 380 int top = bottom - character_offsets[localIndex]; |
| 381 int height = character_offsets[localIndex] - |
| 382 character_offsets[localIndex - 1]; |
| 383 return blink::WebRect(inline_text_box_rect.x, top, |
| 384 inline_text_box_rect.width, height); |
| 385 } |
| 386 int top = bottom - character_offsets[0]; |
| 387 return blink::WebRect(inline_text_box_rect.x, top, |
| 388 inline_text_box_rect.width, character_offsets[0]); |
| 389 } |
| 390 } |
| 391 } |
| 392 |
| 393 DCHECK(false); |
| 394 return blink::WebRect(); |
| 395 } |
| 396 |
| 397 void GetBoundariesForOneWord(const blink::WebAXObject& object, |
| 398 int character_index, |
| 399 int& word_start, |
| 400 int& word_end) { |
| 401 int end = 0; |
| 402 for (unsigned i = 0; i < object.childCount(); i++) { |
| 403 blink::WebAXObject inline_text_box = object.childAt(i); |
| 404 DCHECK_EQ(inline_text_box.role(), blink::WebAXRoleInlineTextBox); |
| 405 int start = end; |
| 406 end += inline_text_box.stringValue().length(); |
| 407 if (end <= character_index) |
| 408 continue; |
| 409 int localIndex = character_index - start; |
| 410 |
| 411 blink::WebVector<int> starts; |
| 412 blink::WebVector<int> ends; |
| 413 inline_text_box.wordBoundaries(starts, ends); |
| 414 size_t word_count = starts.size(); |
| 415 DCHECK_EQ(ends.size(), word_count); |
| 416 |
| 417 // If there are no words, use the InlineTextBox boundaries. |
| 418 if (!word_count) { |
| 419 word_start = start; |
| 420 word_end = end; |
| 421 return; |
| 422 } |
| 423 |
| 424 // Look for a character within any word other than the last. |
| 425 for (size_t j = 0; j < word_count - 1; j++) { |
| 426 if (localIndex <= ends[j]) { |
| 427 word_start = start + starts[j]; |
| 428 word_end = start + ends[j]; |
| 429 return; |
| 430 } |
| 431 } |
| 432 |
| 433 // Return the last word by default. |
| 434 word_start = start + starts[word_count - 1]; |
| 435 word_end = start + ends[word_count - 1]; |
| 436 return; |
| 437 } |
| 438 } |
| 439 |
| 440 // Collects attributes into a string, delimited by dashes. Used by all methods |
| 441 // that output lists of attributes: attributesOfLinkedUIElementsCallback, |
| 442 // AttributesOfChildrenCallback, etc. |
| 443 class AttributesCollector { |
| 444 public: |
| 445 AttributesCollector() {} |
| 446 ~AttributesCollector() {} |
| 447 |
| 448 void CollectAttributes(const blink::WebAXObject& object) { |
| 449 attributes_.append("\n------------\n"); |
| 450 attributes_.append(GetAttributes(object)); |
| 451 } |
| 452 |
| 453 std::string attributes() const { return attributes_; } |
| 454 |
| 455 private: |
| 456 std::string attributes_; |
| 457 |
| 458 DISALLOW_COPY_AND_ASSIGN(AttributesCollector); |
| 459 }; |
| 460 |
| 461 } // namespace |
| 462 |
| 463 // static |
| 464 gin::WrapperInfo WebAXObjectProxy::kWrapperInfo = { |
| 465 gin::kEmbedderNativeGin, |
| 466 }; |
| 467 |
| 468 WebAXObjectProxy::WebAXObjectProxy(const blink::WebAXObject& object, |
| 469 WebAXObjectProxy::Factory* factory) |
| 470 : frame_(NULL), |
| 471 accessibility_object_(object), |
| 472 factory_(factory) { |
| 473 } |
| 474 |
| 475 WebAXObjectProxy::~WebAXObjectProxy() { |
| 476 } |
| 477 |
| 478 gin::ObjectTemplateBuilder |
| 479 WebAXObjectProxy::GetObjectTemplateBuilder(v8::Isolate* isolate) { |
| 480 return gin::Wrappable<WebAXObjectProxy>::GetObjectTemplateBuilder(isolate) |
| 481 .SetMethod("role", &WebAXObjectProxy::Role) |
| 482 .SetMethod("title", &WebAXObjectProxy::Title) |
| 483 .SetMethod("description", &WebAXObjectProxy::Description) |
| 484 .SetMethod("helpText", &WebAXObjectProxy::HelpText) |
| 485 .SetMethod("stringValue", &WebAXObjectProxy::StringValue) |
| 486 .SetMethod("x", &WebAXObjectProxy::X) |
| 487 .SetMethod("y", &WebAXObjectProxy::Y) |
| 488 .SetMethod("width", &WebAXObjectProxy::Width) |
| 489 .SetMethod("height", &WebAXObjectProxy::Height) |
| 490 .SetMethod("intValue", &WebAXObjectProxy::IntValue) |
| 491 .SetMethod("minValue", &WebAXObjectProxy::MinValue) |
| 492 .SetMethod("maxValue", &WebAXObjectProxy::MaxValue) |
| 493 .SetMethod("valueDescription", &WebAXObjectProxy::ValueDescription) |
| 494 .SetMethod("childrenCount", &WebAXObjectProxy::ChildrenCount) |
| 495 .SetMethod("insertionPointLineNumber", |
| 496 &WebAXObjectProxy::InsertionPointLineNumber) |
| 497 .SetMethod("selectedTextRange", &WebAXObjectProxy::SelectedTextRange) |
| 498 .SetMethod("isEnabled", &WebAXObjectProxy::IsEnabled) |
| 499 .SetMethod("isRequired", &WebAXObjectProxy::IsRequired) |
| 500 .SetMethod("isFocused", &WebAXObjectProxy::IsFocused) |
| 501 .SetMethod("isFocusable", &WebAXObjectProxy::IsFocusable) |
| 502 .SetMethod("isSelected", &WebAXObjectProxy::IsSelected) |
| 503 .SetMethod("isSelectable", &WebAXObjectProxy::IsSelectable) |
| 504 .SetMethod("isMultiSelectable", &WebAXObjectProxy::IsMultiSelectable) |
| 505 .SetMethod("isSelectedOptionActive", |
| 506 &WebAXObjectProxy::IsSelectedOptionActive) |
| 507 .SetMethod("isExpanded", &WebAXObjectProxy::IsExpanded) |
| 508 .SetMethod("isChecked", &WebAXObjectProxy::IsChecked) |
| 509 .SetMethod("isVisible", &WebAXObjectProxy::IsVisible) |
| 510 .SetMethod("isOffScreen", &WebAXObjectProxy::IsOffScreen) |
| 511 .SetMethod("isCollapsed", &WebAXObjectProxy::IsCollapsed) |
| 512 .SetMethod("hasPopup", &WebAXObjectProxy::HasPopup) |
| 513 .SetMethod("isValid", &WebAXObjectProxy::IsValid) |
| 514 .SetMethod("isReadOnly", &WebAXObjectProxy::IsReadOnly) |
| 515 .SetMethod("orientation", &WebAXObjectProxy::Orientation) |
| 516 .SetMethod("clickPointX", &WebAXObjectProxy::ClickPointX) |
| 517 .SetMethod("clickPointY", &WebAXObjectProxy::ClickPointY) |
| 518 .SetMethod("rowCount", &WebAXObjectProxy::RowCount) |
| 519 .SetMethod("columnCount", &WebAXObjectProxy::ColumnCount) |
| 520 .SetMethod("isClickable", &WebAXObjectProxy::IsClickable) |
| 521 .SetMethod("allAttributes", &WebAXObjectProxy::AllAttributes) |
| 522 .SetMethod("attributesOfChildren", |
| 523 &WebAXObjectProxy::AttributesOfChildren) |
| 524 .SetMethod("lineForIndex", &WebAXObjectProxy::LineForIndex) |
| 525 .SetMethod("boundsForRange", &WebAXObjectProxy::BoundsForRange) |
| 526 .SetMethod("childAtIndex", &WebAXObjectProxy::ChildAtIndex) |
| 527 .SetMethod("elementAtPoint", &WebAXObjectProxy::ElementAtPoint) |
| 528 .SetMethod("tableHeader", &WebAXObjectProxy::TableHeader) |
| 529 .SetMethod("rowIndexRange", &WebAXObjectProxy::RowIndexRange) |
| 530 .SetMethod("columnIndexRange", &WebAXObjectProxy::ColumnIndexRange) |
| 531 .SetMethod("cellForColumnAndRow", &WebAXObjectProxy::CellForColumnAndRow) |
| 532 .SetMethod("titleUIElement", &WebAXObjectProxy::TitleUIElement) |
| 533 .SetMethod("setSelectedTextRange", |
| 534 &WebAXObjectProxy::SetSelectedTextRange) |
| 535 .SetMethod("isAttributeSettable", &WebAXObjectProxy::IsAttributeSettable) |
| 536 .SetMethod("isPressActionSupported", |
| 537 &WebAXObjectProxy::IsPressActionSupported) |
| 538 .SetMethod("isIncrementActionSupported", |
| 539 &WebAXObjectProxy::IsIncrementActionSupported) |
| 540 .SetMethod("isDecrementActionSupported", |
| 541 &WebAXObjectProxy::IsDecrementActionSupported) |
| 542 .SetMethod("parentElement", &WebAXObjectProxy::ParentElement) |
| 543 .SetMethod("increment", &WebAXObjectProxy::Increment) |
| 544 .SetMethod("decrement", &WebAXObjectProxy::Decrement) |
| 545 .SetMethod("showMenu", &WebAXObjectProxy::ShowMenu) |
| 546 .SetMethod("press", &WebAXObjectProxy::Press) |
| 547 //.SetMethod("isEqual", &WebAXObjectProxy::IsEqual) // TODO: Fix this |
| 548 .SetMethod("addNotificationListener", |
| 549 &WebAXObjectProxy::AddNotificationListener) |
| 550 .SetMethod("removeNotificationListener", |
| 551 &WebAXObjectProxy::RemoveNotificationListener) |
| 552 .SetMethod("takeFocus", &WebAXObjectProxy::TakeFocus) |
| 553 .SetMethod("scrollToMakeVisible", &WebAXObjectProxy::ScrollToMakeVisible) |
| 554 .SetMethod("scrollToMakeVisibleWithSubFocus", |
| 555 &WebAXObjectProxy::ScrollToMakeVisibleWithSubFocus) |
| 556 .SetMethod("scrollToGlobalPoint", &WebAXObjectProxy::ScrollToGlobalPoint) |
| 557 .SetMethod("wordStart", &WebAXObjectProxy::WordStart) |
| 558 .SetMethod("wordEnd", &WebAXObjectProxy::WordEnd); |
| 559 } |
| 560 |
| 561 v8::Handle<v8::Object> WebAXObjectProxy::GetChildAtIndex(unsigned index) { |
| 562 return factory_->GetOrCreate(accessibility_object().childAt(index)); |
| 563 } |
| 564 |
| 565 bool WebAXObjectProxy::IsRoot() const { |
| 566 return false; |
| 567 } |
| 568 |
| 569 bool WebAXObjectProxy::IsEqualToObject(const blink::WebAXObject& other) { |
| 570 return accessibility_object().equals(other); |
| 571 } |
| 572 |
| 573 void WebAXObjectProxy::NotificationReceived( |
| 574 const std::string& notification_name) { |
| 575 // TODO(hajimehoshi): Check them later. |
| 576 v8::Isolate* isolate = v8::Isolate::GetCurrent(); |
| 577 v8::HandleScope handle_scope(isolate); |
| 578 v8::Handle<v8::Context> context = frame_->mainWorldScriptContext(); |
| 579 if (context.IsEmpty()) |
| 580 return; |
| 581 |
| 582 v8::Context::Scope context_scope(context); |
| 583 |
| 584 size_t callback_count = notification_callbacks_.size(); |
| 585 for (size_t i = 0; i < callback_count; i++) { |
| 586 v8::Handle<v8::Value> argv[] = { |
| 587 v8::String::NewFromUtf8(isolate, notification_name.data(), |
| 588 v8::String::kNormalString, |
| 589 notification_name.size()), |
| 590 }; |
| 591 notification_callbacks_[i]->Call(context->Global(), 1, argv); |
| 592 } |
| 593 } |
| 594 |
| 595 std::string WebAXObjectProxy::Role() { |
| 596 return GetRole(accessibility_object()); |
| 597 } |
| 598 |
| 599 std::string WebAXObjectProxy::Title() { |
| 600 return GetTitle(accessibility_object()); |
| 601 } |
| 602 |
| 603 std::string WebAXObjectProxy::Description() { |
| 604 return GetDescription(accessibility_object()); |
| 605 } |
| 606 |
| 607 std::string WebAXObjectProxy::HelpText() { |
| 608 return GetHelpText(accessibility_object()); |
| 609 } |
| 610 |
| 611 std::string WebAXObjectProxy::StringValue() { |
| 612 return GetStringValue(accessibility_object()); |
| 613 } |
| 614 |
| 615 int WebAXObjectProxy::X() { |
| 616 return accessibility_object().boundingBoxRect().x; |
| 617 } |
| 618 |
| 619 int WebAXObjectProxy::Y() { |
| 620 return accessibility_object().boundingBoxRect().y; |
| 621 } |
| 622 |
| 623 int WebAXObjectProxy::Width() { |
| 624 return accessibility_object().boundingBoxRect().width; |
| 625 } |
| 626 |
| 627 int WebAXObjectProxy::Height() { |
| 628 return accessibility_object().boundingBoxRect().height; |
| 629 } |
| 630 |
| 631 int WebAXObjectProxy::IntValue() { |
| 632 if (accessibility_object().supportsRangeValue()) |
| 633 return accessibility_object().valueForRange(); |
| 634 else if (accessibility_object().role() == blink::WebAXRoleHeading) |
| 635 return accessibility_object().headingLevel(); |
| 636 else |
| 637 return atoi(accessibility_object().stringValue().utf8().data()); |
| 638 } |
| 639 |
| 640 int WebAXObjectProxy::MinValue() { |
| 641 return accessibility_object().minValueForRange(); |
| 642 } |
| 643 |
| 644 int WebAXObjectProxy::MaxValue() { |
| 645 return accessibility_object().maxValueForRange(); |
| 646 } |
| 647 |
| 648 std::string WebAXObjectProxy::ValueDescription() { |
| 649 return GetValueDescription(accessibility_object()); |
| 650 } |
| 651 |
| 652 int WebAXObjectProxy::ChildrenCount() { |
| 653 int count = 1; // Root object always has only one child, the WebView. |
| 654 if (!IsRoot()) |
| 655 count = accessibility_object().childCount(); |
| 656 return count; |
| 657 } |
| 658 |
| 659 int WebAXObjectProxy::InsertionPointLineNumber() { |
| 660 if (!accessibility_object().isFocused()) |
| 661 return -1; |
| 662 return accessibility_object().selectionEndLineNumber(); |
| 663 } |
| 664 |
| 665 std::string WebAXObjectProxy::SelectedTextRange() { |
| 666 unsigned selection_start = accessibility_object().selectionStart(); |
| 667 unsigned selection_end = accessibility_object().selectionEnd(); |
| 668 char buffer[100]; |
| 669 snprintf(buffer, sizeof(buffer), "{%d, %d}", |
| 670 selection_start, selection_end - selection_start); |
| 671 return std::string(buffer); |
| 672 } |
| 673 |
| 674 bool WebAXObjectProxy::IsEnabled() { |
| 675 return accessibility_object().isEnabled(); |
| 676 } |
| 677 |
| 678 bool WebAXObjectProxy::IsRequired() { |
| 679 return accessibility_object().isRequired(); |
| 680 } |
| 681 |
| 682 bool WebAXObjectProxy::IsFocused() { |
| 683 return accessibility_object().isFocused(); |
| 684 } |
| 685 |
| 686 bool WebAXObjectProxy::IsFocusable() { |
| 687 return accessibility_object().canSetFocusAttribute(); |
| 688 } |
| 689 |
| 690 bool WebAXObjectProxy::IsSelected() { |
| 691 return accessibility_object().isSelected(); |
| 692 } |
| 693 |
| 694 bool WebAXObjectProxy::IsSelectable() { |
| 695 return accessibility_object().canSetSelectedAttribute(); |
| 696 } |
| 697 |
| 698 bool WebAXObjectProxy::IsMultiSelectable() { |
| 699 return accessibility_object().isMultiSelectable(); |
| 700 } |
| 701 |
| 702 bool WebAXObjectProxy::IsSelectedOptionActive() { |
| 703 return accessibility_object().isSelectedOptionActive(); |
| 704 } |
| 705 |
| 706 bool WebAXObjectProxy::IsExpanded() { |
| 707 return !accessibility_object().isCollapsed(); |
| 708 } |
| 709 |
| 710 bool WebAXObjectProxy::IsChecked() { |
| 711 return accessibility_object().isChecked(); |
| 712 } |
| 713 |
| 714 bool WebAXObjectProxy::IsVisible() { |
| 715 return accessibility_object().isVisible(); |
| 716 } |
| 717 |
| 718 bool WebAXObjectProxy::IsOffScreen() { |
| 719 return accessibility_object().isOffScreen(); |
| 720 } |
| 721 |
| 722 bool WebAXObjectProxy::IsCollapsed() { |
| 723 return accessibility_object().isCollapsed(); |
| 724 } |
| 725 |
| 726 bool WebAXObjectProxy::HasPopup() { |
| 727 return accessibility_object().ariaHasPopup(); |
| 728 } |
| 729 |
| 730 bool WebAXObjectProxy::IsValid() { |
| 731 return !accessibility_object().isDetached(); |
| 732 } |
| 733 |
| 734 bool WebAXObjectProxy::IsReadOnly() { |
| 735 return accessibility_object().isReadOnly(); |
| 736 } |
| 737 |
| 738 std::string WebAXObjectProxy::Orientation() { |
| 739 return GetOrientation(accessibility_object()); |
| 740 } |
| 741 |
| 742 int WebAXObjectProxy::ClickPointX() { |
| 743 return accessibility_object().clickPoint().x; |
| 744 } |
| 745 |
| 746 int WebAXObjectProxy::ClickPointY() { |
| 747 return accessibility_object().clickPoint().y; |
| 748 } |
| 749 |
| 750 int32_t WebAXObjectProxy::RowCount() { |
| 751 return static_cast<int32_t>(accessibility_object().rowCount()); |
| 752 } |
| 753 |
| 754 int32_t WebAXObjectProxy::ColumnCount() { |
| 755 return static_cast<int32_t>(accessibility_object().columnCount()); |
| 756 } |
| 757 |
| 758 bool WebAXObjectProxy::IsClickable() { |
| 759 return accessibility_object().isClickable(); |
| 760 } |
| 761 |
| 762 std::string WebAXObjectProxy::AllAttributes() { |
| 763 return GetAttributes(accessibility_object()); |
| 764 } |
| 765 |
| 766 std::string WebAXObjectProxy::AttributesOfChildren() { |
| 767 AttributesCollector collector; |
| 768 unsigned size = accessibility_object().childCount(); |
| 769 for (unsigned i = 0; i < size; ++i) |
| 770 collector.CollectAttributes(accessibility_object().childAt(i)); |
| 771 return collector.attributes(); |
| 772 } |
| 773 |
| 774 int WebAXObjectProxy::LineForIndex(int index) { |
| 775 blink::WebVector<int> line_breaks; |
| 776 accessibility_object().lineBreaks(line_breaks); |
| 777 int line = 0; |
| 778 int vector_size = static_cast<int>(line_breaks.size()); |
| 779 while (line < vector_size && line_breaks[line] <= index) |
| 780 line++; |
| 781 return line; |
| 782 } |
| 783 |
| 784 std::string WebAXObjectProxy::BoundsForRange(int start, int end) { |
| 785 if (accessibility_object().role() != blink::WebAXRoleStaticText) |
| 786 return std::string(); |
| 787 |
| 788 int len = end - start; |
| 789 |
| 790 // Get the bounds for each character and union them into one large rectangle. |
| 791 // This is just for testing so it doesn't need to be efficient. |
| 792 blink::WebRect bounds = BoundsForCharacter(accessibility_object(), start); |
| 793 for (int i = 1; i < len; i++) { |
| 794 blink::WebRect next = BoundsForCharacter(accessibility_object(), start + i); |
| 795 int right = std::max(bounds.x + bounds.width, next.x + next.width); |
| 796 int bottom = std::max(bounds.y + bounds.height, next.y + next.height); |
| 797 bounds.x = std::min(bounds.x, next.x); |
| 798 bounds.y = std::min(bounds.y, next.y); |
| 799 bounds.width = right - bounds.x; |
| 800 bounds.height = bottom - bounds.y; |
| 801 } |
| 802 |
| 803 char buffer[100]; |
| 804 snprintf(buffer, sizeof(buffer), "{x: %d, y: %d, width: %d, height: %d}", |
| 805 bounds.x, bounds.y, bounds.width, bounds.height); |
| 806 return std::string(buffer); |
| 807 } |
| 808 |
| 809 v8::Handle<v8::Object> WebAXObjectProxy::ChildAtIndex(int index) { |
| 810 return v8::Handle<v8::Object>::Cast(GetChildAtIndex(index)); |
| 811 } |
| 812 |
| 813 v8::Handle<v8::Object> WebAXObjectProxy::ElementAtPoint(int x, int y) { |
| 814 blink::WebPoint point(x, y); |
| 815 blink::WebAXObject obj = accessibility_object().hitTest(point); |
| 816 if (obj.isNull()) |
| 817 return v8::Handle<v8::Object>(); |
| 818 |
| 819 return factory_->GetOrCreate(obj); |
| 820 } |
| 821 |
| 822 v8::Handle<v8::Object> WebAXObjectProxy::TableHeader() { |
| 823 blink::WebAXObject obj = accessibility_object().headerContainerObject(); |
| 824 if (obj.isNull()) |
| 825 return v8::Handle<v8::Object>(); |
| 826 |
| 827 return factory_->GetOrCreate(obj); |
| 828 } |
| 829 |
| 830 std::string WebAXObjectProxy::RowIndexRange() { |
| 831 unsigned row_index = accessibility_object().cellRowIndex(); |
| 832 unsigned row_span = accessibility_object().cellRowSpan(); |
| 833 char buffer[100]; |
| 834 snprintf(buffer, sizeof(buffer), "{%d, %d}", row_index, row_span); |
| 835 return std::string(buffer); |
| 836 } |
| 837 |
| 838 std::string WebAXObjectProxy::ColumnIndexRange() { |
| 839 unsigned column_index = accessibility_object().cellColumnIndex(); |
| 840 unsigned column_span = accessibility_object().cellColumnSpan(); |
| 841 char buffer[100]; |
| 842 snprintf(buffer, sizeof(buffer), "{%d, %d}", column_index, column_span); |
| 843 return std::string(buffer); |
| 844 } |
| 845 |
| 846 v8::Handle<v8::Object> WebAXObjectProxy::CellForColumnAndRow(int column, int row
) { |
| 847 blink::WebAXObject obj = |
| 848 accessibility_object().cellForColumnAndRow(column, row); |
| 849 if (obj.isNull()) |
| 850 return v8::Handle<v8::Object>(); |
| 851 |
| 852 return factory_->GetOrCreate(obj); |
| 853 } |
| 854 |
| 855 v8::Handle<v8::Object> WebAXObjectProxy::TitleUIElement() { |
| 856 blink::WebAXObject obj = accessibility_object().titleUIElement(); |
| 857 if (obj.isNull()) { |
| 858 return v8::Handle<v8::Object>(); |
| 859 } |
| 860 |
| 861 return factory_->GetOrCreate(obj); |
| 862 } |
| 863 |
| 864 void WebAXObjectProxy::SetSelectedTextRange(int selection_start, |
| 865 int selection_end) { |
| 866 accessibility_object().setSelectedTextRange(selection_start, selection_end); |
| 867 } |
| 868 |
| 869 bool WebAXObjectProxy::IsAttributeSettable(const std::string& attribute) { |
| 870 bool settable = false; |
| 871 if (attribute == "AXValue") |
| 872 settable = accessibility_object().canSetValueAttribute(); |
| 873 return settable; |
| 874 } |
| 875 |
| 876 bool WebAXObjectProxy::IsPressActionSupported() { |
| 877 return accessibility_object().canPress(); |
| 878 } |
| 879 |
| 880 bool WebAXObjectProxy::IsIncrementActionSupported() { |
| 881 return accessibility_object().canIncrement(); |
| 882 } |
| 883 |
| 884 bool WebAXObjectProxy::IsDecrementActionSupported() { |
| 885 return accessibility_object().canDecrement(); |
| 886 } |
| 887 |
| 888 v8::Handle<v8::Object> WebAXObjectProxy::ParentElement() { |
| 889 blink::WebAXObject parent_object = accessibility_object().parentObject(); |
| 890 while (parent_object.accessibilityIsIgnored()) |
| 891 parent_object = parent_object.parentObject(); |
| 892 return factory_->GetOrCreate(parent_object); |
| 893 } |
| 894 |
| 895 void WebAXObjectProxy::Increment() { |
| 896 accessibility_object().increment(); |
| 897 } |
| 898 |
| 899 void WebAXObjectProxy::Decrement() { |
| 900 accessibility_object().decrement(); |
| 901 } |
| 902 |
| 903 void WebAXObjectProxy::ShowMenu() { |
| 904 } |
| 905 |
| 906 void WebAXObjectProxy::Press() { |
| 907 accessibility_object().press(); |
| 908 } |
| 909 |
| 910 bool WebAXObjectProxy::IsEqual(v8::Handle<v8::Object> proxy) { |
| 911 //return v8::Handle<WebAXObjectProxy>::Cast<v8::Object>(proxy)->IsEqualToObjec
t(accessibility_object_); |
| 912 // implement |
| 913 return false; |
| 914 } |
| 915 |
| 916 void WebAXObjectProxy::AddNotificationListener( |
| 917 v8::Handle<v8::Function> callback) { |
| 918 notification_callbacks_.push_back(callback); |
| 919 } |
| 920 |
| 921 void WebAXObjectProxy::RemoveNotificationListener() { |
| 922 // FIXME: Implement this. |
| 923 } |
| 924 |
| 925 void WebAXObjectProxy::TakeFocus() { |
| 926 accessibility_object().setFocused(true); |
| 927 } |
| 928 |
| 929 void WebAXObjectProxy::ScrollToMakeVisible() { |
| 930 accessibility_object().scrollToMakeVisible(); |
| 931 } |
| 932 |
| 933 void WebAXObjectProxy::ScrollToMakeVisibleWithSubFocus(int x, int y, |
| 934 int width, int height) { |
| 935 accessibility_object().scrollToMakeVisibleWithSubFocus( |
| 936 blink::WebRect(x, y, width, height)); |
| 937 } |
| 938 |
| 939 void WebAXObjectProxy::ScrollToGlobalPoint(int x, int y) { |
| 940 accessibility_object().scrollToGlobalPoint(blink::WebPoint(x, y)); |
| 941 } |
| 942 |
| 943 int WebAXObjectProxy::WordStart(int character_index) { |
| 944 if (accessibility_object().role() != blink::WebAXRoleStaticText) |
| 945 return -1; |
| 946 |
| 947 int word_start, word_end; |
| 948 GetBoundariesForOneWord(accessibility_object(), character_index, |
| 949 word_start, word_end); |
| 950 return word_start; |
| 951 } |
| 952 |
| 953 int WebAXObjectProxy::WordEnd(int character_index) { |
| 954 if (accessibility_object().role() != blink::WebAXRoleStaticText) |
| 955 return -1; |
| 956 |
| 957 int word_start, word_end; |
| 958 GetBoundariesForOneWord(accessibility_object(), character_index, |
| 959 word_start, word_end); |
| 960 return word_end; |
| 961 } |
| 962 |
| 963 RootWebAXObjectProxy::RootWebAXObjectProxy( |
| 964 const blink::WebAXObject &object, Factory *factory) |
| 965 : WebAXObjectProxy(object, factory) { |
| 966 } |
| 967 |
| 968 v8::Handle<v8::Object> RootWebAXObjectProxy::GetChildAtIndex( |
| 969 unsigned index) { |
| 970 if (index) |
| 971 return v8::Handle<v8::Object>(); |
| 972 |
| 973 return factory()->GetOrCreate(accessibility_object()); |
| 974 } |
| 975 |
| 976 bool RootWebAXObjectProxy::IsRoot() const { |
| 977 return true; |
| 978 } |
| 979 |
| 980 WebAXObjectProxyList::WebAXObjectProxyList() { |
| 981 } |
| 982 |
| 983 WebAXObjectProxyList::~WebAXObjectProxyList() { |
| 984 Clear(); |
| 985 } |
| 986 |
| 987 void WebAXObjectProxyList::Clear() { |
| 988 for (ElementList::iterator i = elements_.begin(); i != elements_.end(); ++i) |
| 989 delete i->Value(); |
| 990 elements_.clear(); |
| 991 } |
| 992 |
| 993 v8::Handle<v8::Object> WebAXObjectProxyList::GetOrCreate( |
| 994 const blink::WebAXObject& object) { |
| 995 if (object.isNull()) |
| 996 return v8::Handle<v8::Object>(); |
| 997 |
| 998 v8::Isolate* isolate = v8::Isolate::GetCurrent(); |
| 999 |
| 1000 size_t elementCount = elements_.size(); |
| 1001 for (size_t i = 0; i < elementCount; i++) { |
| 1002 // TODO: implement this. Use FromV8? |
| 1003 /*static_cast<WebAXObjectProxyList*>(elements_[i].Value()); |
| 1004 if (.IsEqualToObject(object)) |
| 1005 return elements_[i].NewLocal(isolate);*/ |
| 1006 } |
| 1007 |
| 1008 gin::UnsafePersistent<v8::Object> unsafe_element( |
| 1009 isolate, (new WebAXObjectProxy(object, this))->GetWrapper(isolate)); |
| 1010 elements_.push_back(unsafe_element); |
| 1011 return unsafe_element.NewLocal(isolate); |
| 1012 } |
| 1013 |
| 1014 v8::Handle<v8::Object> WebAXObjectProxyList::CreateRoot( |
| 1015 const blink::WebAXObject& object) { |
| 1016 v8::Isolate* isolate = v8::Isolate::GetCurrent(); |
| 1017 gin::UnsafePersistent<v8::Object> unsafe_element( |
| 1018 isolate, (new WebAXObjectProxy(object, this))->GetWrapper(isolate)); |
| 1019 elements_.push_back(unsafe_element); |
| 1020 return unsafe_element.NewLocal(isolate); |
| 1021 } |
| 1022 |
| 1023 } // namespace content |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 172263002:
Move WebAXObjectProxy and AccessibleController from CppBoundClass to gin::Wrappable (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src