Fixed IAccessibleText::TextAtOffset with IA2_TEXT_BOUNDARY_WORD to return text that spans from the …

content/browser/accessibility/browser_accessibility.cc

Index: content/browser/accessibility/browser_accessibility.cc
diff --git a/content/browser/accessibility/browser_accessibility.cc b/content/browser/accessibility/browser_accessibility.cc
index a700e9a9fd30538f4703fdf92d837a50058eb2c0..6216cfa0e1c25a8f39435636ce3d25d59fef76a8 100644
--- a/content/browser/accessibility/browser_accessibility.cc
+++ b/content/browser/accessibility/browser_accessibility.cc
@@ -4,12 +4,15 @@
 
 #include "content/browser/accessibility/browser_accessibility.h"
 
+#include <algorithm>
+
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/common/accessibility_messages.h"
+#include "ui/accessibility/ax_text_utils.h"
 
 namespace content {
 
@@ -337,6 +340,81 @@ gfx::Rect BrowserAccessibility::GetGlobalBoundsForRange(int start, int len)
   return bounds;
 }
 
+int BrowserAccessibility::GetWordStartBoundary(
+    int start, ui::TextBoundaryDirection direction) const {
+  int word_start = 0;
+  if (GetRole() != ui::AX_ROLE_STATIC_TEXT) {
+    for (size_t i = 0; i < InternalChildCount() && start >= 0; ++i) {
+      BrowserAccessibility* child = InternalGetChild(i);
+      int child_len = child->GetStaticTextLenRecursive();
+      if (start >= child_len) {
+        word_start += child_len;
+        start -= child_len;
+        continue;
+      }
+
+      word_start = child->GetWordStartBoundary(start, direction);
+    }
+    return word_start;

[dmazzoni, 2014/10/29 21:49:43]

Perhaps the return value should vary based on |direction|? if direction is
ui::FORWARDS_DIRECTION, if no word start boundaries are found don't you think it
should return the total length of the recursive text?

+  }
+
+  int child_start = 0;
+  int child_end = 0;
+
+  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);
+    std::string child_text;
+    child->GetStringAttribute(ui::AX_ATTR_VALUE, &child_text);
+    int child_len = static_cast<int>(child_text.size());
+    child_end += child_len; // End is one passed the last character.

[dmazzoni, 2014/10/29 21:49:44]

nit: one passed -> one past

+
+    if (start >= child_end)
+      continue;
+
+    const std::vector<int32>& word_starts = child->GetIntListAttribute(
+        ui::AX_ATTR_WORD_STARTS);
+    if (word_starts.empty())
+      continue;
+
+    int local_start = start - child_start;
+    std::vector<int32>::const_iterator iter = std::upper_bound(
+        word_starts.cbegin(), word_starts.cend(), local_start);
+    if (direction == ui::FORWARDS_DIRECTION) {
+      if (iter != word_starts.cend()) {
+        word_start = *iter;
+        break;
+      } else {
+        // In case there are no more children or remaining children have no
+        // text, e.g., an image.
+        word_start = child_end;
+        continue;
+      }
+    } else if (direction == ui::BACKWARDS_DIRECTION) {
+      if (iter != word_starts.cbegin()) {
+        --iter;
+        word_start = *iter;
+      } else {
+        // Return the start of the last word in the previous child.

[dmazzoni, 2014/10/29 21:49:43]

One option would be to treat an inline text box boundary as the start / end of a
word.

There are only a few cases where a word would span an inline text box boundary.

Case 1: suppose that the word wrap is set to break words with no hyphens - i
believe that's one of the allowed options. So then a word might start on one
line and continue to the next. If you're moving by word in a screen reader,
would you really want it to jump from the middle of one line to the middle of
the next? I'm not sure I would - I'd probably want it to jump to the beginning
of the line, but I'm not sure

Case 2: suppose someone makes half of a word bold - should moving by word break
at the style transition, or should it just skip to the beginning / end of the
word spanning the style transition?

The other cases will be similar - the only reason a single word will span two
inline text boxes is if there's a good reason, like a line break, a style
chnage, etc. - and I just want to make sure we're deliberate about what we
choose to do.

+        for (int j = i - 1; j >= 0; --j) {
+          BrowserAccessibility* child = InternalGetChild(j);
+          const std::vector<int32>& word_starts = child->GetIntListAttribute(
+              ui::AX_ATTR_WORD_STARTS);
+          if (word_starts.empty())
+            continue;
+
+          word_start = word_starts[word_starts.size() - 1];
+        }
+      }
+      break;
+    }
+  }
+
+  return word_start;

[dmazzoni, 2014/10/29 21:49:43]

Same - if searching forwards I think the default to return should be the maximum
value, not zero.

+}
+
 BrowserAccessibility* BrowserAccessibility::BrowserAccessibilityForPoint(
     const gfx::Point& point) {
   // The best result found that's a child of this object.