content/browser/accessibility/accessibility_win_browsertest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <vector>
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "base/win/scoped_bstr.h"
  10 #include "base/win/scoped_comptr.h"
  11 #include "base/win/scoped_variant.h"
  12 #include "content/browser/accessibility/accessibility_mode_helper.h"
  13 #include "content/browser/accessibility/accessibility_tree_formatter_utils_win.h"
  14 #include "content/browser/renderer_host/render_view_host_impl.h"
  15 #include "content/public/browser/notification_service.h"
  16 #include "content/public/browser/notification_types.h"
  17 #include "content/public/browser/render_frame_host.h"
  18 #include "content/public/browser/render_widget_host_view.h"
  19 #include "content/public/browser/web_contents.h"
  20 #include "content/public/common/url_constants.h"
  21 #include "content/public/test/content_browser_test.h"
  22 #include "content/public/test/content_browser_test_utils.h"
  23 #include "content/shell/browser/shell.h"
  24 #include "content/test/accessibility_browser_test_utils.h"
  25 #include "third_party/iaccessible2/ia2_api_all.h"
  26 #include "third_party/isimpledom/ISimpleDOMNode.h"
  27 #include "ui/aura/window.h"
  28 #include "ui/aura/window_tree_host.h"
  29
  30 namespace content {
  31
  32 namespace {
  33
  34 // Helpers --------------------------------------------------------------------
  35
  36 base::win::ScopedComPtr<IAccessible> GetAccessibleFromResultVariant(
  37     IAccessible* parent,
  38     VARIANT* var) {
  39   base::win::ScopedComPtr<IAccessible> ptr;
  40   switch (V_VT(var)) {
  41     case VT_DISPATCH: {
  42       IDispatch* dispatch = V_DISPATCH(var);
  43       if (dispatch)
  44         ptr.QueryFrom(dispatch);
  45       break;
  46     }
  47
  48     case VT_I4: {
  49       base::win::ScopedComPtr<IDispatch> dispatch;
  50       HRESULT hr = parent->get_accChild(*var, dispatch.Receive());
  51       EXPECT_TRUE(SUCCEEDED(hr));
  52       if (dispatch.get())
  53         dispatch.QueryInterface(ptr.Receive());
  54       break;
  55     }
  56   }
  57   return ptr;
  58 }
  59
  60 HRESULT QueryIAccessible2(IAccessible* accessible, IAccessible2** accessible2) {
  61   // TODO(ctguil): For some reason querying the IAccessible2 interface from
  62   // IAccessible fails.
  63   base::win::ScopedComPtr<IServiceProvider> service_provider;
  64   HRESULT hr = accessible->QueryInterface(service_provider.Receive());
  65   return SUCCEEDED(hr) ?
  66       service_provider->QueryService(IID_IAccessible2, accessible2) : hr;
  67 }
  68
  69 // Recursively search through all of the descendants reachable from an
  70 // IAccessible node and return true if we find one with the given role
  71 // and name.
  72 void RecursiveFindNodeInAccessibilityTree(IAccessible* node,
  73                                           int32 expected_role,
  74                                           const std::wstring& expected_name,
  75                                           int32 depth,
  76                                           bool* found) {
  77   base::win::ScopedBstr name_bstr;
  78   base::win::ScopedVariant childid_self(CHILDID_SELF);
  79   node->get_accName(childid_self, name_bstr.Receive());
  80   std::wstring name(name_bstr, name_bstr.Length());
  81   base::win::ScopedVariant role;
  82   node->get_accRole(childid_self, role.Receive());
  83   ASSERT_EQ(VT_I4, role.type());
  84
  85   // Print the accessibility tree as we go, because if this test fails
  86   // on the bots, this is really helpful in figuring out why.
  87   for (int i = 0; i < depth; i++)
  88     printf("  ");
  89   printf("role=%s name=%s\n",
  90       base::WideToUTF8(IAccessibleRoleToString(V_I4(&role))).c_str(),
  91       base::WideToUTF8(name).c_str());
  92
  93   if (expected_role == V_I4(&role) && expected_name == name) {
  94     *found = true;
  95     return;
  96   }
  97
  98   LONG child_count = 0;
  99   HRESULT hr = node->get_accChildCount(&child_count);
 100   ASSERT_EQ(S_OK, hr);
 101
 102   scoped_ptr<VARIANT[]> child_array(new VARIANT[child_count]);
 103   LONG obtained_count = 0;
 104   hr = AccessibleChildren(
 105       node, 0, child_count, child_array.get(), &obtained_count);
 106   ASSERT_EQ(S_OK, hr);
 107   ASSERT_EQ(child_count, obtained_count);
 108
 109   for (int index = 0; index < obtained_count; index++) {
 110     base::win::ScopedComPtr<IAccessible> child_accessible(
 111         GetAccessibleFromResultVariant(node, &child_array.get()[index]));
 112     if (child_accessible.get()) {
 113       RecursiveFindNodeInAccessibilityTree(
 114           child_accessible.get(), expected_role, expected_name, depth + 1,
 115           found);
 116       if (*found)
 117         return;
 118     }
 119   }
 120 }
 121
 122
 123 // AccessibilityWinBrowserTest ------------------------------------------------
 124
 125 class AccessibilityWinBrowserTest : public ContentBrowserTest {
 126  public:
 127   AccessibilityWinBrowserTest();
 128   virtual ~AccessibilityWinBrowserTest();
 129
 130  protected:
 131   void LoadInitialAccessibilityTreeFromHtml(const std::string& html);
 132   IAccessible* GetRendererAccessible();
 133   void ExecuteScript(const std::wstring& script);
 134
 135  private:
 136   DISALLOW_COPY_AND_ASSIGN(AccessibilityWinBrowserTest);
 137 };
 138
 139 AccessibilityWinBrowserTest::AccessibilityWinBrowserTest() {
 140 }
 141
 142 AccessibilityWinBrowserTest::~AccessibilityWinBrowserTest() {
 143 }
 144
 145 void AccessibilityWinBrowserTest::LoadInitialAccessibilityTreeFromHtml(
 146     const std::string& html) {
 147   AccessibilityNotificationWaiter waiter(
 148       shell(), AccessibilityModeComplete,
 149       ui::AX_EVENT_LOAD_COMPLETE);
 150   GURL html_data_url("data:text/html," + html);
 151   NavigateToURL(shell(), html_data_url);
 152   waiter.WaitForNotification();
 153 }
 154
 155 // Retrieve the MSAA client accessibility object for the Render Widget Host View
 156 // of the selected tab.
 157 IAccessible* AccessibilityWinBrowserTest::GetRendererAccessible() {
 158   content::WebContents* web_contents = shell()->web_contents();
 159   return web_contents->GetRenderWidgetHostView()->GetNativeViewAccessible();
 160 }
 161
 162 void AccessibilityWinBrowserTest::ExecuteScript(const std::wstring& script) {
 163   shell()->web_contents()->GetMainFrame()->ExecuteJavaScript(script);
 164 }
 165
 166
 167 // AccessibleChecker ----------------------------------------------------------
 168
 169 class AccessibleChecker {
 170  public:
 171   // This constructor can be used if the IA2 role will be the same as the MSAA
 172   // role.
 173   AccessibleChecker(const std::wstring& expected_name,
 174                     int32 expected_role,
 175                     const std::wstring& expected_value);
 176   AccessibleChecker(const std::wstring& expected_name,
 177                     int32 expected_role,
 178                     int32 expected_ia2_role,
 179                     const std::wstring& expected_value);
 180   AccessibleChecker(const std::wstring& expected_name,
 181                     const std::wstring& expected_role,
 182                     int32 expected_ia2_role,
 183                     const std::wstring& expected_value);
 184
 185   // Append an AccessibleChecker that verifies accessibility information for
 186   // a child IAccessible. Order is important.
 187   void AppendExpectedChild(AccessibleChecker* expected_child);
 188
 189   // Check that the name and role of the given IAccessible instance and its
 190   // descendants match the expected names and roles that this object was
 191   // initialized with.
 192   void CheckAccessible(IAccessible* accessible);
 193
 194   // Set the expected value for this AccessibleChecker.
 195   void SetExpectedValue(const std::wstring& expected_value);
 196
 197   // Set the expected state for this AccessibleChecker.
 198   void SetExpectedState(LONG expected_state);
 199
 200  private:
 201   typedef std::vector<AccessibleChecker*> AccessibleCheckerVector;
 202
 203   void CheckAccessibleName(IAccessible* accessible);
 204   void CheckAccessibleRole(IAccessible* accessible);
 205   void CheckIA2Role(IAccessible* accessible);
 206   void CheckAccessibleValue(IAccessible* accessible);
 207   void CheckAccessibleState(IAccessible* accessible);
 208   void CheckAccessibleChildren(IAccessible* accessible);
 209   base::string16 RoleVariantToString(const base::win::ScopedVariant& role);
 210
 211   // Expected accessible name. Checked against IAccessible::get_accName.
 212   std::wstring name_;
 213
 214   // Expected accessible role. Checked against IAccessible::get_accRole.
 215   base::win::ScopedVariant role_;
 216
 217   // Expected IAccessible2 role. Checked against IAccessible2::role.
 218   int32 ia2_role_;
 219
 220   // Expected accessible value. Checked against IAccessible::get_accValue.
 221   std::wstring value_;
 222
 223   // Expected accessible state. Checked against IAccessible::get_accState.
 224   LONG state_;
 225
 226   // Expected accessible children. Checked using IAccessible::get_accChildCount
 227   // and ::AccessibleChildren.
 228   AccessibleCheckerVector children_;
 229 };
 230
 231 AccessibleChecker::AccessibleChecker(const std::wstring& expected_name,
 232                                      int32 expected_role,
 233                                      const std::wstring& expected_value)
 234     : name_(expected_name),
 235       role_(expected_role),
 236       ia2_role_(expected_role),
 237       value_(expected_value),
 238       state_(-1) {
 239 }
 240
 241 AccessibleChecker::AccessibleChecker(const std::wstring& expected_name,
 242                                      int32 expected_role,
 243                                      int32 expected_ia2_role,
 244                                      const std::wstring& expected_value)
 245     : name_(expected_name),
 246       role_(expected_role),
 247       ia2_role_(expected_ia2_role),
 248       value_(expected_value),
 249       state_(-1) {
 250 }
 251
 252 AccessibleChecker::AccessibleChecker(const std::wstring& expected_name,
 253                                      const std::wstring& expected_role,
 254                                      int32 expected_ia2_role,
 255                                      const std::wstring& expected_value)
 256     : name_(expected_name),
 257       role_(expected_role.c_str()),
 258       ia2_role_(expected_ia2_role),
 259       value_(expected_value),
 260       state_(-1) {
 261 }
 262
 263 void AccessibleChecker::AppendExpectedChild(
 264     AccessibleChecker* expected_child) {
 265   children_.push_back(expected_child);
 266 }
 267
 268 void AccessibleChecker::CheckAccessible(IAccessible* accessible) {
 269   SCOPED_TRACE("while checking " +
 270                    base::UTF16ToUTF8(RoleVariantToString(role_)));
 271   CheckAccessibleName(accessible);
 272   CheckAccessibleRole(accessible);
 273   CheckIA2Role(accessible);
 274   CheckAccessibleValue(accessible);
 275   CheckAccessibleState(accessible);
 276   CheckAccessibleChildren(accessible);
 277 }
 278
 279 void AccessibleChecker::SetExpectedValue(const std::wstring& expected_value) {
 280   value_ = expected_value;
 281 }
 282
 283 void AccessibleChecker::SetExpectedState(LONG expected_state) {
 284   state_ = expected_state;
 285 }
 286
 287 void AccessibleChecker::CheckAccessibleName(IAccessible* accessible) {
 288   base::win::ScopedBstr name;
 289   base::win::ScopedVariant childid_self(CHILDID_SELF);
 290   HRESULT hr = accessible->get_accName(childid_self, name.Receive());
 291
 292   if (name_.empty()) {
 293     // If the object doesn't have name S_FALSE should be returned.
 294     EXPECT_EQ(S_FALSE, hr);
 295   } else {
 296     // Test that the correct string was returned.
 297     EXPECT_EQ(S_OK, hr);
 298     EXPECT_EQ(name_, std::wstring(name, name.Length()));
 299   }
 300 }
 301
 302 void AccessibleChecker::CheckAccessibleRole(IAccessible* accessible) {
 303   base::win::ScopedVariant role;
 304   base::win::ScopedVariant childid_self(CHILDID_SELF);
 305   HRESULT hr = accessible->get_accRole(childid_self, role.Receive());
 306   ASSERT_EQ(S_OK, hr);
 307   EXPECT_EQ(0, role_.Compare(role))
 308       << "Expected role: " << RoleVariantToString(role_)
 309       << "\nGot role: " << RoleVariantToString(role);
 310 }
 311
 312 void AccessibleChecker::CheckIA2Role(IAccessible* accessible) {
 313   base::win::ScopedComPtr<IAccessible2> accessible2;
 314   HRESULT hr = QueryIAccessible2(accessible, accessible2.Receive());
 315   ASSERT_EQ(S_OK, hr);
 316   long ia2_role = 0;
 317   hr = accessible2->role(&ia2_role);
 318   ASSERT_EQ(S_OK, hr);
 319   EXPECT_EQ(ia2_role_, ia2_role)
 320     << "Expected ia2 role: " << IAccessible2RoleToString(ia2_role_)
 321     << "\nGot ia2 role: " << IAccessible2RoleToString(ia2_role);
 322 }
 323
 324 void AccessibleChecker::CheckAccessibleValue(IAccessible* accessible) {
 325   // Don't check the value if if's a DOCUMENT role, because the value
 326   // is supposed to be the url (and we don't keep track of that in the
 327   // test expectations).
 328   base::win::ScopedVariant role;
 329   base::win::ScopedVariant childid_self(CHILDID_SELF);
 330   HRESULT hr = accessible->get_accRole(childid_self, role.Receive());
 331   ASSERT_EQ(S_OK, hr);
 332   if (role.type() == VT_I4 && V_I4(&role) == ROLE_SYSTEM_DOCUMENT)
 333     return;
 334
 335   // Get the value.
 336   base::win::ScopedBstr value;
 337   hr = accessible->get_accValue(childid_self, value.Receive());
 338   EXPECT_EQ(S_OK, hr);
 339
 340   // Test that the correct string was returned.
 341   EXPECT_EQ(value_, std::wstring(value, value.Length()));
 342 }
 343
 344 void AccessibleChecker::CheckAccessibleState(IAccessible* accessible) {
 345   if (state_ < 0)
 346     return;
 347
 348   base::win::ScopedVariant state;
 349   base::win::ScopedVariant childid_self(CHILDID_SELF);
 350   HRESULT hr = accessible->get_accState(childid_self, state.Receive());
 351   EXPECT_EQ(S_OK, hr);
 352   ASSERT_EQ(VT_I4, state.type());
 353   LONG obj_state = V_I4(&state);
 354   // Avoid flakiness. The "offscreen" state depends on whether the browser
 355   // window is frontmost or not, and "hottracked" depends on whether the
 356   // mouse cursor happens to be over the element.
 357   obj_state &= ~(STATE_SYSTEM_OFFSCREEN | STATE_SYSTEM_HOTTRACKED);
 358   EXPECT_EQ(state_, obj_state)
 359     << "Expected state: " << IAccessibleStateToString(state_)
 360     << "\nGot state: " << IAccessibleStateToString(obj_state);
 361 }
 362
 363 void AccessibleChecker::CheckAccessibleChildren(IAccessible* parent) {
 364   LONG child_count = 0;
 365   HRESULT hr = parent->get_accChildCount(&child_count);
 366   EXPECT_EQ(S_OK, hr);
 367   ASSERT_EQ(child_count, children_.size());
 368
 369   scoped_ptr<VARIANT[]> child_array(new VARIANT[child_count]);
 370   LONG obtained_count = 0;
 371   hr = AccessibleChildren(parent, 0, child_count,
 372                           child_array.get(), &obtained_count);
 373   ASSERT_EQ(S_OK, hr);
 374   ASSERT_EQ(child_count, obtained_count);
 375
 376   VARIANT* child = child_array.get();
 377   for (AccessibleCheckerVector::iterator child_checker = children_.begin();
 378        child_checker != children_.end();
 379        ++child_checker, ++child) {
 380     base::win::ScopedComPtr<IAccessible> child_accessible(
 381         GetAccessibleFromResultVariant(parent, child));
 382     ASSERT_TRUE(child_accessible.get());
 383     (*child_checker)->CheckAccessible(child_accessible.get());
 384   }
 385 }
 386
 387 base::string16 AccessibleChecker::RoleVariantToString(
 388     const base::win::ScopedVariant& role) {
 389   if (role.type() == VT_I4)
 390     return IAccessibleRoleToString(V_I4(&role));
 391   if (role.type() == VT_BSTR)
 392     return base::string16(V_BSTR(&role), SysStringLen(V_BSTR(&role)));
 393   return base::string16();
 394 }
 395
 396 }  // namespace
 397
 398
 399 // Tests ----------------------------------------------------------------------
 400
 401 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
 402                        TestBusyAccessibilityTree) {
 403  if (GetBaseAccessibilityMode() != AccessibilityModeOff)
 404     return;
 405
 406   NavigateToURL(shell(), GURL(url::kAboutBlankURL));
 407
 408   // The initial accessible returned should have state STATE_SYSTEM_BUSY while
 409   // the accessibility tree is being requested from the renderer.
 410   AccessibleChecker document1_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
 411                                       std::wstring());
 412   document1_checker.SetExpectedState(
 413       STATE_SYSTEM_READONLY | STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_FOCUSED |
 414       STATE_SYSTEM_BUSY);
 415   document1_checker.CheckAccessible(GetRendererAccessible());
 416 }
 417
 418 // Periodically failing.  See crbug.com/145537
 419 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
 420                        DISABLED_TestNotificationActiveDescendantChanged) {
 421   LoadInitialAccessibilityTreeFromHtml(
 422       "<ul tabindex='-1' role='radiogroup' aria-label='ul'>"
 423       "<li id='li'>li</li></ul>");
 424
 425   // Check the browser's copy of the renderer accessibility tree.
 426   AccessibleChecker list_marker_checker(L"\x2022", ROLE_SYSTEM_TEXT,
 427                                         std::wstring());
 428   AccessibleChecker static_text_checker(L"li", ROLE_SYSTEM_TEXT,
 429                                         std::wstring());
 430   AccessibleChecker list_item_checker(std::wstring(), ROLE_SYSTEM_LISTITEM,
 431                                       std::wstring());
 432   list_item_checker.SetExpectedState(STATE_SYSTEM_READONLY);
 433   AccessibleChecker radio_group_checker(L"ul", ROLE_SYSTEM_GROUPING,
 434                                         IA2_ROLE_SECTION, std::wstring());
 435   radio_group_checker.SetExpectedState(STATE_SYSTEM_FOCUSABLE);
 436   AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
 437                                      std::wstring());
 438   list_item_checker.AppendExpectedChild(&list_marker_checker);
 439   list_item_checker.AppendExpectedChild(&static_text_checker);
 440   radio_group_checker.AppendExpectedChild(&list_item_checker);
 441   document_checker.AppendExpectedChild(&radio_group_checker);
 442   document_checker.CheckAccessible(GetRendererAccessible());
 443
 444   // Set focus to the radio group.
 445   scoped_ptr<AccessibilityNotificationWaiter> waiter(
 446       new AccessibilityNotificationWaiter(
 447           shell(), AccessibilityModeComplete,
 448           ui::AX_EVENT_FOCUS));
 449   ExecuteScript(L"document.body.children[0].focus()");
 450   waiter->WaitForNotification();
 451
 452   // Check that the accessibility tree of the browser has been updated.
 453   radio_group_checker.SetExpectedState(
 454       STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_FOCUSED);
 455   document_checker.CheckAccessible(GetRendererAccessible());
 456
 457   // Set the active descendant of the radio group
 458   waiter.reset(new AccessibilityNotificationWaiter(
 459       shell(), AccessibilityModeComplete,
 460       ui::AX_EVENT_FOCUS));
 461   ExecuteScript(
 462       L"document.body.children[0].setAttribute('aria-activedescendant', 'li')");
 463   waiter->WaitForNotification();
 464
 465   // Check that the accessibility tree of the browser has been updated.
 466   list_item_checker.SetExpectedState(
 467       STATE_SYSTEM_READONLY | STATE_SYSTEM_FOCUSED);
 468   radio_group_checker.SetExpectedState(STATE_SYSTEM_FOCUSABLE);
 469   document_checker.CheckAccessible(GetRendererAccessible());
 470 }
 471
 472 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
 473                        TestNotificationCheckedStateChanged) {
 474   LoadInitialAccessibilityTreeFromHtml(
 475       "<body><input type='checkbox' /></body>");
 476
 477   // Check the browser's copy of the renderer accessibility tree.
 478   AccessibleChecker checkbox_checker(std::wstring(), ROLE_SYSTEM_CHECKBUTTON,
 479                                      std::wstring());
 480   checkbox_checker.SetExpectedState(STATE_SYSTEM_FOCUSABLE);
 481   AccessibleChecker body_checker(std::wstring(), L"body", IA2_ROLE_SECTION,
 482                                  std::wstring());
 483   AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
 484                                      std::wstring());
 485   body_checker.AppendExpectedChild(&checkbox_checker);
 486   document_checker.AppendExpectedChild(&body_checker);
 487   document_checker.CheckAccessible(GetRendererAccessible());
 488
 489   // Check the checkbox.
 490   scoped_ptr<AccessibilityNotificationWaiter> waiter(
 491       new AccessibilityNotificationWaiter(
 492           shell(), AccessibilityModeComplete,
 493           ui::AX_EVENT_CHECKED_STATE_CHANGED));
 494   ExecuteScript(L"document.body.children[0].checked=true");
 495   waiter->WaitForNotification();
 496
 497   // Check that the accessibility tree of the browser has been updated.
 498   checkbox_checker.SetExpectedState(
 499       STATE_SYSTEM_CHECKED | STATE_SYSTEM_FOCUSABLE);
 500   document_checker.CheckAccessible(GetRendererAccessible());
 501 }
 502
 503 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
 504                        TestNotificationChildrenChanged) {
 505   // The role attribute causes the node to be in the accessibility tree.
 506   LoadInitialAccessibilityTreeFromHtml("<body role=group></body>");
 507
 508   // Check the browser's copy of the renderer accessibility tree.
 509   AccessibleChecker group_checker(std::wstring(), ROLE_SYSTEM_GROUPING,
 510                                   std::wstring());
 511   AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
 512                                      std::wstring());
 513   document_checker.AppendExpectedChild(&group_checker);
 514   document_checker.CheckAccessible(GetRendererAccessible());
 515
 516   // Change the children of the document body.
 517   scoped_ptr<AccessibilityNotificationWaiter> waiter(
 518       new AccessibilityNotificationWaiter(
 519           shell(),
 520           AccessibilityModeComplete,
 521           ui::AX_EVENT_CHILDREN_CHANGED));
 522   ExecuteScript(L"document.body.innerHTML='<b>new text</b>'");
 523   waiter->WaitForNotification();
 524
 525   // Check that the accessibility tree of the browser has been updated.
 526   AccessibleChecker text_checker(
 527       L"new text", ROLE_SYSTEM_STATICTEXT, std::wstring());
 528   group_checker.AppendExpectedChild(&text_checker);
 529   document_checker.CheckAccessible(GetRendererAccessible());
 530 }
 531
 532 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
 533                        TestNotificationChildrenChanged2) {
 534   // The role attribute causes the node to be in the accessibility tree.
 535   LoadInitialAccessibilityTreeFromHtml(
 536       "<div role=group style='visibility: hidden'>text</div>");
 537
 538   // Check the accessible tree of the browser.
 539   AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
 540                                      std::wstring());
 541   document_checker.CheckAccessible(GetRendererAccessible());
 542
 543   // Change the children of the document body.
 544   scoped_ptr<AccessibilityNotificationWaiter> waiter(
 545       new AccessibilityNotificationWaiter(
 546           shell(), AccessibilityModeComplete,
 547           ui::AX_EVENT_CHILDREN_CHANGED));
 548   ExecuteScript(L"document.body.children[0].style.visibility='visible'");
 549   waiter->WaitForNotification();
 550
 551   // Check that the accessibility tree of the browser has been updated.
 552   AccessibleChecker static_text_checker(L"text", ROLE_SYSTEM_STATICTEXT,
 553                                         std::wstring());
 554   AccessibleChecker group_checker(std::wstring(), ROLE_SYSTEM_GROUPING,
 555                                   std::wstring());
 556   document_checker.AppendExpectedChild(&group_checker);
 557   group_checker.AppendExpectedChild(&static_text_checker);
 558   document_checker.CheckAccessible(GetRendererAccessible());
 559 }
 560
 561 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
 562                        TestNotificationFocusChanged) {
 563   // The role attribute causes the node to be in the accessibility tree.
 564   LoadInitialAccessibilityTreeFromHtml("<div role=group tabindex='-1'></div>");
 565
 566   // Check the browser's copy of the renderer accessibility tree.
 567   SCOPED_TRACE("Check initial tree");
 568   AccessibleChecker group_checker(std::wstring(), ROLE_SYSTEM_GROUPING,
 569                                   std::wstring());
 570   group_checker.SetExpectedState(STATE_SYSTEM_FOCUSABLE);
 571   AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
 572                                      std::wstring());
 573   document_checker.AppendExpectedChild(&group_checker);
 574   document_checker.CheckAccessible(GetRendererAccessible());
 575
 576   // Focus the div in the document
 577   scoped_ptr<AccessibilityNotificationWaiter> waiter(
 578       new AccessibilityNotificationWaiter(
 579           shell(), AccessibilityModeComplete,
 580           ui::AX_EVENT_FOCUS));
 581   ExecuteScript(L"document.body.children[0].focus()");
 582   waiter->WaitForNotification();
 583
 584   // Check that the accessibility tree of the browser has been updated.
 585   SCOPED_TRACE("Check updated tree after focusing div");
 586   group_checker.SetExpectedState(
 587       STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_FOCUSED);
 588   document_checker.CheckAccessible(GetRendererAccessible());
 589
 590   // Focus the document accessible. This will un-focus the current node.
 591   waiter.reset(
 592       new AccessibilityNotificationWaiter(
 593           shell(), AccessibilityModeComplete,
 594           ui::AX_EVENT_BLUR));
 595   base::win::ScopedComPtr<IAccessible> document_accessible(
 596       GetRendererAccessible());
 597   ASSERT_NE(document_accessible.get(), reinterpret_cast<IAccessible*>(NULL));
 598   base::win::ScopedVariant childid_self(CHILDID_SELF);
 599   HRESULT hr = document_accessible->accSelect(SELFLAG_TAKEFOCUS, childid_self);
 600   ASSERT_EQ(S_OK, hr);
 601   waiter->WaitForNotification();
 602
 603   // Check that the accessibility tree of the browser has been updated.
 604   SCOPED_TRACE("Check updated tree after focusing document again");
 605   group_checker.SetExpectedState(STATE_SYSTEM_FOCUSABLE);
 606   document_checker.CheckAccessible(GetRendererAccessible());
 607 }
 608
 609 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
 610                        TestNotificationValueChanged) {
 611   LoadInitialAccessibilityTreeFromHtml(
 612       "<body><input type='text' value='old value'/></body>");
 613
 614   // Check the browser's copy of the renderer accessibility tree.
 615   AccessibleChecker text_field_checker(std::wstring(), ROLE_SYSTEM_TEXT,
 616                                        L"old value");
 617   text_field_checker.SetExpectedState(STATE_SYSTEM_FOCUSABLE);
 618   AccessibleChecker body_checker(std::wstring(), L"body", IA2_ROLE_SECTION,
 619                                  std::wstring());
 620   AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
 621                                      std::wstring());
 622   body_checker.AppendExpectedChild(&text_field_checker);
 623   document_checker.AppendExpectedChild(&body_checker);
 624   document_checker.CheckAccessible(GetRendererAccessible());
 625
 626   // Set the value of the text control
 627   scoped_ptr<AccessibilityNotificationWaiter> waiter(
 628       new AccessibilityNotificationWaiter(
 629           shell(), AccessibilityModeComplete,
 630           ui::AX_EVENT_VALUE_CHANGED));
 631   ExecuteScript(L"document.body.children[0].value='new value'");
 632   waiter->WaitForNotification();
 633
 634   // Check that the accessibility tree of the browser has been updated.
 635   text_field_checker.SetExpectedValue(L"new value");
 636   document_checker.CheckAccessible(GetRendererAccessible());
 637 }
 638
 639 // This test verifies that the web content's accessibility tree is a
 640 // descendant of the main browser window's accessibility tree, so that
 641 // tools like AccExplorer32 or AccProbe can be used to examine Chrome's
 642 // accessibility support.
 643 //
 644 // If you made a change and this test now fails, check that the NativeViewHost
 645 // that wraps the tab contents returns the IAccessible implementation
 646 // provided by RenderWidgetHostViewWin in GetNativeViewAccessible().
 647 // flaky: http://crbug.com/402190
 648 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
 649                        DISABLED_ContainsRendererAccessibilityTree) {
 650   LoadInitialAccessibilityTreeFromHtml(
 651       "<html><head><title>MyDocument</title></head>"
 652       "<body>Content</body></html>");
 653
 654   // Get the accessibility object for the window tree host.
 655   aura::Window* window = shell()->window();
 656   CHECK(window);
 657   aura::WindowTreeHost* window_tree_host = window->GetHost();
 658   CHECK(window_tree_host);
 659   HWND hwnd = window_tree_host->GetAcceleratedWidget();
 660   CHECK(hwnd);
 661   base::win::ScopedComPtr<IAccessible> browser_accessible;
 662   HRESULT hr = AccessibleObjectFromWindow(
 663       hwnd,
 664       OBJID_WINDOW,
 665       IID_IAccessible,
 666       reinterpret_cast<void**>(browser_accessible.Receive()));
 667   ASSERT_EQ(S_OK, hr);
 668
 669   bool found = false;
 670   RecursiveFindNodeInAccessibilityTree(
 671       browser_accessible.get(), ROLE_SYSTEM_DOCUMENT, L"MyDocument", 0, &found);
 672   ASSERT_EQ(found, true);
 673 }
 674
 675 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
 676                        SupportsISimpleDOM) {
 677   LoadInitialAccessibilityTreeFromHtml(
 678       "<body><input type='checkbox' /></body>");
 679
 680   // Get the IAccessible object for the document.
 681   base::win::ScopedComPtr<IAccessible> document_accessible(
 682       GetRendererAccessible());
 683   ASSERT_NE(document_accessible.get(), reinterpret_cast<IAccessible*>(NULL));
 684
 685   // Get the ISimpleDOM object for the document.
 686   base::win::ScopedComPtr<IServiceProvider> service_provider;
 687   HRESULT hr = static_cast<IAccessible*>(document_accessible.get())
 688                    ->QueryInterface(service_provider.Receive());
 689   ASSERT_EQ(S_OK, hr);
 690   const GUID refguid = {0x0c539790, 0x12e4, 0x11cf,
 691                         0xb6, 0x61, 0x00, 0xaa, 0x00, 0x4c, 0xd6, 0xd8};
 692   base::win::ScopedComPtr<ISimpleDOMNode> document_isimpledomnode;
 693   hr = static_cast<IServiceProvider*>(service_provider.get())
 694            ->QueryService(
 695                refguid, IID_ISimpleDOMNode,
 696                reinterpret_cast<void**>(document_isimpledomnode.Receive()));
 697   ASSERT_EQ(S_OK, hr);
 698
 699   base::win::ScopedBstr node_name;
 700   short name_space_id;  // NOLINT
 701   base::win::ScopedBstr node_value;
 702   unsigned int num_children;
 703   unsigned int unique_id;
 704   unsigned short node_type;  // NOLINT
 705   hr = document_isimpledomnode->get_nodeInfo(
 706       node_name.Receive(), &name_space_id, node_value.Receive(), &num_children,
 707       &unique_id, &node_type);
 708   ASSERT_EQ(S_OK, hr);
 709   EXPECT_EQ(NODETYPE_DOCUMENT, node_type);
 710   EXPECT_EQ(1, num_children);
 711   node_name.Reset();
 712   node_value.Reset();
 713
 714   base::win::ScopedComPtr<ISimpleDOMNode> body_isimpledomnode;
 715   hr = document_isimpledomnode->get_firstChild(
 716       body_isimpledomnode.Receive());
 717   ASSERT_EQ(S_OK, hr);
 718   hr = body_isimpledomnode->get_nodeInfo(
 719       node_name.Receive(), &name_space_id, node_value.Receive(), &num_children,
 720       &unique_id, &node_type);
 721   ASSERT_EQ(S_OK, hr);
 722   EXPECT_EQ(L"body", std::wstring(node_name, node_name.Length()));
 723   EXPECT_EQ(NODETYPE_ELEMENT, node_type);
 724   EXPECT_EQ(1, num_children);
 725   node_name.Reset();
 726   node_value.Reset();
 727
 728   base::win::ScopedComPtr<ISimpleDOMNode> checkbox_isimpledomnode;
 729   hr = body_isimpledomnode->get_firstChild(
 730       checkbox_isimpledomnode.Receive());
 731   ASSERT_EQ(S_OK, hr);
 732   hr = checkbox_isimpledomnode->get_nodeInfo(
 733       node_name.Receive(), &name_space_id, node_value.Receive(), &num_children,
 734       &unique_id, &node_type);
 735   ASSERT_EQ(S_OK, hr);
 736   EXPECT_EQ(L"input", std::wstring(node_name, node_name.Length()));
 737   EXPECT_EQ(NODETYPE_ELEMENT, node_type);
 738   EXPECT_EQ(0, num_children);
 739 }
 740
 741 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest, TestRoleGroup) {
 742   LoadInitialAccessibilityTreeFromHtml(
 743       "<fieldset></fieldset><div role=group></div>");
 744
 745   // Check the browser's copy of the renderer accessibility tree.
 746   AccessibleChecker grouping1_checker(std::wstring(), ROLE_SYSTEM_GROUPING,
 747                                       std::wstring());
 748   AccessibleChecker grouping2_checker(std::wstring(), ROLE_SYSTEM_GROUPING,
 749                                       std::wstring());
 750   AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
 751                                      std::wstring());
 752   document_checker.AppendExpectedChild(&grouping1_checker);
 753   document_checker.AppendExpectedChild(&grouping2_checker);
 754   document_checker.CheckAccessible(GetRendererAccessible());
 755 }
 756
 757 }  // namespace content