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

content/browser/accessibility/browser_accessibility_win.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_win.h"
 
 #include <UIAutomationClient.h>
 #include <UIAutomationCoreApi.h>
+#include <algorithm>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/enum_variant.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/windows_version.h"
 #include "content/browser/accessibility/browser_accessibility_manager_win.h"
 #include "content/browser/accessibility/browser_accessibility_state_impl.h"
@@ skipping 3271 matching lines @@
       NOTREACHED();
       return ui::CHAR_BOUNDARY;
   }
 }
 
 LONG BrowserAccessibilityWin::FindBoundary(
     const base::string16& text,
     IA2TextBoundaryType ia2_boundary,
     LONG start_offset,
     ui::TextBoundaryDirection direction) {
+  if (ia2_boundary == IA2_TEXT_BOUNDARY_WORD)
+    return FindWordStartBoundary(text, start_offset, direction);
+
   HandleSpecialTextOffset(text, &start_offset);
   ui::TextBoundaryType boundary = IA2TextBoundaryToTextBoundary(ia2_boundary);
   const std::vector<int32>& line_breaks = GetIntListAttribute(
       ui::AX_ATTR_LINE_BREAKS);
   return ui::FindAccessibleTextBoundary(
       text, line_breaks, boundary, start_offset, direction);
 }
 
+LONG BrowserAccessibilityWin::FindWordStartBoundary(

[dmazzoni, 2014/10/15 22:03:10]

Please move this to browser_accessibility.cc instead so that we can use it on
other platforms if we want to. I believe we need it on Mac too.

+    const base::string16& text,
+    LONG start_offset,
+    ui::TextBoundaryDirection direction) {
+  HandleSpecialTextOffset(text, &start_offset);
+  if (!IsEditableText()) {
+    // We don't actually need the line breaks.
+    const std::vector<int32> line_breaks;
+    return ui::FindAccessibleTextBoundary(
+        text, line_breaks, ui::WORD_START_BOUNDARY, start_offset, direction);
+  }
+
+  LONG word_start = 0;
+  LONG child_start = 0;
+  LONG child_end = 0;
+
+  for (size_t i = 0; i < InternalChildCount(); ++i) {
+    // The next child starts where the previous one ended.
+    child_start = child_end;
+    BrowserAccessibilityWin* child = InternalGetChild(
+        i)->ToBrowserAccessibilityWin();
+    DCHECK_EQ(child->GetRole(), ui::AX_ROLE_INLINE_TEXT_BOX);
+    const base::string16& child_text = child->TextForIAccessibleText();
+    LONG child_len = static_cast<LONG>(child_text.length());
+    child_end += child_len; // End is one passed the last character.
+
+    if (start_offset >= child_end)
+      continue;
+
+    const std::vector<int32>& word_starts = child->GetIntListAttribute(
+        ui::AX_ATTR_WORD_STARTS);
+    if (!word_starts.empty()) {

[dmazzoni, 2014/10/15 22:03:10]

When possible, reverse the direction of a test to minimize indentation, i.e.:

if (word_starts.empty())
  continue;

+      int local_start = static_cast<int32>(start_offset, child_start);
+      if (direction == ui::FORWARDS_DIRECTION) {
+        std::vector<int32>::const_iterator iter = std::upper_bound(
+            word_starts.cbegin(), word_starts.cend(), local_start);
+        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) {
+        std::vector<int32>::const_iterator iter = std::lower_bound(
+            word_starts.cbegin(), word_starts.cend(), local_start);
+        if (iter != word_starts.cbegin() {
+          --iter;
+          word_start = *iter;
+          break;
+        } else {
+          // Return the start of the last word in the previous child.
+          for (int j = i - 1; j >= 0; --j) {
+            child = InternalGetChild(j).ToBrowserAccessibilityWin();
+            word_starts = child->GetIntListAttribute(ui::AX_ATTR_WORD_STARTS);
+            if (!word_starts.empty())
+              word_start = word_starts[word_starts.length() - 1];
+          }
+          break;
+        }
+      }
+    }
+  }
+
+  return word_start;
+}
+
 BrowserAccessibilityWin* BrowserAccessibilityWin::GetFromID(int32 id) {
   return manager()->GetFromID(id)->ToBrowserAccessibilityWin();
 }
 
 void BrowserAccessibilityWin::InitRoleAndState() {
   ia_state_ = 0;
   ia2_state_ = IA2_STATE_OPAQUE;
   ia2_attributes_.clear();
 
   if (HasState(ui::AX_STATE_BUSY))
@@ skipping 529 matching lines @@
   // The role should always be set.
   DCHECK(!role_name_.empty() || ia_role_);
 
   // If we didn't explicitly set the IAccessible2 role, make it the same
   // as the MSAA role.
   if (!ia2_role_)
     ia2_role_ = ia_role_;
 }
 
 }  // namespace content