Use text affinity to return correct accessible line boundaries.

content/browser/accessibility/browser_accessibility_cocoa.mm

 // 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 <execinfo.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #import "content/browser/accessibility/browser_accessibility_cocoa.h"
 
@@ skipping 75 matching lines @@
 // Actions.
 NSString* const NSAccessibilityScrollToVisibleAction = @"AXScrollToVisible";
 
 // A mapping from an accessibility attribute to its method name.
 NSDictionary* attributeToMethodNameMap = nil;
 
 struct AXTextMarkerData {
   AXTreeIDRegistry::AXTreeID tree_id;
   int32_t node_id;
   int offset;
+  ui::AXTextAffinity affinity;
 };
 
 // VoiceOver uses -1 to mean "no limit" for AXResultsLimit.
 const int kAXResultsLimitNoLimit = -1;
 
 extern "C" {
 
 // See http://openradar.appspot.com/9896491. This SPI has been tested on 10.5,
 // 10.6, and 10.7. It allows accessibility clients to observe events posted on
 // this object.
@@ skipping 17 matching lines @@
 AXTextMarkerRef AXTextMarkerRangeCopyStartMarker(
     AXTextMarkerRangeRef text_marker_range);
 
 AXTextMarkerRef AXTextMarkerRangeCopyEndMarker(
     AXTextMarkerRangeRef text_marker_range);
 
 #endif  // MAC_OS_X_VERSION_10_11
 
 }  // extern "C"
 
-id CreateTextMarker(const BrowserAccessibility& object, int offset) {
+id CreateTextMarker(const BrowserAccessibility& object,
+                    int offset,
+                    ui::AXTextAffinity affinity) {
   AXTextMarkerData marker_data;
   marker_data.tree_id = object.manager() ? object.manager()->ax_tree_id() : -1;
   marker_data.node_id = object.GetId();
   marker_data.offset = offset;
+  marker_data.affinity = affinity;
   return (id)base::mac::CFTypeRefToNSObjectAutorelease(AXTextMarkerCreate(
       kCFAllocatorDefault, reinterpret_cast<const UInt8*>(&marker_data),
       sizeof(marker_data)));
 }
 
 id CreateTextMarkerRange(const BrowserAccessibility& start_object,
                          int start_offset,
+                         ui::AXTextAffinity start_affinity,
                          const BrowserAccessibility& end_object,
-                         int end_offset) {
-  id start_marker = CreateTextMarker(start_object, start_offset);
-  id end_marker = CreateTextMarker(end_object, end_offset);
+                         int end_offset,
+                         ui::AXTextAffinity end_affinity) {
+  id start_marker = CreateTextMarker(
+        start_object, start_offset, start_affinity);
+  id end_marker = CreateTextMarker(end_object, end_offset, end_affinity);
   return (id)base::mac::CFTypeRefToNSObjectAutorelease(
       AXTextMarkerRangeCreate(kCFAllocatorDefault, start_marker, end_marker));
 }
 
 bool GetTextMarkerData(AXTextMarkerRef text_marker,
                        BrowserAccessibility** object,
-                       int* offset) {
+                       int* offset,
+                       ui::AXTextAffinity* affinity) {
   DCHECK(text_marker);
   DCHECK(object && offset);
   const auto* marker_data = reinterpret_cast<const AXTextMarkerData*>(
       AXTextMarkerGetBytePtr(text_marker));
   if (!marker_data)
     return false;
 
   const BrowserAccessibilityManager* manager =
       BrowserAccessibilityManager::FromID(marker_data->tree_id);
   if (!manager)
     return false;
 
   *object = manager->GetFromID(marker_data->node_id);
   if (!*object)
     return false;
 
   *offset = marker_data->offset;
   if (*offset < 0)
     return false;
 
+  *affinity = marker_data->affinity;
+
   return true;
 }
 
 bool GetTextMarkerRange(AXTextMarkerRangeRef marker_range,
                         BrowserAccessibility** start_object,
                         int* start_offset,
+                        ui::AXTextAffinity* start_affinity,
                         BrowserAccessibility** end_object,
-                        int* end_offset) {
+                        int* end_offset,
+                        ui::AXTextAffinity* end_affinity) {
   DCHECK(marker_range);
   DCHECK(start_object && start_offset);
   DCHECK(end_object && end_offset);
 
   base::ScopedCFTypeRef<AXTextMarkerRef> start_marker(
       AXTextMarkerRangeCopyStartMarker(marker_range));
   base::ScopedCFTypeRef<AXTextMarkerRef> end_marker(
       AXTextMarkerRangeCopyEndMarker(marker_range));
   if (!start_marker.get() || !end_marker.get())
     return false;
 
-  return GetTextMarkerData(start_marker.get(), start_object, start_offset) &&
-         GetTextMarkerData(end_marker.get(), end_object, end_offset);
+  return GetTextMarkerData(start_marker.get(),
+                           start_object, start_offset, start_affinity) &&
+         GetTextMarkerData(end_marker.get(),
+                           end_object, end_offset, end_affinity);
 }
 
 void AddMisspelledTextAttributes(
     const std::vector<const BrowserAccessibility*>& text_only_objects,
     NSMutableAttributedString* attributed_string) {
   [attributed_string beginEditing];
   for (const BrowserAccessibility* text_object : text_only_objects) {
     const std::vector<int32_t>& marker_types =
         text_object->GetIntListAttribute(ui::AX_ATTR_MARKER_TYPES);
     const std::vector<int>& marker_starts =
@@ skipping 16 matching lines @@
                  range:NSMakeRange(misspelling_start, misspelling_length)];
     }
   }
   [attributed_string endEditing];
 }
 
 NSString* GetTextForTextMarkerRange(AXTextMarkerRangeRef marker_range) {
   BrowserAccessibility* start_object;
   BrowserAccessibility* end_object;
   int start_offset, end_offset;
-  if (!GetTextMarkerRange(marker_range, &start_object, &start_offset,
-                          &end_object, &end_offset)) {
+  ui::AXTextAffinity start_affinity, end_affinity;
+  if (!GetTextMarkerRange(marker_range,
+                          &start_object, &start_offset, &start_affinity,
+                          &end_object, &end_offset, &end_affinity)) {
     return nil;
   }
   DCHECK(start_object && end_object);
   DCHECK_GE(start_offset, 0);
   DCHECK_GE(end_offset, 0);
 
   return base::SysUTF16ToNSString(BrowserAccessibilityManager::GetTextForRange(
       *start_object, start_offset, *end_object, end_offset));
 }
 
 NSAttributedString* GetAttributedTextForTextMarkerRange(
     AXTextMarkerRangeRef marker_range) {
   BrowserAccessibility* start_object;
   BrowserAccessibility* end_object;
   int start_offset, end_offset;
-  if (!GetTextMarkerRange(marker_range, &start_object, &start_offset,
-                          &end_object, &end_offset)) {
+  ui::AXTextAffinity start_affinity, end_affinity;
+  if (!GetTextMarkerRange(marker_range,
+                          &start_object, &start_offset, &start_affinity,
+                          &end_object, &end_offset, &end_affinity)) {
     return nil;
   }
 
   NSString* text = base::SysUTF16ToNSString(
       BrowserAccessibilityManager::GetTextForRange(*start_object, *end_object));
   if ([text length] == 0)
     return nil;
 
   // Be permissive with the start and end offsets.
   if (start_object == end_object && end_offset < start_offset)
@@ skipping 627 matching lines @@
         BrowserAccessibilityManager::PreviousTextOnlyObject(last_text_object);
   }
   while (last_text_object) {
     last_text_object =
         BrowserAccessibilityManager::PreviousTextOnlyObject(last_text_object);
   }
   if (!last_text_object)
     return nil;
 
   return CreateTextMarker(*last_text_object,
-                          last_text_object->GetText().length());
+                          last_text_object->GetText().length(),
+                          ui::AX_TEXT_AFFINITY_DOWNSTREAM);
 }
 
 - (NSNumber*)expanded {
   if (![self instanceActive])
     return nil;
   return [NSNumber numberWithBool:
       GetState(browserAccessibility_, ui::AX_STATE_EXPANDED)];
 }
 
 - (NSNumber*)focused {
@@ skipping 657 matching lines @@
   int32_t focusId = manager->GetTreeData().sel_focus_object_id;
   const BrowserAccessibility* focusObject = manager->GetFromID(focusId);
   if (!focusObject)
     return nil;
 
   int anchorOffset = manager->GetTreeData().sel_anchor_offset;
   int focusOffset = manager->GetTreeData().sel_focus_offset;
   if (anchorOffset < 0 || focusOffset < 0)
     return nil;
 
-  return CreateTextMarkerRange(*anchorObject, anchorOffset, *focusObject,
-                               focusOffset);
+  ui::AXTextAffinity anchorAffinity =
+        manager->GetTreeData().sel_anchor_affinity;
+  ui::AXTextAffinity focusAffinity = manager->GetTreeData().sel_focus_affinity;
+
+  return CreateTextMarkerRange(*anchorObject, anchorOffset, anchorAffinity,
+                               *focusObject, focusOffset, focusAffinity);
 }
 
 - (NSValue*)size {
   if (![self instanceActive])
     return nil;
   gfx::Rect bounds = browserAccessibility_->GetLocalBoundsRect();
   return  [NSValue valueWithSize:NSMakeSize(bounds.width(), bounds.height())];
 }
 
 - (NSString*)sortDirection {
@@ skipping 37 matching lines @@
     first_text_object =
         BrowserAccessibilityManager::NextTextOnlyObject(first_text_object);
   }
   while (first_text_object) {
     first_text_object =
         BrowserAccessibilityManager::NextTextOnlyObject(first_text_object);
   }
   if (!first_text_object)
     return nil;
 
-  return CreateTextMarker(*first_text_object, 0);
+  return CreateTextMarker(*first_text_object, 0, ui::AX_TEXT_AFFINITY_UPSTREAM);
 }
 
 // Returns a subrole based upon the role.
 - (NSString*) subrole {
   if (![self instanceActive])
     return nil;
   ui::AXRole browserAccessibilityRole = [self internalRole];
   if (browserAccessibilityRole == ui::AX_ROLE_TEXT_FIELD &&
       GetState(browserAccessibility_, ui::AX_STATE_PROTECTED)) {
     return NSAccessibilitySecureTextFieldSubrole;
@@ skipping 378 matching lines @@
         if (colIndex > column)
           break;
       }
     }
     return nil;
   }
 
   if ([attribute isEqualToString:@"AXUIElementForTextMarker"]) {
     BrowserAccessibility* object;
     int offset;
-    if (GetTextMarkerData(parameter, &object, &offset))
+    ui::AXTextAffinity affinity;
+    if (GetTextMarkerData(parameter, &object, &offset, &affinity))
       return ToBrowserAccessibilityCocoa(object);
 
     return nil;
   }
 
   if ([attribute isEqualToString:@"AXTextMarkerRangeForUIElement"]) {
     return CreateTextMarkerRange(*browserAccessibility_, 0,
+                                 ui::AX_TEXT_AFFINITY_UPSTREAM,
                                  *browserAccessibility_,
-                                 browserAccessibility_->GetText().length());
+                                 browserAccessibility_->GetText().length(),
+                                 ui::AX_TEXT_AFFINITY_DOWNSTREAM);
   }
 
   if ([attribute isEqualToString:@"AXStringForTextMarkerRange"])
     GetTextForTextMarkerRange(parameter);
 
   if ([attribute isEqualToString:@"AXAttributedStringForTextMarkerRange"])
     return GetAttributedTextForTextMarkerRange(parameter);
 
   if ([attribute isEqualToString:@"AXNextTextMarkerForTextMarker"]) {
     BrowserAccessibility* object;
     int offset;
-    if (!GetTextMarkerData(parameter, &object, &offset))
+    ui::AXTextAffinity affinity;
+    if (!GetTextMarkerData(parameter, &object, &offset, &affinity))
       return nil;
 
     DCHECK(object);
     if ((object->IsSimpleTextControl() || object->IsTextOnlyObject()) &&
         offset < static_cast<int>(object->GetText().length())) {
       ++offset;
     } else {
       do {
         object = BrowserAccessibilityManager::NextTextOnlyObject(object);
       } while (
           object &&
           !(object->IsTextOnlyObject() && object->GetText().length() == 0));
       if (!object)
         return nil;
 
       offset = 0;
     }
 
-    return CreateTextMarker(*object, offset);
+    return CreateTextMarker(*object, offset, ui::AX_TEXT_AFFINITY_DOWNSTREAM);
   }
 
   if ([attribute isEqualToString:@"AXPreviousTextMarkerForTextMarker"]) {
     BrowserAccessibility* object;
     int offset;
-    if (!GetTextMarkerData(parameter, &object, &offset))
+    ui::AXTextAffinity affinity;
+    if (!GetTextMarkerData(parameter, &object, &offset, &affinity))
       return nil;
 
     DCHECK(object);
     if ((object->IsSimpleTextControl() || object->IsTextOnlyObject()) &&
         offset > 0) {
       --offset;
     } else {
       do {
         object = BrowserAccessibilityManager::PreviousTextOnlyObject(object);
       } while (
           object &&
           !(object->IsTextOnlyObject() && object->GetText().length() == 0));
       if (!object)
         return nil;
 
       offset = object->GetText().length() - 1;
     }
 
-    return CreateTextMarker(*object, offset);
+    return CreateTextMarker(*object, offset, ui::AX_TEXT_AFFINITY_DOWNSTREAM);
   }
 
   // Currently we approximate end offsets of words and do not actually calculate
   // end offsets of lines, but use the start offset of the next line instead.
   // This seems to work in simple text fields.
   // TODO(nektar): Fix end offsets of words and lines.
   if ([attribute isEqualToString:@"AXLeftWordTextMarkerRangeForTextMarker"]) {
     BrowserAccessibility* object;
     int original_offset;
-    if (!GetTextMarkerData(parameter, &object, &original_offset))
+    ui::AXTextAffinity affinity;
+    if (!GetTextMarkerData(parameter, &object, &original_offset, &affinity))
       return nil;
 
     int start_offset =
         object->GetWordStartBoundary(original_offset, ui::BACKWARDS_DIRECTION);
     DCHECK_GE(start_offset, 0);
 
     int end_offset =
         object->GetWordStartBoundary(start_offset, ui::FORWARDS_DIRECTION);
     DCHECK_GE(end_offset, 0);
     if (start_offset < end_offset &&
         end_offset < static_cast<int>(object->GetText().length())) {
       --end_offset;
     }
-    return CreateTextMarkerRange(*object, start_offset, *object, end_offset);
+    return CreateTextMarkerRange(*object, start_offset, affinity,
+                                 *object, end_offset, affinity);
   }
 
   if ([attribute isEqualToString:@"AXRightWordTextMarkerRangeForTextMarker"]) {
     BrowserAccessibility* object;
     int original_offset;
-    if (!GetTextMarkerData(parameter, &object, &original_offset))
+    ui::AXTextAffinity affinity;
+    if (!GetTextMarkerData(parameter, &object, &original_offset, &affinity))
       return nil;
 
     int start_offset =
         object->GetWordStartBoundary(original_offset, ui::FORWARDS_DIRECTION);
     DCHECK_GE(start_offset, 0);
 
     int end_offset =
         object->GetWordStartBoundary(start_offset, ui::FORWARDS_DIRECTION);
     DCHECK_GE(end_offset, 0);
     if (start_offset < end_offset &&
         end_offset < static_cast<int>(object->GetText().length())) {
       --end_offset;
     }
-    return CreateTextMarkerRange(*object, start_offset, *object, end_offset);
+    return CreateTextMarkerRange(*object, start_offset, affinity,
+                                 *object, end_offset, affinity);
   }
 
   if ([attribute isEqualToString:@"AXNextWordEndTextMarkerForTextMarker"]) {
     BrowserAccessibility* object;
     int offset;
-    if (!GetTextMarkerData(parameter, &object, &offset))
+    ui::AXTextAffinity affinity;
+    if (!GetTextMarkerData(parameter, &object, &offset, &affinity))
       return nil;
 
     offset = object->GetWordStartBoundary(offset, ui::FORWARDS_DIRECTION);
     DCHECK_GE(offset, 0);
     if (offset > 0 && offset < static_cast<int>(object->GetText().length()))
       --offset;
-    return CreateTextMarker(*object, offset);
+    return CreateTextMarker(*object, offset, affinity);
   }
 
   if ([attribute
           isEqualToString:@"AXPreviousWordStartTextMarkerForTextMarker"]) {
     BrowserAccessibility* object;
     int offset;
-    if (!GetTextMarkerData(parameter, &object, &offset))
+    ui::AXTextAffinity affinity;
+    if (!GetTextMarkerData(parameter, &object, &offset, &affinity))
       return nil;
 
     offset = object->GetWordStartBoundary(offset, ui::BACKWARDS_DIRECTION);
     DCHECK_GE(offset, 0);
-    return CreateTextMarker(*object, offset);
+    return CreateTextMarker(*object, offset, affinity);
   }
 
   if ([attribute isEqualToString:@"AXNextLineEndTextMarkerForTextMarker"]) {
     BrowserAccessibility* object;
     int offset;
-    if (!GetTextMarkerData(parameter, &object, &offset))
+    ui::AXTextAffinity affinity;
+    if (!GetTextMarkerData(parameter, &object, &offset, &affinity))
       return nil;
 
-    offset = object->GetLineStartBoundary(offset, ui::FORWARDS_DIRECTION);
+    offset = object->GetLineStartBoundary(
+        offset, ui::FORWARDS_DIRECTION, affinity);
     DCHECK_GE(offset, 0);
-    return CreateTextMarker(*object, offset);
+    return CreateTextMarker(*object, offset, affinity);
   }
 
   if ([attribute
           isEqualToString:@"AXPreviousLineStartTextMarkerForTextMarker"]) {
     BrowserAccessibility* object;
     int offset;
-    if (!GetTextMarkerData(parameter, &object, &offset))
+    ui::AXTextAffinity affinity;
+    if (!GetTextMarkerData(parameter, &object, &offset, &affinity))
       return nil;
 
-    offset = object->GetLineStartBoundary(offset, ui::BACKWARDS_DIRECTION);
+    offset = object->GetLineStartBoundary(
+        offset, ui::BACKWARDS_DIRECTION, affinity);
     DCHECK_GE(offset, 0);
-    return CreateTextMarker(*object, offset);
+    return CreateTextMarker(*object, offset, affinity);
   }
 
   if ([attribute isEqualToString:@"AXLengthForTextMarkerRange"]) {
     NSString* text = GetTextForTextMarkerRange(parameter);
     return [NSNumber numberWithInt:[text length]];
   }
 
   if ([attribute isEqualToString:
       NSAccessibilityBoundsForRangeParameterizedAttribute]) {
     if ([self internalRole] != ui::AX_ROLE_STATIC_TEXT)
@@ skipping 28 matching lines @@
       return result;
     }
     return nil;
   }
 
   if ([attribute
           isEqualToString:
               NSAccessibilityLineTextMarkerRangeForTextMarkerParameterizedAttribute]) {
     BrowserAccessibility* object;
     int offset;
-    if (!GetTextMarkerData(parameter, &object, &offset))
+    ui::AXTextAffinity affinity;
+    if (!GetTextMarkerData(parameter, &object, &offset, &affinity))
       return nil;
 
     DCHECK(object);
     int start_offset =
-        object->GetLineStartBoundary(offset, ui::BACKWARDS_DIRECTION);
+        object->GetLineStartBoundary(offset, ui::BACKWARDS_DIRECTION, affinity);
     int end_offset =
-        object->GetLineStartBoundary(offset, ui::FORWARDS_DIRECTION);
-    return CreateTextMarkerRange(*object, start_offset, *object, end_offset);
+        object->GetLineStartBoundary(offset, ui::FORWARDS_DIRECTION, affinity);
+    return CreateTextMarkerRange(
+        *object, start_offset, ui::AX_TEXT_AFFINITY_UPSTREAM,
+        *object, end_offset, ui::AX_TEXT_AFFINITY_DOWNSTREAM);
   }
 
   return nil;
 }
 
 // Returns an array of parameterized attributes names that this object will
 // respond to.
 - (NSArray*)accessibilityParameterizedAttributeNames {
   if (![self instanceActive])
     return nil;
@@ skipping 455 matching lines @@
   if (![self instanceActive])
     return [super hash];
   return browserAccessibility_->GetId();
 }
 
 - (BOOL)accessibilityShouldUseUniqueId {
   return YES;
 }
 
 @end