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 2244 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 620 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->anchor_id() != GetId())
+          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();
+          if (previous_word->anchor_id() != GetId())
+            previous_word = position->CreatePositionAtStartOfAnchor();
+        } else {
+          previous_word = std::move(position);
+        }
+        return previous_word->text_offset();
+      }
+    }
   }
 
+  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->anchor_id() != GetId())
+          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->anchor_id() != GetId())
+            previous_line = position->CreatePositionAtStartOfAnchor();
+        } 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, 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 834 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