Switched to using |AXPosition| for calculating word and line boundaries on Windows.

content/browser/accessibility/browser_accessibility_win.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 "content/browser/accessibility/browser_accessibility_win.h"
 
 #include <UIAutomationClient.h>
 #include <UIAutomationCoreApi.h>
 
 #include <algorithm>
@@ skipping 2468 matching lines @@
     BSTR* text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TEXT_AT_OFFSET);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
   if (!instance_active())
     return E_FAIL;
 
   if (!start_offset || !end_offset || !text)
     return E_INVALIDARG;
 
-  const base::string16& text_str = GetText();
   HandleSpecialTextOffset(&offset);
   if (offset < 0)
     return E_INVALIDARG;
 
+  const base::string16& text_str = 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;
@@ skipping 1378 matching lines @@
       start_offset += child->GetText().length();
     else
       start_offset += 1;
   }
 
   win_attributes_->offset_to_text_attributes.swap(attributes_map);
 }
 
 // |offset| could either be a text character or a child index in case of
 // non-text objects.
+// TODO(nektar): Remove this function once selection bugs are fixed in Blink.
 BrowserAccessibilityWin::AXPlatformPositionInstance
-BrowserAccessibilityWin::CreatePositionAt(int offset) const {
+BrowserAccessibilityWin::CreatePositionForSelectionAt(int offset) const {
   if (!IsNativeTextControl() && !IsTextOnlyObject()) {
     DCHECK(manager_);
     const BrowserAccessibilityWin* child = this;
     // TODO(nektar): Make parents of text-only objects not include the text of
     // children in their hypertext.
     for (size_t i = 0; i < InternalChildCount(); ++i) {
       int new_offset = offset;
       child = ToBrowserAccessibilityWin(InternalGetChild(i));
       DCHECK(child);
       if (child->IsTextOnlyObject()) {
         new_offset -= child->GetText().length();
       } else {
         new_offset -= 1;
       }
       if (new_offset <= 0)
         break;
       offset = new_offset;
     }
     AXPlatformPositionInstance position =
         AXPlatformPosition::CreateTextPosition(manager_->ax_tree_id(),
                                                child->GetId(), offset,
                                                ui::AX_TEXT_AFFINITY_DOWNSTREAM)
             ->AsLeafTextPosition();
     if (position->GetAnchor() &&
         position->GetAnchor()->GetRole() == ui::AX_ROLE_INLINE_TEXT_BOX) {
       return position->CreateParentPosition();
     }
     return position;
   }
-  return BrowserAccessibility::CreatePositionAt(offset);
+  return CreatePositionAt(offset);
 }
 
 base::string16 BrowserAccessibilityWin::GetText() const {
   if (PlatformIsChildOfLeaf())
     return BrowserAccessibility::GetText();
   return win_attributes_->hypertext;
 }
 
 //
 // Private methods.
@@ skipping 636 matching lines @@
   base::ReplaceChars(*output, L",", L"\\,", output);
   base::ReplaceChars(*output, L"=", L"\\=", output);
   base::ReplaceChars(*output, L";", L"\\;", output);
 }
 
 void BrowserAccessibilityWin::SetIA2HypertextSelection(LONG start_offset,
                                                        LONG end_offset) {
   HandleSpecialTextOffset(&start_offset);
   HandleSpecialTextOffset(&end_offset);
   AXPlatformPositionInstance start_position =
-      CreatePositionAt(static_cast<int>(start_offset));
+      CreatePositionForSelectionAt(static_cast<int>(start_offset));
   AXPlatformPositionInstance end_position =
-      CreatePositionAt(static_cast<int>(end_offset));
+      CreatePositionForSelectionAt(static_cast<int>(end_offset));
   manager_->SetSelection(AXPlatformRange(start_position->AsTextPosition(),
                                          end_position->AsTextPosition()));
 }
 
 void BrowserAccessibilityWin::StringAttributeToIA2(
     ui::AXStringAttribute attribute,
     const char* ia2_attr) {
   base::string16 value;
   if (GetString16Attribute(attribute, &value)) {
     SanitizeStringAttributeForIA2(value, &value);
@@ skipping 387 matching lines @@
     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;
 
   HandleSpecialTextOffset(&start_offset);
-  if (ia2_boundary == IA2_TEXT_BOUNDARY_WORD)
-    return GetWordStartBoundary(static_cast<int>(start_offset), direction);
-  if (ia2_boundary == IA2_TEXT_BOUNDARY_LINE) {
-    return GetLineStartBoundary(
-        static_cast<int>(start_offset), direction, affinity);
+  if (ia2_boundary == IA2_TEXT_BOUNDARY_WORD) {
+    switch (direction) {
+      case ui::FORWARDS_DIRECTION: {
+        AXPlatformPositionInstance position =
+            CreatePositionAt(static_cast<int>(start_offset), affinity);
+        AXPlatformPositionInstance next_word =
+            position->CreateNextWordStartPosition();
+        if (next_word->IsNullPosition())
+          next_word = position->CreatePositionAtEndOfAnchor();
+        return next_word->text_offset();
+      }
+      case ui::BACKWARDS_DIRECTION: {
+        AXPlatformPositionInstance position =
+            CreatePositionAt(static_cast<int>(start_offset), affinity);
+        AXPlatformPositionInstance previous_word;
+        if (!position->AtStartOfWord()) {
+          previous_word = position->CreatePreviousWordStartPosition();

[dmazzoni, 2017/04/10 22:39:49]

Just curious, should CreatePreviousWordStartPosition and
CreateNextWordStartPosition always return the start or end of anchor if there's
no previous or next word?

I'm just thinking that might be better default behavior. But if another platform
needs this current behavior that's fine.

+          if (previous_word->IsNullPosition())
+            previous_word = position->CreatePositionAtStartOfAnchor();
+        } else {
+          previous_word = std::move(position);
+        }
+        return previous_word->text_offset();
+      }
+    }

[dmazzoni, 2017/04/10 22:39:49]

Maybe add a NOTREACHED() after the switch since there shouldn't be
anything other than FORWARDS or BACKWARDS

   }
 
+  if (ia2_boundary == IA2_TEXT_BOUNDARY_LINE) {
+    switch (direction) {
+      case ui::FORWARDS_DIRECTION: {
+        AXPlatformPositionInstance position =
+            CreatePositionAt(static_cast<int>(start_offset), affinity);
+        AXPlatformPositionInstance next_line =
+            position->CreateNextLineStartPosition();
+        if (next_line->IsNullPosition())
+          next_line = position->CreatePositionAtEndOfAnchor();
+        return next_line->text_offset();
+      }
+      case ui::BACKWARDS_DIRECTION: {
+        AXPlatformPositionInstance position =
+            CreatePositionAt(static_cast<int>(start_offset), affinity);
+        AXPlatformPositionInstance previous_line;
+        if (!position->AtStartOfLine()) {
+          previous_line = position->CreatePreviousLineStartPosition();
+          if (previous_line->IsNullPosition())
+            previous_line = position->CreatePositionAtStartOfAnchor();
+        } else {
+          previous_line = std::move(position);
+        }
+        return previous_line->text_offset();
+      }
+    }

[dmazzoni, 2017/04/10 22:39:49]

NOTREACHED

+  }
+
+  // TODO(nektar): |AXPosition| can handle other types of boundaries as well.
   ui::TextBoundaryType boundary = IA2TextBoundaryToTextBoundary(ia2_boundary);
   return ui::FindAccessibleTextBoundary(text, GetLineStartOffsets(), boundary,
                                         start_offset, direction, affinity);
 }
 
 LONG BrowserAccessibilityWin::FindStartOfStyle(
     LONG start_offset,
     ui::TextBoundaryDirection direction) const {
   LONG text_length = static_cast<LONG>(GetText().length());
   DCHECK_GE(start_offset, 0);
@@ skipping 826 matching lines @@
   return static_cast<BrowserAccessibilityWin*>(obj);
 }
 
 const BrowserAccessibilityWin*
 ToBrowserAccessibilityWin(const BrowserAccessibility* obj) {
   DCHECK(!obj || obj->IsNative());
   return static_cast<const BrowserAccessibilityWin*>(obj);
 }
 
 }  // namespace content