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 358 matching lines @@
   return bounds;
 }
 
 gfx::Rect BrowserAccessibility::GetLocalBoundsForRange(int start, int len)
     const {
   DCHECK_GE(start, 0);
   DCHECK_GE(len, 0);
 
   // Standard text fields such as textarea have an embedded div inside them that
   // holds all the text.
+  // TODO(nektar): This is fragile! Replace with code that flattens tree.
   if (IsSimpleTextControl() && InternalChildCount() == 1)
     return InternalGetChild(0)->GetLocalBoundsForRange(start, len);
 
   if (GetRole() != ui::AX_ROLE_STATIC_TEXT) {
     gfx::Rect bounds;
     for (size_t i = 0; i < InternalChildCount() && len > 0; ++i) {
       BrowserAccessibility* child = 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_length_in_parent = 1;
@@ skipping 144 matching lines @@
   // 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());
+
+    // 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())) {
+      // 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);
+            break;
+          case ui::BACKWARDS_DIRECTION:
+            line_start +=
+                child->GetLineStartBoundary(std::max(start, 0), direction);
+            break;
+        }
+      } else {
+        line_length += child_length;
+      }
+
+      break;
+    }
     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())
-      break;
 
     if (!child->IsNextSiblingOnSameLine()) {
+      // We are on a new line.
       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 57 matching lines @@
 
     default:
       // If there are no children, the word start boundary is still unknown or
       // found previously depending on the direction.
       if (!InternalChildCount())
         return word_start_not_found;
 
       const BrowserAccessibility* this_object = this;
       // Standard text fields such as textarea have an embedded div inside them
       // that should be skipped.
+      // TODO(nektar): This is fragile. Replace with code that flattens tree.
       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()) {
@@ skipping 512 matching lines @@
       break;
 
     manager = root->GetParent()->manager();
     root = manager->GetRoot();
   }
 
   return bounds;
 }
 
 }  // namespace content