Fixed algorithms that compute bounding rectangles and word start offsets to take into account IA2 h…

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 86 matching lines @@
   return false;
 }
 
 bool BrowserAccessibility::IsTextOnlyObject() const {
   return GetRole() == ui::AX_ROLE_STATIC_TEXT ||
       GetRole() == ui::AX_ROLE_LINE_BREAK;
 }
 
 BrowserAccessibility* BrowserAccessibility::PlatformGetChild(
     uint32_t child_index) const {
-  DCHECK(child_index < PlatformChildCount());
+  DCHECK_LT(child_index, PlatformChildCount());
   BrowserAccessibility* result = nullptr;
 
   if (HasIntAttribute(ui::AX_ATTR_CHILD_TREE_ID)) {
     BrowserAccessibilityManager* child_manager =
         BrowserAccessibilityManager::FromID(
             GetIntAttribute(ui::AX_ATTR_CHILD_TREE_ID));
     if (child_manager)
       result = child_manager->GetRoot();
   } else {
     result = InternalGetChild(child_index);
@@ skipping 135 matching lines @@
 
   // Adjust the bounds by the top left corner of the containing view's bounds
   // in screen coordinates.
   bounds.Offset(manager_->GetViewBounds().OffsetFromOrigin());
 
   return bounds;
 }
 
 gfx::Rect BrowserAccessibility::GetLocalBoundsForRange(int start, int len)
     const {
+  // Standard text fields such as textarea have an embedded div inside them that
+  // holds all the text.
+  if (IsSimpleTextControl() && InternalChildCount() == 1)
+    return InternalGetChild(0)->GetLocalBoundsForRange(start, len);
+
   if (GetRole() != ui::AX_ROLE_STATIC_TEXT) {
-    // Apply recursively to all static text descendants. For example, if
-    // you call it on a div with two text node children, it just calls
-    // GetLocalBoundsForRange on each of the two children (adjusting
-    // |start| for each one) and unions the resulting rects.
     gfx::Rect bounds;
-    for (size_t i = 0; i < InternalChildCount(); ++i) {
+    for (size_t i = 0; i < InternalChildCount() && start >= 0; ++i) {
       BrowserAccessibility* child = InternalGetChild(i);
-      int child_len = child->GetInnerTextLength();
-      if (start < child_len && start + len > 0) {
-        gfx::Rect child_rect = child->GetLocalBoundsForRange(start, len);
+      // Child objects are of length one, since they are represented by a single
+      // special character. The exception is text-only objects.
+      int child_length_in_parent = 1;
+      if (child->IsTextOnlyObject())
+        child_length_in_parent = static_cast<int>(child->GetText().size());
+      if (start < child_length_in_parent) {
+        gfx::Rect child_rect;
+        if (child->IsTextOnlyObject())
+          child_rect = child->GetLocalBoundsForRange(start, len);
+        else
+          child_rect = child->GetLocalBoundsForRange(
+              start, static_cast<int>(child->GetText().size()));
         bounds.Union(child_rect);
+        len -= child_length_in_parent;
       }
-      start -= child_len;
+      start -= child_length_in_parent;
     }
     return ElementBoundsToLocalBounds(bounds);
   }
 
   int end = start + len;
   int child_start = 0;
   int child_end = 0;
 
   gfx::Rect bounds;
   for (size_t i = 0; i < InternalChildCount() && child_end < start + len; ++i) {
     BrowserAccessibility* child = InternalGetChild(i);
     if (child->GetRole() != ui::AX_ROLE_INLINE_TEXT_BOX) {
       DLOG(WARNING) << "BrowserAccessibility objects with role STATIC_TEXT " <<
           "should have children of role INLINE_TEXT_BOX.";
       continue;
     }
 
-    std::string child_text;
-    child->GetStringAttribute(ui::AX_ATTR_NAME, &child_text);
-    int child_len = static_cast<int>(child_text.size());
+    int child_len = static_cast<int>(GetText().size());
     child_start = child_end;
     child_end += child_len;
 
     if (child_end < start)
       continue;
 
     int overlap_start = std::max(start, child_start);
     int overlap_end = std::min(end, child_end);
 
     int local_start = overlap_start - child_start;
@@ skipping 68 matching lines @@
   base::string16 value = GetString16Attribute(ui::AX_ATTR_VALUE);
   if (value.empty() && IsSimpleTextControl())
     value = GetInnerText();
   return value;
 }
 
 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 = GetInnerTextLength();
+  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);
         DCHECK_EQ(child->GetRole(), ui::AX_ROLE_INLINE_TEXT_BOX);
-        const std::string& child_text = child->GetStringAttribute(
-            ui::AX_ATTR_NAME);
-        int child_len = static_cast<int>(child_text.size());
+        int child_len = static_cast<int>(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;
         }
 
         int local_start = start - child_start;
@@ skipping 32 matching lines @@
     case ui::AX_ROLE_LINE_BREAK:
       // Words never start at a line break.
       return word_start_not_found;
 
     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.
+      if (IsSimpleTextControl() && InternalChildCount() == 1) {
+        this_object = InternalGetChild(0);
+      }
       int child_start = 0;
-      for (size_t i = 0; i < InternalChildCount(); ++i) {
-        BrowserAccessibility* child = InternalGetChild(i);
-        int child_len = child->GetInnerTextLength();
-        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;
-        }
+      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 special character. The exception is text-only objects.
+        int child_len = 1;
+        if (child->IsTextOnlyObject()) {
+          child_len = static_cast<int>(child->GetText().size());
+          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)) {
-          break;
+          // Decide when to stop searching.
+          if ((word_start != word_start_not_found &&
+               direction == ui::FORWARDS_DIRECTION) ||
+              (start < child_len && direction == ui::BACKWARDS_DIRECTION)) {
+            break;
+          }
         }
 
         child_start += child_len;
         if (start >= child_len)
           start -= child_len;
         else
           start = -1;
       }
       return word_start;
   }
@@ skipping 168 matching lines @@
   }
 
   *is_defined = true;
 
   if (base::EqualsASCII(value, "true"))
     return true;
 
   if (base::EqualsASCII(value, "mixed"))
     *is_mixed = true;
 
-  return false;  // Not set
+  return false;  // Not set.
+}
+
+base::string16 BrowserAccessibility::GetText() const {
+  return GetInnerText();
 }
 
 bool BrowserAccessibility::HasState(ui::AXState state_enum) const {
   return (GetState() >> state_enum) & 1;
 }
 
 bool BrowserAccessibility::IsCellOrTableHeaderRole() const {
   return (GetRole() == ui::AX_ROLE_CELL ||
           GetRole() == ui::AX_ROLE_COLUMN_HEADER ||
           GetRole() == ui::AX_ROLE_ROW_HEADER);
 }
 
 bool BrowserAccessibility::HasCaret() const {
-  if (IsEditableText() && !HasState(ui::AX_STATE_RICHLY_EDITABLE) &&
+  if (HasState(ui::AX_STATE_EDITABLE) &&
+      !HasState(ui::AX_STATE_RICHLY_EDITABLE) &&
       HasIntAttribute(ui::AX_ATTR_TEXT_SEL_START) &&
       HasIntAttribute(ui::AX_ATTR_TEXT_SEL_END)) {
     return true;
   }
 
   // The caret is always at the focus of the selection.
   int32_t focus_id = manager()->GetTreeData().sel_focus_object_id;
   BrowserAccessibility* focus_object = manager()->GetFromID(focus_id);
   if (!focus_object)
     return false;
 
   if (!focus_object->IsDescendantOf(this))
     return false;
 
   return true;
 }
 
-bool BrowserAccessibility::IsEditableText() const {
-  return HasState(ui::AX_STATE_EDITABLE);
-}
-
 bool BrowserAccessibility::IsWebAreaForPresentationalIframe() const {
   if (GetRole() != ui::AX_ROLE_WEB_AREA &&
       GetRole() != ui::AX_ROLE_ROOT_WEB_AREA) {
     return false;
   }
 
   BrowserAccessibility* parent = GetParent();
   if (!parent)
     return false;
 
@@ skipping 80 matching lines @@
 base::string16 BrowserAccessibility::GetInnerText() const {
   if (IsTextOnlyObject())
     return GetString16Attribute(ui::AX_ATTR_NAME);
 
   base::string16 text;
   for (size_t i = 0; i < InternalChildCount(); ++i)
     text += InternalGetChild(i)->GetInnerText();
   return text;
 }
 
-int BrowserAccessibility::GetInnerTextLength() const {
-  return static_cast<int>(GetInnerText().size());
-}
-
 void BrowserAccessibility::FixEmptyBounds(gfx::Rect* bounds) const
 {
   if (bounds->width() > 0 && bounds->height() > 0)
     return;
 
   for (size_t i = 0; i < InternalChildCount(); ++i) {
     // Compute the bounds of each child - this calls FixEmptyBounds
     // recursively if necessary.
     BrowserAccessibility* child = InternalGetChild(i);
     gfx::Rect child_bounds = child->GetLocalBoundsRect();
@@ skipping 47 matching lines @@
       }
       need_to_offset_web_area = true;
     }
     parent = parent->GetParent();
   }
 
   return bounds;
 }
 
 }  // namespace content