content/shell/renderer/test_runner/web_ax_object_proxy.cc

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