Scope and clean up uses of AccessibilityMode.

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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
@@ skipping 85 matching lines @@
 };
 
 AccessibilityWinBrowserTest::AccessibilityWinBrowserTest() {
 }
 
 AccessibilityWinBrowserTest::~AccessibilityWinBrowserTest() {
 }
 
 void AccessibilityWinBrowserTest::LoadInitialAccessibilityTreeFromHtml(
     const std::string& html) {
-  AccessibilityNotificationWaiter waiter(
-      shell()->web_contents(), ACCESSIBILITY_MODE_COMPLETE,
-      ui::AX_EVENT_LOAD_COMPLETE);
+  AccessibilityNotificationWaiter waiter(shell()->web_contents(),
+                                         AccessibilityMode::kComplete,
+                                         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() {
   content::WebContents* web_contents = shell()->web_contents();
   return web_contents->GetRenderWidgetHostView()->GetNativeViewAccessible();
@@ skipping 35 matching lines @@
       GetAccessibleFromVariant(form.get(), form_children[1].AsInput()).get(),
       input.Receive()));
   LONG input_role = 0;
   ASSERT_HRESULT_SUCCEEDED(input->role(&input_role));
   ASSERT_EQ(ROLE_SYSTEM_TEXT, input_role);
 
   // Retrieve the IAccessibleText interface for the field.
   ASSERT_HRESULT_SUCCEEDED(input.QueryInterface(input_text->Receive()));
 
   // Set the caret on the last character.
-  AccessibilityNotificationWaiter waiter(
-      shell()->web_contents(), ACCESSIBILITY_MODE_COMPLETE,
-      ui::AX_EVENT_TEXT_SELECTION_CHANGED);
+  AccessibilityNotificationWaiter waiter(shell()->web_contents(),
+                                         AccessibilityMode::kComplete,
+                                         ui::AX_EVENT_TEXT_SELECTION_CHANGED);
   std::wstring caret_offset = base::UTF16ToWide(base::IntToString16(
       static_cast<int>(CONTENTS_LENGTH - 1)));
   ExecuteScript(std::wstring(
       L"var textField = document.getElementById('textField');"
       L"textField.focus();"
       L"textField.setSelectionRange(") +
       caret_offset + L"," + caret_offset + L");");
   waiter.WaitForNotification();
 }
 
@@ skipping 29 matching lines @@
           .get(),
       textarea.Receive()));
   LONG textarea_role = 0;
   ASSERT_HRESULT_SUCCEEDED(textarea->role(&textarea_role));
   ASSERT_EQ(ROLE_SYSTEM_TEXT, textarea_role);
 
   // Retrieve the IAccessibleText interface for the field.
   ASSERT_HRESULT_SUCCEEDED(textarea.QueryInterface(textarea_text->Receive()));
 
   // Set the caret on the last character.
-  AccessibilityNotificationWaiter waiter(
-      shell()->web_contents(), ACCESSIBILITY_MODE_COMPLETE,
-      ui::AX_EVENT_TEXT_SELECTION_CHANGED);
+  AccessibilityNotificationWaiter waiter(shell()->web_contents(),
+                                         AccessibilityMode::kComplete,
+                                         ui::AX_EVENT_TEXT_SELECTION_CHANGED);
   std::wstring caret_offset = base::UTF16ToWide(base::IntToString16(
       static_cast<int>(CONTENTS_LENGTH - 1)));
   ExecuteScript(std::wstring(
       L"var textField = document.getElementById('textField');"
       L"textField.focus();"
       L"textField.setSelectionRange(") +
       caret_offset + L"," + caret_offset + L");");
   waiter.WaitForNotification();
 }
 
@@ skipping 436 matching lines @@
                                      std::wstring());
   list_item_checker.AppendExpectedChild(&list_marker_checker);
   list_item_checker.AppendExpectedChild(&static_text_checker);
   radio_group_checker.AppendExpectedChild(&list_item_checker);
   document_checker.AppendExpectedChild(&radio_group_checker);
   document_checker.CheckAccessible(GetRendererAccessible());
 
   // Set focus to the radio group.
   std::unique_ptr<AccessibilityNotificationWaiter> waiter(
       new AccessibilityNotificationWaiter(shell()->web_contents(),
-                                          ACCESSIBILITY_MODE_COMPLETE,
+                                          AccessibilityMode::kComplete,
                                           ui::AX_EVENT_FOCUS));
   ExecuteScript(L"document.body.children[0].focus()");
   waiter->WaitForNotification();
 
   // Check that the accessibility tree of the browser has been updated.
   radio_group_checker.SetExpectedState(
       STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_FOCUSED);
   document_checker.CheckAccessible(GetRendererAccessible());
 
   // Set the active descendant of the radio group
-  waiter.reset(new AccessibilityNotificationWaiter(
-      shell()->web_contents(), ACCESSIBILITY_MODE_COMPLETE,
-      ui::AX_EVENT_FOCUS));
+  waiter.reset(new AccessibilityNotificationWaiter(shell()->web_contents(),
+                                                   AccessibilityMode::kComplete,
+                                                   ui::AX_EVENT_FOCUS));
   ExecuteScript(
       L"document.body.children[0].setAttribute('aria-activedescendant', 'li')");
   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());
 }
@@ skipping 11 matching lines @@
                                  std::wstring());
   AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
                                      std::wstring());
   body_checker.AppendExpectedChild(&checkbox_checker);
   document_checker.AppendExpectedChild(&body_checker);
   document_checker.CheckAccessible(GetRendererAccessible());
 
   // Check the checkbox.
   std::unique_ptr<AccessibilityNotificationWaiter> waiter(
       new AccessibilityNotificationWaiter(shell()->web_contents(),
-                                          ACCESSIBILITY_MODE_COMPLETE,
+                                          AccessibilityMode::kComplete,
                                           ui::AX_EVENT_CHECKED_STATE_CHANGED));
   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,
                        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.
   std::unique_ptr<AccessibilityNotificationWaiter> waiter(
       new AccessibilityNotificationWaiter(shell()->web_contents(),
-                                          ACCESSIBILITY_MODE_COMPLETE,
+                                          AccessibilityMode::kComplete,
                                           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_STATICTEXT, std::wstring());
   group_checker.AppendExpectedChild(&text_checker);
   document_checker.CheckAccessible(GetRendererAccessible());
 }
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
                        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.
   std::unique_ptr<AccessibilityNotificationWaiter> waiter(
       new AccessibilityNotificationWaiter(shell()->web_contents(),
-                                          ACCESSIBILITY_MODE_COMPLETE,
+                                          AccessibilityMode::kComplete,
                                           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_STATICTEXT,
                                         std::wstring());
   AccessibleChecker group_checker(std::wstring(), ROLE_SYSTEM_GROUPING,
                                   std::wstring());
   document_checker.AppendExpectedChild(&group_checker);
@@ skipping 12 matching lines @@
                                   std::wstring());
   group_checker.SetExpectedState(STATE_SYSTEM_FOCUSABLE);
   AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
                                      std::wstring());
   document_checker.AppendExpectedChild(&group_checker);
   document_checker.CheckAccessible(GetRendererAccessible());
 
   // Focus the div in the document
   std::unique_ptr<AccessibilityNotificationWaiter> waiter(
       new AccessibilityNotificationWaiter(shell()->web_contents(),
-                                          ACCESSIBILITY_MODE_COMPLETE,
+                                          AccessibilityMode::kComplete,
                                           ui::AX_EVENT_FOCUS));
   ExecuteScript(L"document.body.children[0].focus()");
   waiter->WaitForNotification();
 
   // Check that the accessibility tree of the browser has been updated.
   SCOPED_TRACE("Check updated tree after focusing div");
   group_checker.SetExpectedState(
       STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_FOCUSED);
   document_checker.CheckAccessible(GetRendererAccessible());
 
   // Focus the document accessible. This will un-focus the current node.
-  waiter.reset(
-      new AccessibilityNotificationWaiter(
-          shell()->web_contents(), ACCESSIBILITY_MODE_COMPLETE,
-          ui::AX_EVENT_BLUR));
+  waiter.reset(new AccessibilityNotificationWaiter(shell()->web_contents(),
+                                                   AccessibilityMode::kComplete,
+                                                   ui::AX_EVENT_BLUR));
   base::win::ScopedComPtr<IAccessible> document_accessible(
       GetRendererAccessible());
   ASSERT_NE(document_accessible.get(), reinterpret_cast<IAccessible*>(NULL));
   base::win::ScopedVariant childid_self(CHILDID_SELF);
   HRESULT hr = document_accessible->accSelect(SELFLAG_TAKEFOCUS, childid_self);
   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");
@@ skipping 14 matching lines @@
                                  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
   std::unique_ptr<AccessibilityNotificationWaiter> waiter(
       new AccessibilityNotificationWaiter(shell()->web_contents(),
-                                          ACCESSIBILITY_MODE_COMPLETE,
+                                          AccessibilityMode::kComplete,
                                           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
@@ skipping 219 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest, TestScrollToPoint) {
   base::win::ScopedComPtr<IAccessible2> paragraph;
   SetUpSampleParagraph(&paragraph);
 
   LONG prev_x, prev_y, x, y, width, height;
   base::win::ScopedVariant childid_self(CHILDID_SELF);
   ASSERT_HRESULT_SUCCEEDED(
       paragraph->accLocation(&prev_x, &prev_y, &width, &height, childid_self));
   AccessibilityNotificationWaiter location_changed_waiter(
-      shell()->web_contents(), ACCESSIBILITY_MODE_COMPLETE,
+      shell()->web_contents(), AccessibilityMode::kComplete,
       ui::AX_EVENT_LOCATION_CHANGED);
   EXPECT_HRESULT_SUCCEEDED(
       paragraph->scrollToPoint(IA2_COORDTYPE_PARENT_RELATIVE, 0, 0));
   location_changed_waiter.WaitForNotification();
 
   ASSERT_HRESULT_SUCCEEDED(
       paragraph->accLocation(&x, &y, &width, &height, childid_self));
   EXPECT_EQ(prev_x, x);
   EXPECT_GT(prev_y, y);
 
@@ skipping 10 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest, TestSetCaretOffset) {
   base::win::ScopedComPtr<IAccessibleText> input_text;
   SetUpInputField(&input_text);
 
   LONG caret_offset = 0;
   HRESULT hr = input_text->get_caretOffset(&caret_offset);
   EXPECT_EQ(S_OK, hr);
   EXPECT_EQ(CONTENTS_LENGTH - 1, caret_offset);
 
-  AccessibilityNotificationWaiter waiter(
-      shell()->web_contents(),
-      ACCESSIBILITY_MODE_COMPLETE,
-      ui::AX_EVENT_TEXT_SELECTION_CHANGED);
+  AccessibilityNotificationWaiter waiter(shell()->web_contents(),
+                                         AccessibilityMode::kComplete,
+                                         ui::AX_EVENT_TEXT_SELECTION_CHANGED);
   caret_offset = 0;
   hr = input_text->setCaretOffset(caret_offset);
   EXPECT_EQ(S_OK, hr);
   waiter.WaitForNotification();
 
   hr = input_text->get_caretOffset(&caret_offset);
   EXPECT_EQ(S_OK, hr);
   EXPECT_EQ(0, caret_offset);
 }
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
                        TestMultiLineSetCaretOffset) {
   base::win::ScopedComPtr<IAccessibleText> textarea_text;
   SetUpTextareaField(&textarea_text);
 
     LONG caret_offset = 0;
   HRESULT hr = textarea_text->get_caretOffset(&caret_offset);
   EXPECT_EQ(S_OK, hr);
   EXPECT_EQ(CONTENTS_LENGTH - 1, caret_offset);
 
-  AccessibilityNotificationWaiter waiter(
-      shell()->web_contents(),
-      ACCESSIBILITY_MODE_COMPLETE,
-      ui::AX_EVENT_TEXT_SELECTION_CHANGED);
+  AccessibilityNotificationWaiter waiter(shell()->web_contents(),
+                                         AccessibilityMode::kComplete,
+                                         ui::AX_EVENT_TEXT_SELECTION_CHANGED);
   caret_offset = 0;
   hr = textarea_text->setCaretOffset(caret_offset);
   EXPECT_EQ(S_OK, hr);
   waiter.WaitForNotification();
 
   hr = textarea_text->get_caretOffset(&caret_offset);
   EXPECT_EQ(S_OK, hr);
   EXPECT_EQ(0, caret_offset);
 }
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest, TestSetSelection) {
   base::win::ScopedComPtr<IAccessibleText> input_text;
   SetUpInputField(&input_text);
 
   LONG start_offset, end_offset;
   EXPECT_HRESULT_FAILED(
       input_text->get_selection(1, &start_offset, &end_offset));
   HRESULT hr = input_text->get_selection(0, &start_offset, &end_offset);
   // There is no selection, just a caret.
   EXPECT_EQ(E_INVALIDARG, hr);
 
   AccessibilityNotificationWaiter waiter(shell()->web_contents(),
-                                         ACCESSIBILITY_MODE_COMPLETE,
+                                         AccessibilityMode::kComplete,
                                          ui::AX_EVENT_TEXT_SELECTION_CHANGED);
   start_offset = 0;
   end_offset = CONTENTS_LENGTH;
   EXPECT_HRESULT_FAILED(input_text->setSelection(1, start_offset, end_offset));
   EXPECT_HRESULT_SUCCEEDED(
       input_text->setSelection(0, start_offset, end_offset));
   waiter.WaitForNotification();
 
   hr = input_text->get_selection(0, &start_offset, &end_offset);
   EXPECT_EQ(S_OK, hr);
@@ skipping 18 matching lines @@
   SetUpTextareaField(&textarea_text);
 
   LONG start_offset, end_offset;
   EXPECT_HRESULT_FAILED(
       textarea_text->get_selection(1, &start_offset, &end_offset));
   HRESULT hr = textarea_text->get_selection(0, &start_offset, &end_offset);
   // There is no selection, just a caret.
   EXPECT_EQ(E_INVALIDARG, hr);
 
   AccessibilityNotificationWaiter waiter(shell()->web_contents(),
-                                         ACCESSIBILITY_MODE_COMPLETE,
+                                         AccessibilityMode::kComplete,
                                          ui::AX_EVENT_TEXT_SELECTION_CHANGED);
   start_offset = 0;
   end_offset = CONTENTS_LENGTH;
   EXPECT_HRESULT_FAILED(
       textarea_text->setSelection(1, start_offset, end_offset));
   EXPECT_HRESULT_SUCCEEDED(
       textarea_text->setSelection(0, start_offset, end_offset));
   waiter.WaitForNotification();
 
   hr = textarea_text->get_selection(0, &start_offset, &end_offset);
@@ skipping 17 matching lines @@
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
                        TestStaticTextSetSelection) {
   base::win::ScopedComPtr<IAccessibleText> paragraph_text;
   SetUpSampleParagraph(&paragraph_text);
 
   LONG n_characters;
   ASSERT_HRESULT_SUCCEEDED(paragraph_text->get_nCharacters(&n_characters));
   ASSERT_LT(0, n_characters);
 
   AccessibilityNotificationWaiter waiter(
-      shell()->web_contents(), ACCESSIBILITY_MODE_COMPLETE,
+      shell()->web_contents(), AccessibilityMode::kComplete,
       ui::AX_EVENT_DOCUMENT_SELECTION_CHANGED);
   LONG start_offset = 0;
   LONG end_offset = n_characters;
   EXPECT_HRESULT_FAILED(
       paragraph_text->setSelection(1, start_offset, end_offset));
   EXPECT_HRESULT_SUCCEEDED(
       paragraph_text->setSelection(0, start_offset, end_offset));
   waiter.WaitForNotification();
 
   HRESULT hr = paragraph_text->get_selection(0, &start_offset, &end_offset);
@@ skipping 590 matching lines @@
 
   base::win::ScopedVariant childid_self(CHILDID_SELF);
   base::win::ScopedBstr image_name;
   EXPECT_HRESULT_SUCCEEDED(
       image->get_accName(childid_self, image_name.Receive()));
   EXPECT_EQ(L"image", std::wstring(image_name, image_name.Length()));
   image_name.Release();
   // Cllicking the image will change its name.
   EXPECT_HRESULT_SUCCEEDED(image_action->doAction(0));
   AccessibilityNotificationWaiter waiter(shell()->web_contents(),
-                                         ACCESSIBILITY_MODE_COMPLETE,
+                                         AccessibilityMode::kComplete,
                                          ui::AX_EVENT_TEXT_CHANGED);
   waiter.WaitForNotification();
   EXPECT_HRESULT_SUCCEEDED(
       image->get_accName(childid_self, image_name.Receive()));
   EXPECT_EQ(L"image2", std::wstring(image_name, image_name.Length()));
   EXPECT_HRESULT_FAILED(image_action->doAction(1));
 }
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest, HasHWNDAfterNavigation) {
   // This test simulates a scenario where RenderWidgetHostViewAura::SetSize
   // is not called again after its window is added to the root window.
   // Ensure that we still get a legacy HWND for accessibility.
 
   host_resolver()->AddRule("*", "127.0.0.1");
   ASSERT_TRUE(embedded_test_server()->Start());
   WebContentsImpl* web_contents = static_cast<WebContentsImpl*>(
       shell()->web_contents());
   WebContentsView* web_contents_view = web_contents->GetView();
   WebContentsViewAura* web_contents_view_aura =
       static_cast<WebContentsViewAura*>(web_contents_view);
 
   // Set a flag that will cause WebContentsViewAura to initialize a
   // RenderWidgetHostViewAura with a null parent view.
   web_contents_view_aura->set_init_rwhv_with_null_parent_for_testing(true);
 
   // Navigate to a new page and wait for the accessibility tree to load.
-  AccessibilityNotificationWaiter waiter(
-      shell()->web_contents(),
-      ACCESSIBILITY_MODE_COMPLETE,
-      ui::AX_EVENT_LOAD_COMPLETE);
+  AccessibilityNotificationWaiter waiter(shell()->web_contents(),
+                                         AccessibilityMode::kComplete,
+                                         ui::AX_EVENT_LOAD_COMPLETE);
   NavigateToURL(shell(), embedded_test_server()->GetURL(
       "/accessibility/html/article.html"));
   waiter.WaitForNotification();
 
   // At this point the root of the accessibility tree shouldn't have an HWND
   // because we never gave a parent window to the RWHVA.
   BrowserAccessibilityManagerWin* manager =
       static_cast<BrowserAccessibilityManagerWin*>(
           web_contents->GetRootBrowserAccessibilityManager());
   ASSERT_EQ(nullptr, manager->GetParentHWND());
 
   // Now add the RWHVA's window to the root window and ensure that we have
   // an HWND for accessibility now.
   web_contents_view->GetNativeView()->AddChild(
       web_contents->GetRenderWidgetHostView()->GetNativeView());
   ASSERT_NE(nullptr, manager->GetParentHWND());
 }
 
 }  // namespace content