Use text affinity to return correct accessible line boundaries.

content/browser/accessibility/browser_accessibility.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.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 503 matching lines @@
   // Some screen readers like Jaws and older versions of VoiceOver require a
   // value to be set in text fields with rich content, even though the same
   // information is available on the children.
   if (value.empty() && (IsSimpleTextControl() || IsRichTextControl()))
     value = GetInnerText();
   return value;
 }
 
 int BrowserAccessibility::GetLineStartBoundary(
     int start,
-    ui::TextBoundaryDirection direction) const {
+    ui::TextBoundaryDirection direction,
+    ui::AXTextAffinity affinity) const {
   DCHECK_GE(start, 0);
   DCHECK_LE(start, static_cast<int>(GetText().length()));
 
   if (IsSimpleTextControl()) {
     const std::vector<int32_t>& line_breaks =
         GetIntListAttribute(ui::AX_ATTR_LINE_BREAKS);
     return ui::FindAccessibleTextBoundary(GetText(), line_breaks,
-                                          ui::LINE_BOUNDARY, start, direction);
+                                          ui::LINE_BOUNDARY, start, direction,
+                                          affinity);
   }
 
   // Keeps track of the start offset of each consecutive line.
   int line_start = 0;
   // Keeps track of the length of each consecutive line.
   int line_length = 0;
   for (size_t i = 0; i < InternalChildCount(); ++i) {
     const BrowserAccessibility* child = InternalGetChild(i);
     DCHECK(child);
     // Child objects are of length one, since they are represented by a
     // single embedded object character. The exception is text-only objects.
     int child_length = 1;
     if (child->IsTextOnlyObject())
       child_length = static_cast<int>(child->GetText().length());
 
+    // Determine if |start| is within this child. As a special case, if
+    // the affinity is upstream, then the cursor position between two
+    // lines belongs to the previous line.
+    bool start_index_within_child = start < child_length;
+    if (start == child_length &&
+        !child->IsNextSiblingOnSameLine() &&
+        affinity == ui::AX_TEXT_AFFINITY_UPSTREAM) {
+      start_index_within_child = true;
+    }
+
     // Stop when we reach both the child containing our start offset and, in
     // case we are searching forward, the child that is at the end of the line
     // on which this object is located.
-    if (start < child_length && (direction == ui::BACKWARDS_DIRECTION ||
-                                 !child->IsNextSiblingOnSameLine())) {
+    if (start_index_within_child && (direction == ui::BACKWARDS_DIRECTION ||
+                                     !child->IsNextSiblingOnSameLine())) {
       // Recurse into the inline text boxes.
       if (child->GetRole() == ui::AX_ROLE_STATIC_TEXT) {
         switch (direction) {
           case ui::FORWARDS_DIRECTION:
-            line_length +=
-                child->GetLineStartBoundary(std::max(start, 0), direction);
+            line_length += child->GetLineStartBoundary(
+                std::max(start, 0), direction, affinity);
             break;
           case ui::BACKWARDS_DIRECTION:
-            line_start +=
-                child->GetLineStartBoundary(std::max(start, 0), direction);
+            line_start += child->GetLineStartBoundary(
+                std::max(start, 0), direction, affinity);
             break;
         }
       } else {
         line_length += child_length;
       }
 
       break;
     }
     line_length += child_length;
 
@@ skipping 631 matching lines @@
       break;
 
     manager = root->GetParent()->manager();
     root = manager->GetRoot();
   }
 
   return bounds;
 }
 
 }  // namespace content