Initial accessibility controller implementation.

This is just a first pass, to avoid patch-hugeness.

R=darin
TEST=LayoutTests/accessibility
BUG=10322

Review URL: http://codereview.chromium.org/275009

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@29041 0039d316-1c4b-4281-b951-d872f2087c98

10 files changed, 852 insertions, 19 deletions

diff --git a/webkit/tools/layout_tests/test_expectations.txt b/webkit/tools/layout_tests/test_expectations.txt
index d8c4e63..9fd56b2 100644
--- a/webkit/tools/layout_tests/test_expectations.txt
+++ b/webkit/tools/layout_tests/test_expectations.txt
@@ -1204,26 +1204,16 @@ BUG13809 WIN LINUX : LayoutTests/fast/canvas/canvas-empty-image-pattern.html = F
 // and then baselined if necessary.
 // ----------------------------------------------------------------------------
 
-// Accessibility is off in the browser, and accessibility is not a priority
-// for the current release.
-// Need to implement window.accessibilityController for these to work.
+// Need to finish implementing window.accessibilityController for these to work.
 BUG10322 : LayoutTests/accessibility = FAIL PASS
 BUG10322 : LayoutTests/accessibility/non-native-image-crash.html = PASS
-BUG10322 : LayoutTests/accessibility/aria-describedby-on-input.html = FAIL
-BUG10322 : LayoutTests/accessibility/aria-disabled.html = FAIL
-BUG10322 : LayoutTests/accessibility/aria-hidden.html = FAIL
-BUG10322 : LayoutTests/accessibility/aria-label.html = FAIL
-BUG10322 : LayoutTests/accessibility/aria-labelledby-on-input.html = FAIL
-BUG10322 : LayoutTests/accessibility/aria-labelledby-stay-within.html = FAIL
 BUG10322 : LayoutTests/accessibility/aria-link-supports-press.html = FAIL
 BUG10322 : LayoutTests/accessibility/aria-readonly.html = FAIL
-BUG10322 : LayoutTests/accessibility/aria-roles.html = FAIL
 BUG10322 : LayoutTests/accessibility/aria-tables.html = FAIL
 BUG10322 : LayoutTests/accessibility/button-press-action.html = FAIL
 BUG10322 : LayoutTests/accessibility/canvas.html = FAIL
 BUG10322 : LayoutTests/accessibility/editable-webarea-context-menu-point.html = FAIL
 BUG10322 : LayoutTests/accessibility/iframe-bastardization.html = FAIL
-BUG10322 : LayoutTests/accessibility/ignore-spacer-elements.html = FAIL
 BUG10322 : LayoutTests/accessibility/image-map1.html = FAIL
 BUG10322 : LayoutTests/accessibility/image-map2.html = FAIL
 BUG10322 : LayoutTests/accessibility/img-aria-button-alt-tag.html = FAIL
@@ -1233,11 +1223,9 @@ BUG10322 : LayoutTests/accessibility/label-for-control-hittest.html = FAIL
 BUG10322 : LayoutTests/accessibility/language-attribute.html = FAIL
 BUG10322 : LayoutTests/accessibility/legend.html = FAIL
 BUG10322 : LayoutTests/accessibility/lists.html = FAIL
-BUG10322 : LayoutTests/accessibility/nested-layout-crash.html = FAIL
 BUG10322 : LayoutTests/accessibility/nochildren-elements.html = FAIL
 BUG10322 : LayoutTests/accessibility/non-data-table-cell-title-ui-element.html = FAIL
 BUG10322 : LayoutTests/accessibility/onclick-handlers.html = FAIL
-BUG10322 : LayoutTests/accessibility/placeholder.html = FAIL
 BUG10322 BUG10351 : LayoutTests/accessibility/plugin.html = FAIL
 BUG10322 : LayoutTests/accessibility/radio-button-checkbox-size.html = FAIL
 BUG10322 : LayoutTests/accessibility/radio-button-group-members.html = FAIL
@@ -1247,9 +1235,6 @@ BUG10322 : LayoutTests/accessibility/table-attributes.html = FAIL
 BUG10322 : LayoutTests/accessibility/table-cell-spans.html = FAIL
 BUG10322 : LayoutTests/accessibility/table-cells.html = FAIL
 BUG10322 : LayoutTests/accessibility/table-detection.html = FAIL
-BUG10322 : LayoutTests/accessibility/table-modification-crash.html = FAIL
-BUG10322 : LayoutTests/accessibility/table-nofirstbody.html = FAIL
-BUG10322 : LayoutTests/accessibility/table-notbody.html = FAIL
 BUG10322 : LayoutTests/accessibility/table-one-cell.html = FAIL
 BUG10322 : LayoutTests/accessibility/table-sections.html = FAIL
 BUG10322 : LayoutTests/accessibility/table-with-aria-role.html = FAIL
@@ -1260,9 +1245,8 @@ BUG10322 : LayoutTests/accessibility/textarea-selected-text-range.html = FAIL
 BUG10322 : LayoutTests/accessibility/th-as-title-ui.html = FAIL
 BUG10322 : LayoutTests/accessibility/transformed-element.html = FAIL
 BUG10322 : LayoutTests/accessibility/visible-elements.html = FAIL
-BUG10322 : LayoutTests/accessibility/input-slider.html = TIMEOUT
+BUG10322 : LayoutTests/accessibility/input-slider.html = FAIL
 BUG10322 : LayoutTests/platform/mac/accessibility = FAIL
-BUG10322 : LayoutTests/platform/mac-snowleopard/accessibility = FAIL
 BUG10322 : LayoutTests/platform/win/accessibility = FAIL
 // Introduced in http://trac.webkit.org/changeset/48368
 BUG10322 SKIP : LayoutTests/platform/win/accessibility/scroll-to-anchor.html = FAIL
diff --git a/webkit/tools/test_shell/accessibility_controller.cc b/webkit/tools/test_shell/accessibility_controller.cc
new file mode 100755
index 0000000..f17752c
--- /dev/null
+++ b/webkit/tools/test_shell/accessibility_controller.cc
@@ -0,0 +1,102 @@
+// Copyright (c) 2006-2009 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 "config.h"
+
+#include "AXObjectCache.h"
+
+#undef LOG
+
+#include <vector>
+
+#include "base/logging.h"
+
+#include "webkit/api/public/WebAccessibilityObject.h"
+#include "webkit/api/public/WebFrame.h"
+#include "webkit/tools/test_shell/accessibility_controller.h"
+#include "webkit/tools/test_shell/test_shell.h"
+#include "webkit/glue/webview_impl.h"
+
+using WebKit::WebAccessibilityObject;
+using WebKit::WebFrame;
+
+AccessibilityController::AccessibilityController(TestShell* shell)
+    : shell_(shell) {
+
+  BindMethod("logFocusEvents",
+      &AccessibilityController::LogFocusEventsCallback);
+  BindMethod("logScrollingStartEvents",
+      &AccessibilityController::LogScrollingStartEventsCallback);
+
+  BindProperty("focusedElement",
+      &AccessibilityController::FocusedElementGetterCallback);
+  BindProperty("rootElement",
+      &AccessibilityController::RootElementGetterCallback);
+
+  BindFallbackMethod(&AccessibilityController::FallbackCallback);
+}
+
+void AccessibilityController::BindToJavascript(
+    WebFrame* frame, const std::wstring& classname) {
+  WebCore::AXObjectCache::enableAccessibility();
+  CppBoundClass::BindToJavascript(frame, classname);
+}
+
+void AccessibilityController::Reset() {
+  root_element_ = WebAccessibilityObject();
+  focused_element_ = WebAccessibilityObject();
+  elements_.Clear();
+}
+
+void AccessibilityController::SetFocusedElement(
+    const WebAccessibilityObject& focused_element) {
+  focused_element_ = focused_element;
+}
+
+AccessibilityUIElement* AccessibilityController::GetFocusedElement() {
+  if (focused_element_.isNull())
+    focused_element_ = shell_->webView()->accessibilityObject();
+
+  return elements_.Create(focused_element_);
+}
+
+AccessibilityUIElement* AccessibilityController::GetRootElement() {
+  if (root_element_.isNull())
+    root_element_ = shell_->webView()->accessibilityObject();
+  return elements_.CreateRoot(root_element_);
+}
+
+void AccessibilityController::LogFocusEventsCallback(
+    const CppArgumentList &args,
+    CppVariant *result) {
+  // As of r49031, this is not being used upstream.
+  result->SetNull();
+}
+
+void AccessibilityController::LogScrollingStartEventsCallback(
+    const CppArgumentList &args,
+    CppVariant *result) {
+  // As of r49031, this is not being used upstream.
+  result->SetNull();
+}
+
+void AccessibilityController::FocusedElementGetterCallback(CppVariant* result) {
+  result->Set(*(GetFocusedElement()->GetAsCppVariant()));
+}
+
+void AccessibilityController::RootElementGetterCallback(CppVariant *result) {
+  result->Set(*(GetRootElement()->GetAsCppVariant()));
+}
+
+void AccessibilityController::FallbackCallback(const CppArgumentList &args,
+                                               CppVariant *result) {
+  std::wstring message(
+      L"JavaScript ERROR: unknown method called on AccessibilityController");
+  if (!shell_->layout_test_mode()) {
+    logging::LogMessage("CONSOLE:", 0).stream() << message;
+  } else {
+    printf("CONSOLE MESSAGE: %S\n", message.c_str());
+  }
+  result->SetNull();
+}
diff --git a/webkit/tools/test_shell/accessibility_controller.h b/webkit/tools/test_shell/accessibility_controller.h
new file mode 100755
index 0000000..018c2f1
--- /dev/null
+++ b/webkit/tools/test_shell/accessibility_controller.h
@@ -0,0 +1,51 @@
+// Copyright (c) 2006-2009 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.
+
+#ifndef WEBKIT_TOOLS_TEST_SHELL_ACCESSIBILITY_CONTROLLER_H_
+#define WEBKIT_TOOLS_TEST_SHELL_ACCESSIBILITY_CONTROLLER_H_
+
+#include "webkit/glue/cpp_bound_class.h"
+#include "webkit/tools/test_shell/accessibility_ui_element.h"
+
+namespace WebKit {
+class WebAccessibilityObject;
+class WebFrame;
+}
+
+class AccessibilityUIElement;
+class AccessibilityUIElementList;
+class TestShell;
+
+class AccessibilityController : public CppBoundClass {
+ public:
+  explicit AccessibilityController(TestShell* shell);
+
+  // shadow to include accessibility initialization.
+  void BindToJavascript(
+      WebKit::WebFrame* frame, const std::wstring& classname);
+  void Reset();
+
+  void SetFocusedElement(const WebKit::WebAccessibilityObject& focused_element);
+  AccessibilityUIElement* GetFocusedElement();
+  AccessibilityUIElement* GetRootElement();
+
+ private:
+  // Bound methods and properties
+  void LogFocusEventsCallback(const CppArgumentList& args, CppVariant* result);
+  void LogScrollingStartEventsCallback(
+      const CppArgumentList& args, CppVariant* result);
+  void FallbackCallback(const CppArgumentList& args, CppVariant* result);
+
+  void FocusedElementGetterCallback(CppVariant* result);
+  void RootElementGetterCallback(CppVariant* result);
+
+  WebKit::WebAccessibilityObject focused_element_;
+  WebKit::WebAccessibilityObject root_element_;
+
+  AccessibilityUIElementList elements_;
+
+  TestShell* shell_;
+};
+
+#endif  // WEBKIT_TOOLS_TEST_SHELL_ACCESSIBILITY_CONTROLLER_H_
diff --git a/webkit/tools/test_shell/accessibility_ui_element.cc b/webkit/tools/test_shell/accessibility_ui_element.cc
new file mode 100755
index 0000000..50a70e6
--- /dev/null
+++ b/webkit/tools/test_shell/accessibility_ui_element.cc
@@ -0,0 +1,526 @@
+// Copyright (c) 2006-2008 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 "config.h"
+
+#include "AccessibilityObject.h"
+
+#undef LOG
+
+#include "webkit/api/public/WebAccessibilityObject.h"
+#include "webkit/glue/glue_util.h"
+#include "webkit/tools/test_shell/accessibility_ui_element.h"
+
+using namespace WebCore;
+
+using WebKit::WebAccessibilityObject;
+
+using webkit_glue::StringToStdString;
+using webkit_glue::AccessibilityObjectToWebAccessibilityObject;
+using webkit_glue::WebAccessibilityObjectToAccessibilityObject;
+
+namespace {
+
+static PassRefPtr<AccessibilityObject> AXObject(
+    const WebAccessibilityObject& object) {
+  RefPtr<AccessibilityObject> o =
+      WebAccessibilityObjectToAccessibilityObject(object);
+  // Always ask to update the render tree before querying accessibility object.
+  o->updateBackingStore();
+  return o;
+}
+
+// Map role value to string, matching Safari/Mac platform implementation to
+// avoid rebaselining layout tests.
+static std::string RoleToString(AccessibilityRole role) {
+  std::string result = "AXRole: AX";
+  switch (role) {
+    case ButtonRole:
+      return result.append("Button");
+    case RadioButtonRole:
+      return result.append("RadioButton");
+    case CheckBoxRole:
+      return result.append("CheckBox");
+    case SliderRole:
+      return result.append("Slider");
+    case TabGroupRole:
+      return result.append("TabGroup");
+    case TextFieldRole:
+      return result.append("TextField");
+    case StaticTextRole:
+      return result.append("StaticText");
+    case TextAreaRole:
+      return result.append("TextArea");
+    case ScrollAreaRole:
+      return result.append("ScrollArea");
+    case PopUpButtonRole:
+      return result.append("PopUpButton");
+    case MenuButtonRole:
+      return result.append("MenuButton");
+    case TableRole:
+      return result.append("Table");
+    case ApplicationRole:
+      return result.append("Application");
+    case GroupRole:
+      return result.append("Group");
+    case RadioGroupRole:
+      return result.append("RadioGroup");
+    case ListRole:
+      return result.append("List");
+    case ScrollBarRole:
+      return result.append("ScrollBar");
+    case ValueIndicatorRole:
+      return result.append("ValueIndicator");
+    case ImageRole:
+      return result.append("Image");
+    case MenuBarRole:
+      return result.append("MenuBar");
+    case MenuRole:
+      return result.append("Menu");
+    case MenuItemRole:
+      return result.append("MenuItem");
+    case ColumnRole:
+      return result.append("Column");
+    case RowRole:
+      return result.append("Row");
+    case ToolbarRole:
+      return result.append("Toolbar");
+    case BusyIndicatorRole:
+      return result.append("BusyIndicator");
+    case ProgressIndicatorRole:
+      return result.append("ProgressIndicator");
+    case WindowRole:
+      return result.append("Window");
+    case DrawerRole:
+      return result.append("Drawer");
+    case SystemWideRole:
+      return result.append("SystemWide");
+    case OutlineRole:
+      return result.append("Outline");
+    case IncrementorRole:
+      return result.append("Incrementor");
+    case BrowserRole:
+      return result.append("Browser");
+    case ComboBoxRole:
+      return result.append("ComboBox");
+    case SplitGroupRole:
+      return result.append("SplitGroup");
+    case SplitterRole:
+      return result.append("Splitter");
+    case ColorWellRole:
+      return result.append("ColorWell");
+    case GrowAreaRole:
+      return result.append("GrowArea");
+    case SheetRole:
+      return result.append("Sheet");
+    case HelpTagRole:
+      return result.append("HelpTag");
+    case MatteRole:
+      return result.append("Matte");
+    case RulerRole:
+      return result.append("Ruler");
+    case RulerMarkerRole:
+      return result.append("RulerMarker");
+    case LinkRole:
+      return result.append("Link");
+    case DisclosureTriangleRole:
+      return result.append("DisclosureTriangle");
+    case GridRole:
+      return result.append("Grid");
+    case CellRole:
+      return result.append("Cell");
+    case ColumnHeaderRole:
+      return result.append("ColumnHeader");
+    case RowHeaderRole:
+      return result.append("RowHeader");
+    case WebCoreLinkRole:
+      // Maps to Link role.
+      return result.append("Link");
+    case ImageMapLinkRole:
+      return result.append("ImageMapLink");
+    case ImageMapRole:
+      return result.append("ImageMap");
+    case ListMarkerRole:
+      return result.append("ListMarker");
+    case WebAreaRole:
+      return result.append("WebArea");
+    case HeadingRole:
+      return result.append("Heading");
+    case ListBoxRole:
+      return result.append("ListBox");
+    case ListBoxOptionRole:
+      return result.append("ListBoxOption");
+    case TableHeaderContainerRole:
+      return result.append("TableHeaderContainer");
+    case DefinitionListTermRole:
+      return result.append("DefinitionListTerm");
+    case DefinitionListDefinitionRole:
+      return result.append("DefinitionListDefinition");
+    case AnnotationRole:
+      return result.append("Annotation");
+    case SliderThumbRole:
+      return result.append("SliderThumb");
+    case LandmarkApplicationRole:
+      return result.append("LandmarkApplication");
+    case LandmarkBannerRole:
+      return result.append("LandmarkBanner");
+    case LandmarkComplementaryRole:
+      return result.append("LandmarkComplementary");
+    case LandmarkContentInfoRole:
+      return result.append("LandmarkContentInfo");
+    case LandmarkMainRole:
+      return result.append("LandmarkMain");
+    case LandmarkNavigationRole:
+      return result.append("LandmarkNavigation");
+    case LandmarkSearchRole:
+      return result.append("LandmarkSearch");
+    case ApplicationLogRole:
+      return result.append("ApplicationLog");
+    case ApplicationMarqueeRole:
+      return result.append("ApplicationMarquee");
+    case ApplicationStatusRole:
+      return result.append("ApplicationStatus");
+    case ApplicationTimerRole:
+      return result.append("ApplicationTimer");
+    case DocumentRole:
+      return result.append("Document");
+    case DocumentArticleRole:
+      return result.append("DocumentArticle");
+    case DocumentNoteRole:
+      return result.append("DocumentNote");
+    case DocumentRegionRole:
+      return result.append("DocumentRegion");
+    case UserInterfaceTooltipRole:
+      return result.append("UserInterfaceTooltip");
+    default:
+      // Also matches UnknownRole.
+      return result.append("Unknown");
+  }
+}
+
+}  // namespace
+
+AccessibilityUIElement::AccessibilityUIElement(
+    const WebKit::WebAccessibilityObject& object,
+    Factory* factory)
+    : accessibility_object_(object),
+      factory_(factory) {
+
+  DCHECK(factory);
+
+  BindMethod("allAttributes", &AccessibilityUIElement::AllAttributesCallback);
+  BindMethod("attributesOfLinkedUIElements",
+             &AccessibilityUIElement::AttributesOfLinkedUIElementsCallback);
+  BindMethod("attributesOfDocumentLinks",
+             &AccessibilityUIElement::AttributesOfDocumentLinksCallback);
+  BindMethod("attributesOfChildren",
+             &AccessibilityUIElement::AttributesOfChildrenCallback);
+  BindMethod("parameterizedAttributeNames",
+             &AccessibilityUIElement::ParametrizedAttributeNamesCallback);
+  BindMethod("lineForIndex", &AccessibilityUIElement::LineForIndexCallback);
+  BindMethod("boundsForRange", &AccessibilityUIElement::BoundsForRangeCallback);
+  BindMethod("stringForRange", &AccessibilityUIElement::StringForRangeCallback);
+  BindMethod("childAtIndex", &AccessibilityUIElement::ChildAtIndexCallback);
+  BindMethod("elementAtPoint", &AccessibilityUIElement::ElementAtPointCallback);
+  BindMethod("attributesOfColumnHeaders",
+             &AccessibilityUIElement::AttributesOfColumnHeadersCallback);
+  BindMethod("attributesOfRowHeaders",
+             &AccessibilityUIElement::AttributesOfRowHeadersCallback);
+  BindMethod("attributesOfColumns",
+             &AccessibilityUIElement::AttributesOfColumnsCallback);
+  BindMethod("attributesOfRows",
+             &AccessibilityUIElement::AttributesOfRowsCallback);
+  BindMethod("attributesOfVisibleCells",
+             &AccessibilityUIElement::AttributesOfVisibleCellsCallback);
+  BindMethod("attributesOfHeader",
+             &AccessibilityUIElement::AttributesOfHeaderCallback);
+  BindMethod("indexInTable", &AccessibilityUIElement::IndexInTableCallback);
+  BindMethod("rowIndexRange", &AccessibilityUIElement::RowIndexRangeCallback);
+  BindMethod("columnIndexRange",
+             &AccessibilityUIElement::ColumnIndexRangeCallback);
+  BindMethod("cellForColumnAndRow",
+             &AccessibilityUIElement::CellForColumnAndRowCallback);
+  BindMethod("titleUIElement", &AccessibilityUIElement::TitleUIElementCallback);
+  BindMethod("setSelectedTextRange",
+             &AccessibilityUIElement::SetSelectedTextRangeCallback);
+  BindMethod("attributeValue", &AccessibilityUIElement::AttributeValueCallback);
+  BindMethod("isAttributeSettable",
+             &AccessibilityUIElement::IsAttributeSettableCallback);
+  BindMethod("isActionSupported",
+             &AccessibilityUIElement::IsActionSupportedCallback);
+  BindMethod("parentElement", &AccessibilityUIElement::ParentElementCallback);
+  BindMethod("increment", &AccessibilityUIElement::IncrementCallback);
+  BindMethod("decrement", &AccessibilityUIElement::DecrementCallback);
+
+  BindProperty("role", &AccessibilityUIElement::RoleGetterCallback);
+  BindProperty("subrole", &subrole_);
+  BindProperty("title", &AccessibilityUIElement::TitleGetterCallback);
+  BindProperty("description",
+      &AccessibilityUIElement::DescriptionGetterCallback);
+  BindProperty("language", &language_);
+  BindProperty("x", &x_);
+  BindProperty("y", &y_);
+  BindProperty("width", &width_);
+  BindProperty("height", &height_);
+  BindProperty("clickPointX", &click_point_x_);
+  BindProperty("clickPointY", &click_point_y_);
+  BindProperty("intValue", &int_value_);
+  BindProperty("minValue", &min_value_);
+  BindProperty("maxValue", &max_value_);
+  BindProperty("childrenCount",
+      &AccessibilityUIElement::ChildrenCountGetterCallback);
+  BindProperty("insertionPointLineNumber", &insertion_point_line_number_);
+  BindProperty("selectedTextRange", &selected_text_range);
+  BindProperty("isEnabled", &AccessibilityUIElement::IsEnabledGetterCallback);
+  BindProperty("isRequired", &is_required_);
+  BindProperty("valueDescription", &value_description_);
+
+  BindFallbackMethod(&AccessibilityUIElement::FallbackCallback);
+}
+
+AccessibilityUIElement* AccessibilityUIElement::GetChildAtIndex(
+    unsigned index) {
+  RefPtr<AccessibilityObject> object = AXObject(accessibility_object());
+  if (object->children().size() <= index)
+    return NULL;
+
+  WebAccessibilityObject child =
+      AccessibilityObjectToWebAccessibilityObject(object->children()[index]);
+  return factory_->Create(child);
+}
+
+std::string AccessibilityUIElement::GetTitle() {
+  std::string title = StringToStdString(AXObject(
+      accessibility_object())->title());
+  return title.insert(0, "AXTitle: ");
+}
+
+std::string AccessibilityUIElement::GetDescription() {
+  std::string description = StringToStdString(AXObject(
+      accessibility_object())->accessibilityDescription());
+  return description.insert(0, "AXDescription: ");
+}
+
+void AccessibilityUIElement::AllAttributesCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  // TODO(dglazkov): Concatenate all attributes of the AccessibilityObject.
+  std::string attributes(GetTitle());
+  result->Set(attributes);
+}
+
+void AccessibilityUIElement::AttributesOfLinkedUIElementsCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::AttributesOfDocumentLinksCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::AttributesOfChildrenCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::ParametrizedAttributeNamesCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::LineForIndexCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::BoundsForRangeCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::StringForRangeCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::ChildAtIndexCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  if (args.size() == 0 || !args[0].isNumber()) {
+    result->SetNull();
+    return;
+  }
+
+  AccessibilityUIElement* child = GetChildAtIndex(args[0].ToInt32());
+  if (!child) {
+    result->SetNull();
+    return;
+  }
+
+  result->Set(*(child->GetAsCppVariant()));
+}
+
+void AccessibilityUIElement::ElementAtPointCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::AttributesOfColumnHeadersCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::AttributesOfRowHeadersCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::AttributesOfColumnsCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::AttributesOfRowsCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::AttributesOfVisibleCellsCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::AttributesOfHeaderCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::IndexInTableCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::RowIndexRangeCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::ColumnIndexRangeCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::CellForColumnAndRowCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::TitleUIElementCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::SetSelectedTextRangeCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::AttributeValueCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::IsAttributeSettableCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::IsActionSupportedCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  // This one may be really hard to implement.
+  // Not exposed by AccessibilityObject.
+  result->SetNull();
+}
+
+void AccessibilityUIElement::ParentElementCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::IncrementCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::DecrementCallback(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+}
+
+void AccessibilityUIElement::FallbackCallback(const CppArgumentList &args,
+                                              CppVariant *result) {
+  // TODO(dglazkov): Implement this.
+  result->SetNull();
+}
+
+void AccessibilityUIElement::ChildrenCountGetterCallback(CppVariant* result) {
+  int count = 1;  // Root object always has only one child, the WebView.
+  if (!IsRoot())
+    count = AXObject(accessibility_object())->children().size();
+  result->Set(count);
+}
+
+void AccessibilityUIElement::DescriptionGetterCallback(CppVariant *result) {
+  result->Set(GetDescription());
+}
+
+void AccessibilityUIElement::IsEnabledGetterCallback(CppVariant* result) {
+  result->Set(AXObject(accessibility_object())->isEnabled());
+}
+
+void AccessibilityUIElement::RoleGetterCallback(CppVariant* result) {
+  result->Set(RoleToString(AXObject(accessibility_object())->roleValue()));
+}
+
+void AccessibilityUIElement::TitleGetterCallback(CppVariant* result) {
+  result->Set(GetTitle());
+}
+
+
+RootAccessibilityUIElement::RootAccessibilityUIElement(
+    const WebKit::WebAccessibilityObject &object,
+    Factory *factory) : AccessibilityUIElement(object, factory) { }
+
+AccessibilityUIElement* RootAccessibilityUIElement::GetChildAtIndex(
+    unsigned index) {
+  if (index != 0)
+    return NULL;
+
+  return factory()->Create(accessibility_object());
+}
+
+
+AccessibilityUIElementList ::~AccessibilityUIElementList() {
+  Clear();
+}
+
+void AccessibilityUIElementList::Clear() {
+  for (ElementList::iterator i = elements_.begin(); i != elements_.end(); ++i)
+    delete (*i);
+  elements_.clear();
+}
+
+AccessibilityUIElement* AccessibilityUIElementList::Create(
+    const WebAccessibilityObject& object) {
+  AccessibilityUIElement* element = new AccessibilityUIElement(object, this);
+  elements_.push_back(element);
+  return element;
+}
+
+AccessibilityUIElement* AccessibilityUIElementList::CreateRoot(
+    const WebAccessibilityObject& object) {
+  AccessibilityUIElement* element =
+      new RootAccessibilityUIElement(object, this);
+  elements_.push_back(element);
+  return element;
+}
diff --git a/webkit/tools/test_shell/accessibility_ui_element.h b/webkit/tools/test_shell/accessibility_ui_element.h
new file mode 100755
index 0000000..9340257
--- /dev/null
+++ b/webkit/tools/test_shell/accessibility_ui_element.h
@@ -0,0 +1,144 @@
+// Copyright (c) 2006-2009 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.
+
+#ifndef WEBKIT_TOOLS_TEST_SHELL_ACCESSIBILITY_UI_ELEMENT_H_
+#define WEBKIT_TOOLS_TEST_SHELL_ACCESSIBILITY_UI_ELEMENT_H_
+
+#include "webkit/glue/cpp_bound_class.h"
+
+namespace WebKit {
+class WebAccessibilityObject;
+}
+
+class AccessibilityUIElement : public CppBoundClass {
+ public:
+  class Factory {
+  public:
+    virtual ~Factory() { }
+    virtual AccessibilityUIElement* Create(
+        const WebKit::WebAccessibilityObject& object) = 0;
+  };
+
+  AccessibilityUIElement(
+      const WebKit::WebAccessibilityObject& accessibility_object,
+      Factory* factory);
+
+  virtual AccessibilityUIElement* GetChildAtIndex(unsigned index);
+  virtual bool IsRoot() const { return false; }
+
+  std::string GetTitle();
+  std::string GetDescription();
+
+ protected:
+  const WebKit::WebAccessibilityObject& accessibility_object() const {
+    return accessibility_object_;
+  }
+  Factory* factory() const { return factory_; }
+
+ private:
+  // Bound methods and properties.
+  void AllAttributesCallback(const CppArgumentList& args, CppVariant* result);
+  void AttributesOfLinkedUIElementsCallback(
+      const CppArgumentList& args, CppVariant* result);
+  void AttributesOfDocumentLinksCallback(
+      const CppArgumentList& args, CppVariant* result);
+  void AttributesOfChildrenCallback(
+      const CppArgumentList& args, CppVariant* result);
+  void ParametrizedAttributeNamesCallback(
+      const CppArgumentList& args, CppVariant* result);
+  void LineForIndexCallback(const CppArgumentList& args, CppVariant* result);
+  void BoundsForRangeCallback(const CppArgumentList& args, CppVariant* result);
+  void StringForRangeCallback(const CppArgumentList& args, CppVariant* result);
+  void ChildAtIndexCallback(const CppArgumentList& args, CppVariant* result);
+  void ElementAtPointCallback(const CppArgumentList& args, CppVariant* result);
+  void AttributesOfColumnHeadersCallback(
+      const CppArgumentList& args, CppVariant* result);
+  void AttributesOfRowHeadersCallback(
+      const CppArgumentList& args, CppVariant* result);
+  void AttributesOfColumnsCallback(
+      const CppArgumentList& args, CppVariant* result);
+  void AttributesOfRowsCallback(
+      const CppArgumentList& args, CppVariant* result);
+  void AttributesOfVisibleCellsCallback(
+      const CppArgumentList& args, CppVariant* result);
+  void AttributesOfHeaderCallback(
+      const CppArgumentList& args, CppVariant* result);
+  void IndexInTableCallback(const CppArgumentList& args, CppVariant* result);
+  void RowIndexRangeCallback(const CppArgumentList& args, CppVariant* result);
+  void ColumnIndexRangeCallback(
+      const CppArgumentList& args, CppVariant* result);
+  void CellForColumnAndRowCallback(
+      const CppArgumentList& args, CppVariant* result);
+  void TitleUIElementCallback(const CppArgumentList& args, CppVariant* result);
+  void SetSelectedTextRangeCallback(
+      const CppArgumentList& args, CppVariant* result);
+  void AttributeValueCallback(const CppArgumentList& args, CppVariant* result);
+  void IsAttributeSettableCallback(
+      const CppArgumentList& args, CppVariant* result);
+  void IsActionSupportedCallback(
+      const CppArgumentList& args, CppVariant* result);
+  void ParentElementCallback(const CppArgumentList& args, CppVariant* result);
+  void IncrementCallback(const CppArgumentList& args, CppVariant* result);
+  void DecrementCallback(const CppArgumentList& args, CppVariant* result);
+  void FallbackCallback(const CppArgumentList& args, CppVariant* result);
+
+  void ChildrenCountGetterCallback(CppVariant* result);
+  void DescriptionGetterCallback(CppVariant* result);
+  void IsEnabledGetterCallback(CppVariant* result);
+  void RoleGetterCallback(CppVariant* result);
+  void TitleGetterCallback(CppVariant* result);
+
+  CppVariant subrole_;
+  CppVariant language_;
+  CppVariant x_;
+  CppVariant y_;
+  CppVariant width_;
+  CppVariant height_;
+  CppVariant click_point_x_;
+  CppVariant click_point_y_;
+  CppVariant int_value_;
+  CppVariant min_value_;
+  CppVariant max_value_;
+  CppVariant children_count_;
+  CppVariant insertion_point_line_number_;
+  CppVariant selected_text_range;
+  CppVariant is_required_;
+  CppVariant value_description_;
+
+  WebKit::WebAccessibilityObject accessibility_object_;
+  Factory* factory_;
+};
+
+
+class RootAccessibilityUIElement : public AccessibilityUIElement {
+ public:
+  RootAccessibilityUIElement(
+      const WebKit::WebAccessibilityObject& accessibility_object,
+      Factory* factory);
+
+  virtual AccessibilityUIElement* GetChildAtIndex(unsigned index);
+  virtual bool IsRoot() const { return true; }
+};
+
+
+// Provides simple lifetime management of the AccessibilityUIElement instances:
+// all AccessibilityUIElements ever created from the controller are stored in
+// a list and cleared explicitly.
+class AccessibilityUIElementList : public AccessibilityUIElement::Factory {
+ public:
+  AccessibilityUIElementList() { }
+  virtual ~AccessibilityUIElementList();
+
+  void Clear();
+  virtual AccessibilityUIElement* Create(
+      const WebKit::WebAccessibilityObject& object);
+  AccessibilityUIElement* CreateRoot(
+      const WebKit::WebAccessibilityObject& object);
+
+ private:
+  typedef std::vector<AccessibilityUIElement*> ElementList;
+  ElementList elements_;
+};
+
+#endif  // WEBKIT_TOOLS_TEST_SHELL_ACCESSIBILITY_UI_ELEMENT_H_
diff --git a/webkit/tools/test_shell/test_shell.cc b/webkit/tools/test_shell/test_shell.cc
index 988eb60..d18d2e2 100644
--- a/webkit/tools/test_shell/test_shell.cc
+++ b/webkit/tools/test_shell/test_shell.cc
@@ -31,6 +31,7 @@
 #include "skia/ext/bitmap_platform_device.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
+#include "webkit/api/public/WebAccessibilityObject.h"
 #include "webkit/api/public/WebFrame.h"
 #include "webkit/api/public/WebKit.h"
 #include "webkit/api/public/WebRect.h"
@@ -43,6 +44,7 @@
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/glue/webpreferences.h"
 #include "webkit/glue/webview.h"
+#include "webkit/tools/test_shell/accessibility_controller.h"
 #include "webkit/tools/test_shell/simple_resource_loader_bridge.h"
 #include "webkit/tools/test_shell/test_navigation_controller.h"
 #include "webkit/tools/test_shell/test_shell_switches.h"
@@ -113,6 +115,7 @@ TestShell::TestShell()
       test_params_(NULL),
       is_modal_(false),
       dump_stats_table_on_exit_(false) {
+    accessibility_controller_.reset(new AccessibilityController(this));
     delegate_.reset(new TestWebViewDelegate(this));
     popup_delegate_.reset(new TestWebViewDelegate(this));
     layout_test_controller_.reset(new LayoutTestController(this));
@@ -455,6 +458,8 @@ void TestShell::Show(WebNavigationPolicy policy) {
 void TestShell::BindJSObjectsToWindow(WebFrame* frame) {
   // Only bind the test classes if we're running tests.
   if (layout_test_mode_) {
+    accessibility_controller_->BindToJavascript(
+        frame, L"accessibilityController");
     layout_test_controller_->BindToJavascript(frame, L"layoutTestController");
     event_sending_controller_->BindToJavascript(frame, L"eventSender");
     text_input_controller_->BindToJavascript(frame, L"textInputController");
@@ -514,6 +519,7 @@ void TestShell::SizeToDefault() {
 }
 
 void TestShell::ResetTestController() {
+  accessibility_controller_->Reset();
   layout_test_controller_->Reset();
   event_sending_controller_->Reset();
   delegate_->Reset();
diff --git a/webkit/tools/test_shell/test_shell.gyp b/webkit/tools/test_shell/test_shell.gyp
index 6020264..50f6628 100644
--- a/webkit/tools/test_shell/test_shell.gyp
+++ b/webkit/tools/test_shell/test_shell.gyp
@@ -51,6 +51,10 @@
         'mac/test_webview_delegate.mm',
         'mac/webview_host.mm',
         'mac/webwidget_host.mm',
+        'accessibility_controller.cc',
+        'accessibility_controller.h',
+        'accessibility_ui_element.cc',
+        'accessibility_ui_element.h',
         'drag_delegate.cc',
         'drag_delegate.h',
         'drop_delegate.cc',
diff --git a/webkit/tools/test_shell/test_shell.h b/webkit/tools/test_shell/test_shell.h
index aa25368..72c0407 100644
--- a/webkit/tools/test_shell/test_shell.h
+++ b/webkit/tools/test_shell/test_shell.h
@@ -47,6 +47,7 @@
 typedef std::list<gfx::NativeWindow> WindowList;
 
 struct WebPreferences;
+class AccessibilityController;
 class TestNavigationEntry;
 class TestNavigationController;
 
@@ -112,6 +113,9 @@ public:
     // We use this to avoid relying on Windows focus during layout test mode.
     void SetFocus(WebWidgetHost* host, bool enable);
 
+    AccessibilityController* accessibility_controller() const {
+      return accessibility_controller_.get();
+    }
     LayoutTestController* layout_test_controller() {
       return layout_test_controller_.get();
     }
@@ -321,6 +325,7 @@ private:
     // Default timeout in ms for file page loads when in layout test mode.
     static int file_test_timeout_ms_;
 
+    scoped_ptr<AccessibilityController> accessibility_controller_;
     scoped_ptr<LayoutTestController> layout_test_controller_;
 
     scoped_ptr<EventSendingController> event_sending_controller_;
diff --git a/webkit/tools/test_shell/test_webview_delegate.cc b/webkit/tools/test_shell/test_webview_delegate.cc
index 1a197d2..de5af01 100644
--- a/webkit/tools/test_shell/test_webview_delegate.cc
+++ b/webkit/tools/test_shell/test_webview_delegate.cc
@@ -20,6 +20,7 @@
 #include "base/string_util.h"
 #include "base/trace_event.h"
 #include "net/base/net_errors.h"
+#include "webkit/api/public/WebAccessibilityObject.h"
 #include "webkit/api/public/WebConsoleMessage.h"
 #include "webkit/api/public/WebContextMenuData.h"
 #include "webkit/api/public/WebCString.h"
@@ -41,6 +42,7 @@
 #include "webkit/api/public/WebURLResponse.h"
 #include "webkit/appcache/appcache_interfaces.h"
 #include "webkit/glue/glue_serialize.h"
+#include "webkit/glue/glue_util.h"
 #include "webkit/glue/media/buffered_data_source.h"
 #include "webkit/glue/media/media_resource_loader_bridge_factory.h"
 #include "webkit/glue/media/simple_data_source.h"
@@ -53,6 +55,7 @@
 #include "webkit/glue/plugins/webplugin_delegate_impl.h"
 #include "webkit/glue/webmediaplayer_impl.h"
 #include "webkit/glue/window_open_disposition.h"
+#include "webkit/tools/test_shell/accessibility_controller.h"
 #include "webkit/tools/test_shell/test_navigation_controller.h"
 #include "webkit/tools/test_shell/test_shell.h"
 #include "webkit/tools/test_shell/test_web_worker.h"
@@ -63,6 +66,7 @@
 #include "webkit/tools/test_shell/drop_delegate.h"
 #endif
 
+using WebKit::WebAccessibilityObject;
 using WebKit::WebConsoleMessage;
 using WebKit::WebContextMenuData;
 using WebKit::WebData;
@@ -98,6 +102,8 @@ using WebKit::WebWidget;
 using WebKit::WebWorker;
 using WebKit::WebWorkerClient;
 
+using webkit_glue::AccessibilityObjectToWebAccessibilityObject;
+
 namespace {
 
 // WebNavigationType debugging strings taken from PolicyDelegate.mm.
@@ -909,6 +915,11 @@ void TestWebViewDelegate::didRunInsecureContent(
     printf("didRunInsecureContent\n");
 }
 
+void TestWebViewDelegate::focusAccessibilityObject(
+    const WebAccessibilityObject& object) {
+  shell_->accessibility_controller()->SetFocusedElement(object);
+}
+
 // Public methods ------------------------------------------------------------
 
 TestWebViewDelegate::TestWebViewDelegate(TestShell* shell)
diff --git a/webkit/tools/test_shell/test_webview_delegate.h b/webkit/tools/test_shell/test_webview_delegate.h
index f840b41..3724ff4 100644
--- a/webkit/tools/test_shell/test_webview_delegate.h
+++ b/webkit/tools/test_shell/test_webview_delegate.h
@@ -141,7 +141,7 @@ class TestWebViewDelegate : public WebViewDelegate,
   virtual void didAddHistoryItem() {}
   virtual void didUpdateInspectorSettings() {}
   virtual void focusAccessibilityObject(
-      const WebKit::WebAccessibilityObject& object) {}
+      const WebKit::WebAccessibilityObject& object);
 
   // WebKit::WebWidgetClient
   virtual void didInvalidateRect(const WebKit::WebRect& rect);