Fixed a bug that assumed that static text object span only one line

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 @@
     value = GetInnerText();
   return value;
 }
 
 int BrowserAccessibility::GetLineStartBoundary(
     int start,
     ui::TextBoundaryDirection direction) 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);
-  }
+  // Standard text fields such as textarea have an embedded div inside them that
+  // holds all the text.
+  if (IsSimpleTextControl() && InternalChildCount() == 1)

[dmazzoni, 2016/05/05 18:35:04]

Why doesn't it work if you just delete this if statement entirely? It seems like
this logic below should work for any container element by recursing until it
finds the first inline text box descendant.

+    return InternalGetChild(0)->GetLineStartBoundary(start, direction);
 
   // 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());
     line_length += child_length;
-    start -= child_length;
 
-    // Stop when we reach both the object containing our start offset and the
-    // end of the line on which this object is located.
-    if (start < 0 && !child->IsNextSiblingOnSameLine())
+    // Stop when we reach both the child containing our start offset and the
+    // child that is at the end of the line on which this object is located.
+    if (start < child_length && !child->IsNextSiblingOnSameLine()) {
+      // Recurse into the inline text boxes.
+      if (child->GetRole() == ui::AX_ROLE_STATIC_TEXT)
+        return line_start + child->GetLineStartBoundary(start, direction);
+
+      // There are no inline text boxes to look at.
       break;
+    }
 
     if (!child->IsNextSiblingOnSameLine()) {
       line_start += line_length;
       line_length = 0;
     }
+    start -= child_length;
   }
 
-  int result = 0;
   switch (direction) {
     case ui::FORWARDS_DIRECTION:
-      result = line_start + line_length;
-      break;
+      return line_start + line_length;
     case ui::BACKWARDS_DIRECTION:
-      result = line_start;
-      break;
-    default:
-      NOTREACHED();
+      return line_start;
   }
-  return result;
+  NOTREACHED();
+  return 0;
 }
 
 int BrowserAccessibility::GetWordStartBoundary(
     int start, ui::TextBoundaryDirection direction) const {
   DCHECK_GE(start, -1);
   // Special offset that indicates that a word boundary has not been found.
   int word_start_not_found = static_cast<int>(GetText().size());
   int word_start = word_start_not_found;
 
   switch (GetRole()) {
@@ skipping 589 matching lines @@
       break;
 
     manager = root->GetParent()->manager();
     root = manager->GetRoot();
   }
 
   return bounds;
 }
 
 }  // namespace content