Rename WebKit namespace to blink (part 3)

content/browser/accessibility/cross_platform_accessibility_browsertest.cc

 // Copyright (c) 2012 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 <string>
 #include <vector>
 
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 22 matching lines @@
 
 class CrossPlatformAccessibilityBrowserTest : public ContentBrowserTest {
  public:
   CrossPlatformAccessibilityBrowserTest() {}
 
   // Tell the renderer to send an accessibility tree, then wait for the
   // notification that it's been received.
   const AccessibilityNodeDataTreeNode& GetAccessibilityNodeDataTree(
       AccessibilityMode accessibility_mode = AccessibilityModeComplete) {
     AccessibilityNotificationWaiter waiter(
-        shell(), accessibility_mode, WebKit::WebAXEventLayoutComplete);
+        shell(), accessibility_mode, blink::WebAXEventLayoutComplete);
     waiter.WaitForNotification();
     return waiter.GetAccessibilityNodeDataTree();
   }
 
   // Make sure each node in the tree has an unique id.
   void RecursiveAssertUniqueIds(
       const AccessibilityNodeDataTreeNode& 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++)
@@ skipping 91 matching lines @@
       "Accessibility Test",
       GetAttr(tree, AccessibilityNodeData::ATTR_DOC_TITLE).c_str());
   EXPECT_STREQ(
       "html", GetAttr(tree, AccessibilityNodeData::ATTR_DOC_DOCTYPE).c_str());
   EXPECT_STREQ(
       "text/html",
       GetAttr(tree, AccessibilityNodeData::ATTR_DOC_MIMETYPE).c_str());
   EXPECT_STREQ(
       "Accessibility Test",
       GetAttr(tree, AccessibilityNodeData::ATTR_NAME).c_str());
-  EXPECT_EQ(WebKit::WebAXRoleRootWebArea, tree.role);
+  EXPECT_EQ(blink::WebAXRoleRootWebArea, tree.role);
 
   // Check properites of the BODY element.
   ASSERT_EQ(1U, tree.children.size());
   const AccessibilityNodeDataTreeNode& body = tree.children[0];
-  EXPECT_EQ(WebKit::WebAXRoleGroup, body.role);
+  EXPECT_EQ(blink::WebAXRoleGroup, 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 AccessibilityNodeDataTreeNode& button = body.children[0];
-  EXPECT_EQ(WebKit::WebAXRoleButton, button.role);
+  EXPECT_EQ(blink::WebAXRoleButton, button.role);
   EXPECT_STREQ(
       "input", GetAttr(button, AccessibilityNodeData::ATTR_HTML_TAG).c_str());
   EXPECT_STREQ(
       "push",
       GetAttr(button, AccessibilityNodeData::ATTR_NAME).c_str());
   EXPECT_STREQ(
       "inline-block",
       GetAttr(button, AccessibilityNodeData::ATTR_DISPLAY).c_str());
   ASSERT_EQ(2U, button.html_attributes.size());
   EXPECT_STREQ("type", button.html_attributes[0].first.c_str());
   EXPECT_STREQ("button", button.html_attributes[0].second.c_str());
   EXPECT_STREQ("value", button.html_attributes[1].first.c_str());
   EXPECT_STREQ("push", button.html_attributes[1].second.c_str());
 
   const AccessibilityNodeDataTreeNode& checkbox = body.children[1];
-  EXPECT_EQ(WebKit::WebAXRoleCheckBox, checkbox.role);
+  EXPECT_EQ(blink::WebAXRoleCheckBox, checkbox.role);
   EXPECT_STREQ(
       "input", GetAttr(checkbox, AccessibilityNodeData::ATTR_HTML_TAG).c_str());
   EXPECT_STREQ(
       "inline-block",
       GetAttr(checkbox, AccessibilityNodeData::ATTR_DISPLAY).c_str());
   ASSERT_EQ(1U, checkbox.html_attributes.size());
   EXPECT_STREQ("type", checkbox.html_attributes[0].first.c_str());
   EXPECT_STREQ("checkbox", checkbox.html_attributes[0].second.c_str());
 }
 
 IN_PROC_BROWSER_TEST_F(CrossPlatformAccessibilityBrowserTest,
                        UnselectedEditableTextAccessibility) {
   // Create a data url and load it.
   const char url_str[] =
       "data:text/html,"
       "<!doctype html>"
       "<body>"
       "<input value=\"Hello, world.\"/>"
       "</body></html>";
   GURL url(url_str);
   NavigateToURL(shell(), url);
 
   const AccessibilityNodeDataTreeNode& tree = GetAccessibilityNodeDataTree();
   ASSERT_EQ(1U, tree.children.size());
   const AccessibilityNodeDataTreeNode& body = tree.children[0];
   ASSERT_EQ(1U, body.children.size());
   const AccessibilityNodeDataTreeNode& text = body.children[0];
-  EXPECT_EQ(WebKit::WebAXRoleTextField, text.role);
+  EXPECT_EQ(blink::WebAXRoleTextField, text.role);
   EXPECT_STREQ(
       "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.",
       GetAttr(text, AccessibilityNodeData::ATTR_VALUE).c_str());
 
   // TODO(dmazzoni): as soon as more accessibility code is cross-platform,
   // this code should test that the accessible info is dynamically updated
@@ skipping 10 matching lines @@
       "<input value=\"Hello, world.\"/>"
       "</body></html>";
   GURL url(url_str);
   NavigateToURL(shell(), url);
 
   const AccessibilityNodeDataTreeNode& tree = GetAccessibilityNodeDataTree();
   ASSERT_EQ(1U, tree.children.size());
   const AccessibilityNodeDataTreeNode& body = tree.children[0];
   ASSERT_EQ(1U, body.children.size());
   const AccessibilityNodeDataTreeNode& text = body.children[0];
-  EXPECT_EQ(WebKit::WebAXRoleTextField, text.role);
+  EXPECT_EQ(blink::WebAXRoleTextField, text.role);
   EXPECT_STREQ(
       "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.",
       GetAttr(text, AccessibilityNodeData::ATTR_VALUE).c_str());
 }
 
 IN_PROC_BROWSER_TEST_F(CrossPlatformAccessibilityBrowserTest,
                        MultipleInheritanceAccessibility) {
   // 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 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[] =
       "data:text/html,"
       "<!doctype html>"
       "<table border=1><tr><td>1</td><td>2</td></tr></table>";
   GURL url(url_str);
   NavigateToURL(shell(), url);
 
   const AccessibilityNodeDataTreeNode& tree = GetAccessibilityNodeDataTree();
   ASSERT_EQ(1U, tree.children.size());
   const AccessibilityNodeDataTreeNode& table = tree.children[0];
-  EXPECT_EQ(WebKit::WebAXRoleTable, table.role);
+  EXPECT_EQ(blink::WebAXRoleTable, table.role);
   const AccessibilityNodeDataTreeNode& row = table.children[0];
-  EXPECT_EQ(WebKit::WebAXRoleRow, row.role);
+  EXPECT_EQ(blink::WebAXRoleRow, row.role);
   const AccessibilityNodeDataTreeNode& cell1 = row.children[0];
-  EXPECT_EQ(WebKit::WebAXRoleCell, cell1.role);
+  EXPECT_EQ(blink::WebAXRoleCell, cell1.role);
   const AccessibilityNodeDataTreeNode& cell2 = row.children[1];
-  EXPECT_EQ(WebKit::WebAXRoleCell, cell2.role);
+  EXPECT_EQ(blink::WebAXRoleCell, cell2.role);
   const AccessibilityNodeDataTreeNode& column1 = table.children[1];
-  EXPECT_EQ(WebKit::WebAXRoleColumn, column1.role);
+  EXPECT_EQ(blink::WebAXRoleColumn, column1.role);
   EXPECT_EQ(0U, column1.children.size());
   EXPECT_EQ(1U, column1.intlist_attributes.size());
   EXPECT_EQ(AccessibilityNodeData::ATTR_INDIRECT_CHILD_IDS,
             column1.intlist_attributes[0].first);
   const std::vector<int32> column1_indirect_child_ids =
       column1.intlist_attributes[0].second;
   EXPECT_EQ(1U, column1_indirect_child_ids.size());
   EXPECT_EQ(cell1.id, column1_indirect_child_ids[0]);
   const AccessibilityNodeDataTreeNode& column2 = table.children[2];
-  EXPECT_EQ(WebKit::WebAXRoleColumn, column2.role);
+  EXPECT_EQ(blink::WebAXRoleColumn, column2.role);
   EXPECT_EQ(0U, column2.children.size());
   EXPECT_EQ(AccessibilityNodeData::ATTR_INDIRECT_CHILD_IDS,
             column2.intlist_attributes[0].first);
   const std::vector<int32> column2_indirect_child_ids =
       column2.intlist_attributes[0].second;
   EXPECT_EQ(1U, column2_indirect_child_ids.size());
   EXPECT_EQ(cell2.id, column2_indirect_child_ids[0]);
 }
 
 IN_PROC_BROWSER_TEST_F(CrossPlatformAccessibilityBrowserTest,
@@ skipping 32 matching lines @@
       "</body></html>";
   GURL url(url_str);
   NavigateToURL(shell(), url);
 
   const AccessibilityNodeDataTreeNode& tree = GetAccessibilityNodeDataTree();
   ASSERT_EQ(1U, tree.children.size());
   const AccessibilityNodeDataTreeNode& body = tree.children[0];
   ASSERT_EQ(3U, body.children.size());
 
   const AccessibilityNodeDataTreeNode& button1 = body.children[0];
-  EXPECT_EQ(WebKit::WebAXRoleButton, button1.role);
+  EXPECT_EQ(blink::WebAXRoleButton, button1.role);
   EXPECT_STREQ(
       "Button 1",
       GetAttr(button1, AccessibilityNodeData::ATTR_NAME).c_str());
 
   const AccessibilityNodeDataTreeNode& iframe = body.children[1];
   EXPECT_STREQ("iframe",
                GetAttr(iframe, AccessibilityNodeData::ATTR_HTML_TAG).c_str());
   ASSERT_EQ(1U, iframe.children.size());
 
   const AccessibilityNodeDataTreeNode& scroll_area = iframe.children[0];
-  EXPECT_EQ(WebKit::WebAXRoleScrollArea, scroll_area.role);
+  EXPECT_EQ(blink::WebAXRoleScrollArea, scroll_area.role);
   ASSERT_EQ(1U, scroll_area.children.size());
 
   const AccessibilityNodeDataTreeNode& sub_document = scroll_area.children[0];
-  EXPECT_EQ(WebKit::WebAXRoleWebArea, sub_document.role);
+  EXPECT_EQ(blink::WebAXRoleWebArea, sub_document.role);
   ASSERT_EQ(1U, sub_document.children.size());
 
   const AccessibilityNodeDataTreeNode& sub_body = sub_document.children[0];
   ASSERT_EQ(1U, sub_body.children.size());
 
   const AccessibilityNodeDataTreeNode& button2 = sub_body.children[0];
-  EXPECT_EQ(WebKit::WebAXRoleButton, button2.role);
+  EXPECT_EQ(blink::WebAXRoleButton, button2.role);
   EXPECT_STREQ("Button 2",
                GetAttr(button2, AccessibilityNodeData::ATTR_NAME).c_str());
 
   const AccessibilityNodeDataTreeNode& button3 = body.children[2];
-  EXPECT_EQ(WebKit::WebAXRoleButton, button3.role);
+  EXPECT_EQ(blink::WebAXRoleButton, button3.role);
   EXPECT_STREQ("Button 3",
                GetAttr(button3, AccessibilityNodeData::ATTR_NAME).c_str());
 }
 
 IN_PROC_BROWSER_TEST_F(CrossPlatformAccessibilityBrowserTest,
                        DuplicateChildrenAccessibility) {
   // Here's another html snippet where WebKit has a parent node containing
   // two duplicate child nodes. Instead of checking the exact output, just
   // make sure that no id is reused in the resulting tree.
   const char url_str[] =
@@ skipping 25 matching lines @@
       " </tr>"
       " <tr>"
       "  <td>3</td><td colspan=2>4</td>"
       " </tr>"
       "</table>";
   GURL url(url_str);
   NavigateToURL(shell(), url);
 
   const AccessibilityNodeDataTreeNode& tree = GetAccessibilityNodeDataTree();
   const AccessibilityNodeDataTreeNode& table = tree.children[0];
-  EXPECT_EQ(WebKit::WebAXRoleTable, table.role);
+  EXPECT_EQ(blink::WebAXRoleTable, table.role);
   ASSERT_GE(table.children.size(), 5U);
-  EXPECT_EQ(WebKit::WebAXRoleRow, table.children[0].role);
-  EXPECT_EQ(WebKit::WebAXRoleRow, table.children[1].role);
-  EXPECT_EQ(WebKit::WebAXRoleColumn, table.children[2].role);
-  EXPECT_EQ(WebKit::WebAXRoleColumn, table.children[3].role);
-  EXPECT_EQ(WebKit::WebAXRoleColumn, table.children[4].role);
+  EXPECT_EQ(blink::WebAXRoleRow, table.children[0].role);
+  EXPECT_EQ(blink::WebAXRoleRow, table.children[1].role);
+  EXPECT_EQ(blink::WebAXRoleColumn, table.children[2].role);
+  EXPECT_EQ(blink::WebAXRoleColumn, table.children[3].role);
+  EXPECT_EQ(blink::WebAXRoleColumn, 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 AccessibilityNodeDataTreeNode& cell1 = table.children[0].children[0];
   const AccessibilityNodeDataTreeNode& cell2 = table.children[0].children[1];
   const AccessibilityNodeDataTreeNode& cell3 = table.children[1].children[0];
   const AccessibilityNodeDataTreeNode& cell4 = table.children[1].children[1];
 
   ASSERT_EQ(AccessibilityNodeData::ATTR_CELL_IDS,
@@ skipping 43 matching lines @@
   const AccessibilityNodeDataTreeNode& tree = GetAccessibilityNodeDataTree();
 
   ASSERT_EQ(1U, tree.children.size());
   const AccessibilityNodeDataTreeNode& textbox = tree.children[0];
 
   EXPECT_EQ(
       true, GetBoolAttr(textbox, AccessibilityNodeData::ATTR_CAN_SET_VALUE));
 }
 
 }  // namespace content