Accessible boundsForRange common impl

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 "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 171 matching lines @@
 gfx::Rect BrowserAccessibility::GetGlobalBoundsRect() const {
   gfx::Rect bounds = GetLocalBoundsRect();
 
   // 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 {
+  DCHECK_EQ(role_, WebKit::WebAXRoleStaticText);
+  int end = start + len;
+  int child_start = 0;
+  int child_end = 0;
+
+  gfx::Rect bounds;
+  for (size_t i = 0; i < children_.size(); i++) {

[David Tseng, 2013/10/17 21:32:02]

You only need to iterate up to text length "end", right?

[dmazzoni, 2013/10/21 17:25:38]

Good point. I added a condition to the for loop so that it only continues as
long as child_end < start + len.

[David Tseng, 2013/10/23 17:00:50]

nit: ++i

[dmazzoni, 2013/11/01 18:39:37]

Done.

+    BrowserAccessibility* child = children_[i];
+    DCHECK_EQ(child->role(), WebKit::WebAXRoleInlineTextBox);
+    std::string child_text;
+    child->GetStringAttribute(AccessibilityNodeData::ATTR_VALUE, &child_text);
+    int child_len = static_cast<int>(child_text.size());
+    child_start = child_end;
+    child_end += child_len;
+
+    int overlap_start = std::max(start, child_start);

[aboxhall, 2013/10/04 18:53:07]

Could we just do
if (start > child_end || end < child_start) 
  continue;
before calculating the overlap?

Having something called 'overlap' which may potentially not be an overlap is
breaking my brain a bit :)

[dmazzoni, 2013/10/21 17:25:38]

Done.

+    int overlap_end = std::min(end, child_end);
+
+    if (overlap_end <= overlap_start)
+      continue;
+
+    int local_start = overlap_start - child_start;
+    int local_end = overlap_end - child_start;
+
+    gfx::Rect child_rect = child->location();
+    int text_direction = child->GetIntAttribute(
+        AccessibilityNodeData::ATTR_TEXT_DIRECTION);
+    const std::vector<int32>& character_offsets = child->GetIntListAttribute(
+        AccessibilityNodeData::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) {
+      default:

[David Tseng, 2013/10/23 17:00:50]

Do you expect to get anything other than the four values below?

[dmazzoni, 2013/11/01 18:39:37]

No. Changed to NOTREACHED.

+      case WebKit::WebAXTextDirectionLR: {
+        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 WebKit::WebAXTextDirectionRL: {
+        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 WebKit::WebAXTextDirectionTB: {
+        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 WebKit::WebAXTextDirectionBT: {
+        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;
+      }
+    }
+
+    if (bounds.width() == 0 && bounds.height() == 0)

[aboxhall, 2013/10/04 18:53:07]

Would IsEmpty() do here? Or is it conceivable that we could have a bounding box
with zero width or height but not both?

[dmazzoni, 2013/10/21 17:25:38]

It will happen - a common example is a space character that's not actually
printed, like the space character right at the point where a line is wrapped.
The space doesn't actually have any width.

+      bounds = child_overlap_rect;
+    else
+      bounds.Union(child_overlap_rect);
+  }
+
+  return bounds;
+}
+
+gfx::Rect BrowserAccessibility::GetGlobalBoundsForRange(int start, int len)
+    const {
+  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;
+}
+
 BrowserAccessibility* BrowserAccessibility::BrowserAccessibilityForPoint(
     const gfx::Point& point) {
   // Walk the children recursively looking for the BrowserAccessibility that
   // most tightly encloses the specified point.
   for (int i = children_.size() - 1; i >= 0; --i) {
     BrowserAccessibility* child = children_[i];
     if (child->GetGlobalBoundsRect().Contains(point))
       return child->BrowserAccessibilityForPoint(point);
   }
   return this;
@@ skipping 283 matching lines @@
     return name_;
   }
 
   std::string result;
   for (size_t i = 0; i < children_.size(); ++i)
     result += children_[i]->GetTextRecursive();
   return result;
 }
 
 }  // namespace content