Fixed algorithms that compute bounding rectangles and word start offsets to take into account IA2 h…

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 <vector>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/sys_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_mode_helper.h"
 #include "content/browser/accessibility/accessibility_tree_formatter.h"
 #include "content/browser/accessibility/accessibility_tree_formatter_utils_win.h"
+#include "content/browser/accessibility/browser_accessibility_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"
@@ skipping 26 matching lines @@
 
  protected:
   class AccessibleChecker;
   void LoadInitialAccessibilityTreeFromHtml(const std::string& html);
   IAccessible* GetRendererAccessible();
   void ExecuteScript(const std::wstring& script);
   void SetUpInputField(
       base::win::ScopedComPtr<IAccessibleText>* input_text);
   void SetUpTextareaField(
       base::win::ScopedComPtr<IAccessibleText>* textarea_text);
+  void SetUpSampleParagraph(
+      base::win::ScopedComPtr<IAccessibleText>* paragraph_text);
 
   static base::win::ScopedComPtr<IAccessible> GetAccessibleFromVariant(
       IAccessible* parent,
       VARIANT* var);
   static HRESULT QueryIAccessible2(IAccessible* accessible,
                                    IAccessible2** accessible2);
   static void FindNodeInAccessibilityTree(IAccessible* node,
                                           int32_t expected_role,
                                           const std::wstring& expected_name,
                                           int32_t depth,
                                           bool* found);
   static void CheckTextAtOffset(
-      base::win::ScopedComPtr<IAccessibleText>& element,
+      base::win::ScopedComPtr<IAccessibleText>& object,
       LONG offset,
       IA2TextBoundaryType boundary_type,
       LONG expected_start_offset,
       LONG expected_end_offset,
       const std::wstring& expected_text);
   static std::vector<base::win::ScopedVariant> GetAllAccessibleChildren(
       IAccessible* element);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AccessibilityWinBrowserTest);
@@ skipping 37 matching lines @@
       net::EscapeQueryParamValue(INPUT_CONTENTS, false) + std::string(
       "'></form></body></html>"));
 
   // Retrieve the IAccessible interface for the web page.
   base::win::ScopedComPtr<IAccessible> document(GetRendererAccessible());
   std::vector<base::win::ScopedVariant> document_children =
       GetAllAccessibleChildren(document.get());
   ASSERT_EQ(1u, document_children.size());
 
   base::win::ScopedComPtr<IAccessible2> form;
-  HRESULT hr = QueryIAccessible2(GetAccessibleFromVariant(
-      document.get(), document_children[0].AsInput()).get(), form.Receive());
-  ASSERT_EQ(S_OK, hr);
+  ASSERT_HRESULT_SUCCEEDED(QueryIAccessible2(
+      GetAccessibleFromVariant(document.get(), document_children[0].AsInput())
+          .get(),
+      form.Receive()));
   std::vector<base::win::ScopedVariant> form_children =
       GetAllAccessibleChildren(form.get());
   ASSERT_EQ(2u, form_children.size());
 
   // Find the input text field.
   base::win::ScopedComPtr<IAccessible2> input;
-  hr = QueryIAccessible2(GetAccessibleFromVariant(
-      form.get(), form_children[1].AsInput()).get(), input.Receive());
-  ASSERT_EQ(S_OK, hr);
+  ASSERT_HRESULT_SUCCEEDED(QueryIAccessible2(
+      GetAccessibleFromVariant(form.get(), form_children[1].AsInput()).get(),
+      input.Receive()));
   LONG input_role = 0;
-  hr = input->role(&input_role);
-  ASSERT_EQ(S_OK, hr);
+  ASSERT_HRESULT_SUCCEEDED(input->role(&input_role));
   ASSERT_EQ(ROLE_SYSTEM_TEXT, input_role);
 
   // Retrieve the IAccessibleText interface for the field.
-  hr = input.QueryInterface(input_text->Receive());
-  ASSERT_EQ(S_OK, hr);
+  ASSERT_HRESULT_SUCCEEDED(input.QueryInterface(input_text->Receive()));
 
   // Set the caret on the last character.
   AccessibilityNotificationWaiter waiter(
       shell(), AccessibilityModeComplete,
       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();"
@@ skipping 12 matching lines @@
       net::EscapeQueryParamValue(TEXTAREA_CONTENTS, false) + std::string(
       "</textarea></body></html>"));
 
   // Retrieve the IAccessible interface for the web page.
   base::win::ScopedComPtr<IAccessible> document(GetRendererAccessible());
   std::vector<base::win::ScopedVariant> document_children =
       GetAllAccessibleChildren(document.get());
   ASSERT_EQ(1u, document_children.size());
 
   base::win::ScopedComPtr<IAccessible2> section;
-  HRESULT hr = QueryIAccessible2(GetAccessibleFromVariant(
-      document.get(), document_children[0].AsInput()).get(), section.Receive());
-  ASSERT_EQ(S_OK, hr);
+  ASSERT_HRESULT_SUCCEEDED(QueryIAccessible2(
+      GetAccessibleFromVariant(document.get(), document_children[0].AsInput())
+          .get(),
+      section.Receive()));
   std::vector<base::win::ScopedVariant> section_children =
       GetAllAccessibleChildren(section.get());
   ASSERT_EQ(1u, section_children.size());
 
   // Find the textarea text field.
   base::win::ScopedComPtr<IAccessible2> textarea;
-  hr = QueryIAccessible2(GetAccessibleFromVariant(
-      section.get(), section_children[0].AsInput()).get(), textarea.Receive());
-  ASSERT_EQ(S_OK, hr);
+  ASSERT_HRESULT_SUCCEEDED(QueryIAccessible2(
+      GetAccessibleFromVariant(section.get(), section_children[0].AsInput())
+          .get(),
+      textarea.Receive()));
   LONG textarea_role = 0;
-  hr = textarea->role(&textarea_role);
-  ASSERT_EQ(S_OK, hr);
+  ASSERT_HRESULT_SUCCEEDED(textarea->role(&textarea_role));
   ASSERT_EQ(ROLE_SYSTEM_TEXT, textarea_role);
 
   // Retrieve the IAccessibleText interface for the field.
-  hr = textarea.QueryInterface(textarea_text->Receive());
-  ASSERT_EQ(S_OK, hr);
+  ASSERT_HRESULT_SUCCEEDED(textarea.QueryInterface(textarea_text->Receive()));
 
   // Set the caret on the last character.
   AccessibilityNotificationWaiter waiter(
       shell(), AccessibilityModeComplete,
       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();
 }
 
+// Loads a page with  a paragraph of sample text.
+void AccessibilityWinBrowserTest::SetUpSampleParagraph(
+    base::win::ScopedComPtr<IAccessibleText>* paragraph_text) {
+  ASSERT_NE(nullptr, paragraph_text);
+  LoadInitialAccessibilityTreeFromHtml(std::string(
+      "<!DOCTYPE html><html><body>"
+      "<p><b>Game theory</b> is \"the study of "
+      "<a href=\"#\" title=\"Mathematical model\">mathematical models</a> "
+      "of conflict and<br>cooperation between intelligent rational "
+      "decision-makers.\"</p></body></html>"));
+
+  // Retrieve the IAccessible interface for the web page.
+  base::win::ScopedComPtr<IAccessible> document(GetRendererAccessible());
+  std::vector<base::win::ScopedVariant> document_children =
+      GetAllAccessibleChildren(document.get());
+  ASSERT_EQ(1u, document_children.size());
+
+  base::win::ScopedComPtr<IAccessible2> paragraph;
+  ASSERT_HRESULT_SUCCEEDED(QueryIAccessible2(
+      GetAccessibleFromVariant(document.get(), document_children[0].AsInput())
+          .get(),
+      paragraph.Receive()));
+  LONG paragraph_role = 0;
+  ASSERT_HRESULT_SUCCEEDED(paragraph->role(&paragraph_role));
+  ASSERT_EQ(IA2_ROLE_PARAGRAPH, paragraph_role);
+  ASSERT_HRESULT_SUCCEEDED(paragraph.QueryInterface(paragraph_text->Receive()));
+}
 
 // Static helpers ------------------------------------------------
 
 base::win::ScopedComPtr<IAccessible>
 AccessibilityWinBrowserTest::GetAccessibleFromVariant(
     IAccessible* parent,
     VARIANT* var) {
   base::win::ScopedComPtr<IAccessible> ptr;
   switch (V_VT(var)) {
     case VT_DISPATCH: {
@@ skipping 67 matching lines @@
           found);
       if (*found)
         return;
     }
   }
 }
 
 // Ensures that the text and the start and end offsets retrieved using
 // get_textAtOffset match the expected values.
 void AccessibilityWinBrowserTest::CheckTextAtOffset(
-    base::win::ScopedComPtr<IAccessibleText>& element,
+    base::win::ScopedComPtr<IAccessibleText>& object,
     LONG offset,
     IA2TextBoundaryType boundary_type,
     LONG expected_start_offset,
     LONG expected_end_offset,
     const std::wstring& expected_text) {
   testing::Message message;
   message << "While checking for \'" << expected_text << "\' at " <<
       expected_start_offset << '-' << expected_end_offset << '.';
   SCOPED_TRACE(message);
 
   LONG start_offset = 0;
   LONG end_offset = 0;
   base::win::ScopedBstr text;
-  HRESULT hr = element->get_textAtOffset(
-      offset, boundary_type,
-      &start_offset, &end_offset, text.Receive());
+  HRESULT hr = object->get_textAtOffset(offset, boundary_type, &start_offset,
+                                        &end_offset, text.Receive());
   EXPECT_EQ(S_OK, hr);
   EXPECT_EQ(expected_start_offset, start_offset);
   EXPECT_EQ(expected_end_offset, end_offset);
   EXPECT_EQ(expected_text, std::wstring(text, text.Length()));
 }
 
 std::vector<base::win::ScopedVariant>
 AccessibilityWinBrowserTest::GetAllAccessibleChildren(
     IAccessible* element) {
   LONG child_count = 0;
@@ skipping 610 matching lines @@
   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());
 }
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
-                       TestSetCaretOffset) {
+                       TestCharacterExtentsWithInvalidArguments) {
+  base::win::ScopedComPtr<IAccessibleText> paragraph_text;
+  SetUpSampleParagraph(&paragraph_text);
+
+  LONG invalid_offset = -3;
+  LONG x = -1, y = -1;
+  LONG width = -1, height = -1;
+
+  HRESULT hr = paragraph_text->get_characterExtents(
+      invalid_offset, IA2_COORDTYPE_SCREEN_RELATIVE, &x, &y, &width, &height);
+  EXPECT_EQ(E_INVALIDARG, hr);
+  EXPECT_EQ(-1, x);
+  EXPECT_EQ(-1, y);
+  EXPECT_EQ(-1, width);
+  EXPECT_EQ(-1, height);
+  hr = paragraph_text->get_characterExtents(
+      invalid_offset, IA2_COORDTYPE_PARENT_RELATIVE, &x, &y, &width, &height);
+  EXPECT_EQ(E_INVALIDARG, hr);
+  EXPECT_EQ(-1, x);
+  EXPECT_EQ(-1, y);
+  EXPECT_EQ(-1, width);
+  EXPECT_EQ(-1, height);
+
+  LONG n_characters;
+  ASSERT_HRESULT_SUCCEEDED(paragraph_text->get_nCharacters(&n_characters));
+  ASSERT_LT(0, n_characters);
+
+  invalid_offset = n_characters + 1;
+  hr = paragraph_text->get_characterExtents(
+      invalid_offset, IA2_COORDTYPE_SCREEN_RELATIVE, &x, &y, &width, &height);
+  EXPECT_EQ(E_INVALIDARG, hr);
+  EXPECT_EQ(-1, x);
+  EXPECT_EQ(-1, y);
+  EXPECT_EQ(-1, width);
+  EXPECT_EQ(-1, height);
+  hr = paragraph_text->get_characterExtents(
+      invalid_offset, IA2_COORDTYPE_PARENT_RELATIVE, &x, &y, &width, &height);
+  EXPECT_EQ(E_INVALIDARG, hr);
+  EXPECT_EQ(-1, x);
+  EXPECT_EQ(-1, y);
+  EXPECT_EQ(-1, width);
+  EXPECT_EQ(-1, height);
+}
+
+IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest, TestCharacterExtents) {
+  base::win::ScopedComPtr<IAccessibleText> paragraph_text;
+  SetUpSampleParagraph(&paragraph_text);
+
+  const LONG newline_offset = 46;
+  LONG n_characters;
+  ASSERT_HRESULT_SUCCEEDED(paragraph_text->get_nCharacters(&n_characters));
+  ASSERT_LT(0, n_characters);
+
+  LONG x, y, width, height;
+  LONG previous_x, previous_y;
+
+  for (int coordinate = IA2_COORDTYPE_SCREEN_RELATIVE;
+       coordinate <= IA2_COORDTYPE_PARENT_RELATIVE; ++coordinate) {
+    auto coordinate_type = static_cast<IA2CoordinateType>(coordinate);
+    EXPECT_HRESULT_SUCCEEDED(paragraph_text->get_characterExtents(
+        0, coordinate_type, &x, &y, &width, &height));
+    EXPECT_LE(0, x) << "at offset 0";
+    EXPECT_LE(0, y) << "at offset 0";
+    EXPECT_LT(0, width) << "at offset 0";
+    EXPECT_LT(0, height) << "at offset 0";
+
+    for (LONG offset = 1; offset < newline_offset; ++offset) {
+      previous_x = x;
+      previous_y = y;
+
+      EXPECT_HRESULT_SUCCEEDED(paragraph_text->get_characterExtents(
+          offset, coordinate_type, &x, &y, &width, &height));
+      EXPECT_LT(previous_x, x) << "at offset " << offset;
+      EXPECT_EQ(previous_y, y) << "at offset " << offset;
+      EXPECT_LT(0, width) << "at offset " << offset;
+      EXPECT_LT(0, height) << "at offset " << offset;
+    }
+
+    EXPECT_HRESULT_SUCCEEDED(paragraph_text->get_characterExtents(
+        newline_offset + 1, coordinate_type, &x, &y, &width, &height));
+    EXPECT_LE(0, x) << "at offset " << newline_offset + 1;
+    EXPECT_GT(previous_x, x) << "at offset " << newline_offset + 1;
+    EXPECT_LT(previous_y, y) << "at offset " << newline_offset + 1;
+    EXPECT_LT(0, width) << "at offset " << newline_offset + 1;
+    EXPECT_LT(0, height) << "at offset " << newline_offset + 1;
+
+    for (LONG offset = newline_offset + 2; offset < n_characters; ++offset) {
+      previous_x = x;
+      previous_y = y;
+
+      EXPECT_HRESULT_SUCCEEDED(paragraph_text->get_characterExtents(
+          offset, coordinate_type, &x, &y, &width, &height));
+      EXPECT_LT(previous_x, x) << "at offset " << offset;
+      EXPECT_EQ(previous_y, y) << "at offset " << offset;
+      EXPECT_LT(0, width) << "at offset " << offset;
+      EXPECT_LT(0, height) << "at offset " << offset;
+    }
+  }
+}
+
+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(), AccessibilityModeComplete,
@@ skipping 25 matching lines @@
   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,
-                       TestTextAtOffsetWithInvalidArgs) {
+                       TestTextAtOffsetWithInvalidArguments) {
   base::win::ScopedComPtr<IAccessibleText> input_text;
   SetUpInputField(&input_text);
   HRESULT hr = input_text->get_textAtOffset(
       0, IA2_TEXT_BOUNDARY_CHAR, NULL, NULL, NULL);
   EXPECT_EQ(E_INVALIDARG, hr);
 
   // Test invalid offset.
   LONG start_offset = 0;
   LONG end_offset = 0;
   base::win::ScopedBstr text;
@@ skipping 72 matching lines @@
   hr = input_text->get_textAtOffset(
       IA2_TEXT_OFFSET_LENGTH, IA2_TEXT_BOUNDARY_ALL,
       &start_offset, &end_offset, text.Receive());
   EXPECT_EQ(S_FALSE, hr);
   EXPECT_EQ(0, start_offset);
   EXPECT_EQ(0, end_offset);
   EXPECT_EQ(nullptr, static_cast<BSTR>(text));
 }
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
-                       TestMultiLineTextAtOffsetWithInvalidArgs) {
+                       TestMultiLineTextAtOffsetWithInvalidArguments) {
   base::win::ScopedComPtr<IAccessibleText> textarea_text;
   SetUpTextareaField(&textarea_text);
   HRESULT hr = textarea_text->get_textAtOffset(
       0, IA2_TEXT_BOUNDARY_CHAR, NULL, NULL, NULL);
   EXPECT_EQ(E_INVALIDARG, hr);
 
   // Test invalid offset.
   LONG start_offset = 0;
   LONG end_offset = 0;
   base::win::ScopedBstr text;
@@ skipping 264 matching lines @@
       40, CONTENTS_LENGTH, L"like\".");
   CheckTextAtOffset(textarea_text, 45, IA2_TEXT_BOUNDARY_WORD,
       40, CONTENTS_LENGTH, L"like\".");
 
   // Test special offsets.
   CheckTextAtOffset(textarea_text, IA2_TEXT_OFFSET_CARET,
       IA2_TEXT_BOUNDARY_WORD, 40, CONTENTS_LENGTH, L"like\".");
 }
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
+                       TestStaticTextAtOffsetWithBoundaryWord) {
+  base::win::ScopedComPtr<IAccessibleText> paragraph_text;
+  SetUpSampleParagraph(&paragraph_text);
+  base::string16 embedded_character(
+      1, BrowserAccessibilityWin::kEmbeddedCharacter);
+  std::vector<std::wstring> words;
+  words.push_back(L"Game ");
+  words.push_back(L"theory ");
+  words.push_back(L"is \"");
+  words.push_back(L"the ");
+  words.push_back(L"study ");
+  words.push_back(L"of " + embedded_character + L' ');
+  words.push_back(L"of ");
+  words.push_back(L"conflict ");
+  words.push_back(L"and\n");
+  words.push_back(L"cooperation ");
+  words.push_back(L"between ");
+  words.push_back(L"intelligent ");
+  words.push_back(L"rational ");
+  words.push_back(L"decision-");
+  words.push_back(L"makers.\"");
+
+  // Try to retrieve one word after another.
+  LONG word_start_offset = 0;
+  for (auto& word : words) {
+    LONG word_end_offset = word_start_offset + word.size();
+    CheckTextAtOffset(paragraph_text, word_start_offset, IA2_TEXT_BOUNDARY_WORD,
+                      word_start_offset, word_end_offset, word);
+    word_start_offset = word_end_offset;
+  }
+}
+
+IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
                        TestTextAtOffsetWithBoundarySentence) {
   base::win::ScopedComPtr<IAccessibleText> input_text;
   SetUpInputField(&input_text);
 
   // Sentence navigation is not currently implemented.
   LONG start_offset = 0;
   LONG end_offset = 0;
   base::win::ScopedBstr text;
   HRESULT hr = input_text->get_textAtOffset(
       5, IA2_TEXT_BOUNDARY_SENTENCE,
@@ skipping 71 matching lines @@
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
                        TestMultiLineTextAtOffsetWithBoundaryAll) {
   base::win::ScopedComPtr<IAccessibleText> textarea_text;
   SetUpTextareaField(&textarea_text);
 
   CheckTextAtOffset(textarea_text, CONTENTS_LENGTH - 1, IA2_TEXT_BOUNDARY_ALL,
       0, CONTENTS_LENGTH, base::SysUTF8ToWide(TEXTAREA_CONTENTS));
 }
 
 }  // namespace content