Refactor all accessibility code out of webkit/glue.

content/browser/accessibility/renderer_accessibility_browsertest.cc

Index: content/browser/accessibility/renderer_accessibility_browsertest.cc
diff --git a/content/browser/accessibility/renderer_accessibility_browsertest.cc b/content/browser/accessibility/renderer_accessibility_browsertest.cc
index c70c3e61b9a0b7212fb7c2bb1e430d176a144fa1..26885716d9542e5b28144bfdd48a28117e7ff0ae 100644
--- a/content/browser/accessibility/renderer_accessibility_browsertest.cc
+++ b/content/browser/accessibility/renderer_accessibility_browsertest.cc
@@ -10,6 +10,7 @@
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
+#include "content/common/accessibility_node_data.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_widget_host_view.h"
@@ -21,11 +22,11 @@
 #include "ui/base/win/atl_module.h"
 #endif
 
+using content::AccessibilityNodeData;
 using content::OpenURLParams;
 using content::RenderViewHostImpl;
 using content::RenderWidgetHostImpl;
 using content::Referrer;
-using webkit_glue::WebAccessibility;
 
 namespace {
 
@@ -35,7 +36,7 @@ class RendererAccessibilityBrowserTest : public InProcessBrowserTest {
 
   // Tell the renderer to send an accessibility tree, then wait for the
   // notification that it's been received.
-  const WebAccessibility& GetWebAccessibilityTree(
+  const AccessibilityNodeData& GetAccessibilityNodeDataTree(
       AccessibilityMode accessibility_mode = AccessibilityModeComplete) {
     ui_test_utils::WindowedNotificationObserver tree_updated_observer(
         content::NOTIFICATION_RENDER_VIEW_HOST_ACCESSIBILITY_TREE_UPDATED,
@@ -53,7 +54,7 @@ class RendererAccessibilityBrowserTest : public InProcessBrowserTest {
 
   // Make sure each node in the tree has an unique id.
   void RecursiveAssertUniqueIds(
-      const WebAccessibility& node, base::hash_set<int>* ids) {
+      const AccessibilityNodeData& node, base::hash_set<int>* ids) {
     ASSERT_TRUE(ids->find(node.id) == ids->end());
     ids->insert(node.id);
     for (size_t i = 0; i < node.children.size(); i++)
@@ -65,12 +66,12 @@ class RendererAccessibilityBrowserTest : public InProcessBrowserTest {
   void TearDownInProcessBrowserTestFixture();
 
  protected:
-  std::string GetAttr(const WebAccessibility& node,
-                      const WebAccessibility::StringAttribute attr);
-  int GetIntAttr(const WebAccessibility& node,
-                 const WebAccessibility::IntAttribute attr);
-  bool GetBoolAttr(const WebAccessibility& node,
-                   const WebAccessibility::BoolAttribute attr);
+  std::string GetAttr(const AccessibilityNodeData& node,
+                      const AccessibilityNodeData::StringAttribute attr);
+  int GetIntAttr(const AccessibilityNodeData& node,
+                 const AccessibilityNodeData::IntAttribute attr);
+  bool GetBoolAttr(const AccessibilityNodeData& node,
+                   const AccessibilityNodeData::BoolAttribute attr);
 };
 
 void RendererAccessibilityBrowserTest::SetUpInProcessBrowserTestFixture() {
@@ -86,25 +87,25 @@ void RendererAccessibilityBrowserTest::TearDownInProcessBrowserTestFixture() {
 #endif
 }
 
-// Convenience method to get the value of a particular WebAccessibility
+// Convenience method to get the value of a particular AccessibilityNodeData
 // node attribute as a UTF-8 const char*.
 std::string RendererAccessibilityBrowserTest::GetAttr(
-    const WebAccessibility& node,
-    const WebAccessibility::StringAttribute attr) {
-  std::map<WebAccessibility::StringAttribute, string16>::const_iterator iter =
-      node.string_attributes.find(attr);
+    const AccessibilityNodeData& node,
+    const AccessibilityNodeData::StringAttribute attr) {
+  std::map<AccessibilityNodeData::StringAttribute, string16>::const_iterator
+      iter = node.string_attributes.find(attr);
   if (iter != node.string_attributes.end())
     return UTF16ToUTF8(iter->second);
   else
     return "";
 }
 
-// Convenience method to get the value of a particular WebAccessibility
+// Convenience method to get the value of a particular AccessibilityNodeData
 // node integer attribute.
 int RendererAccessibilityBrowserTest::GetIntAttr(
-    const WebAccessibility& node,
-    const WebAccessibility::IntAttribute attr) {
-  std::map<WebAccessibility::IntAttribute, int32>::const_iterator iter =
+    const AccessibilityNodeData& node,
+    const AccessibilityNodeData::IntAttribute attr) {
+  std::map<AccessibilityNodeData::IntAttribute, int32>::const_iterator iter =
       node.int_attributes.find(attr);
   if (iter != node.int_attributes.end())
     return iter->second;
@@ -112,12 +113,12 @@ int RendererAccessibilityBrowserTest::GetIntAttr(
     return -1;
 }
 
-// Convenience method to get the value of a particular WebAccessibility
+// Convenience method to get the value of a particular AccessibilityNodeData
 // node boolean attribute.
 bool RendererAccessibilityBrowserTest::GetBoolAttr(
-    const WebAccessibility& node,
-    const WebAccessibility::BoolAttribute attr) {
-  std::map<WebAccessibility::BoolAttribute, bool>::const_iterator iter =
+    const AccessibilityNodeData& node,
+    const AccessibilityNodeData::BoolAttribute attr) {
+  std::map<AccessibilityNodeData::BoolAttribute, bool>::const_iterator iter =
       node.bool_attributes.find(attr);
   if (iter != node.bool_attributes.end())
     return iter->second;
@@ -138,50 +139,55 @@ IN_PROC_BROWSER_TEST_F(RendererAccessibilityBrowserTest,
   GURL url(url_str);
   browser()->OpenURL(OpenURLParams(
       url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED, false));
-  const WebAccessibility& tree = GetWebAccessibilityTree();
+  const AccessibilityNodeData& tree = GetAccessibilityNodeDataTree();
 
   // Check properties of the root element of the tree.
-  EXPECT_STREQ(url_str, GetAttr(tree, WebAccessibility::ATTR_DOC_URL).c_str());
+  EXPECT_STREQ(url_str,
+               GetAttr(tree, AccessibilityNodeData::ATTR_DOC_URL).c_str());
   EXPECT_STREQ(
       "Accessibility Test",
-      GetAttr(tree, WebAccessibility::ATTR_DOC_TITLE).c_str());
+      GetAttr(tree, AccessibilityNodeData::ATTR_DOC_TITLE).c_str());
   EXPECT_STREQ(
-      "html", GetAttr(tree, WebAccessibility::ATTR_DOC_DOCTYPE).c_str());
+      "html", GetAttr(tree, AccessibilityNodeData::ATTR_DOC_DOCTYPE).c_str());
   EXPECT_STREQ(
-      "text/html", GetAttr(tree, WebAccessibility::ATTR_DOC_MIMETYPE).c_str());
+      "text/html",
+      GetAttr(tree, AccessibilityNodeData::ATTR_DOC_MIMETYPE).c_str());
   EXPECT_STREQ("Accessibility Test", UTF16ToUTF8(tree.name).c_str());
-  EXPECT_EQ(WebAccessibility::ROLE_ROOT_WEB_AREA, tree.role);
+  EXPECT_EQ(AccessibilityNodeData::ROLE_ROOT_WEB_AREA, tree.role);
 
   // Check properites of the BODY element.
   ASSERT_EQ(1U, tree.children.size());
-  const WebAccessibility& body = tree.children[0];
-  EXPECT_EQ(WebAccessibility::ROLE_GROUP, body.role);
-  EXPECT_STREQ("body", GetAttr(body, WebAccessibility::ATTR_HTML_TAG).c_str());
-  EXPECT_STREQ("block", GetAttr(body, WebAccessibility::ATTR_DISPLAY).c_str());
+  const AccessibilityNodeData& body = tree.children[0];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_GROUP, body.role);
+  EXPECT_STREQ("body",
+               GetAttr(body, AccessibilityNodeData::ATTR_HTML_TAG).c_str());
+  EXPECT_STREQ("block",
+               GetAttr(body, AccessibilityNodeData::ATTR_DISPLAY).c_str());
 
   // Check properties of the two children of the BODY element.
   ASSERT_EQ(2U, body.children.size());
 
-  const WebAccessibility& button = body.children[0];
-  EXPECT_EQ(WebAccessibility::ROLE_BUTTON, button.role);
+  const AccessibilityNodeData& button = body.children[0];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_BUTTON, button.role);
   EXPECT_STREQ(
-      "input", GetAttr(button, WebAccessibility::ATTR_HTML_TAG).c_str());
+      "input", GetAttr(button, AccessibilityNodeData::ATTR_HTML_TAG).c_str());
   EXPECT_STREQ("push", UTF16ToUTF8(button.name).c_str());
   EXPECT_STREQ(
-      "inline-block", GetAttr(button, WebAccessibility::ATTR_DISPLAY).c_str());
+      "inline-block",
+      GetAttr(button, AccessibilityNodeData::ATTR_DISPLAY).c_str());
   ASSERT_EQ(2U, button.html_attributes.size());
   EXPECT_STREQ("type", UTF16ToUTF8(button.html_attributes[0].first).c_str());
   EXPECT_STREQ("button", UTF16ToUTF8(button.html_attributes[0].second).c_str());
   EXPECT_STREQ("value", UTF16ToUTF8(button.html_attributes[1].first).c_str());
   EXPECT_STREQ("push", UTF16ToUTF8(button.html_attributes[1].second).c_str());
 
-  const WebAccessibility& checkbox = body.children[1];
-  EXPECT_EQ(WebAccessibility::ROLE_CHECKBOX, checkbox.role);
+  const AccessibilityNodeData& checkbox = body.children[1];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_CHECKBOX, checkbox.role);
   EXPECT_STREQ(
-      "input", GetAttr(checkbox, WebAccessibility::ATTR_HTML_TAG).c_str());
+      "input", GetAttr(checkbox, AccessibilityNodeData::ATTR_HTML_TAG).c_str());
   EXPECT_STREQ(
       "inline-block",
-      GetAttr(checkbox, WebAccessibility::ATTR_DISPLAY).c_str());
+      GetAttr(checkbox, AccessibilityNodeData::ATTR_DISPLAY).c_str());
   ASSERT_EQ(1U, checkbox.html_attributes.size());
   EXPECT_STREQ(
       "type", UTF16ToUTF8(checkbox.html_attributes[0].first).c_str());
@@ -202,16 +208,16 @@ IN_PROC_BROWSER_TEST_F(RendererAccessibilityBrowserTest,
   browser()->OpenURL(OpenURLParams(
       url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED, false));
 
-  const WebAccessibility& tree = GetWebAccessibilityTree();
+  const AccessibilityNodeData& tree = GetAccessibilityNodeDataTree();
   ASSERT_EQ(1U, tree.children.size());
-  const WebAccessibility& body = tree.children[0];
+  const AccessibilityNodeData& body = tree.children[0];
   ASSERT_EQ(1U, body.children.size());
-  const WebAccessibility& text = body.children[0];
-  EXPECT_EQ(WebAccessibility::ROLE_TEXT_FIELD, text.role);
+  const AccessibilityNodeData& text = body.children[0];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_TEXT_FIELD, text.role);
   EXPECT_STREQ(
-      "input", GetAttr(text, WebAccessibility::ATTR_HTML_TAG).c_str());
-  EXPECT_EQ(0, GetIntAttr(text, WebAccessibility::ATTR_TEXT_SEL_START));
-  EXPECT_EQ(0, GetIntAttr(text, WebAccessibility::ATTR_TEXT_SEL_END));
+      "input", GetAttr(text, AccessibilityNodeData::ATTR_HTML_TAG).c_str());
+  EXPECT_EQ(0, GetIntAttr(text, AccessibilityNodeData::ATTR_TEXT_SEL_START));
+  EXPECT_EQ(0, GetIntAttr(text, AccessibilityNodeData::ATTR_TEXT_SEL_END));
   EXPECT_STREQ("Hello, world.", UTF16ToUTF8(text.value).c_str());
 
   // TODO(dmazzoni): as soon as more accessibility code is cross-platform,
@@ -232,16 +238,16 @@ IN_PROC_BROWSER_TEST_F(RendererAccessibilityBrowserTest,
   browser()->OpenURL(OpenURLParams(
       url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED, false));
 
-  const WebAccessibility& tree = GetWebAccessibilityTree();
+  const AccessibilityNodeData& tree = GetAccessibilityNodeDataTree();
   ASSERT_EQ(1U, tree.children.size());
-  const WebAccessibility& body = tree.children[0];
+  const AccessibilityNodeData& body = tree.children[0];
   ASSERT_EQ(1U, body.children.size());
-  const WebAccessibility& text = body.children[0];
-  EXPECT_EQ(WebAccessibility::ROLE_TEXT_FIELD, text.role);
+  const AccessibilityNodeData& text = body.children[0];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_TEXT_FIELD, text.role);
   EXPECT_STREQ(
-      "input", GetAttr(text, WebAccessibility::ATTR_HTML_TAG).c_str());
-  EXPECT_EQ(0, GetIntAttr(text, WebAccessibility::ATTR_TEXT_SEL_START));
-  EXPECT_EQ(13, GetIntAttr(text, WebAccessibility::ATTR_TEXT_SEL_END));
+      "input", GetAttr(text, AccessibilityNodeData::ATTR_HTML_TAG).c_str());
+  EXPECT_EQ(0, GetIntAttr(text, AccessibilityNodeData::ATTR_TEXT_SEL_START));
+  EXPECT_EQ(13, GetIntAttr(text, AccessibilityNodeData::ATTR_TEXT_SEL_END));
   EXPECT_STREQ("Hello, world.", UTF16ToUTF8(text.value).c_str());
 }
 
@@ -249,7 +255,7 @@ IN_PROC_BROWSER_TEST_F(RendererAccessibilityBrowserTest,
                        CrossPlatformMultipleInheritanceAccessibility) {
   // In a WebKit accessibility render tree for a table, each cell is a
   // child of both a row and a column, so it appears to use multiple
-  // inheritance. Make sure that the WebAccessibilityObject tree only
+  // inheritance. Make sure that the AccessibilityNodeDataObject tree only
   // keeps one copy of each cell, and uses an indirect child id for the
   // additional reference to it.
   const char url_str[] =
@@ -260,23 +266,23 @@ IN_PROC_BROWSER_TEST_F(RendererAccessibilityBrowserTest,
   browser()->OpenURL(OpenURLParams(
       url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED, false));
 
-  const WebAccessibility& tree = GetWebAccessibilityTree();
+  const AccessibilityNodeData& tree = GetAccessibilityNodeDataTree();
   ASSERT_EQ(1U, tree.children.size());
-  const WebAccessibility& table = tree.children[0];
-  EXPECT_EQ(WebAccessibility::ROLE_TABLE, table.role);
-  const WebAccessibility& row = table.children[0];
-  EXPECT_EQ(WebAccessibility::ROLE_ROW, row.role);
-  const WebAccessibility& cell1 = row.children[0];
-  EXPECT_EQ(WebAccessibility::ROLE_CELL, cell1.role);
-  const WebAccessibility& cell2 = row.children[1];
-  EXPECT_EQ(WebAccessibility::ROLE_CELL, cell2.role);
-  const WebAccessibility& column1 = table.children[1];
-  EXPECT_EQ(WebAccessibility::ROLE_COLUMN, column1.role);
+  const AccessibilityNodeData& table = tree.children[0];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_TABLE, table.role);
+  const AccessibilityNodeData& row = table.children[0];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_ROW, row.role);
+  const AccessibilityNodeData& cell1 = row.children[0];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_CELL, cell1.role);
+  const AccessibilityNodeData& cell2 = row.children[1];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_CELL, cell2.role);
+  const AccessibilityNodeData& column1 = table.children[1];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_COLUMN, column1.role);
   EXPECT_EQ(0U, column1.children.size());
   EXPECT_EQ(1U, column1.indirect_child_ids.size());
   EXPECT_EQ(cell1.id, column1.indirect_child_ids[0]);
-  const WebAccessibility& column2 = table.children[2];
-  EXPECT_EQ(WebAccessibility::ROLE_COLUMN, column2.role);
+  const AccessibilityNodeData& column2 = table.children[2];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_COLUMN, column2.role);
   EXPECT_EQ(0U, column2.children.size());
   EXPECT_EQ(1U, column2.indirect_child_ids.size());
   EXPECT_EQ(cell2.id, column2.indirect_child_ids[0]);
@@ -301,7 +307,7 @@ IN_PROC_BROWSER_TEST_F(
   browser()->OpenURL(OpenURLParams(
       url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED, false));
 
-  const WebAccessibility& tree = GetWebAccessibilityTree();
+  const AccessibilityNodeData& tree = GetAccessibilityNodeDataTree();
   base::hash_set<int> ids;
   RecursiveAssertUniqueIds(tree, &ids);
 }
@@ -322,37 +328,37 @@ IN_PROC_BROWSER_TEST_F(RendererAccessibilityBrowserTest,
   browser()->OpenURL(OpenURLParams(
       url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED, false));
 
-  const WebAccessibility& tree = GetWebAccessibilityTree();
+  const AccessibilityNodeData& tree = GetAccessibilityNodeDataTree();
   ASSERT_EQ(1U, tree.children.size());
-  const WebAccessibility& body = tree.children[0];
+  const AccessibilityNodeData& body = tree.children[0];
   ASSERT_EQ(3U, body.children.size());
 
-  const WebAccessibility& button1 = body.children[0];
-  EXPECT_EQ(WebAccessibility::ROLE_BUTTON, button1.role);
+  const AccessibilityNodeData& button1 = body.children[0];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_BUTTON, button1.role);
   EXPECT_STREQ("Button 1", UTF16ToUTF8(button1.name).c_str());
 
-  const WebAccessibility& iframe = body.children[1];
+  const AccessibilityNodeData& iframe = body.children[1];
   EXPECT_STREQ("iframe",
-               GetAttr(iframe, WebAccessibility::ATTR_HTML_TAG).c_str());
+               GetAttr(iframe, AccessibilityNodeData::ATTR_HTML_TAG).c_str());
   ASSERT_EQ(1U, iframe.children.size());
 
-  const WebAccessibility& scroll_area = iframe.children[0];
-  EXPECT_EQ(WebAccessibility::ROLE_SCROLLAREA, scroll_area.role);
+  const AccessibilityNodeData& scroll_area = iframe.children[0];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_SCROLLAREA, scroll_area.role);
   ASSERT_EQ(1U, scroll_area.children.size());
 
-  const WebAccessibility& sub_document = scroll_area.children[0];
-  EXPECT_EQ(WebAccessibility::ROLE_WEB_AREA, sub_document.role);
+  const AccessibilityNodeData& sub_document = scroll_area.children[0];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_WEB_AREA, sub_document.role);
   ASSERT_EQ(1U, sub_document.children.size());
 
-  const WebAccessibility& sub_body = sub_document.children[0];
+  const AccessibilityNodeData& sub_body = sub_document.children[0];
   ASSERT_EQ(1U, sub_body.children.size());
 
-  const WebAccessibility& button2 = sub_body.children[0];
-  EXPECT_EQ(WebAccessibility::ROLE_BUTTON, button2.role);
+  const AccessibilityNodeData& button2 = sub_body.children[0];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_BUTTON, button2.role);
   EXPECT_STREQ("Button 2", UTF16ToUTF8(button2.name).c_str());
 
-  const WebAccessibility& button3 = body.children[2];
-  EXPECT_EQ(WebAccessibility::ROLE_BUTTON, button3.role);
+  const AccessibilityNodeData& button3 = body.children[2];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_BUTTON, button3.role);
   EXPECT_STREQ("Button 3", UTF16ToUTF8(button3.name).c_str());
 }
 
@@ -369,7 +375,7 @@ IN_PROC_BROWSER_TEST_F(RendererAccessibilityBrowserTest,
   browser()->OpenURL(OpenURLParams(
       url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED, false));
 
-  const WebAccessibility& tree = GetWebAccessibilityTree();
+  const AccessibilityNodeData& tree = GetAccessibilityNodeDataTree();
   base::hash_set<int> ids;
   RecursiveAssertUniqueIds(tree, &ids);
 }
@@ -397,22 +403,23 @@ IN_PROC_BROWSER_TEST_F(RendererAccessibilityBrowserTest,
   browser()->OpenURL(OpenURLParams(
       url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED, false));
 
-  const WebAccessibility& tree = GetWebAccessibilityTree();
-  const WebAccessibility& table = tree.children[0];
-  EXPECT_EQ(WebAccessibility::ROLE_TABLE, table.role);
+  const AccessibilityNodeData& tree = GetAccessibilityNodeDataTree();
+  const AccessibilityNodeData& table = tree.children[0];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_TABLE, table.role);
   ASSERT_GE(table.children.size(), 5U);
-  EXPECT_EQ(WebAccessibility::ROLE_ROW, table.children[0].role);
-  EXPECT_EQ(WebAccessibility::ROLE_ROW, table.children[1].role);
-  EXPECT_EQ(WebAccessibility::ROLE_COLUMN, table.children[2].role);
-  EXPECT_EQ(WebAccessibility::ROLE_COLUMN, table.children[3].role);
-  EXPECT_EQ(WebAccessibility::ROLE_COLUMN, table.children[4].role);
-  EXPECT_EQ(3, GetIntAttr(table, WebAccessibility::ATTR_TABLE_COLUMN_COUNT));
-  EXPECT_EQ(2, GetIntAttr(table, WebAccessibility::ATTR_TABLE_ROW_COUNT));
-
-  const WebAccessibility& cell1 = table.children[0].children[0];
-  const WebAccessibility& cell2 = table.children[0].children[1];
-  const WebAccessibility& cell3 = table.children[1].children[0];
-  const WebAccessibility& cell4 = table.children[1].children[1];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_ROW, table.children[0].role);
+  EXPECT_EQ(AccessibilityNodeData::ROLE_ROW, table.children[1].role);
+  EXPECT_EQ(AccessibilityNodeData::ROLE_COLUMN, table.children[2].role);
+  EXPECT_EQ(AccessibilityNodeData::ROLE_COLUMN, table.children[3].role);
+  EXPECT_EQ(AccessibilityNodeData::ROLE_COLUMN, table.children[4].role);
+  EXPECT_EQ(3,
+            GetIntAttr(table, AccessibilityNodeData::ATTR_TABLE_COLUMN_COUNT));
+  EXPECT_EQ(2, GetIntAttr(table, AccessibilityNodeData::ATTR_TABLE_ROW_COUNT));
+
+  const AccessibilityNodeData& cell1 = table.children[0].children[0];
+  const AccessibilityNodeData& cell2 = table.children[0].children[1];
+  const AccessibilityNodeData& cell3 = table.children[1].children[0];
+  const AccessibilityNodeData& cell4 = table.children[1].children[1];
 
   ASSERT_EQ(6U, table.cell_ids.size());
   EXPECT_EQ(cell1.id, table.cell_ids[0]);
@@ -423,25 +430,25 @@ IN_PROC_BROWSER_TEST_F(RendererAccessibilityBrowserTest,
   EXPECT_EQ(cell4.id, table.cell_ids[5]);
 
   EXPECT_EQ(0, GetIntAttr(cell1,
-                          WebAccessibility::ATTR_TABLE_CELL_COLUMN_INDEX));
+                          AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_INDEX));
   EXPECT_EQ(0, GetIntAttr(cell1,
-                          WebAccessibility::ATTR_TABLE_CELL_ROW_INDEX));
+                          AccessibilityNodeData::ATTR_TABLE_CELL_ROW_INDEX));
   EXPECT_EQ(2, GetIntAttr(cell1,
-                          WebAccessibility::ATTR_TABLE_CELL_COLUMN_SPAN));
+                          AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_SPAN));
   EXPECT_EQ(1, GetIntAttr(cell1,
-                          WebAccessibility::ATTR_TABLE_CELL_ROW_SPAN));
+                          AccessibilityNodeData::ATTR_TABLE_CELL_ROW_SPAN));
   EXPECT_EQ(2, GetIntAttr(cell2,
-                          WebAccessibility::ATTR_TABLE_CELL_COLUMN_INDEX));
+                          AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_INDEX));
   EXPECT_EQ(1, GetIntAttr(cell2,
-                          WebAccessibility::ATTR_TABLE_CELL_COLUMN_SPAN));
+                          AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_SPAN));
   EXPECT_EQ(0, GetIntAttr(cell3,
-                          WebAccessibility::ATTR_TABLE_CELL_COLUMN_INDEX));
+                          AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_INDEX));
   EXPECT_EQ(1, GetIntAttr(cell3,
-                          WebAccessibility::ATTR_TABLE_CELL_COLUMN_SPAN));
+                          AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_SPAN));
   EXPECT_EQ(1, GetIntAttr(cell4,
-                          WebAccessibility::ATTR_TABLE_CELL_COLUMN_INDEX));
+                          AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_INDEX));
   EXPECT_EQ(2, GetIntAttr(cell4,
-                          WebAccessibility::ATTR_TABLE_CELL_COLUMN_SPAN));
+                          AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_SPAN));
 }
 
 IN_PROC_BROWSER_TEST_F(RendererAccessibilityBrowserTest,
@@ -455,13 +462,13 @@ IN_PROC_BROWSER_TEST_F(RendererAccessibilityBrowserTest,
   GURL url(url_str);
   browser()->OpenURL(OpenURLParams(
       url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED, false));
-  const WebAccessibility& tree = GetWebAccessibilityTree();
+  const AccessibilityNodeData& tree = GetAccessibilityNodeDataTree();
 
   ASSERT_EQ(1U, tree.children.size());
-  const WebAccessibility& textbox = tree.children[0];
+  const AccessibilityNodeData& textbox = tree.children[0];
 
   EXPECT_EQ(
-      true, GetBoolAttr(textbox, WebAccessibility::ATTR_CAN_SET_VALUE));
+      true, GetBoolAttr(textbox, AccessibilityNodeData::ATTR_CAN_SET_VALUE));
 }
 
 IN_PROC_BROWSER_TEST_F(RendererAccessibilityBrowserTest,
@@ -487,38 +494,38 @@ IN_PROC_BROWSER_TEST_F(RendererAccessibilityBrowserTest,
   GURL url(url_str);
   browser()->OpenURL(OpenURLParams(
       url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED, false));
-  const WebAccessibility& tree = GetWebAccessibilityTree(
+  const AccessibilityNodeData& tree = GetAccessibilityNodeDataTree(
       AccessibilityModeEditableTextOnly);
 
-  const WebAccessibility& text0 = tree.children[0];
-  EXPECT_EQ(WebAccessibility::ROLE_TEXT_FIELD, text0.role);
+  const AccessibilityNodeData& text0 = tree.children[0];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_TEXT_FIELD, text0.role);
   EXPECT_STREQ("text0", UTF16ToUTF8(text0.value).c_str());
 
-  const WebAccessibility& text1 = tree.children[1];
-  EXPECT_EQ(WebAccessibility::ROLE_TEXTAREA, text1.role);
+  const AccessibilityNodeData& text1 = tree.children[1];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_TEXTAREA, text1.role);
   EXPECT_STREQ("text1", UTF16ToUTF8(text1.value).c_str());
 
-  const WebAccessibility& text2 = tree.children[2];
-  EXPECT_EQ(WebAccessibility::ROLE_TEXT_FIELD, text2.role);
+  const AccessibilityNodeData& text2 = tree.children[2];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_TEXT_FIELD, text2.role);
   EXPECT_STREQ("text2", UTF16ToUTF8(text2.value).c_str());
 
-  const WebAccessibility& text3 = tree.children[3];
-  EXPECT_EQ(WebAccessibility::ROLE_GROUP, text3.role);
+  const AccessibilityNodeData& text3 = tree.children[3];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_GROUP, text3.role);
 
-  const WebAccessibility& text4 = tree.children[4];
-  EXPECT_EQ(WebAccessibility::ROLE_TEXT_FIELD, text4.role);
+  const AccessibilityNodeData& text4 = tree.children[4];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_TEXT_FIELD, text4.role);
   EXPECT_STREQ("text4", UTF16ToUTF8(text4.value).c_str());
 
-  const WebAccessibility& text5 = tree.children[5];
-  EXPECT_EQ(WebAccessibility::ROLE_TEXTAREA, text5.role);
+  const AccessibilityNodeData& text5 = tree.children[5];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_TEXTAREA, text5.role);
   EXPECT_STREQ("text5", UTF16ToUTF8(text5.value).c_str());
 
-  const WebAccessibility& text6 = tree.children[6];
-  EXPECT_EQ(WebAccessibility::ROLE_TEXT_FIELD, text6.role);
+  const AccessibilityNodeData& text6 = tree.children[6];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_TEXT_FIELD, text6.role);
   EXPECT_STREQ("text6", UTF16ToUTF8(text6.value).c_str());
 
-  const WebAccessibility& text7 = tree.children[7];
-  EXPECT_EQ(WebAccessibility::ROLE_GROUP, text7.role);
+  const AccessibilityNodeData& text7 = tree.children[7];
+  EXPECT_EQ(AccessibilityNodeData::ROLE_GROUP, text7.role);
 }
 
 }  // namespace