Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(195)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: components/test_runner/web_ax_object_proxy.cc

Issue 2707183003: Move //components/test_runner back into //content/shell (Closed)
Patch Set: Trim DEPS Created 3 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« components/subresource_filter/DEPS ('K') | « components/test_runner/web_ax_object_proxy.h ('k') | components/test_runner/web_frame_test_client.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: components/test_runner/web_ax_object_proxy.cc
diff --git a/components/test_runner/web_ax_object_proxy.cc b/components/test_runner/web_ax_object_proxy.cc
deleted file mode 100644
index 90df73a954577c1ec0c0ee0bedf8e025d17a9f49..0000000000000000000000000000000000000000
--- a/components/test_runner/web_ax_object_proxy.cc
+++ /dev/null
@@ -1,1767 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "components/test_runner/web_ax_object_proxy.h"
-
-#include <stddef.h>
-
-#include "base/macros.h"
-#include "base/strings/stringprintf.h"
-#include "gin/handle.h"
-#include "third_party/WebKit/public/platform/WebFloatRect.h"
-#include "third_party/WebKit/public/platform/WebPoint.h"
-#include "third_party/WebKit/public/platform/WebRect.h"
-#include "third_party/WebKit/public/platform/WebString.h"
-#include "third_party/WebKit/public/web/WebFrame.h"
-#include "third_party/WebKit/public/web/WebKit.h"
-#include "third_party/skia/include/core/SkMatrix44.h"
-#include "ui/gfx/geometry/rect_f.h"
-#include "ui/gfx/transform.h"
-
-namespace test_runner {
-
-namespace {
-
-// Map role value to string, matching Safari/Mac platform implementation to
-// avoid rebaselining layout tests.
-std::string RoleToString(blink::WebAXRole role)
-{
- std::string result = "AXRole: AX";
- switch (role) {
- case blink::WebAXRoleAbbr:
- return result.append("Abbr");
- case blink::WebAXRoleAlertDialog:
- return result.append("AlertDialog");
- case blink::WebAXRoleAlert:
- return result.append("Alert");
- case blink::WebAXRoleAnnotation:
- return result.append("Annotation");
- case blink::WebAXRoleApplication:
- return result.append("Application");
- case blink::WebAXRoleArticle:
- return result.append("Article");
- case blink::WebAXRoleAudio:
- return result.append("Audio");
- case blink::WebAXRoleBanner:
- return result.append("Banner");
- case blink::WebAXRoleBlockquote:
- return result.append("Blockquote");
- case blink::WebAXRoleBusyIndicator:
- return result.append("BusyIndicator");
- case blink::WebAXRoleButton:
- return result.append("Button");
- case blink::WebAXRoleCanvas:
- return result.append("Canvas");
- case blink::WebAXRoleCaption:
- return result.append("Caption");
- case blink::WebAXRoleCell:
- return result.append("Cell");
- case blink::WebAXRoleCheckBox:
- return result.append("CheckBox");
- case blink::WebAXRoleColorWell:
- return result.append("ColorWell");
- case blink::WebAXRoleColumnHeader:
- return result.append("ColumnHeader");
- case blink::WebAXRoleColumn:
- return result.append("Column");
- case blink::WebAXRoleComboBox:
- return result.append("ComboBox");
- case blink::WebAXRoleComplementary:
- return result.append("Complementary");
- case blink::WebAXRoleContentInfo:
- return result.append("ContentInfo");
- case blink::WebAXRoleDate:
- return result.append("DateField");
- case blink::WebAXRoleDateTime:
- return result.append("DateTimeField");
- case blink::WebAXRoleDefinition:
- return result.append("Definition");
- case blink::WebAXRoleDescriptionListDetail:
- return result.append("DescriptionListDetail");
- case blink::WebAXRoleDescriptionList:
- return result.append("DescriptionList");
- case blink::WebAXRoleDescriptionListTerm:
- return result.append("DescriptionListTerm");
- case blink::WebAXRoleDetails:
- return result.append("Details");
- case blink::WebAXRoleDialog:
- return result.append("Dialog");
- case blink::WebAXRoleDirectory:
- return result.append("Directory");
- case blink::WebAXRoleDisclosureTriangle:
- return result.append("DisclosureTriangle");
- case blink::WebAXRoleDiv:
- return result.append("Div");
- case blink::WebAXRoleDocument:
- return result.append("Document");
- case blink::WebAXRoleEmbeddedObject:
- return result.append("EmbeddedObject");
- case blink::WebAXRoleFigcaption:
- return result.append("Figcaption");
- case blink::WebAXRoleFigure:
- return result.append("Figure");
- case blink::WebAXRoleFooter:
- return result.append("Footer");
- case blink::WebAXRoleForm:
- return result.append("Form");
- case blink::WebAXRoleGrid:
- return result.append("Grid");
- case blink::WebAXRoleGroup:
- return result.append("Group");
- case blink::WebAXRoleHeading:
- return result.append("Heading");
- case blink::WebAXRoleIgnored:
- return result.append("Ignored");
- case blink::WebAXRoleImageMapLink:
- return result.append("ImageMapLink");
- case blink::WebAXRoleImageMap:
- return result.append("ImageMap");
- case blink::WebAXRoleImage:
- return result.append("Image");
- case blink::WebAXRoleInlineTextBox:
- return result.append("InlineTextBox");
- case blink::WebAXRoleInputTime:
- return result.append("InputTime");
- case blink::WebAXRoleLabel:
- return result.append("Label");
- case blink::WebAXRoleLegend:
- return result.append("Legend");
- case blink::WebAXRoleLink:
- return result.append("Link");
- case blink::WebAXRoleLineBreak:
- return result.append("LineBreak");
- case blink::WebAXRoleListBoxOption:
- return result.append("ListBoxOption");
- case blink::WebAXRoleListBox:
- return result.append("ListBox");
- case blink::WebAXRoleListItem:
- return result.append("ListItem");
- case blink::WebAXRoleListMarker:
- return result.append("ListMarker");
- case blink::WebAXRoleList:
- return result.append("List");
- case blink::WebAXRoleLog:
- return result.append("Log");
- case blink::WebAXRoleMain:
- return result.append("Main");
- case blink::WebAXRoleMark:
- return result.append("Mark");
- case blink::WebAXRoleMarquee:
- return result.append("Marquee");
- case blink::WebAXRoleMath:
- return result.append("Math");
- case blink::WebAXRoleMenuBar:
- return result.append("MenuBar");
- case blink::WebAXRoleMenuButton:
- return result.append("MenuButton");
- case blink::WebAXRoleMenuItem:
- return result.append("MenuItem");
- case blink::WebAXRoleMenuItemCheckBox:
- return result.append("MenuItemCheckBox");
- case blink::WebAXRoleMenuItemRadio:
- return result.append("MenuItemRadio");
- case blink::WebAXRoleMenuListOption:
- return result.append("MenuListOption");
- case blink::WebAXRoleMenuListPopup:
- return result.append("MenuListPopup");
- case blink::WebAXRoleMenu:
- return result.append("Menu");
- case blink::WebAXRoleMeter:
- return result.append("Meter");
- case blink::WebAXRoleNavigation:
- return result.append("Navigation");
- case blink::WebAXRoleNone:
- return result.append("None");
- case blink::WebAXRoleNote:
- return result.append("Note");
- case blink::WebAXRoleOutline:
- return result.append("Outline");
- case blink::WebAXRoleParagraph:
- return result.append("Paragraph");
- case blink::WebAXRolePopUpButton:
- return result.append("PopUpButton");
- case blink::WebAXRolePre:
- return result.append("Pre");
- case blink::WebAXRolePresentational:
- return result.append("Presentational");
- case blink::WebAXRoleProgressIndicator:
- return result.append("ProgressIndicator");
- case blink::WebAXRoleRadioButton:
- return result.append("RadioButton");
- case blink::WebAXRoleRadioGroup:
- return result.append("RadioGroup");
- case blink::WebAXRoleRegion:
- return result.append("Region");
- case blink::WebAXRoleRootWebArea:
- return result.append("RootWebArea");
- case blink::WebAXRoleRowHeader:
- return result.append("RowHeader");
- case blink::WebAXRoleRow:
- return result.append("Row");
- case blink::WebAXRoleRuby:
- return result.append("Ruby");
- case blink::WebAXRoleRuler:
- return result.append("Ruler");
- case blink::WebAXRoleSVGRoot:
- return result.append("SVGRoot");
- case blink::WebAXRoleScrollArea:
- return result.append("ScrollArea");
- case blink::WebAXRoleScrollBar:
- return result.append("ScrollBar");
- case blink::WebAXRoleSeamlessWebArea:
- return result.append("SeamlessWebArea");
- case blink::WebAXRoleSearch:
- return result.append("Search");
- case blink::WebAXRoleSearchBox:
- return result.append("SearchBox");
- case blink::WebAXRoleSlider:
- return result.append("Slider");
- case blink::WebAXRoleSliderThumb:
- return result.append("SliderThumb");
- case blink::WebAXRoleSpinButtonPart:
- return result.append("SpinButtonPart");
- case blink::WebAXRoleSpinButton:
- return result.append("SpinButton");
- case blink::WebAXRoleSplitter:
- return result.append("Splitter");
- case blink::WebAXRoleStaticText:
- return result.append("StaticText");
- case blink::WebAXRoleStatus:
- return result.append("Status");
- case blink::WebAXRoleSwitch:
- return result.append("Switch");
- case blink::WebAXRoleTabGroup:
- return result.append("TabGroup");
- case blink::WebAXRoleTabList:
- return result.append("TabList");
- case blink::WebAXRoleTabPanel:
- return result.append("TabPanel");
- case blink::WebAXRoleTab:
- return result.append("Tab");
- case blink::WebAXRoleTableHeaderContainer:
- return result.append("TableHeaderContainer");
- case blink::WebAXRoleTable:
- return result.append("Table");
- case blink::WebAXRoleTextField:
- return result.append("TextField");
- case blink::WebAXRoleTime:
- return result.append("Time");
- case blink::WebAXRoleTimer:
- return result.append("Timer");
- case blink::WebAXRoleToggleButton:
- return result.append("ToggleButton");
- case blink::WebAXRoleToolbar:
- return result.append("Toolbar");
- case blink::WebAXRoleTreeGrid:
- return result.append("TreeGrid");
- case blink::WebAXRoleTreeItem:
- return result.append("TreeItem");
- case blink::WebAXRoleTree:
- return result.append("Tree");
- case blink::WebAXRoleUnknown:
- return result.append("Unknown");
- case blink::WebAXRoleUserInterfaceTooltip:
- return result.append("UserInterfaceTooltip");
- case blink::WebAXRoleVideo:
- return result.append("Video");
- case blink::WebAXRoleWebArea:
- return result.append("WebArea");
- case blink::WebAXRoleWindow:
- return result.append("Window");
- default:
- return result.append("Unknown");
- }
-}
-
-std::string GetStringValue(const blink::WebAXObject& object) {
- std::string value;
- if (object.role() == blink::WebAXRoleColorWell) {
- unsigned int color = object.colorValue();
- unsigned int red = (color >> 16) & 0xFF;
- unsigned int green = (color >> 8) & 0xFF;
- unsigned int blue = color & 0xFF;
- value = base::StringPrintf("rgba(%d, %d, %d, 1)",
- red, green, blue);
- } else {
- value = object.stringValue().utf8();
- }
- return value.insert(0, "AXValue: ");
-}
-
-std::string GetRole(const blink::WebAXObject& object) {
- std::string role_string = RoleToString(object.role());
-
- // Special-case canvas with fallback content because Chromium wants to treat
- // this as essentially a separate role that it can map differently depending
- // on the platform.
- if (object.role() == blink::WebAXRoleCanvas &&
- object.canvasHasFallbackContent()) {
- role_string += "WithFallbackContent";
- }
-
- return role_string;
-}
-
-std::string GetValueDescription(const blink::WebAXObject& object) {
- std::string value_description = object.valueDescription().utf8();
- return value_description.insert(0, "AXValueDescription: ");
-}
-
-std::string GetLanguage(const blink::WebAXObject& object) {
- std::string language = object.language().utf8();
- return language.insert(0, "AXLanguage: ");
-}
-
-std::string GetAttributes(const blink::WebAXObject& object) {
- std::string attributes(object.name().utf8());
- attributes.append("\n");
- attributes.append(GetRole(object));
- return attributes;
-}
-
-// New bounds calculation algorithm. Retrieves the frame-relative bounds
-// of an object by calling getRelativeBounds and then applying the offsets
-// and transforms recursively on each container of this object.
-blink::WebFloatRect BoundsForObject(const blink::WebAXObject& object) {
- blink::WebAXObject container;
- blink::WebFloatRect bounds;
- SkMatrix44 matrix;
- object.getRelativeBounds(container, bounds, matrix);
- gfx::RectF computedBounds(0, 0, bounds.width, bounds.height);
- while (!container.isDetached()) {
- computedBounds.Offset(bounds.x, bounds.y);
- computedBounds.Offset(
- -container.getScrollOffset().x, -container.getScrollOffset().y);
- if (!matrix.isIdentity()) {
- gfx::Transform transform(matrix);
- transform.TransformRect(&computedBounds);
- }
- container.getRelativeBounds(container, bounds, matrix);
- }
- return blink::WebFloatRect(computedBounds.x(),
- computedBounds.y(),
- computedBounds.width(),
- computedBounds.height());
-}
-
-blink::WebRect BoundsForCharacter(const blink::WebAXObject& object,
- int characterIndex) {
- DCHECK_EQ(object.role(), blink::WebAXRoleStaticText);
- int end = 0;
- for (unsigned i = 0; i < object.childCount(); i++) {
- blink::WebAXObject inline_text_box = object.childAt(i);
- DCHECK_EQ(inline_text_box.role(), blink::WebAXRoleInlineTextBox);
- int start = end;
- blink::WebString name = inline_text_box.name();
- end += name.length();
- if (characterIndex < start || characterIndex >= end)
- continue;
-
- blink::WebFloatRect inline_text_box_rect = BoundsForObject(inline_text_box);
-
- int localIndex = characterIndex - start;
- blink::WebVector<int> character_offsets;
- inline_text_box.characterOffsets(character_offsets);
- if (character_offsets.size() != name.length())
- return blink::WebRect();
-
- switch (inline_text_box.textDirection()) {
- case blink::WebAXTextDirectionLR: {
- if (localIndex) {
- int left = inline_text_box_rect.x + character_offsets[localIndex - 1];
- int width = character_offsets[localIndex] -
- character_offsets[localIndex - 1];
- return blink::WebRect(left, inline_text_box_rect.y,
- width, inline_text_box_rect.height);
- }
- return blink::WebRect(
- inline_text_box_rect.x, inline_text_box_rect.y,
- character_offsets[0], inline_text_box_rect.height);
- }
- case blink::WebAXTextDirectionRL: {
- int right = inline_text_box_rect.x + inline_text_box_rect.width;
-
- if (localIndex) {
- int left = right - character_offsets[localIndex];
- int width = character_offsets[localIndex] -
- character_offsets[localIndex - 1];
- return blink::WebRect(left, inline_text_box_rect.y,
- width, inline_text_box_rect.height);
- }
- int left = right - character_offsets[0];
- return blink::WebRect(
- left, inline_text_box_rect.y,
- character_offsets[0], inline_text_box_rect.height);
- }
- case blink::WebAXTextDirectionTB: {
- if (localIndex) {
- int top = inline_text_box_rect.y + character_offsets[localIndex - 1];
- int height = character_offsets[localIndex] -
- character_offsets[localIndex - 1];
- return blink::WebRect(inline_text_box_rect.x, top,
- inline_text_box_rect.width, height);
- }
- return blink::WebRect(inline_text_box_rect.x, inline_text_box_rect.y,
- inline_text_box_rect.width, character_offsets[0]);
- }
- case blink::WebAXTextDirectionBT: {
- int bottom = inline_text_box_rect.y + inline_text_box_rect.height;
-
- if (localIndex) {
- int top = bottom - character_offsets[localIndex];
- int height = character_offsets[localIndex] -
- character_offsets[localIndex - 1];
- return blink::WebRect(inline_text_box_rect.x, top,
- inline_text_box_rect.width, height);
- }
- int top = bottom - character_offsets[0];
- return blink::WebRect(inline_text_box_rect.x, top,
- inline_text_box_rect.width, character_offsets[0]);
- }
- }
- }
-
- DCHECK(false);
- return blink::WebRect();
-}
-
-std::vector<std::string> GetMisspellings(blink::WebAXObject& object) {
- std::vector<std::string> misspellings;
- std::string text(object.name().utf8());
-
- blink::WebVector<blink::WebAXMarkerType> marker_types;
- blink::WebVector<int> marker_starts;
- blink::WebVector<int> marker_ends;
- object.markers(marker_types, marker_starts, marker_ends);
- DCHECK_EQ(marker_types.size(), marker_starts.size());
- DCHECK_EQ(marker_starts.size(), marker_ends.size());
-
- for (size_t i = 0; i < marker_types.size(); ++i) {
- if (marker_types[i] & blink::WebAXMarkerTypeSpelling) {
- misspellings.push_back(
- text.substr(marker_starts[i], marker_ends[i] - marker_starts[i]));
- }
- }
-
- return misspellings;
-}
-
-void GetBoundariesForOneWord(const blink::WebAXObject& object,
- int character_index,
- int& word_start,
- int& word_end) {
- int end = 0;
- for (size_t i = 0; i < object.childCount(); i++) {
- blink::WebAXObject inline_text_box = object.childAt(i);
- DCHECK_EQ(inline_text_box.role(), blink::WebAXRoleInlineTextBox);
- int start = end;
- blink::WebString name = inline_text_box.name();
- end += name.length();
- if (end <= character_index)
- continue;
- int localIndex = character_index - start;
-
- blink::WebVector<int> starts;
- blink::WebVector<int> ends;
- inline_text_box.wordBoundaries(starts, ends);
- size_t word_count = starts.size();
- DCHECK_EQ(ends.size(), word_count);
-
- // If there are no words, use the InlineTextBox boundaries.
- if (!word_count) {
- word_start = start;
- word_end = end;
- return;
- }
-
- // Look for a character within any word other than the last.
- for (size_t j = 0; j < word_count - 1; j++) {
- if (localIndex <= ends[j]) {
- word_start = start + starts[j];
- word_end = start + ends[j];
- return;
- }
- }
-
- // Return the last word by default.
- word_start = start + starts[word_count - 1];
- word_end = start + ends[word_count - 1];
- return;
- }
-}
-
-// Collects attributes into a string, delimited by dashes. Used by all methods
-// that output lists of attributes: attributesOfLinkedUIElementsCallback,
-// AttributesOfChildrenCallback, etc.
-class AttributesCollector {
- public:
- AttributesCollector() {}
- ~AttributesCollector() {}
-
- void CollectAttributes(const blink::WebAXObject& object) {
- attributes_.append("\n------------\n");
- attributes_.append(GetAttributes(object));
- }
-
- std::string attributes() const { return attributes_; }
-
- private:
- std::string attributes_;
-
- DISALLOW_COPY_AND_ASSIGN(AttributesCollector);
-};
-
-class SparseAttributeAdapter : public blink::WebAXSparseAttributeClient {
- public:
- SparseAttributeAdapter() {}
- ~SparseAttributeAdapter() override {}
-
- std::map<blink::WebAXBoolAttribute, bool> bool_attributes;
- std::map<blink::WebAXStringAttribute, blink::WebString> string_attributes;
- std::map<blink::WebAXObjectAttribute, blink::WebAXObject> object_attributes;
- std::map<blink::WebAXObjectVectorAttribute,
- blink::WebVector<blink::WebAXObject>>
- object_vector_attributes;
-
- private:
- void addBoolAttribute(blink::WebAXBoolAttribute attribute,
- bool value) override {
- bool_attributes[attribute] = value;
- }
-
- void addStringAttribute(blink::WebAXStringAttribute attribute,
- const blink::WebString& value) override {
- string_attributes[attribute] = value;
- }
-
- void addObjectAttribute(blink::WebAXObjectAttribute attribute,
- const blink::WebAXObject& value) override {
- object_attributes[attribute] = value;
- }
-
- void addObjectVectorAttribute(
- blink::WebAXObjectVectorAttribute attribute,
- const blink::WebVector<blink::WebAXObject>& value) override {
- object_vector_attributes[attribute] = value;
- }
-};
-
-} // namespace
-
-gin::WrapperInfo WebAXObjectProxy::kWrapperInfo = {
- gin::kEmbedderNativeGin};
-
-WebAXObjectProxy::WebAXObjectProxy(const blink::WebAXObject& object,
- WebAXObjectProxy::Factory* factory)
- : accessibility_object_(object),
- factory_(factory) {
-}
-
-WebAXObjectProxy::~WebAXObjectProxy() {}
-
-gin::ObjectTemplateBuilder
-WebAXObjectProxy::GetObjectTemplateBuilder(v8::Isolate* isolate) {
- return gin::Wrappable<WebAXObjectProxy>::GetObjectTemplateBuilder(isolate)
- .SetProperty("role", &WebAXObjectProxy::Role)
- .SetProperty("stringValue", &WebAXObjectProxy::StringValue)
- .SetProperty("language", &WebAXObjectProxy::Language)
- .SetProperty("x", &WebAXObjectProxy::X)
- .SetProperty("y", &WebAXObjectProxy::Y)
- .SetProperty("width", &WebAXObjectProxy::Width)
- .SetProperty("height", &WebAXObjectProxy::Height)
- .SetProperty("intValue", &WebAXObjectProxy::IntValue)
- .SetProperty("minValue", &WebAXObjectProxy::MinValue)
- .SetProperty("maxValue", &WebAXObjectProxy::MaxValue)
- .SetProperty("valueDescription", &WebAXObjectProxy::ValueDescription)
- .SetProperty("childrenCount", &WebAXObjectProxy::ChildrenCount)
- .SetProperty("selectionAnchorObject",
- &WebAXObjectProxy::SelectionAnchorObject)
- .SetProperty("selectionAnchorOffset",
- &WebAXObjectProxy::SelectionAnchorOffset)
- .SetProperty("selectionAnchorAffinity",
- &WebAXObjectProxy::SelectionAnchorAffinity)
- .SetProperty("selectionFocusObject",
- &WebAXObjectProxy::SelectionFocusObject)
- .SetProperty("selectionFocusOffset",
- &WebAXObjectProxy::SelectionFocusOffset)
- .SetProperty("selectionFocusAffinity",
- &WebAXObjectProxy::SelectionFocusAffinity)
- .SetProperty("selectionStart", &WebAXObjectProxy::SelectionStart)
- .SetProperty("selectionEnd", &WebAXObjectProxy::SelectionEnd)
- .SetProperty("selectionStartLineNumber",
- &WebAXObjectProxy::SelectionStartLineNumber)
- .SetProperty("selectionEndLineNumber",
- &WebAXObjectProxy::SelectionEndLineNumber)
- .SetProperty("isEnabled", &WebAXObjectProxy::IsEnabled)
- .SetProperty("isRequired", &WebAXObjectProxy::IsRequired)
- .SetProperty("isEditable", &WebAXObjectProxy::IsEditable)
- .SetProperty("isRichlyEditable", &WebAXObjectProxy::IsRichlyEditable)
- .SetProperty("isFocused", &WebAXObjectProxy::IsFocused)
- .SetProperty("isFocusable", &WebAXObjectProxy::IsFocusable)
- .SetProperty("isModal", &WebAXObjectProxy::IsModal)
- .SetProperty("isSelected", &WebAXObjectProxy::IsSelected)
- .SetProperty("isSelectable", &WebAXObjectProxy::IsSelectable)
- .SetProperty("isMultiSelectable", &WebAXObjectProxy::IsMultiSelectable)
- .SetProperty("isSelectedOptionActive",
- &WebAXObjectProxy::IsSelectedOptionActive)
- .SetProperty("isExpanded", &WebAXObjectProxy::IsExpanded)
- .SetProperty("isChecked", &WebAXObjectProxy::IsChecked)
- .SetProperty("isVisible", &WebAXObjectProxy::IsVisible)
- .SetProperty("isOffScreen", &WebAXObjectProxy::IsOffScreen)
- .SetProperty("isCollapsed", &WebAXObjectProxy::IsCollapsed)
- .SetProperty("hasPopup", &WebAXObjectProxy::HasPopup)
- .SetProperty("isValid", &WebAXObjectProxy::IsValid)
- .SetProperty("isReadOnly", &WebAXObjectProxy::IsReadOnly)
- .SetProperty("backgroundColor", &WebAXObjectProxy::BackgroundColor)
- .SetProperty("color", &WebAXObjectProxy::Color)
- .SetProperty("colorValue", &WebAXObjectProxy::ColorValue)
- .SetProperty("fontFamily", &WebAXObjectProxy::FontFamily)
- .SetProperty("fontSize", &WebAXObjectProxy::FontSize)
- .SetProperty("orientation", &WebAXObjectProxy::Orientation)
- .SetProperty("posInSet", &WebAXObjectProxy::PosInSet)
- .SetProperty("setSize", &WebAXObjectProxy::SetSize)
- .SetProperty("clickPointX", &WebAXObjectProxy::ClickPointX)
- .SetProperty("clickPointY", &WebAXObjectProxy::ClickPointY)
- .SetProperty("rowCount", &WebAXObjectProxy::RowCount)
- .SetProperty("rowHeadersCount", &WebAXObjectProxy::RowHeadersCount)
- .SetProperty("columnCount", &WebAXObjectProxy::ColumnCount)
- .SetProperty("columnHeadersCount", &WebAXObjectProxy::ColumnHeadersCount)
- .SetProperty("isClickable", &WebAXObjectProxy::IsClickable)
- .SetProperty("isButtonStateMixed", &WebAXObjectProxy::IsButtonStateMixed)
- //
- // NEW bounding rect calculation - high-level interface
- //
- .SetProperty("boundsX", &WebAXObjectProxy::BoundsX)
- .SetProperty("boundsY", &WebAXObjectProxy::BoundsY)
- .SetProperty("boundsWidth", &WebAXObjectProxy::BoundsWidth)
- .SetProperty("boundsHeight", &WebAXObjectProxy::BoundsHeight)
- .SetMethod("allAttributes", &WebAXObjectProxy::AllAttributes)
- .SetMethod("attributesOfChildren",
- &WebAXObjectProxy::AttributesOfChildren)
- .SetMethod("ariaControlsElementAtIndex",
- &WebAXObjectProxy::AriaControlsElementAtIndex)
- .SetMethod("ariaFlowToElementAtIndex",
- &WebAXObjectProxy::AriaFlowToElementAtIndex)
- .SetMethod("ariaOwnsElementAtIndex",
- &WebAXObjectProxy::AriaOwnsElementAtIndex)
- .SetMethod("lineForIndex", &WebAXObjectProxy::LineForIndex)
- .SetMethod("boundsForRange", &WebAXObjectProxy::BoundsForRange)
- .SetMethod("childAtIndex", &WebAXObjectProxy::ChildAtIndex)
- .SetMethod("elementAtPoint", &WebAXObjectProxy::ElementAtPoint)
- .SetMethod("tableHeader", &WebAXObjectProxy::TableHeader)
- .SetMethod("rowHeaderAtIndex", &WebAXObjectProxy::RowHeaderAtIndex)
- .SetMethod("columnHeaderAtIndex", &WebAXObjectProxy::ColumnHeaderAtIndex)
- .SetMethod("rowIndexRange", &WebAXObjectProxy::RowIndexRange)
- .SetMethod("columnIndexRange", &WebAXObjectProxy::ColumnIndexRange)
- .SetMethod("cellForColumnAndRow", &WebAXObjectProxy::CellForColumnAndRow)
- .SetMethod("setSelectedTextRange",
- &WebAXObjectProxy::SetSelectedTextRange)
- .SetMethod("setSelection", &WebAXObjectProxy::SetSelection)
- .SetMethod("isAttributeSettable", &WebAXObjectProxy::IsAttributeSettable)
- .SetMethod("isPressActionSupported",
- &WebAXObjectProxy::IsPressActionSupported)
- .SetMethod("isIncrementActionSupported",
- &WebAXObjectProxy::IsIncrementActionSupported)
- .SetMethod("isDecrementActionSupported",
- &WebAXObjectProxy::IsDecrementActionSupported)
- .SetMethod("parentElement", &WebAXObjectProxy::ParentElement)
- .SetMethod("increment", &WebAXObjectProxy::Increment)
- .SetMethod("decrement", &WebAXObjectProxy::Decrement)
- .SetMethod("showMenu", &WebAXObjectProxy::ShowMenu)
- .SetMethod("press", &WebAXObjectProxy::Press)
- .SetMethod("setValue", &WebAXObjectProxy::SetValue)
- .SetMethod("isEqual", &WebAXObjectProxy::IsEqual)
- .SetMethod("setNotificationListener",
- &WebAXObjectProxy::SetNotificationListener)
- .SetMethod("unsetNotificationListener",
- &WebAXObjectProxy::UnsetNotificationListener)
- .SetMethod("takeFocus", &WebAXObjectProxy::TakeFocus)
- .SetMethod("scrollToMakeVisible", &WebAXObjectProxy::ScrollToMakeVisible)
- .SetMethod("scrollToMakeVisibleWithSubFocus",
- &WebAXObjectProxy::ScrollToMakeVisibleWithSubFocus)
- .SetMethod("scrollToGlobalPoint", &WebAXObjectProxy::ScrollToGlobalPoint)
- .SetMethod("scrollX", &WebAXObjectProxy::ScrollX)
- .SetMethod("scrollY", &WebAXObjectProxy::ScrollY)
- .SetMethod("wordStart", &WebAXObjectProxy::WordStart)
- .SetMethod("wordEnd", &WebAXObjectProxy::WordEnd)
- .SetMethod("nextOnLine", &WebAXObjectProxy::NextOnLine)
- .SetMethod("previousOnLine", &WebAXObjectProxy::PreviousOnLine)
- .SetMethod("misspellingAtIndex", &WebAXObjectProxy::MisspellingAtIndex)
- // TODO(hajimehoshi): This is for backward compatibility. Remove them.
- .SetMethod("addNotificationListener",
- &WebAXObjectProxy::SetNotificationListener)
- .SetMethod("removeNotificationListener",
- &WebAXObjectProxy::UnsetNotificationListener)
- //
- // NEW accessible name and description accessors
- //
- .SetProperty("name", &WebAXObjectProxy::Name)
- .SetProperty("nameFrom", &WebAXObjectProxy::NameFrom)
- .SetMethod("nameElementCount", &WebAXObjectProxy::NameElementCount)
- .SetMethod("nameElementAtIndex", &WebAXObjectProxy::NameElementAtIndex)
- .SetProperty("description", &WebAXObjectProxy::Description)
- .SetProperty("descriptionFrom", &WebAXObjectProxy::DescriptionFrom)
- .SetProperty("placeholder", &WebAXObjectProxy::Placeholder)
- .SetProperty("misspellingsCount", &WebAXObjectProxy::MisspellingsCount)
- .SetMethod("descriptionElementCount",
- &WebAXObjectProxy::DescriptionElementCount)
- .SetMethod("descriptionElementAtIndex",
- &WebAXObjectProxy::DescriptionElementAtIndex)
- //
- // NEW bounding rect calculation - low-level interface
- //
- .SetMethod("offsetContainer", &WebAXObjectProxy::OffsetContainer)
- .SetMethod("boundsInContainerX", &WebAXObjectProxy::BoundsInContainerX)
- .SetMethod("boundsInContainerY", &WebAXObjectProxy::BoundsInContainerY)
- .SetMethod("boundsInContainerWidth",
- &WebAXObjectProxy::BoundsInContainerWidth)
- .SetMethod("boundsInContainerHeight",
- &WebAXObjectProxy::BoundsInContainerHeight)
- .SetMethod("hasNonIdentityTransform",
- &WebAXObjectProxy::HasNonIdentityTransform);
-}
-
-v8::Local<v8::Object> WebAXObjectProxy::GetChildAtIndex(unsigned index) {
- return factory_->GetOrCreate(accessibility_object_.childAt(index));
-}
-
-bool WebAXObjectProxy::IsRoot() const {
- return false;
-}
-
-bool WebAXObjectProxy::IsEqualToObject(const blink::WebAXObject& other) {
- return accessibility_object_.equals(other);
-}
-
-void WebAXObjectProxy::NotificationReceived(
- blink::WebFrame* frame,
- const std::string& notification_name) {
- if (notification_callback_.IsEmpty())
- return;
-
- v8::Local<v8::Context> context = frame->mainWorldScriptContext();
- if (context.IsEmpty())
- return;
-
- v8::Isolate* isolate = blink::mainThreadIsolate();
-
- v8::Local<v8::Value> argv[] = {
- v8::String::NewFromUtf8(isolate, notification_name.data(),
- v8::String::kNormalString,
- notification_name.size()),
- };
- frame->callFunctionEvenIfScriptDisabled(
- v8::Local<v8::Function>::New(isolate, notification_callback_),
- context->Global(),
- arraysize(argv),
- argv);
-}
-
-void WebAXObjectProxy::Reset() {
- notification_callback_.Reset();
-}
-
-std::string WebAXObjectProxy::Role() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return GetRole(accessibility_object_);
-}
-
-std::string WebAXObjectProxy::StringValue() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return GetStringValue(accessibility_object_);
-}
-
-std::string WebAXObjectProxy::Language() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return GetLanguage(accessibility_object_);
-}
-
-int WebAXObjectProxy::X() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return BoundsForObject(accessibility_object_).x;
-}
-
-int WebAXObjectProxy::Y() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return BoundsForObject(accessibility_object_).y;
-}
-
-int WebAXObjectProxy::Width() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return BoundsForObject(accessibility_object_).width;
-}
-
-int WebAXObjectProxy::Height() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return BoundsForObject(accessibility_object_).height;
-}
-
-int WebAXObjectProxy::IntValue() {
- accessibility_object_.updateLayoutAndCheckValidity();
- if (accessibility_object_.supportsRangeValue())
- return accessibility_object_.valueForRange();
- else if (accessibility_object_.role() == blink::WebAXRoleHeading)
- return accessibility_object_.headingLevel();
- else
- return atoi(accessibility_object_.stringValue().utf8().data());
-}
-
-int WebAXObjectProxy::MinValue() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.minValueForRange();
-}
-
-int WebAXObjectProxy::MaxValue() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.maxValueForRange();
-}
-
-std::string WebAXObjectProxy::ValueDescription() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return GetValueDescription(accessibility_object_);
-}
-
-int WebAXObjectProxy::ChildrenCount() {
- accessibility_object_.updateLayoutAndCheckValidity();
- int count = 1; // Root object always has only one child, the WebView.
- if (!IsRoot())
- count = accessibility_object_.childCount();
- return count;
-}
-
-v8::Local<v8::Value> WebAXObjectProxy::SelectionAnchorObject() {
- accessibility_object_.updateLayoutAndCheckValidity();
-
- blink::WebAXObject anchorObject;
- int anchorOffset = -1;
- blink::WebAXTextAffinity anchorAffinity;
- blink::WebAXObject focusObject;
- int focusOffset = -1;
- blink::WebAXTextAffinity focusAffinity;
- accessibility_object_.selection(anchorObject, anchorOffset, anchorAffinity,
- focusObject, focusOffset, focusAffinity);
- if (anchorObject.isNull())
- return v8::Null(blink::mainThreadIsolate());
-
- return factory_->GetOrCreate(anchorObject);
-}
-
-int WebAXObjectProxy::SelectionAnchorOffset() {
- accessibility_object_.updateLayoutAndCheckValidity();
-
- blink::WebAXObject anchorObject;
- int anchorOffset = -1;
- blink::WebAXTextAffinity anchorAffinity;
- blink::WebAXObject focusObject;
- int focusOffset = -1;
- blink::WebAXTextAffinity focusAffinity;
- accessibility_object_.selection(anchorObject, anchorOffset, anchorAffinity,
- focusObject, focusOffset, focusAffinity);
- if (anchorOffset < 0)
- return -1;
-
- return anchorOffset;
-}
-
-std::string WebAXObjectProxy::SelectionAnchorAffinity() {
- accessibility_object_.updateLayoutAndCheckValidity();
-
- blink::WebAXObject anchorObject;
- int anchorOffset = -1;
- blink::WebAXTextAffinity anchorAffinity;
- blink::WebAXObject focusObject;
- int focusOffset = -1;
- blink::WebAXTextAffinity focusAffinity;
- accessibility_object_.selection(anchorObject, anchorOffset, anchorAffinity,
- focusObject, focusOffset, focusAffinity);
- return anchorAffinity == blink::WebAXTextAffinityUpstream ?
- "upstream" : "downstream";
-}
-
-v8::Local<v8::Value> WebAXObjectProxy::SelectionFocusObject() {
- accessibility_object_.updateLayoutAndCheckValidity();
-
- blink::WebAXObject anchorObject;
- int anchorOffset = -1;
- blink::WebAXTextAffinity anchorAffinity;
- blink::WebAXObject focusObject;
- int focusOffset = -1;
- blink::WebAXTextAffinity focusAffinity;
- accessibility_object_.selection(anchorObject, anchorOffset, anchorAffinity,
- focusObject, focusOffset, focusAffinity);
- if (focusObject.isNull())
- return v8::Null(blink::mainThreadIsolate());
-
- return factory_->GetOrCreate(focusObject);
-}
-
-int WebAXObjectProxy::SelectionFocusOffset() {
- accessibility_object_.updateLayoutAndCheckValidity();
-
- blink::WebAXObject anchorObject;
- int anchorOffset = -1;
- blink::WebAXTextAffinity anchorAffinity;
- blink::WebAXObject focusObject;
- int focusOffset = -1;
- blink::WebAXTextAffinity focusAffinity;
- accessibility_object_.selection(anchorObject, anchorOffset, anchorAffinity,
- focusObject, focusOffset, focusAffinity);
- if (focusOffset < 0)
- return -1;
-
- return focusOffset;
-}
-
-std::string WebAXObjectProxy::SelectionFocusAffinity() {
- accessibility_object_.updateLayoutAndCheckValidity();
-
- blink::WebAXObject anchorObject;
- int anchorOffset = -1;
- blink::WebAXTextAffinity anchorAffinity;
- blink::WebAXObject focusObject;
- int focusOffset = -1;
- blink::WebAXTextAffinity focusAffinity;
- accessibility_object_.selection(anchorObject, anchorOffset, anchorAffinity,
- focusObject, focusOffset, focusAffinity);
- return focusAffinity == blink::WebAXTextAffinityUpstream ?
- "upstream" : "downstream";
-}
-
-int WebAXObjectProxy::SelectionStart() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.selectionStart();
-}
-
-int WebAXObjectProxy::SelectionEnd() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.selectionEnd();
-}
-
-int WebAXObjectProxy::SelectionStartLineNumber() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.selectionStartLineNumber();
-}
-
-int WebAXObjectProxy::SelectionEndLineNumber() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.selectionEndLineNumber();
-}
-
-bool WebAXObjectProxy::IsEnabled() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.isEnabled();
-}
-
-bool WebAXObjectProxy::IsRequired() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.isRequired();
-}
-
-bool WebAXObjectProxy::IsEditable() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.isEditable();
-}
-
-bool WebAXObjectProxy::IsRichlyEditable() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.isRichlyEditable();
-}
-
-bool WebAXObjectProxy::IsFocused() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.isFocused();
-}
-
-bool WebAXObjectProxy::IsFocusable() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.canSetFocusAttribute();
-}
-
-bool WebAXObjectProxy::IsModal() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.isModal();
-}
-
-bool WebAXObjectProxy::IsSelected() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.isSelected();
-}
-
-bool WebAXObjectProxy::IsSelectable() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.canSetSelectedAttribute();
-}
-
-bool WebAXObjectProxy::IsMultiSelectable() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.isMultiSelectable();
-}
-
-bool WebAXObjectProxy::IsSelectedOptionActive() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.isSelectedOptionActive();
-}
-
-bool WebAXObjectProxy::IsExpanded() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.isExpanded() == blink::WebAXExpandedExpanded;
-}
-
-bool WebAXObjectProxy::IsChecked() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.isChecked();
-}
-
-bool WebAXObjectProxy::IsCollapsed() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.isExpanded() == blink::WebAXExpandedCollapsed;
-}
-
-bool WebAXObjectProxy::IsVisible() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.isVisible();
-}
-
-bool WebAXObjectProxy::IsOffScreen() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.isOffScreen();
-}
-
-bool WebAXObjectProxy::HasPopup() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.ariaHasPopup();
-}
-
-bool WebAXObjectProxy::IsValid() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return !accessibility_object_.isDetached();
-}
-
-bool WebAXObjectProxy::IsReadOnly() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.isReadOnly();
-}
-
-unsigned int WebAXObjectProxy::BackgroundColor() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.backgroundColor();
-}
-
-unsigned int WebAXObjectProxy::Color() {
- accessibility_object_.updateLayoutAndCheckValidity();
- unsigned int color = accessibility_object_.color();
- // Remove the alpha because it's always 1 and thus not informative.
- return color & 0xFFFFFF;
-}
-
-// For input elements of type color.
-unsigned int WebAXObjectProxy::ColorValue() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.colorValue();
-}
-
-std::string WebAXObjectProxy::FontFamily() {
- accessibility_object_.updateLayoutAndCheckValidity();
- std::string font_family(accessibility_object_.fontFamily().utf8());
- return font_family.insert(0, "AXFontFamily: ");
-}
-
-float WebAXObjectProxy::FontSize() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.fontSize();
-}
-
-std::string WebAXObjectProxy::Orientation() {
- accessibility_object_.updateLayoutAndCheckValidity();
- if (accessibility_object_.orientation() == blink::WebAXOrientationVertical)
- return "AXOrientation: AXVerticalOrientation";
- else if (accessibility_object_.orientation()
- == blink::WebAXOrientationHorizontal)
- return "AXOrientation: AXHorizontalOrientation";
-
- return std::string();
-}
-
-int WebAXObjectProxy::PosInSet() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.posInSet();
-}
-
-int WebAXObjectProxy::SetSize() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.setSize();
-}
-
-int WebAXObjectProxy::ClickPointX() {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebFloatRect bounds = BoundsForObject(accessibility_object_);
- return bounds.x + bounds.width / 2;
-}
-
-int WebAXObjectProxy::ClickPointY() {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebFloatRect bounds = BoundsForObject(accessibility_object_);
- return bounds.y + bounds.height / 2;
-}
-
-int32_t WebAXObjectProxy::RowCount() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return static_cast<int32_t>(accessibility_object_.rowCount());
-}
-
-int32_t WebAXObjectProxy::RowHeadersCount() {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebVector<blink::WebAXObject> headers;
- accessibility_object_.rowHeaders(headers);
- return static_cast<int32_t>(headers.size());
-}
-
-int32_t WebAXObjectProxy::ColumnCount() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return static_cast<int32_t>(accessibility_object_.columnCount());
-}
-
-int32_t WebAXObjectProxy::ColumnHeadersCount()
-{
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebVector<blink::WebAXObject> headers;
- accessibility_object_.columnHeaders(headers);
- return static_cast<int32_t>(headers.size());
-}
-
-bool WebAXObjectProxy::IsClickable() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.isClickable();
-}
-
-bool WebAXObjectProxy::IsButtonStateMixed() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.isButtonStateMixed();
-}
-
-v8::Local<v8::Object> WebAXObjectProxy::AriaControlsElementAtIndex(
- unsigned index) {
- accessibility_object_.updateLayoutAndCheckValidity();
- SparseAttributeAdapter attribute_adapter;
- accessibility_object_.getSparseAXAttributes(attribute_adapter);
- blink::WebVector<blink::WebAXObject> elements =
- attribute_adapter.object_vector_attributes
- [blink::WebAXObjectVectorAttribute::AriaControls];
- size_t elementCount = elements.size();
- if (index >= elementCount)
- return v8::Local<v8::Object>();
-
- return factory_->GetOrCreate(elements[index]);
-}
-
-v8::Local<v8::Object> WebAXObjectProxy::AriaFlowToElementAtIndex(
- unsigned index) {
- accessibility_object_.updateLayoutAndCheckValidity();
- SparseAttributeAdapter attribute_adapter;
- accessibility_object_.getSparseAXAttributes(attribute_adapter);
- blink::WebVector<blink::WebAXObject> elements =
- attribute_adapter.object_vector_attributes
- [blink::WebAXObjectVectorAttribute::AriaFlowTo];
- size_t elementCount = elements.size();
- if (index >= elementCount)
- return v8::Local<v8::Object>();
-
- return factory_->GetOrCreate(elements[index]);
-}
-
-v8::Local<v8::Object> WebAXObjectProxy::AriaOwnsElementAtIndex(unsigned index)
-{
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebVector<blink::WebAXObject> elements;
- accessibility_object_.ariaOwns(elements);
- size_t elementCount = elements.size();
- if (index >= elementCount)
- return v8::Local<v8::Object>();
-
- return factory_->GetOrCreate(elements[index]);
-}
-
-std::string WebAXObjectProxy::AllAttributes() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return GetAttributes(accessibility_object_);
-}
-
-std::string WebAXObjectProxy::AttributesOfChildren() {
- accessibility_object_.updateLayoutAndCheckValidity();
- AttributesCollector collector;
- unsigned size = accessibility_object_.childCount();
- for (unsigned i = 0; i < size; ++i)
- collector.CollectAttributes(accessibility_object_.childAt(i));
- return collector.attributes();
-}
-
-int WebAXObjectProxy::LineForIndex(int index) {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebVector<int> line_breaks;
- accessibility_object_.lineBreaks(line_breaks);
- int line = 0;
- int vector_size = static_cast<int>(line_breaks.size());
- while (line < vector_size && line_breaks[line] <= index)
- line++;
- return line;
-}
-
-std::string WebAXObjectProxy::BoundsForRange(int start, int end) {
- accessibility_object_.updateLayoutAndCheckValidity();
- if (accessibility_object_.role() != blink::WebAXRoleStaticText)
- return std::string();
-
- if (!accessibility_object_.updateLayoutAndCheckValidity())
- return std::string();
-
- int len = end - start;
-
- // Get the bounds for each character and union them into one large rectangle.
- // This is just for testing so it doesn't need to be efficient.
- blink::WebRect bounds = BoundsForCharacter(accessibility_object_, start);
- for (int i = 1; i < len; i++) {
- blink::WebRect next = BoundsForCharacter(accessibility_object_, start + i);
- int right = std::max(bounds.x + bounds.width, next.x + next.width);
- int bottom = std::max(bounds.y + bounds.height, next.y + next.height);
- bounds.x = std::min(bounds.x, next.x);
- bounds.y = std::min(bounds.y, next.y);
- bounds.width = right - bounds.x;
- bounds.height = bottom - bounds.y;
- }
-
- return base::StringPrintf("{x: %d, y: %d, width: %d, height: %d}",
- bounds.x, bounds.y, bounds.width, bounds.height);
-}
-
-v8::Local<v8::Object> WebAXObjectProxy::ChildAtIndex(int index) {
- accessibility_object_.updateLayoutAndCheckValidity();
- return GetChildAtIndex(index);
-}
-
-v8::Local<v8::Object> WebAXObjectProxy::ElementAtPoint(int x, int y) {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebPoint point(x, y);
- blink::WebAXObject obj = accessibility_object_.hitTest(point);
- if (obj.isNull())
- return v8::Local<v8::Object>();
-
- return factory_->GetOrCreate(obj);
-}
-
-v8::Local<v8::Object> WebAXObjectProxy::TableHeader() {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebAXObject obj = accessibility_object_.headerContainerObject();
- if (obj.isNull())
- return v8::Local<v8::Object>();
-
- return factory_->GetOrCreate(obj);
-}
-
-v8::Local<v8::Object> WebAXObjectProxy::RowHeaderAtIndex(unsigned index) {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebVector<blink::WebAXObject> headers;
- accessibility_object_.rowHeaders(headers);
- size_t headerCount = headers.size();
- if (index >= headerCount)
- return v8::Local<v8::Object>();
-
- return factory_->GetOrCreate(headers[index]);
-}
-
-v8::Local<v8::Object> WebAXObjectProxy::ColumnHeaderAtIndex(unsigned index) {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebVector<blink::WebAXObject> headers;
- accessibility_object_.columnHeaders(headers);
- size_t headerCount = headers.size();
- if (index >= headerCount)
- return v8::Local<v8::Object>();
-
- return factory_->GetOrCreate(headers[index]);
-}
-
-std::string WebAXObjectProxy::RowIndexRange() {
- accessibility_object_.updateLayoutAndCheckValidity();
- unsigned row_index = accessibility_object_.cellRowIndex();
- unsigned row_span = accessibility_object_.cellRowSpan();
- return base::StringPrintf("{%d, %d}", row_index, row_span);
-}
-
-std::string WebAXObjectProxy::ColumnIndexRange() {
- accessibility_object_.updateLayoutAndCheckValidity();
- unsigned column_index = accessibility_object_.cellColumnIndex();
- unsigned column_span = accessibility_object_.cellColumnSpan();
- return base::StringPrintf("{%d, %d}", column_index, column_span);
-}
-
-v8::Local<v8::Object> WebAXObjectProxy::CellForColumnAndRow(
- int column, int row) {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebAXObject obj =
- accessibility_object_.cellForColumnAndRow(column, row);
- if (obj.isNull())
- return v8::Local<v8::Object>();
-
- return factory_->GetOrCreate(obj);
-}
-
-void WebAXObjectProxy::SetSelectedTextRange(int selection_start,
- int length) {
- accessibility_object_.updateLayoutAndCheckValidity();
- accessibility_object_.setSelectedTextRange(selection_start,
- selection_start + length);
-}
-
-void WebAXObjectProxy::SetSelection(
- v8::Local<v8::Value> anchor_object, int anchor_offset,
- v8::Local<v8::Value> focus_object, int focus_offset) {
- if (anchor_object.IsEmpty() || focus_object.IsEmpty() ||
- !anchor_object->IsObject() || !focus_object->IsObject() ||
- anchor_offset < 0 || focus_offset < 0) {
- return;
- }
-
- WebAXObjectProxy* web_ax_anchor = nullptr;
- if (!gin::ConvertFromV8(
- blink::mainThreadIsolate(), anchor_object, &web_ax_anchor)) {
- return;
- }
- DCHECK(web_ax_anchor);
-
- WebAXObjectProxy* web_ax_focus = nullptr;
- if (!gin::ConvertFromV8(
- blink::mainThreadIsolate(), focus_object, &web_ax_focus)) {
- return;
- }
- DCHECK(web_ax_focus);
-
- accessibility_object_.updateLayoutAndCheckValidity();
- accessibility_object_.setSelection(
- web_ax_anchor->accessibility_object_, anchor_offset,
- web_ax_focus->accessibility_object_, focus_offset);
-}
-
-bool WebAXObjectProxy::IsAttributeSettable(const std::string& attribute) {
- accessibility_object_.updateLayoutAndCheckValidity();
- bool settable = false;
- if (attribute == "AXValue")
- settable = accessibility_object_.canSetValueAttribute();
- return settable;
-}
-
-bool WebAXObjectProxy::IsPressActionSupported() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.canPress();
-}
-
-bool WebAXObjectProxy::IsIncrementActionSupported() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.canIncrement();
-}
-
-bool WebAXObjectProxy::IsDecrementActionSupported() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.canDecrement();
-}
-
-v8::Local<v8::Object> WebAXObjectProxy::ParentElement() {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebAXObject parent_object = accessibility_object_.parentObject();
- while (parent_object.accessibilityIsIgnored())
- parent_object = parent_object.parentObject();
- return factory_->GetOrCreate(parent_object);
-}
-
-void WebAXObjectProxy::Increment() {
- accessibility_object_.updateLayoutAndCheckValidity();
- accessibility_object_.increment();
-}
-
-void WebAXObjectProxy::Decrement() {
- accessibility_object_.updateLayoutAndCheckValidity();
- accessibility_object_.decrement();
-}
-
-void WebAXObjectProxy::ShowMenu() {
- accessibility_object_.showContextMenu();
-}
-
-void WebAXObjectProxy::Press() {
- accessibility_object_.updateLayoutAndCheckValidity();
- accessibility_object_.press();
-}
-
-bool WebAXObjectProxy::SetValue(const std::string& value) {
- accessibility_object_.updateLayoutAndCheckValidity();
- if (!accessibility_object_.canSetValueAttribute())
- return false;
-
- accessibility_object_.setValue(blink::WebString::fromUTF8(value));
- return true;
-}
-
-bool WebAXObjectProxy::IsEqual(v8::Local<v8::Object> proxy) {
- WebAXObjectProxy* unwrapped_proxy = NULL;
- if (!gin::ConvertFromV8(blink::mainThreadIsolate(), proxy, &unwrapped_proxy))
- return false;
- return unwrapped_proxy->IsEqualToObject(accessibility_object_);
-}
-
-void WebAXObjectProxy::SetNotificationListener(
- v8::Local<v8::Function> callback) {
- v8::Isolate* isolate = blink::mainThreadIsolate();
- notification_callback_.Reset(isolate, callback);
-}
-
-void WebAXObjectProxy::UnsetNotificationListener() {
- notification_callback_.Reset();
-}
-
-void WebAXObjectProxy::TakeFocus() {
- accessibility_object_.updateLayoutAndCheckValidity();
- accessibility_object_.setFocused(true);
-}
-
-void WebAXObjectProxy::ScrollToMakeVisible() {
- accessibility_object_.updateLayoutAndCheckValidity();
- accessibility_object_.scrollToMakeVisible();
-}
-
-void WebAXObjectProxy::ScrollToMakeVisibleWithSubFocus(int x, int y,
- int width, int height) {
- accessibility_object_.updateLayoutAndCheckValidity();
- accessibility_object_.scrollToMakeVisibleWithSubFocus(
- blink::WebRect(x, y, width, height));
-}
-
-void WebAXObjectProxy::ScrollToGlobalPoint(int x, int y) {
- accessibility_object_.updateLayoutAndCheckValidity();
- accessibility_object_.scrollToGlobalPoint(blink::WebPoint(x, y));
-}
-
-int WebAXObjectProxy::ScrollX() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.getScrollOffset().x;
-}
-
-int WebAXObjectProxy::ScrollY() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.getScrollOffset().y;
-}
-
-float WebAXObjectProxy::BoundsX() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return BoundsForObject(accessibility_object_).x;
-}
-
-float WebAXObjectProxy::BoundsY() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return BoundsForObject(accessibility_object_).y;
-}
-
-float WebAXObjectProxy::BoundsWidth() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return BoundsForObject(accessibility_object_).width;
-}
-
-float WebAXObjectProxy::BoundsHeight() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return BoundsForObject(accessibility_object_).height;
-}
-
-int WebAXObjectProxy::WordStart(int character_index) {
- accessibility_object_.updateLayoutAndCheckValidity();
- if (accessibility_object_.role() != blink::WebAXRoleStaticText)
- return -1;
-
- int word_start = 0, word_end = 0;
- GetBoundariesForOneWord(accessibility_object_, character_index,
- word_start, word_end);
- return word_start;
-}
-
-int WebAXObjectProxy::WordEnd(int character_index) {
- accessibility_object_.updateLayoutAndCheckValidity();
- if (accessibility_object_.role() != blink::WebAXRoleStaticText)
- return -1;
-
- int word_start = 0, word_end = 0;
- GetBoundariesForOneWord(accessibility_object_, character_index,
- word_start, word_end);
- return word_end;
-}
-
-v8::Local<v8::Object> WebAXObjectProxy::NextOnLine() {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebAXObject obj = accessibility_object_.nextOnLine();
- if (obj.isNull())
- return v8::Local<v8::Object>();
-
- return factory_->GetOrCreate(obj);
-}
-
-v8::Local<v8::Object> WebAXObjectProxy::PreviousOnLine() {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebAXObject obj = accessibility_object_.previousOnLine();
- if (obj.isNull())
- return v8::Local<v8::Object>();
-
- return factory_->GetOrCreate(obj);
-}
-
-std::string WebAXObjectProxy::MisspellingAtIndex(int index) {
- accessibility_object_.updateLayoutAndCheckValidity();
- if (index < 0 || index >= MisspellingsCount())
- return std::string();
- return GetMisspellings(accessibility_object_)[index];
-}
-
-std::string WebAXObjectProxy::Name() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return accessibility_object_.name().utf8();
-}
-
-std::string WebAXObjectProxy::NameFrom() {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebAXNameFrom nameFrom = blink::WebAXNameFromUninitialized;
- blink::WebVector<blink::WebAXObject> nameObjects;
- accessibility_object_.name(nameFrom, nameObjects);
- switch(nameFrom) {
- case blink::WebAXNameFromUninitialized:
- return "";
- case blink::WebAXNameFromAttribute:
- return "attribute";
- case blink::WebAXNameFromCaption:
- return "caption";
- case blink::WebAXNameFromContents:
- return "contents";
- case blink::WebAXNameFromPlaceholder:
- return "placeholder";
- case blink::WebAXNameFromRelatedElement:
- return "relatedElement";
- case blink::WebAXNameFromValue:
- return "value";
- case blink::WebAXNameFromTitle:
- return "title";
- }
-
- NOTREACHED();
- return std::string();
-}
-
-int WebAXObjectProxy::NameElementCount() {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebAXNameFrom nameFrom;
- blink::WebVector<blink::WebAXObject> nameObjects;
- accessibility_object_.name(nameFrom, nameObjects);
- return static_cast<int>(nameObjects.size());
-}
-
-v8::Local<v8::Object> WebAXObjectProxy::NameElementAtIndex(unsigned index) {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebAXNameFrom nameFrom;
- blink::WebVector<blink::WebAXObject> nameObjects;
- accessibility_object_.name(nameFrom, nameObjects);
- if (index >= nameObjects.size())
- return v8::Local<v8::Object>();
- return factory_->GetOrCreate(nameObjects[index]);
-}
-
-std::string WebAXObjectProxy::Description() {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebAXNameFrom nameFrom;
- blink::WebVector<blink::WebAXObject> nameObjects;
- accessibility_object_.name(nameFrom, nameObjects);
- blink::WebAXDescriptionFrom descriptionFrom;
- blink::WebVector<blink::WebAXObject> descriptionObjects;
- return accessibility_object_.description(
- nameFrom, descriptionFrom, descriptionObjects).utf8();
-}
-
-std::string WebAXObjectProxy::DescriptionFrom() {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebAXNameFrom nameFrom;
- blink::WebVector<blink::WebAXObject> nameObjects;
- accessibility_object_.name(nameFrom, nameObjects);
- blink::WebAXDescriptionFrom descriptionFrom =
- blink::WebAXDescriptionFromUninitialized;
- blink::WebVector<blink::WebAXObject> descriptionObjects;
- accessibility_object_.description(
- nameFrom, descriptionFrom, descriptionObjects);
- switch(descriptionFrom) {
- case blink::WebAXDescriptionFromUninitialized:
- return "";
- case blink::WebAXDescriptionFromAttribute:
- return "attribute";
- case blink::WebAXDescriptionFromContents:
- return "contents";
- case blink::WebAXDescriptionFromRelatedElement:
- return "relatedElement";
- }
-
- NOTREACHED();
- return std::string();
-}
-
-std::string WebAXObjectProxy::Placeholder() {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebAXNameFrom nameFrom;
- blink::WebVector<blink::WebAXObject> nameObjects;
- accessibility_object_.name(nameFrom, nameObjects);
- return accessibility_object_.placeholder(nameFrom).utf8();
-}
-
-int WebAXObjectProxy::MisspellingsCount() {
- accessibility_object_.updateLayoutAndCheckValidity();
- return GetMisspellings(accessibility_object_).size();
-}
-
-int WebAXObjectProxy::DescriptionElementCount() {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebAXNameFrom nameFrom;
- blink::WebVector<blink::WebAXObject> nameObjects;
- accessibility_object_.name(nameFrom, nameObjects);
- blink::WebAXDescriptionFrom descriptionFrom;
- blink::WebVector<blink::WebAXObject> descriptionObjects;
- accessibility_object_.description(
- nameFrom, descriptionFrom, descriptionObjects);
- return static_cast<int>(descriptionObjects.size());
-}
-
-v8::Local<v8::Object> WebAXObjectProxy::DescriptionElementAtIndex(
- unsigned index) {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebAXNameFrom nameFrom;
- blink::WebVector<blink::WebAXObject> nameObjects;
- accessibility_object_.name(nameFrom, nameObjects);
- blink::WebAXDescriptionFrom descriptionFrom;
- blink::WebVector<blink::WebAXObject> descriptionObjects;
- accessibility_object_.description(
- nameFrom, descriptionFrom, descriptionObjects);
- if (index >= descriptionObjects.size())
- return v8::Local<v8::Object>();
- return factory_->GetOrCreate(descriptionObjects[index]);
-}
-
-v8::Local<v8::Object> WebAXObjectProxy::OffsetContainer() {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebAXObject container;
- blink::WebFloatRect bounds;
- SkMatrix44 matrix;
- accessibility_object_.getRelativeBounds(container, bounds, matrix);
- return factory_->GetOrCreate(container);
-}
-
-float WebAXObjectProxy::BoundsInContainerX() {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebAXObject container;
- blink::WebFloatRect bounds;
- SkMatrix44 matrix;
- accessibility_object_.getRelativeBounds(container, bounds, matrix);
- return bounds.x;
-}
-
-float WebAXObjectProxy::BoundsInContainerY() {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebAXObject container;
- blink::WebFloatRect bounds;
- SkMatrix44 matrix;
- accessibility_object_.getRelativeBounds(container, bounds, matrix);
- return bounds.y;
-}
-
-float WebAXObjectProxy::BoundsInContainerWidth() {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebAXObject container;
- blink::WebFloatRect bounds;
- SkMatrix44 matrix;
- accessibility_object_.getRelativeBounds(container, bounds, matrix);
- return bounds.width;
-}
-
-float WebAXObjectProxy::BoundsInContainerHeight() {
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebAXObject container;
- blink::WebFloatRect bounds;
- SkMatrix44 matrix;
- accessibility_object_.getRelativeBounds(container, bounds, matrix);
- return bounds.height;
-}
-
-bool WebAXObjectProxy::HasNonIdentityTransform() {
- accessibility_object_.updateLayoutAndCheckValidity();
- accessibility_object_.updateLayoutAndCheckValidity();
- blink::WebAXObject container;
- blink::WebFloatRect bounds;
- SkMatrix44 matrix;
- accessibility_object_.getRelativeBounds(container, bounds, matrix);
- return !matrix.isIdentity();
-}
-
-RootWebAXObjectProxy::RootWebAXObjectProxy(
- const blink::WebAXObject &object, Factory *factory)
- : WebAXObjectProxy(object, factory) {
-}
-
-v8::Local<v8::Object> RootWebAXObjectProxy::GetChildAtIndex(unsigned index) {
- if (index)
- return v8::Local<v8::Object>();
-
- return factory()->GetOrCreate(accessibility_object());
-}
-
-bool RootWebAXObjectProxy::IsRoot() const {
- return true;
-}
-
-WebAXObjectProxyList::WebAXObjectProxyList()
- : elements_(blink::mainThreadIsolate()) {
-}
-
-WebAXObjectProxyList::~WebAXObjectProxyList() {
- Clear();
-}
-
-void WebAXObjectProxyList::Clear() {
- v8::Isolate* isolate = blink::mainThreadIsolate();
- v8::HandleScope handle_scope(isolate);
- size_t elementCount = elements_.Size();
- for (size_t i = 0; i < elementCount; i++) {
- WebAXObjectProxy* unwrapped_object = NULL;
- bool result = gin::ConvertFromV8(isolate, elements_.Get(i),
- &unwrapped_object);
- DCHECK(result);
- DCHECK(unwrapped_object);
- unwrapped_object->Reset();
- }
- elements_.Clear();
-}
-
-v8::Local<v8::Object> WebAXObjectProxyList::GetOrCreate(
- const blink::WebAXObject& object) {
- if (object.isNull())
- return v8::Local<v8::Object>();
-
- v8::Isolate* isolate = blink::mainThreadIsolate();
-
- size_t elementCount = elements_.Size();
- for (size_t i = 0; i < elementCount; i++) {
- WebAXObjectProxy* unwrapped_object = NULL;
- bool result = gin::ConvertFromV8(isolate, elements_.Get(i),
- &unwrapped_object);
- DCHECK(result);
- DCHECK(unwrapped_object);
- if (unwrapped_object->IsEqualToObject(object))
- return elements_.Get(i);
- }
-
- v8::Local<v8::Value> value_handle = gin::CreateHandle(
- isolate, new WebAXObjectProxy(object, this)).ToV8();
- if (value_handle.IsEmpty())
- return v8::Local<v8::Object>();
- v8::Local<v8::Object> handle = value_handle->ToObject(isolate);
- elements_.Append(handle);
- return handle;
-}
-
-} // namespace test_runner
« components/subresource_filter/DEPS ('K') | « components/test_runner/web_ax_object_proxy.h ('k') | components/test_runner/web_frame_test_client.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698