Fixed bugs with finding line boundaries using IA2 get_textAtOffset and AXPosition::AtStartOfLine.

content/browser/accessibility/browser_accessibility_com_win.cc

 // Copyright (c) 2017 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 "content/browser/accessibility/browser_accessibility_com_win.h"
 
 #include <UIAutomationClient.h>
 #include <UIAutomationCoreApi.h>
 
 #include <algorithm>
@@ skipping 2261 matching lines @@
     BSTR* text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TEXT_AT_OFFSET);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
   if (!owner())
     return E_FAIL;
 
   if (!start_offset || !end_offset || !text)
     return E_INVALIDARG;
 
+  *start_offset = 0;
+  *end_offset = 0;
+  *text = nullptr;
+
   HandleSpecialTextOffset(&offset);
   if (offset < 0)
     return E_INVALIDARG;
 
   const base::string16& text_str = owner()->GetText();
   LONG text_len = text_str.length();
   if (offset > text_len)
     return E_INVALIDARG;
 
   // The IAccessible2 spec says we don't have to implement the "sentence"
   // boundary type, we can just let the screenreader handle it.
-  if (boundary_type == IA2_TEXT_BOUNDARY_SENTENCE) {
-    *start_offset = 0;
-    *end_offset = 0;
-    *text = NULL;
+  if (boundary_type == IA2_TEXT_BOUNDARY_SENTENCE)
     return S_FALSE;
-  }
 
   // According to the IA2 Spec, only line boundaries should succeed when
   // the offset is one past the end of the text.
-  if (offset == text_len) {
-    if (boundary_type == IA2_TEXT_BOUNDARY_LINE) {
-      --offset;
-    } else {
-      *start_offset = 0;
-      *end_offset = 0;
-      *text = nullptr;
-      return S_FALSE;
-    }
-  }
+  if (offset == text_len && boundary_type != IA2_TEXT_BOUNDARY_LINE)
+    return S_FALSE;
 
-  *start_offset =
-      FindBoundary(text_str, boundary_type, offset, ui::BACKWARDS_DIRECTION);
-  *end_offset =
-      FindBoundary(text_str, boundary_type, offset, ui::FORWARDS_DIRECTION);
-  return get_text(*start_offset, *end_offset, text);
+  LONG start = FindBoundary(boundary_type, offset, ui::BACKWARDS_DIRECTION);
+  LONG end = FindBoundary(boundary_type, start, ui::FORWARDS_DIRECTION);
+  if (end < offset)
+    return S_FALSE;
+
+  *start_offset = start;
+  *end_offset = end;
+  return get_text(start, end, text);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_textBeforeOffset(
     LONG offset,
     IA2TextBoundaryType boundary_type,
     LONG* start_offset,
     LONG* end_offset,
     BSTR* text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TEXT_BEFORE_OFFSET);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
   if (!owner())
     return E_FAIL;
 
   if (!start_offset || !end_offset || !text)
     return E_INVALIDARG;
 
+  *start_offset = 0;
+  *end_offset = 0;
+  *text = NULL;
+
+  const base::string16& text_str = owner()->GetText();
+  LONG text_len = text_str.length();
+  if (offset > text_len)
+    return E_INVALIDARG;
+
   // The IAccessible2 spec says we don't have to implement the "sentence"
   // boundary type, we can just let the screenreader handle it.
-  if (boundary_type == IA2_TEXT_BOUNDARY_SENTENCE) {
-    *start_offset = 0;
-    *end_offset = 0;
-    *text = NULL;
+  if (boundary_type == IA2_TEXT_BOUNDARY_SENTENCE)
     return S_FALSE;
-  }
 
-  const base::string16& text_str = owner()->GetText();
-
-  *start_offset =
-      FindBoundary(text_str, boundary_type, offset, ui::BACKWARDS_DIRECTION);
+  *start_offset = FindBoundary(boundary_type, offset, ui::BACKWARDS_DIRECTION);
   *end_offset = offset;
   return get_text(*start_offset, *end_offset, text);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_textAfterOffset(
     LONG offset,
     IA2TextBoundaryType boundary_type,
     LONG* start_offset,
     LONG* end_offset,
     BSTR* text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TEXT_AFTER_OFFSET);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
   if (!owner())
     return E_FAIL;
 
   if (!start_offset || !end_offset || !text)
     return E_INVALIDARG;
 
+  *start_offset = 0;
+  *end_offset = 0;
+  *text = NULL;
+
+  const base::string16& text_str = owner()->GetText();
+  LONG text_len = text_str.length();
+  if (offset > text_len)
+    return E_INVALIDARG;
+
   // The IAccessible2 spec says we don't have to implement the "sentence"
   // boundary type, we can just let the screenreader handle it.
-  if (boundary_type == IA2_TEXT_BOUNDARY_SENTENCE) {
-    *start_offset = 0;
-    *end_offset = 0;
-    *text = NULL;
+  if (boundary_type == IA2_TEXT_BOUNDARY_SENTENCE)
     return S_FALSE;
-  }
-
-  const base::string16& text_str = owner()->GetText();
 
   *start_offset = offset;
-  *end_offset =
-      FindBoundary(text_str, boundary_type, offset, ui::FORWARDS_DIRECTION);
+  *end_offset = FindBoundary(boundary_type, offset, ui::FORWARDS_DIRECTION);
   return get_text(*start_offset, *end_offset, text);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_newText(IA2TextSegment* new_text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_NEW_TEXT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
   if (!new_text)
@@ skipping 2399 matching lines @@
     case IA2_TEXT_BOUNDARY_PARAGRAPH:
       return ui::PARAGRAPH_BOUNDARY;
     case IA2_TEXT_BOUNDARY_ALL:
       return ui::ALL_BOUNDARY;
   }
   NOTREACHED();
   return ui::CHAR_BOUNDARY;
 }
 
 LONG BrowserAccessibilityComWin::FindBoundary(
-    const base::string16& text,
     IA2TextBoundaryType ia2_boundary,
     LONG start_offset,
     ui::TextBoundaryDirection direction) {
   // If the boundary is relative to the caret, use the selection
   // affinity, otherwise default to downstream affinity.
   ui::AXTextAffinity affinity =
       start_offset == IA2_TEXT_OFFSET_CARET
           ? Manager()->GetTreeData().sel_focus_affinity
           : ui::AX_TEXT_AFFINITY_DOWNSTREAM;
 
@@ skipping 47 matching lines @@
         } else {
           previous_line = std::move(position);
         }
         return previous_line->text_offset();
       }
     }
   }
 
   // TODO(nektar): |AXPosition| can handle other types of boundaries as well.
   ui::TextBoundaryType boundary = IA2TextBoundaryToTextBoundary(ia2_boundary);
-  return ui::FindAccessibleTextBoundary(text, owner()->GetLineStartOffsets(),
-                                        boundary, start_offset, direction,
-                                        affinity);
+  return ui::FindAccessibleTextBoundary(
+      owner()->GetText(), owner()->GetLineStartOffsets(), boundary,
+      start_offset, direction, affinity);
 }
 
 LONG BrowserAccessibilityComWin::FindStartOfStyle(
     LONG start_offset,
     ui::TextBoundaryDirection direction) const {
   LONG text_length = static_cast<LONG>(owner()->GetText().length());
   DCHECK_GE(start_offset, 0);
   DCHECK_LE(start_offset, text_length);
 
   switch (direction) {
@@ skipping 836 matching lines @@
 
 BrowserAccessibilityComWin* ToBrowserAccessibilityComWin(
     BrowserAccessibility* obj) {
   if (!obj || !obj->IsNative())
     return nullptr;
   auto* result = static_cast<BrowserAccessibilityWin*>(obj)->GetCOM();
   return result;
 }
 
 }  // namespace content