Adds color, font size, text direction and text styles to the accessibility tree.

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 <algorithm>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 244 matching lines @@
     const std::vector<int32>& character_offsets = child->GetIntListAttribute(
         ui::AX_ATTR_CHARACTER_OFFSETS);
     int start_pixel_offset =
         local_start > 0 ? character_offsets[local_start - 1] : 0;
     int end_pixel_offset =
         local_end > 0 ? character_offsets[local_end - 1] : 0;
 
     gfx::Rect child_overlap_rect;
     switch (text_direction) {
       case ui::AX_TEXT_DIRECTION_NONE:
-      case ui::AX_TEXT_DIRECTION_LR: {
+      case ui::AX_TEXT_DIRECTION_LTR: {
         int left = child_rect.x() + start_pixel_offset;
         int right = child_rect.x() + end_pixel_offset;
         child_overlap_rect = gfx::Rect(left, child_rect.y(),
                                        right - left, child_rect.height());
         break;
       }
-      case ui::AX_TEXT_DIRECTION_RL: {
+      case ui::AX_TEXT_DIRECTION_RTL: {
         int right = child_rect.right() - start_pixel_offset;
         int left = child_rect.right() - end_pixel_offset;
         child_overlap_rect = gfx::Rect(left, child_rect.y(),
                                        right - left, child_rect.height());
         break;
       }
-      case ui::AX_TEXT_DIRECTION_TB: {
+      case ui::AX_TEXT_DIRECTION_TTB: {
         int top = child_rect.y() + start_pixel_offset;
         int bottom = child_rect.y() + end_pixel_offset;
         child_overlap_rect = gfx::Rect(child_rect.x(), top,
                                        child_rect.width(), bottom - top);
         break;
       }
-      case ui::AX_TEXT_DIRECTION_BT: {
+      case ui::AX_TEXT_DIRECTION_BTT: {
         int bottom = child_rect.bottom() - start_pixel_offset;
         int top = child_rect.bottom() - end_pixel_offset;
         child_overlap_rect = gfx::Rect(child_rect.x(), top,
                                        child_rect.width(), bottom - top);
         break;
       }
       default:
         NOTREACHED();
     }
 
@@ skipping 11 matching lines @@
   gfx::Rect bounds = GetLocalBoundsForRange(start, len);
 
   // Adjust the bounds by the top left corner of the containing view's bounds
   // in screen coordinates.
   bounds.Offset(manager_->GetViewBounds().OffsetFromOrigin());
 
   return bounds;
 }
 
 int BrowserAccessibility::GetWordStartBoundary(
-    int start, ui::TextBoundaryDirection direction) const {
-  DCHECK_GE(start, -1);
+    int offset, ui::TextBoundaryDirection direction) const {
+  DCHECK_GE(offset, -1);
+  int text_len = GetStaticTextLenRecursive();
+  DCHECK_LE(offset, text_len);
+
   // Special offset that indicates that a word boundary has not been found.
-  int word_start_not_found = GetStaticTextLenRecursive();
+  int word_start_not_found = text_len;
   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_VALUE);
-        int child_len = static_cast<int>(child_text.size());
-        child_end += child_len; // End is one past the last character.
+        if (child->GetRole(), ui::AX_ROLE_INLINE_TEXT_BOX) {
+          LOG(WARNING) << "Found child of AX_ROLE_STATIC_TEXT that is not " <<
+              "AX_ROLE_INLINE_TEXT_BOX. ID=" child->GetId());
+          continue;
+        }
+        int child_len = GetStaticTextLenRecursive();
+        child_end += child_len;
 
         const std::vector<int32>& word_starts = child->GetIntListAttribute(
             ui::AX_ATTR_WORD_STARTS);
         if (word_starts.empty()) {
           word_start = child_end;
           continue;
         }
 
-        int local_start = start - child_start;
+        int local_offset = offset - child_start;
         std::vector<int32>::const_iterator iter = std::upper_bound(
-            word_starts.begin(), word_starts.end(), local_start);
+            word_starts.begin(), word_starts.end(), local_offset);
         if (iter != word_starts.end()) {
           if (direction == ui::FORWARDS_DIRECTION) {
             word_start = child_start + *iter;
           } else if (direction == ui::BACKWARDS_DIRECTION) {
             if (iter == word_starts.begin()) {
               // Return the position of the last word in the previous child.
               word_start = prev_word_start;
             } else {
               word_start = child_start + *(iter - 1);
             }
@@ skipping 33 matching lines @@
         int child_len = child->GetStaticTextLenRecursive();
         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 &&
+            (offset < child_len &&
             direction == ui::BACKWARDS_DIRECTION)) {
           break;
         }
 
         child_start += child_len;
-        if (start >= child_len)
-          start -= child_len;
+        if (offset >= child_len)
+          offset -= child_len;
         else
-          start = -1;
+          offset = -1;
       }
       return word_start;
   }
 }
 
+int BrowserAccessibility::GetStyleChangeBoundary(
+    int offset, ui::TextBoundaryDirection direction) const {
+  DCHECK_GE(offset, 0);
+  int text_len = GetStaticTextLenRecursive();
+  DCHECK_LE(offset, text_len);
+
+  int style_change_start;
+  if (direction == ui::BACKWARDS_DIRECTION)
+    style_change_start = 0;
+  else if (direction == ui::FORWARDS_DIRECTION)
+    style_change_start = text_len;
+  else
+    NOTREACHED();
+
+  if (IsTextLeaf())
+    return style_change_start;
+
+  BrowserAccessibility* leaf = GetTextLeafAtOffset(offset, &style_change_start);
+  DCHECK(leaf);
+
+  BrowserAccessibility* sibling = leaf;
+  if (direction == ui::BACKWARDS_DIRECTION)
+    while ((sibling = GetPreviousTextLeaf()) && HaveSameStyle(*leaf, *sibling)) {
+      style_change_start -= sibling->GetStaticTextLenRecursive();
+      leaf = sibling;
+    }
+  else if (direction == ui::FORWARDS_DIRECTION)
+    while (sibling = GetNextTextLeaf() && HaveSameStyle(*leaf, *sibling)) {
+      style_change_start += leaf->GetStaticTextLenRecursive();
+      leaf = sibling;
+    }
+
+  return style_change_start;
+}
+
 BrowserAccessibility* BrowserAccessibility::BrowserAccessibilityForPoint(
     const gfx::Point& point) {
   // The best result found that's a child of this object.
   BrowserAccessibility* child_result = NULL;
   // The best result that's an indirect descendant like grandchild, etc.
   BrowserAccessibility* descendant_result = NULL;
 
   // Walk the children recursively looking for the BrowserAccessibility that
   // most tightly encloses the specified point. Walk backwards so that in
   // the absence of any other information, we assume the object that occurs
@@ skipping 323 matching lines @@
   if (!parent)
     return false;
 
   BrowserAccessibility* grandparent = parent->GetParent();
   if (!grandparent)
     return false;
 
   return grandparent->GetRole() == ui::AX_ROLE_IFRAME_PRESENTATIONAL;
 }
 
+//
+// Protected methods.
+//
+
+BrowserAccessibility* BrowserAccessibility::GetFirstTextLeaf() const {
+  int unused_leaf_offset;
+  return GetTextLeafAtOffset(0, &unused_leaf_offset);
+}
+
+//
+// Private methods.
+//
+
+// Return true only for objects that are the deepest possible descendants which
+// include complete text information.
+// For example, objects with role AX_ROLE_EDIT_FIELD are not the deepest nodes
+// with complete text information because they have objects with role
+// AX_ROLE_STATIC_TEXT as their descendants which hold the text information.
+// However, an object with role AX_ROLE_BUTTON has no AX_ROLE_STATIC_TEXT
+// descendant and it stores its text information directly.
+bool BrowserAccessibility::IsTextLeaf() const {
+  switch (GetRole()) {
+    case ui::AX_ROLE_BUTTON:
+    case ui::AX_ROLE_CHECK_BOX:
+    case ui::AX_ROLE_COLOR_WELL:
+    case ui::AX_ROLE_COMBO_BOX:
+    case ui::AX_ROLE_DATE:
+    case ui::AX_ROLE_DATE_TIME:
+    case ui::AX_ROLE_IMAGE:
+    case ui::AX_ROLE_LINE_BREAK:
+    case ui::AX_ROLE_LIST_MARKER:
+    case ui::AX_ROLE_POP_UP_BUTTON:
+    case ui::AX_ROLE_RADIO_BUTTON:
+    case ui::AX_ROLE_SEARCH_BOX:
+    case ui::AX_ROLE_TOGGLE_BUTTON:
+    case ui::AX_ROLE_STATIC_TEXT:
+      return true;
+    default:
+      return false;
+  }
+}
+
 int BrowserAccessibility::GetStaticTextLenRecursive() const {
-  if (GetRole() == ui::AX_ROLE_STATIC_TEXT ||
-      GetRole() == ui::AX_ROLE_LINE_BREAK) {
+  if (IsTextLeaf())
     return static_cast<int>(GetStringAttribute(ui::AX_ATTR_VALUE).size());
-  }
 
   int len = 0;
   for (size_t i = 0; i < InternalChildCount(); ++i)
     len += InternalGetChild(i)->GetStaticTextLenRecursive();
   return len;
 }
 
+// TODO(nektar): Refactor whole class to use this function where appropriate.
+BrowserAccessibility* BrowserAccessibility::GetTextLeafAtOffset(
+    int offset,
+    int* leaf_start_offset) const {
+  DCHECK_GE(offset, 0);
+  DCHECK_LE(offset, GetStaticTextLenRecursive());
+  DCHECK(child_start_offset);
+
+  if (IsTextLeaf()) {
+    *leaf_start_offset = 0;
+    return this;
+  }
+
+  int child_start = 0;
+  BrowserAccessibility* leaf = nullptr;
+  for (size_t i = 0; i < InternalChildCount(); ++i) {
+    BrowserAccessibility* child = InternalGetChild(i);
+    int child_len = GetStaticTextLenRecursive();
+    int child_end = child_start + child_len;
+    if (offset < child_end) {
+      leaf = child->GetTextLeafAtOffset(offset, leaf_start_offset);
+      break;
+    }
+
+    child_start = child_end;
+    offset -= child_len;
+  }
+
+  *leaf_start_offset += child_start;
+  return leaf;
+}
+
+BrowserAccessibility* BrowserAccessibility::GetLastTextLeaf() const {
+  int text_len = GetStaticTextLenRecursive();
+  if (text_len <= 0)
+    return GetFirstTextLeaf();
+
+  int unused_leaf_offset;
+  return GetTextLeafAtOffset(text_len - 1, &unused_leaf_offset);
+}
+
+BrowserAccessibility* BrowserAccessibility::GetNextTextLeaf() const {
+  if (GetFirstTextLeaf() && GetFirstTextLeaf() != this)
+    return GetNextFirstLeaf();
+
+  BrowserAccessibility* next_leaf = nullptr;
+  BrowserAccessibility* current_object = GetNextSibling();
+  while (!next_leaf && current_object) {
+    next_leaf = current_object->GetFirstTextLeaf();
+    current_object = current_object->GetNextSibling();
+  }
+  if (next_leaf)
+    return next_leaf;
+
+  if (GetParent() && GetParent()->GetNextSibling())
+    next_leaf = GetParent()->GetNextSibling()->GetNextTextLeaf();
+
+  return next_leaf;
+}
+
+BrowserAccessibility* BrowserAccessibility::GetPreviousTextLeaf() const {
+  BrowserAccessibility* previous_leaf = nullptr;
+  BrowserAccessibility* current_object = GetPreviousSibling();
+  while (!previous_leaf && current_object) {
+    previous_leaf = current_object->GetLastTextLeaf();
+    current_object = current_object->GetPreviousSibling();
+  }
+  if (previous_leaf)
+    return previous_leaf;
+
+  if (GetParent() && GetParent()->GetPreviousSibling())
+    previous_leaf = GetParent()->GetPreviousSibling()->GetPreviousTextLeaf();
+
+  return previous_leaf;
+}
+
 BrowserAccessibility* BrowserAccessibility::GetParentForBoundsCalculation()
     const {
   if (!node_ || !manager_)
     return NULL;
   ui::AXNode* parent = node_->parent();
   if (parent)
     return manager_->GetFromAXNode(parent);
 
   if (!manager_->delegate())
     return NULL;
@@ skipping 34 matching lines @@
         bounds.Offset(-sx, -sy);
       }
       need_to_offset_web_area = true;
     }
     parent = parent->GetParentForBoundsCalculation();
   }
 
   return bounds;
 }
 
+//
+// Static methods.
+//
+
+bool BrowserAccessibility::HaveSameStyle(BrowserAccessibility& object1,
+                                         BrowserAccessibility& object2) {
+  
+}
+
 }  // namespace content