Correctly finds line boundaries in objects with rich text on Windows.

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 168 matching lines @@
   if (GetParent() &&
       GetIndexInParent() >= 0 &&
       GetIndexInParent() < static_cast<int>(
           GetParent()->InternalChildCount() - 1)) {
     return GetParent()->InternalGetChild(GetIndexInParent() + 1);
   }
 
   return nullptr;
 }
 
+bool BrowserAccessibility::IsPreviousSiblingOnSameLine() const {
+  const BrowserAccessibility* previous_sibling = GetPreviousSibling();
+  if (!previous_sibling)
+    return false;
+
+  int32_t previous_on_line_id;
+  if (GetIntAttribute(ui::AX_ATTR_PREVIOUS_ON_LINE_ID, &previous_on_line_id)) {
+    const BrowserAccessibility* previous_on_line =
+        manager()->GetFromID(previous_on_line_id);
+    // In the case of static text objects, the object designated to be the
+    // previous object on this line might be a child of the previous sibling,
+    // i.e. the last inline text box of the previous static text object.
+    return previous_on_line &&
+           previous_on_line->IsDescendantOf(previous_sibling);
+  }
+  return false;
+}
+
+bool BrowserAccessibility::IsNextSiblingOnSameLine() const {
+  const BrowserAccessibility* next_sibling = GetNextSibling();
+  if (!next_sibling)
+    return false;
+
+  int32_t next_on_line_id;
+  if (GetIntAttribute(ui::AX_ATTR_NEXT_ON_LINE_ID, &next_on_line_id)) {
+    const BrowserAccessibility* next_on_line =
+        manager()->GetFromID(next_on_line_id);
+    // In the case of static text objects, the object designated to be the next
+    // object on this line might be a child of the next sibling, i.e. the first
+    // inline text box of the next static text object.
+    return next_on_line && next_on_line->IsDescendantOf(next_sibling);
+  }
+  return false;
+}
+
 BrowserAccessibility* BrowserAccessibility::PlatformDeepestFirstChild() const {
   if (!PlatformChildCount())
     return nullptr;
 
   BrowserAccessibility* deepest_child = PlatformGetChild(0);
   while (deepest_child->PlatformChildCount())
     deepest_child = deepest_child->PlatformGetChild(0);
 
   return deepest_child;
 }
@@ skipping 262 matching lines @@
 base::string16 BrowserAccessibility::GetValue() const {
   base::string16 value = GetString16Attribute(ui::AX_ATTR_VALUE);
   // 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 {
+  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);
+  }
+
+  // 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 && !IsNextSiblingOnSameLine())
+      break;
+
+    if (!IsNextSiblingOnSameLine()) {
+      line_start += line_length;
+      line_length = 0;
+    }
+  }
+
+  switch (direction) {
+    case ui::FORWARDS_DIRECTION:
+      return line_start + line_length;
+    case ui::BACKWARDS_DIRECTION:
+      return line_start;
+    default:
+      NOTREACHED();
+  }
+  return static_cast<int>(GetText().length());
+  ;

[dmazzoni, 2016/04/22 15:34:49]

nit: extra semicolon?

+}
+
 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()) {
     case ui::AX_ROLE_STATIC_TEXT: {
       int prev_word_start = word_start_not_found;
       int child_start = 0;
       int child_end = 0;
 
       // Go through the inline text boxes.
       for (size_t i = 0; i < InternalChildCount(); ++i) {
         // The next child starts where the previous one ended.
         child_start = child_end;
-        BrowserAccessibility* child = InternalGetChild(i);
+        const BrowserAccessibility* child = InternalGetChild(i);
         DCHECK_EQ(child->GetRole(), ui::AX_ROLE_INLINE_TEXT_BOX);
         int child_len = static_cast<int>(child->GetText().size());
         child_end += child_len; // End is one past the last character.
 
         const std::vector<int32_t>& word_starts =
             child->GetIntListAttribute(ui::AX_ATTR_WORD_STARTS);
         if (word_starts.empty()) {
           word_start = child_end;
           continue;
         }
@@ skipping 47 matching lines @@
       if (IsSimpleTextControl() && InternalChildCount() == 1) {
         this_object = InternalGetChild(0);
       }
       int child_start = 0;
       for (size_t i = 0; i < this_object->InternalChildCount(); ++i) {
         BrowserAccessibility* child = this_object->InternalGetChild(i);
         // Child objects are of length one, since they are represented by a
         // single embedded object character. The exception is text-only objects.
         int child_len = 1;
         if (child->IsTextOnlyObject()) {
-          child_len = static_cast<int>(child->GetText().size());
+          child_len = static_cast<int>(child->GetText().length());
           int child_word_start = child->GetWordStartBoundary(start, direction);
           if (child_word_start < child_len) {
             // We have found a possible word boundary.
             word_start = child_start + child_word_start;
           }
 
           // Decide when to stop searching.
           if ((word_start != word_start_not_found &&
                direction == ui::FORWARDS_DIRECTION) ||
               (start < child_len && direction == ui::BACKWARDS_DIRECTION)) {
@@ skipping 498 matching lines @@
       break;
 
     manager = root->GetParent()->manager();
     root = manager->GetRoot();
   }
 
   return bounds;
 }
 
 }  // namespace content