Update browser accessibility tree on a renderer accessibility object state ch...

chrome/browser/accessibility_win_browsertest.cc

 // Copyright (c) 2010 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 <atlbase.h>
 #include <vector>
 
 #include "base/scoped_comptr_win.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_window.h"
@@ skipping 64 matching lines @@
   void AppendExpectedChild(AccessibleChecker* expected_child);
 
   // Check that the name and role of the given IAccessible instance and its
   // descendants match the expected names and roles that this object was
   // initialized with.
   void CheckAccessible(IAccessible* accessible);
 
   // Set the expected value for this AccessibleChecker.
   void SetExpectedValue(wstring expected_value);
 
+  // Set the expected state for this AccessibleChecker.
+  void SetExpectedState(LONG expected_state);
+
  private:
   void CheckAccessibleName(IAccessible* accessible);
   void CheckAccessibleRole(IAccessible* accessible);
   void CheckAccessibleValue(IAccessible* accessible);
+  void CheckAccessibleState(IAccessible* accessible);
   void CheckAccessibleChildren(IAccessible* accessible);
 
  private:
   typedef vector<AccessibleChecker*> AccessibleCheckerVector;
 
   // Expected accessible name. Checked against IAccessible::get_accName.
   wstring name_;
 
   // Expected accessible role. Checked against IAccessible::get_accRole.
   CComVariant role_;
 
   // Expected accessible value. Checked against IAccessible::get_accValue.
   wstring value_;
 
+  // Expected accessible state. Checked against IAccessible::get_accState.
+  LONG state_;
+
   // Expected accessible children. Checked using IAccessible::get_accChildCount
   // and ::AccessibleChildren.
   AccessibleCheckerVector children_;
 };
 
 VARIANT CreateI4Variant(LONG value) {
   VARIANT variant = {0};
 
   V_VT(&variant) = VT_I4;
   V_I4(&variant) = value;
@@ skipping 34 matching lines @@
   EXPECT_EQ(S_OK, hr);
   EXPECT_NE(accessible, reinterpret_cast<IAccessible*>(NULL));
 
   return accessible;
 }
 
 AccessibleChecker::AccessibleChecker(
     wstring expected_name, int32 expected_role, wstring expected_value) :
     name_(expected_name),
     role_(expected_role),
-    value_(expected_value) {
+    value_(expected_value),
+    state_(-1) {
 }
 
 AccessibleChecker::AccessibleChecker(
     wstring expected_name, wstring expected_role, wstring expected_value) :
     name_(expected_name),
     role_(expected_role.c_str()),
-    value_(expected_value) {
+    value_(expected_value),
+    state_(-1) {
 }
 
 void AccessibleChecker::AppendExpectedChild(
     AccessibleChecker* expected_child) {
   children_.push_back(expected_child);
 }
 
 void AccessibleChecker::CheckAccessible(IAccessible* accessible) {
   CheckAccessibleName(accessible);
   CheckAccessibleRole(accessible);
   CheckAccessibleValue(accessible);
+  CheckAccessibleState(accessible);
   CheckAccessibleChildren(accessible);
 }
 
 void AccessibleChecker::SetExpectedValue(wstring expected_value) {
   value_ = expected_value;
 }
 
+void AccessibleChecker::SetExpectedState(LONG expected_state) {
+  state_ = expected_state;
+}
+
 void AccessibleChecker::CheckAccessibleName(IAccessible* accessible) {
   CComBSTR name;
   HRESULT hr =
       accessible->get_accName(CreateI4Variant(CHILDID_SELF), &name);
 
   if (name_.empty()) {
     // If the object doesn't have name S_FALSE should be returned.
     EXPECT_EQ(hr, S_FALSE);
   } else {
     // Test that the correct string was returned.
@@ skipping 15 matching lines @@
   CComBSTR value;
   HRESULT hr =
       accessible->get_accValue(CreateI4Variant(CHILDID_SELF), &value);
   EXPECT_EQ(hr, S_OK);
 
   // Test that the correct string was returned.
   EXPECT_STREQ(value_.c_str(),
                wstring(value.m_str, SysStringLen(value)).c_str());
 }
 
+void AccessibleChecker::CheckAccessibleState(IAccessible* accessible) {
+  if (state_ < 0)
+    return;
+
+  VARIANT var_state = {0};
+  HRESULT hr =
+      accessible->get_accState(CreateI4Variant(CHILDID_SELF), &var_state);
+  EXPECT_EQ(hr, S_OK);
+  EXPECT_EQ(VT_I4, V_VT(&var_state));
+  ASSERT_TRUE(state_ == V_I4(&var_state));
+}
+
 void AccessibleChecker::CheckAccessibleChildren(IAccessible* parent) {
   LONG child_count = 0;
   HRESULT hr = parent->get_accChildCount(&child_count);
   EXPECT_EQ(hr, S_OK);
   ASSERT_EQ(child_count, children_.size());
 
   auto_ptr<VARIANT> child_array(new VARIANT[child_count]);
   LONG obtained_count = 0;
   hr = AccessibleChildren(parent, 0, child_count,
                           child_array.get(), &obtained_count);
@@ skipping 71 matching lines @@
   hr = document_accessible->get_accName(CreateI4Variant(CHILDID_SELF), &name);
   ASSERT_EQ(E_FAIL, hr);
 }
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
                        TestDynamicAccessibilityTree) {
   // By requesting an accessible chrome will believe a screen reader has been
   // detected. Request and wait for the accessibility tree to be updated.
   GURL tree_url(
       "data:text/html,<html><body><div onclick=\"this.innerHTML='<b>new text"
-      "</b>';\"><b>old text</b></div></body></html>");
+      "</b>';\"><b>old text</b></div><div><input type='checkbox' /></div>"
+      "</body></html>");
   browser()->OpenURL(tree_url, GURL(), CURRENT_TAB, PageTransition::TYPED);
   ScopedComPtr<IAccessible> document_accessible(
       GetRenderWidgetHostViewClientAccessible());
   ui_test_utils::WaitForNotification(
       NotificationType::RENDER_VIEW_HOST_ACCESSIBILITY_TREE_UPDATED);
 
   AccessibleChecker text_checker(L"", ROLE_SYSTEM_TEXT, L"old text");
+
+  AccessibleChecker div_checker1(L"", L"div", L"");

[dmazzoni, 2010/09/01 15:10:52]

How about div1_checker through div3_checker?

[Chris Guillory, 2010/09/01 15:35:27]

Done. I like that better.

+  div_checker1.AppendExpectedChild(&text_checker);
+
   AccessibleChecker checkbox_checker(L"", ROLE_SYSTEM_CHECKBUTTON, L"");
+  checkbox_checker.SetExpectedState(
+      STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_READONLY);
 
-  AccessibleChecker div_checker(L"", L"div", L"");
-  div_checker.AppendExpectedChild(&text_checker);
+  AccessibleChecker div_checker2(L"", L"div", L"");
+  div_checker2.AppendExpectedChild(&checkbox_checker);
 
   AccessibleChecker document_checker(L"", ROLE_SYSTEM_DOCUMENT, L"");
-  document_checker.AppendExpectedChild(&div_checker);
+  document_checker.AppendExpectedChild(&div_checker1);
+  document_checker.AppendExpectedChild(&div_checker2);
+
+  // TODO(ctguil): Fix: We should not be expecting busy state here.
+  document_checker.SetExpectedState(STATE_SYSTEM_BUSY);
 
   // Check the accessible tree of the browser.
   document_accessible = GetRenderWidgetHostViewClientAccessible();
   ASSERT_NE(document_accessible.get(), reinterpret_cast<IAccessible*>(NULL));
   document_checker.CheckAccessible(document_accessible);
 
   // Perform the default action on the div which executes the script that
   // updates text node within the div.
   CComPtr<IDispatch> div_dispatch;
   HRESULT hr = document_accessible->get_accChild(CreateI4Variant(1),
                                                  &div_dispatch);
   EXPECT_EQ(hr, S_OK);
   CComQIPtr<IAccessible> div_accessible(div_dispatch);
   hr = div_accessible->accDoDefaultAction(CreateI4Variant(CHILDID_SELF));
   EXPECT_EQ(hr, S_OK);
   ui_test_utils::WaitForNotification(
       NotificationType::RENDER_VIEW_HOST_ACCESSIBILITY_TREE_UPDATED);
 
+  div_dispatch.Release();
+  div_accessible.Release();
+
+  // Check that the accessibility tree of the browser has been updated.
+  text_checker.SetExpectedValue(L"new text");
+  document_checker.CheckAccessible(document_accessible);
+
+  // Perform the default action on the checkbox which marks it as checked.
+  hr = document_accessible->get_accChild(CreateI4Variant(2), &div_dispatch);
+  EXPECT_EQ(hr, S_OK);
+  div_accessible = div_dispatch;
+  CComPtr<IDispatch> checkbox_dispatch;
+  hr = div_accessible->get_accChild(CreateI4Variant(1), &checkbox_dispatch);
+  EXPECT_EQ(hr, S_OK);
+  CComQIPtr<IAccessible> checkbox_accessible(checkbox_dispatch);
+  hr = checkbox_accessible->accDoDefaultAction(CreateI4Variant(CHILDID_SELF));
+  EXPECT_EQ(hr, S_OK);
+  ui_test_utils::WaitForNotification(
+      NotificationType::RENDER_VIEW_HOST_ACCESSIBILITY_TREE_UPDATED);
+
   // Check that the accessibility tree of the browser has been updated.
-  text_checker.SetExpectedValue(L"new text");
+  checkbox_checker.SetExpectedState(
+      STATE_SYSTEM_CHECKED | STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_FOCUSED |
+      STATE_SYSTEM_READONLY);
   document_checker.CheckAccessible(document_accessible);
 }
 }  // namespace.