Fix accessibility in Windows x64 build.

content/browser/accessibility/accessibility_win_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 <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/scoped_bstr.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_variant.h"
 #include "content/browser/accessibility/accessibility_tree_formatter_utils_win.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/shell/browser/shell.h"
 #include "content/test/accessibility_browser_test_utils.h"
 #include "third_party/iaccessible2/ia2_api_all.h"
 #include "third_party/isimpledom/ISimpleDOMNode.h"
-
-// TODO(dmazzoni): Disabled accessibility tests on Win64. crbug.com/179717
-#if defined(ARCH_CPU_X86_64)
-#define MAYBE(x) DISABLED_##x
-#else
-#define MAYBE(x) x
-#endif
+#include "ui/aura/window.h"
+#include "ui/aura/window_tree_host.h"
 
 namespace content {
 
 namespace {
 
-
 // Helpers --------------------------------------------------------------------
 
 base::win::ScopedComPtr<IAccessible> GetAccessibleFromResultVariant(
     IAccessible* parent,
     VARIANT* var) {
   base::win::ScopedComPtr<IAccessible> ptr;
   switch (V_VT(var)) {
     case VT_DISPATCH: {
       IDispatch* dispatch = V_DISPATCH(var);
       if (dispatch)
@@ skipping 35 matching lines @@
   node->get_accName(childid_self, name_bstr.Receive());
   std::wstring name(name_bstr, name_bstr.Length());
   base::win::ScopedVariant role;
   node->get_accRole(childid_self, role.Receive());
   ASSERT_EQ(VT_I4, role.type());
 
   // Print the accessibility tree as we go, because if this test fails
   // on the bots, this is really helpful in figuring out why.
   for (int i = 0; i < depth; i++)
     printf("  ");
-  printf("role=%d name=%s\n", V_I4(&role), base::WideToUTF8(name).c_str());
+  printf("role=%s name=%s\n",
+      base::WideToUTF8(IAccessibleRoleToString(V_I4(&role))).c_str(),
+      base::WideToUTF8(name).c_str());
 
   if (expected_role == V_I4(&role) && expected_name == name) {
     *found = true;
     return;
   }
 
   LONG child_count = 0;
   HRESULT hr = node->get_accChildCount(&child_count);
   ASSERT_EQ(S_OK, hr);
 
@@ skipping 46 matching lines @@
       shell(), AccessibilityModeComplete,
       ui::AX_EVENT_LOAD_COMPLETE);
   GURL html_data_url("data:text/html," + html);
   NavigateToURL(shell(), html_data_url);
   waiter.WaitForNotification();
 }
 
 // Retrieve the MSAA client accessibility object for the Render Widget Host View
 // of the selected tab.
 IAccessible* AccessibilityWinBrowserTest::GetRendererAccessible() {
-  HWND hwnd_render_widget_host_view =
-      shell()->web_contents()->GetRenderWidgetHostView()->GetNativeView();
-
-  // Invoke windows screen reader detection by sending the WM_GETOBJECT message
-  // with kIdCustom as the LPARAM.
-  const int32 kIdCustom = 1;
-  SendMessage(
-      hwnd_render_widget_host_view, WM_GETOBJECT, OBJID_CLIENT, kIdCustom);
-
-  IAccessible* accessible;
-  HRESULT hr = AccessibleObjectFromWindow(
-      hwnd_render_widget_host_view, OBJID_CLIENT,
-      IID_IAccessible, reinterpret_cast<void**>(&accessible));
-
-  EXPECT_EQ(S_OK, hr);
-  EXPECT_NE(accessible, reinterpret_cast<IAccessible*>(NULL));
-
-  return accessible;
+  content::WebContents* web_contents = shell()->web_contents();
+  return web_contents->GetRenderWidgetHostView()->GetNativeViewAccessible();
 }
 
 void AccessibilityWinBrowserTest::ExecuteScript(const std::wstring& script) {
   shell()->web_contents()->GetMainFrame()->ExecuteJavaScript(script);
 }
 
 
 // AccessibleChecker ----------------------------------------------------------
 
 class AccessibleChecker {
@@ skipping 222 matching lines @@
     return base::string16(V_BSTR(&role), SysStringLen(V_BSTR(&role)));
   return base::string16();
 }
 
 }  // namespace
 
 
 // Tests ----------------------------------------------------------------------
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
-                       MAYBE(TestBusyAccessibilityTree)) {
+                       TestBusyAccessibilityTree) {
   NavigateToURL(shell(), GURL(url::kAboutBlankURL));
 
   // The initial accessible returned should have state STATE_SYSTEM_BUSY while
   // the accessibility tree is being requested from the renderer.
   AccessibleChecker document1_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
                                       std::wstring());
   document1_checker.SetExpectedState(
       STATE_SYSTEM_READONLY | STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_FOCUSED |
       STATE_SYSTEM_BUSY);
   document1_checker.CheckAccessible(GetRendererAccessible());
 }
 
-// Flaky, http://crbug.com/167320 .
-IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
-                       DISABLED_TestRendererAccessibilityTree) {
-  LoadInitialAccessibilityTreeFromHtml(
-      "<html><head><title>Accessibility Win Test</title></head>"
-      "<body><input type='button' value='push' /><input type='checkbox' />"
-      "</body></html>");
-
-  // Check the browser's copy of the renderer accessibility tree.
-  AccessibleChecker button_checker(L"push", ROLE_SYSTEM_PUSHBUTTON,
-                                   std::wstring());
-  AccessibleChecker checkbox_checker(std::wstring(), ROLE_SYSTEM_CHECKBUTTON,
-                                     std::wstring());
-  AccessibleChecker body_checker(std::wstring(), L"body", IA2_ROLE_SECTION,
-                                 std::wstring());
-  AccessibleChecker document2_checker(L"Accessibility Win Test",
-                                      ROLE_SYSTEM_DOCUMENT, std::wstring());
-  body_checker.AppendExpectedChild(&button_checker);
-  body_checker.AppendExpectedChild(&checkbox_checker);
-  document2_checker.AppendExpectedChild(&body_checker);
-  document2_checker.CheckAccessible(GetRendererAccessible());
-
-  // Check that document accessible has a parent accessible.
-  base::win::ScopedComPtr<IAccessible> document_accessible(
-      GetRendererAccessible());
-  ASSERT_NE(document_accessible.get(), reinterpret_cast<IAccessible*>(NULL));
-  base::win::ScopedComPtr<IDispatch> parent_dispatch;
-  HRESULT hr = document_accessible->get_accParent(parent_dispatch.Receive());
-  EXPECT_EQ(S_OK, hr);
-  EXPECT_NE(parent_dispatch, reinterpret_cast<IDispatch*>(NULL));
-
-  // Navigate to another page.
-  NavigateToURL(shell(), GURL(url::kAboutBlankURL));
-
-  // Verify that the IAccessible reference still points to a valid object and
-  // that calls to its methods fail since the tree is no longer valid after
-  // the page navagation.
-  base::win::ScopedBstr name;
-  base::win::ScopedVariant childid_self(CHILDID_SELF);
-  hr = document_accessible->get_accName(childid_self, name.Receive());
-  ASSERT_EQ(E_FAIL, hr);
-}
-
 // Periodically failing.  See crbug.com/145537
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
                        DISABLED_TestNotificationActiveDescendantChanged) {
   LoadInitialAccessibilityTreeFromHtml(
       "<ul tabindex='-1' role='radiogroup' aria-label='ul'>"
       "<li id='li'>li</li></ul>");
 
   // Check the browser's copy of the renderer accessibility tree.
   AccessibleChecker list_marker_checker(L"\x2022", ROLE_SYSTEM_TEXT,
                                         std::wstring());
@@ skipping 35 matching lines @@
   waiter->WaitForNotification();
 
   // Check that the accessibility tree of the browser has been updated.
   list_item_checker.SetExpectedState(
       STATE_SYSTEM_READONLY | STATE_SYSTEM_FOCUSED);
   radio_group_checker.SetExpectedState(STATE_SYSTEM_FOCUSABLE);
   document_checker.CheckAccessible(GetRendererAccessible());
 }
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
-                       MAYBE(TestNotificationCheckedStateChanged)) {
+                       TestNotificationCheckedStateChanged) {
   LoadInitialAccessibilityTreeFromHtml(
       "<body><input type='checkbox' /></body>");
 
   // Check the browser's copy of the renderer accessibility tree.
   AccessibleChecker checkbox_checker(std::wstring(), ROLE_SYSTEM_CHECKBUTTON,
                                      std::wstring());
   checkbox_checker.SetExpectedState(STATE_SYSTEM_FOCUSABLE);
   AccessibleChecker body_checker(std::wstring(), L"body", IA2_ROLE_SECTION,
                                  std::wstring());
   AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
@@ skipping 10 matching lines @@
   ExecuteScript(L"document.body.children[0].checked=true");
   waiter->WaitForNotification();
 
   // Check that the accessibility tree of the browser has been updated.
   checkbox_checker.SetExpectedState(
       STATE_SYSTEM_CHECKED | STATE_SYSTEM_FOCUSABLE);
   document_checker.CheckAccessible(GetRendererAccessible());
 }
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
-                       MAYBE(TestNotificationChildrenChanged)) {
+                       TestNotificationChildrenChanged) {
   // The role attribute causes the node to be in the accessibility tree.
   LoadInitialAccessibilityTreeFromHtml("<body role=group></body>");
 
   // Check the browser's copy of the renderer accessibility tree.
   AccessibleChecker group_checker(std::wstring(), ROLE_SYSTEM_GROUPING,
                                   std::wstring());
   AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
                                      std::wstring());
   document_checker.AppendExpectedChild(&group_checker);
   document_checker.CheckAccessible(GetRendererAccessible());
 
   // Change the children of the document body.
   scoped_ptr<AccessibilityNotificationWaiter> waiter(
       new AccessibilityNotificationWaiter(
           shell(),
           AccessibilityModeComplete,
           ui::AX_EVENT_CHILDREN_CHANGED));
   ExecuteScript(L"document.body.innerHTML='<b>new text</b>'");
   waiter->WaitForNotification();
 
   // Check that the accessibility tree of the browser has been updated.
-  AccessibleChecker text_checker(L"new text", ROLE_SYSTEM_TEXT, std::wstring());
+  AccessibleChecker text_checker(
+      L"new text", ROLE_SYSTEM_STATICTEXT, std::wstring());
   group_checker.AppendExpectedChild(&text_checker);
   document_checker.CheckAccessible(GetRendererAccessible());
 }
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
-                       MAYBE(TestNotificationChildrenChanged2)) {
+                       TestNotificationChildrenChanged2) {
   // The role attribute causes the node to be in the accessibility tree.
   LoadInitialAccessibilityTreeFromHtml(
       "<div role=group style='visibility: hidden'>text</div>");
 
   // Check the accessible tree of the browser.
   AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
                                      std::wstring());
   document_checker.CheckAccessible(GetRendererAccessible());
 
   // Change the children of the document body.
   scoped_ptr<AccessibilityNotificationWaiter> waiter(
       new AccessibilityNotificationWaiter(
           shell(), AccessibilityModeComplete,
           ui::AX_EVENT_CHILDREN_CHANGED));
   ExecuteScript(L"document.body.children[0].style.visibility='visible'");
   waiter->WaitForNotification();
 
   // Check that the accessibility tree of the browser has been updated.
-  AccessibleChecker static_text_checker(L"text", ROLE_SYSTEM_TEXT,
+  AccessibleChecker static_text_checker(L"text", ROLE_SYSTEM_STATICTEXT,
                                         std::wstring());
   AccessibleChecker group_checker(std::wstring(), ROLE_SYSTEM_GROUPING,
                                   std::wstring());
   document_checker.AppendExpectedChild(&group_checker);
   group_checker.AppendExpectedChild(&static_text_checker);
   document_checker.CheckAccessible(GetRendererAccessible());
 }
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
-                       MAYBE(TestNotificationFocusChanged)) {
+                       TestNotificationFocusChanged) {
   // The role attribute causes the node to be in the accessibility tree.
   LoadInitialAccessibilityTreeFromHtml("<div role=group tabindex='-1'></div>");
 
   // Check the browser's copy of the renderer accessibility tree.
   SCOPED_TRACE("Check initial tree");
   AccessibleChecker group_checker(std::wstring(), ROLE_SYSTEM_GROUPING,
                                   std::wstring());
   group_checker.SetExpectedState(STATE_SYSTEM_FOCUSABLE);
   AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
                                      std::wstring());
@@ skipping 27 matching lines @@
   ASSERT_EQ(S_OK, hr);
   waiter->WaitForNotification();
 
   // Check that the accessibility tree of the browser has been updated.
   SCOPED_TRACE("Check updated tree after focusing document again");
   group_checker.SetExpectedState(STATE_SYSTEM_FOCUSABLE);
   document_checker.CheckAccessible(GetRendererAccessible());
 }
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
-                       MAYBE(TestNotificationValueChanged)) {
+                       TestNotificationValueChanged) {
   LoadInitialAccessibilityTreeFromHtml(
       "<body><input type='text' value='old value'/></body>");
 
   // Check the browser's copy of the renderer accessibility tree.
   AccessibleChecker text_field_checker(std::wstring(), ROLE_SYSTEM_TEXT,
                                        L"old value");
   text_field_checker.SetExpectedState(STATE_SYSTEM_FOCUSABLE);
   AccessibleChecker body_checker(std::wstring(), L"body", IA2_ROLE_SECTION,
                                  std::wstring());
   AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
                                      std::wstring());
   body_checker.AppendExpectedChild(&text_field_checker);
   document_checker.AppendExpectedChild(&body_checker);
   document_checker.CheckAccessible(GetRendererAccessible());
 
   // Set the value of the text control
   scoped_ptr<AccessibilityNotificationWaiter> waiter(
       new AccessibilityNotificationWaiter(
           shell(), AccessibilityModeComplete,
-          ui::AX_EVENT_VALUE_CHANGE));
+          ui::AX_EVENT_VALUE_CHANGED));
   ExecuteScript(L"document.body.children[0].value='new value'");
   waiter->WaitForNotification();
 
   // Check that the accessibility tree of the browser has been updated.
   text_field_checker.SetExpectedValue(L"new value");
   document_checker.CheckAccessible(GetRendererAccessible());
 }
 
 // This test verifies that the web content's accessibility tree is a
 // descendant of the main browser window's accessibility tree, so that
 // tools like AccExplorer32 or AccProbe can be used to examine Chrome's
 // accessibility support.
 //
 // If you made a change and this test now fails, check that the NativeViewHost
 // that wraps the tab contents returns the IAccessible implementation
 // provided by RenderWidgetHostViewWin in GetNativeViewAccessible().
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
-                       MAYBE(ContainsRendererAccessibilityTree)) {
+                       ContainsRendererAccessibilityTree) {
   LoadInitialAccessibilityTreeFromHtml(
       "<html><head><title>MyDocument</title></head>"
       "<body>Content</body></html>");
 
-  // Get the accessibility object for the browser window.
-  HWND browser_hwnd = shell()->window();
+  // Get the accessibility object for the window tree host.
+  aura::Window* window = shell()->window();
+  CHECK(window);
+  aura::WindowTreeHost* window_tree_host = window->GetHost();
+  CHECK(window_tree_host);
+  HWND hwnd = window_tree_host->GetAcceleratedWidget();
+  CHECK(hwnd);
   base::win::ScopedComPtr<IAccessible> browser_accessible;
   HRESULT hr = AccessibleObjectFromWindow(
-      browser_hwnd,
+      hwnd,
       OBJID_WINDOW,
       IID_IAccessible,
       reinterpret_cast<void**>(browser_accessible.Receive()));
   ASSERT_EQ(S_OK, hr);
 
   bool found = false;
   RecursiveFindNodeInAccessibilityTree(
       browser_accessible.get(), ROLE_SYSTEM_DOCUMENT, L"MyDocument", 0, &found);
   ASSERT_EQ(found, true);
 }
 
-// Disabled because of http://crbug.com/144390.
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
-                       DISABLED_TestToggleButtonRoleAndStates) {
-  AccessibleChecker* button_checker;
-  std::string button_html("data:text/html,");
-  AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
-                                     std::wstring());
-  AccessibleChecker body_checker(std::wstring(), L"body", IA2_ROLE_SECTION,
-                                 std::wstring());
-  document_checker.AppendExpectedChild(&body_checker);
-
-// Temporary macro
-#define ADD_BUTTON(html, ia2_role, state) \
-    button_html += html; \
-    button_checker = new AccessibleChecker(L"x", ROLE_SYSTEM_PUSHBUTTON, \
-      ia2_role, std::wstring()); \
-    button_checker->SetExpectedState(state); \
-    body_checker.AppendExpectedChild(button_checker)
-
-  // If aria-pressed is 'undefined', empty or not present, use PUSHBUTTON
-  // Otherwise use TOGGLE_BUTTON, even if the value is invalid.
-  // The spec does this in an attempt future-proof in case new values are added.
-  ADD_BUTTON("<span role='button' aria-pressed='false'>x</span>",
-      IA2_ROLE_TOGGLE_BUTTON, 0);
-  ADD_BUTTON("<span role='button' aria-pressed='true'>x</span>",
-      IA2_ROLE_TOGGLE_BUTTON, STATE_SYSTEM_PRESSED);
-  ADD_BUTTON("<span role='button' aria-pressed='mixed'>x</span>",
-      IA2_ROLE_TOGGLE_BUTTON, STATE_SYSTEM_MIXED);
-  ADD_BUTTON("<span role='button' aria-pressed='xyz'>x</span>",
-    IA2_ROLE_TOGGLE_BUTTON, 0);
-  ADD_BUTTON("<span role='button' aria-pressed=''>x</span>",
-      ROLE_SYSTEM_PUSHBUTTON, 0);
-  ADD_BUTTON("<span role='button' aria-pressed>x</span>",
-      ROLE_SYSTEM_PUSHBUTTON, 0);
-  ADD_BUTTON("<span role='button' aria-pressed='undefined'>x</span>",
-      ROLE_SYSTEM_PUSHBUTTON, 0);
-  ADD_BUTTON("<span role='button'>x</span>", ROLE_SYSTEM_PUSHBUTTON, 0);
-  ADD_BUTTON("<input type='button' aria-pressed='true' value='x'/>",
-      IA2_ROLE_TOGGLE_BUTTON, STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_PRESSED);
-  ADD_BUTTON("<input type='button' aria-pressed='false' value='x'/>",
-      IA2_ROLE_TOGGLE_BUTTON, STATE_SYSTEM_FOCUSABLE);
-  ADD_BUTTON("<input type='button' aria-pressed='mixed' value='x'>",
-      IA2_ROLE_TOGGLE_BUTTON, STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_MIXED);
-  ADD_BUTTON("<input type='button' aria-pressed='xyz' value='x'/>",
-      IA2_ROLE_TOGGLE_BUTTON, STATE_SYSTEM_FOCUSABLE);
-  ADD_BUTTON("<input type='button' aria-pressed='' value='x'/>",
-      ROLE_SYSTEM_PUSHBUTTON, STATE_SYSTEM_FOCUSABLE);
-  ADD_BUTTON("<input type='button' aria-pressed value='x'>",
-      ROLE_SYSTEM_PUSHBUTTON, STATE_SYSTEM_FOCUSABLE);
-  ADD_BUTTON("<input type='button' aria-pressed='undefined' value='x'>",
-      ROLE_SYSTEM_PUSHBUTTON, STATE_SYSTEM_FOCUSABLE);
-  ADD_BUTTON("<input type='button' value='x'>",
-      ROLE_SYSTEM_PUSHBUTTON, STATE_SYSTEM_FOCUSABLE);
-  ADD_BUTTON("<button aria-pressed='true'>x</button>",
-      IA2_ROLE_TOGGLE_BUTTON, STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_PRESSED);
-  ADD_BUTTON("<button aria-pressed='false'>x</button>",
-      IA2_ROLE_TOGGLE_BUTTON, STATE_SYSTEM_FOCUSABLE);
-  ADD_BUTTON("<button aria-pressed='mixed'>x</button>", IA2_ROLE_TOGGLE_BUTTON,
-      STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_MIXED);
-  ADD_BUTTON("<button aria-pressed='xyz'>x</button>", IA2_ROLE_TOGGLE_BUTTON,
-      STATE_SYSTEM_FOCUSABLE);
-  ADD_BUTTON("<button aria-pressed=''>x</button>",
-      ROLE_SYSTEM_PUSHBUTTON, STATE_SYSTEM_FOCUSABLE);
-  ADD_BUTTON("<button aria-pressed>x</button>",
-      ROLE_SYSTEM_PUSHBUTTON, STATE_SYSTEM_FOCUSABLE);
-  ADD_BUTTON("<button aria-pressed='undefined'>x</button>",
-      ROLE_SYSTEM_PUSHBUTTON, STATE_SYSTEM_FOCUSABLE);
-  ADD_BUTTON("<button>x</button>", ROLE_SYSTEM_PUSHBUTTON,
-      STATE_SYSTEM_FOCUSABLE);
-#undef ADD_BUTTON    // Temporary macro
-
-  LoadInitialAccessibilityTreeFromHtml(button_html);
-  document_checker.CheckAccessible(GetRendererAccessible());
-}
-
-IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
-                       MAYBE(SupportsISimpleDOM)) {
+                       SupportsISimpleDOM) {
   LoadInitialAccessibilityTreeFromHtml(
       "<body><input type='checkbox' /></body>");
 
   // Get the IAccessible object for the document.
   base::win::ScopedComPtr<IAccessible> document_accessible(
       GetRendererAccessible());
   ASSERT_NE(document_accessible.get(), reinterpret_cast<IAccessible*>(NULL));
 
   // Get the ISimpleDOM object for the document.
   base::win::ScopedComPtr<IServiceProvider> service_provider;
@@ skipping 43 matching lines @@
   ASSERT_EQ(S_OK, hr);
   hr = checkbox_isimpledomnode->get_nodeInfo(
       node_name.Receive(), &name_space_id, node_value.Receive(), &num_children,
       &unique_id, &node_type);
   ASSERT_EQ(S_OK, hr);
   EXPECT_EQ(L"input", std::wstring(node_name, node_name.Length()));
   EXPECT_EQ(NODETYPE_ELEMENT, node_type);
   EXPECT_EQ(0, num_children);
 }
 
-IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest, MAYBE(TestRoleGroup)) {
+IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest, TestRoleGroup) {
   LoadInitialAccessibilityTreeFromHtml(
       "<fieldset></fieldset><div role=group></div>");
 
   // Check the browser's copy of the renderer accessibility tree.
   AccessibleChecker grouping1_checker(std::wstring(), ROLE_SYSTEM_GROUPING,
                                       std::wstring());
   AccessibleChecker grouping2_checker(std::wstring(), ROLE_SYSTEM_GROUPING,
                                       std::wstring());
   AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
                                      std::wstring());
   document_checker.AppendExpectedChild(&grouping1_checker);
   document_checker.AppendExpectedChild(&grouping2_checker);
   document_checker.CheckAccessible(GetRendererAccessible());
 }
 
 }  // namespace content