a11y: Move CreateTextMarker[Range] to TextMarkerHelperMac.

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.
 
 #import "content/browser/accessibility/browser_accessibility_cocoa.h"
 
 #include <execinfo.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
 #include <map>
 #include <memory>
 #include <utility>
 
 #include "base/mac/foundation_util.h"
 #include "base/mac/scoped_cftyperef.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/app/strings/grit/content_strings.h"
 #include "content/browser/accessibility/ax_platform_position.h"
 #include "content/browser/accessibility/browser_accessibility_mac.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/browser/accessibility/browser_accessibility_manager_mac.h"
 #include "content/browser/accessibility/one_shot_accessibility_tree_search.h"
 #include "content/public/common/content_client.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/accessibility/ax_range.h"
 #import "ui/accessibility/platform/ax_platform_node_mac.h"
+#import "ui/accessibility/platform/text_marker_helper_mac.h"
 
 using AXPlatformPositionInstance =
     content::AXPlatformPosition::AXPositionInstance;
 using AXPlatformRange = ui::AXRange<AXPlatformPositionInstance::element_type>;
-using AXTextMarkerRangeRef = CFTypeRef;
-using AXTextMarkerRef = CFTypeRef;
 using StringAttribute = ui::AXStringAttribute;
 using content::AXPlatformPosition;
 using content::AccessibilityMatchPredicate;
 using content::BrowserAccessibility;
 using content::BrowserAccessibilityDelegate;
 using content::BrowserAccessibilityManager;
 using content::BrowserAccessibilityManagerMac;
 using content::ContentClient;
 using content::OneShotAccessibilityTreeSearch;
 using ui::AXNodeData;
@@ skipping 57 matching lines @@
 
 // Actions.
 NSString* const NSAccessibilityScrollToVisibleAction = @"AXScrollToVisible";
 
 // A mapping from an accessibility attribute to its method name.
 NSDictionary* attributeToMethodNameMap = nil;
 
 // VoiceOver uses -1 to mean "no limit" for AXResultsLimit.
 const int kAXResultsLimitNoLimit = -1;
 
-extern "C" {
+class BrowserPositionFactory : public ui::PositionFactory {
+ public:
+  explicit BrowserPositionFactory(
+      content::BrowserAccessibility* browser_accessibility)
+      : browser_accessibility_(browser_accessibility) {}
 
-// The following are private accessibility APIs required for cursor navigation
-// and text selection. VoiceOver started relying on them in Mac OS X 10.11.
-#if !defined(MAC_OS_X_VERSION_10_11) || \
-    MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_11
+  ui::AXPositionPointer GetRoot() const override;
+  ui::AXRangePointer GetSelection() const override;
+  ui::AXPositionPointer GetFromData(
+      const ui::AXPositionData& data) const override;
+  id GetAccessibilityObject(const ui::AXPositionData& data) const override;
 
-AXTextMarkerRef AXTextMarkerCreate(CFAllocatorRef allocator,
-                                   const UInt8* bytes,
-                                   CFIndex length);
+ private:
+  bool IsActive() const {
+    return browser_accessibility_ && browser_accessibility_->instance_active();
+  }
 
-const UInt8* AXTextMarkerGetBytePtr(AXTextMarkerRef text_marker);
+  content::BrowserAccessibility* browser_accessibility_;
 
-size_t AXTextMarkerGetLength(AXTextMarkerRef text_marker);
+  DISALLOW_COPY_AND_ASSIGN(BrowserPositionFactory);
+};
 
-AXTextMarkerRangeRef AXTextMarkerRangeCreate(CFAllocatorRef allocator,
-                                             AXTextMarkerRef start_marker,
-                                             AXTextMarkerRef end_marker);
+AXPlatformRange CreateRangeFromTextMarkerRange(id marker_range) {
+  ui::AXPositionData start, end;
+  if (![TextMarkerHelperMac getRangeDataFromMarkerRange:marker_range
+                                                  start:&start
+                                                    end:&end]) {
+    return AXPlatformRange();
+  }
 
-AXTextMarkerRef AXTextMarkerRangeCopyStartMarker(
-    AXTextMarkerRangeRef text_marker_range);
-
-AXTextMarkerRef AXTextMarkerRangeCopyEndMarker(
-    AXTextMarkerRangeRef text_marker_range);
-
-#endif  // MAC_OS_X_VERSION_10_11
-
-}  // extern "C"
-
-// AXTextMarkerCreate copies from data buffer given to it.
-id CreateTextMarker(AXPlatformPositionInstance position) {
-  AXTextMarkerRef text_marker = AXTextMarkerCreate(
-      kCFAllocatorDefault, reinterpret_cast<const UInt8*>(position.get()),
-      sizeof(AXPlatformPosition));
-  return static_cast<id>(
-      base::mac::CFTypeRefToNSObjectAutorelease(text_marker));
-}
-
-// |range| is destructed at the end of this method. |anchor| and |focus| are
-// copied into the individual text markers.
-id CreateTextMarkerRange(const AXPlatformRange range) {
-  base::ScopedCFTypeRef<AXTextMarkerRef> start_marker(AXTextMarkerCreate(
-      kCFAllocatorDefault, reinterpret_cast<const UInt8*>(range.anchor()),
-      sizeof(AXPlatformPosition)));
-  base::ScopedCFTypeRef<AXTextMarkerRef> end_marker(AXTextMarkerCreate(
-      kCFAllocatorDefault, reinterpret_cast<const UInt8*>(range.focus()),
-      sizeof(AXPlatformPosition)));
-  AXTextMarkerRangeRef marker_range =
-      AXTextMarkerRangeCreate(kCFAllocatorDefault, start_marker, end_marker);
-  return static_cast<id>(
-      base::mac::CFTypeRefToNSObjectAutorelease(marker_range));
-}
-
-AXPlatformPositionInstance CreatePositionFromTextMarker(
-    AXTextMarkerRef text_marker) {
-  DCHECK(text_marker);
-  if (AXTextMarkerGetLength(text_marker) != sizeof(AXPlatformPosition))
-    return AXPlatformPosition::CreateNullPosition();
-  const UInt8* source_buffer = AXTextMarkerGetBytePtr(text_marker);
-  if (!source_buffer)
-    return AXPlatformPosition::CreateNullPosition();
-  UInt8* destination_buffer = new UInt8[sizeof(AXPlatformPosition)];
-  std::memcpy(destination_buffer, source_buffer, sizeof(AXPlatformPosition));
-  AXPlatformPosition::AXPositionInstance position(
-      reinterpret_cast<AXPlatformPosition::AXPositionInstance::pointer>(
-          destination_buffer));
-  if (!position)
-    return AXPlatformPosition::CreateNullPosition();
-  return position;
-}
-
-AXPlatformRange CreateRangeFromTextMarkerRange(
-    AXTextMarkerRangeRef marker_range) {
-  DCHECK(marker_range);
-  base::ScopedCFTypeRef<AXTextMarkerRef> start_marker(
-      AXTextMarkerRangeCopyStartMarker(marker_range));
-  base::ScopedCFTypeRef<AXTextMarkerRef> end_marker(
-      AXTextMarkerRangeCopyEndMarker(marker_range));
-  if (!start_marker.get() || !end_marker.get())
-    return AXPlatformRange();
-
-  AXPlatformPositionInstance anchor =
-      CreatePositionFromTextMarker(start_marker.get());
-  AXPlatformPositionInstance focus =
-      CreatePositionFromTextMarker(end_marker.get());
-  // |AXPlatformRange| takes ownership of its anchor and focus.
-  return AXPlatformRange(std::move(anchor), std::move(focus));
+  return AXPlatformRange(AXPlatformPosition::CreateFromData(start),
+                         AXPlatformPosition::CreateFromData(end));
 }
 
 AXPlatformPositionInstance CreateTextPosition(
     const BrowserAccessibility& object,
     int offset,
     ui::AXTextAffinity affinity) {
   if (!object.instance_active())
     return AXPlatformPosition::CreateNullPosition();
 
   const BrowserAccessibilityManager* manager = object.manager();
   DCHECK(manager);
   return AXPlatformPosition::CreateTextPosition(
       manager->ax_tree_id(), object.GetId(), offset, affinity);
 }
 
-AXPlatformRange CreateTextRange(const BrowserAccessibility& start_object,
-                                int start_offset,
-                                ui::AXTextAffinity start_affinity,
-                                const BrowserAccessibility& end_object,
-                                int end_offset,
-                                ui::AXTextAffinity end_affinity) {
+ui::AXRangePointer CreateTextRange(const BrowserAccessibility& start_object,
+                                   int start_offset,
+                                   ui::AXTextAffinity start_affinity,
+                                   const BrowserAccessibility& end_object,
+                                   int end_offset,
+                                   ui::AXTextAffinity end_affinity) {
   AXPlatformPositionInstance anchor =
       CreateTextPosition(start_object, start_offset, start_affinity);
   AXPlatformPositionInstance focus =
       CreateTextPosition(end_object, end_offset, end_affinity);
-  // |AXPlatformRange| takes ownership of its anchor and focus.
-  return AXPlatformRange(std::move(anchor), std::move(focus));
+  // |AXRangePointer| takes ownership of its anchor and focus.
+  return ui::AXRangePointer(std::move(anchor), std::move(focus));
 }
 
 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 12 matching lines @@
       DCHECK_GT(misspelling_length, 0);
       [attributed_string
           addAttribute:NSAccessibilityMarkedMisspelledTextAttribute
                  value:@YES
                  range:NSMakeRange(misspelling_start, misspelling_length)];
     }
   }
   [attributed_string endEditing];
 }
 
-NSString* GetTextForTextMarkerRange(AXTextMarkerRangeRef marker_range) {
+NSString* GetTextForTextMarkerRange(id marker_range) {
   AXPlatformRange range = CreateRangeFromTextMarkerRange(marker_range);
   if (range.IsNull())
     return nil;
   return base::SysUTF16ToNSString(range.GetText());
 }
 
-NSAttributedString* GetAttributedTextForTextMarkerRange(
-    AXTextMarkerRangeRef marker_range) {
+NSAttributedString* GetAttributedTextForTextMarkerRange(id marker_range) {
   BrowserAccessibility* start_object;
   BrowserAccessibility* end_object;
   int start_offset, end_offset;
   ui::AXTextAffinity start_affinity, end_affinity;
   AXPlatformRange ax_range = CreateRangeFromTextMarkerRange(marker_range);
   if (ax_range.IsNull())
     return nil;
   start_object = ax_range.anchor()->GetAnchor();
   end_object = ax_range.focus()->GetAnchor();
   start_offset = ax_range.anchor()->text_offset();
@@ skipping 237 matching lines @@
 }  // namespace
 
 // The following private WebKit accessibility attribute became public in 10.12.
 #if !defined(MAC_OS_X_VERSION_10_12) || \
     MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_12
 extern "C" {
 NSString* const NSAccessibilityRequiredAttribute = @"AXRequired";
 }
 #endif  // MAC_OS_X_VERSION_10_12
 
-@implementation BrowserAccessibilityCocoa
+@interface BrowserAccessibilityCocoa ()
+
+// Lazily creates a TextMarkerHelper and returns it.
+- (TextMarkerHelperMac*)textMarkerHelper;
+
+@end
+
+@implementation BrowserAccessibilityCocoa {
+  base::scoped_nsobject<TextMarkerHelperMac> textMarkerHelper_;
+}
 
 + (void)initialize {
   const struct {
     NSString* attribute;
     NSString* methodName;
   } attributeToMethodNameContainer[] = {
       {NSAccessibilityARIAAtomicAttribute, @"ariaAtomic"},
       {NSAccessibilityARIABusyAttribute, @"ariaBusy"},
       {NSAccessibilityARIAColumnCountAttribute, @"ariaColumnCount"},
       {NSAccessibilityARIAColumnIndexAttribute, @"ariaColumnIndex"},
@@ skipping 422 matching lines @@
   return nil;
 }
 
 - (NSNumber*)enabled {
   if (![self instanceActive])
     return nil;
   return [NSNumber numberWithBool:
       !GetState(browserAccessibility_, ui::AX_STATE_DISABLED)];
 }
 
-// Returns a text marker that points to the last character in the document that
-// can be selected with VoiceOver.
+- (id)startTextMarker {
+  return [[self textMarkerHelper] startTextMarker];
+}
+
 - (id)endTextMarker {
-  const BrowserAccessibility* root =
-      browserAccessibility_->manager()->GetRoot();
-  if (!root)
-    return nil;
-
-  AXPlatformPositionInstance position = root->CreatePositionAt(0);
-  return CreateTextMarker(position->CreatePositionAtEndOfAnchor());
+  return [[self textMarkerHelper] endTextMarker];
 }
 
 - (NSNumber*)expanded {
   if (![self instanceActive])
     return nil;
   return [NSNumber numberWithBool:
       GetState(browserAccessibility_, ui::AX_STATE_EXPANDED)];
 }
 
 - (NSNumber*)focused {
@@ skipping 673 matching lines @@
   }
 
   if (selStart > selEnd)
     std::swap(selStart, selEnd);
 
   int selLength = selEnd - selStart;
   return [NSValue valueWithRange:NSMakeRange(selStart, selLength)];
 }
 
 - (id)selectedTextMarkerRange {
-  if (![self instanceActive])
-    return nil;
-
-  BrowserAccessibilityManager* manager = browserAccessibility_->manager();
-  if (!manager)
-    return nil;
-
-  int32_t anchorId = manager->GetTreeData().sel_anchor_object_id;
-  const BrowserAccessibility* anchorObject = manager->GetFromID(anchorId);
-  if (!anchorObject)
-    return nil;
-
-  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;
-
-  ui::AXTextAffinity anchorAffinity =
-        manager->GetTreeData().sel_anchor_affinity;
-  ui::AXTextAffinity focusAffinity = manager->GetTreeData().sel_focus_affinity;
-
-  return CreateTextMarkerRange(CreateTextRange(*anchorObject, anchorOffset,
-                                               anchorAffinity, *focusObject,
-                                               focusOffset, focusAffinity));
+  return [[self textMarkerHelper] selectedTextMarkerRange];
 }
 
 - (NSValue*)size {
   if (![self instanceActive])
     return nil;
   gfx::Rect bounds = browserAccessibility_->GetPageBoundsRect();
   return  [NSValue valueWithSize:NSMakeSize(bounds.width(), bounds.height())];
 }
 
 - (NSString*)sortDirection {
@@ skipping 13 matching lines @@
     return NSAccessibilityDescendingSortDirectionValue;
   case ui::AX_SORT_DIRECTION_OTHER:
     return NSAccessibilityUnknownSortDirectionValue;
   default:
     NOTREACHED();
   }
 
   return nil;
 }
 
-// Returns a text marker that points to the first character in the document that
-// can be selected with VoiceOver.
-- (id)startTextMarker {
-  const BrowserAccessibility* root =
-      browserAccessibility_->manager()->GetRoot();
-  if (!root)
-    return nil;
-
-  AXPlatformPositionInstance position = root->CreatePositionAt(0);
-  return CreateTextMarker(position->CreatePositionAtStartOfAnchor());
-}
-
 // 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 250 matching lines @@
   NSString* value = base::SysUTF16ToNSString(browserAccessibility_->GetValue());
   NSMutableAttributedString* attributedValue =
       [[[NSMutableAttributedString alloc] initWithString:value] autorelease];
   std::vector<const BrowserAccessibility*> textOnlyObjects =
       BrowserAccessibilityManager::FindTextOnlyObjectsInRange(
           *browserAccessibility_, *browserAccessibility_);
   AddMisspelledTextAttributes(textOnlyObjects, attributedValue);
   return [attributedValue attributedSubstringFromRange:range];
 }
 
+- (TextMarkerHelperMac*)textMarkerHelper {
+  if (!textMarkerHelper_) {
+    textMarkerHelper_.reset([[TextMarkerHelperMac alloc]
+        initWithFactory:base::MakeUnique<BrowserPositionFactory>(
+                            browserAccessibility_)]);
+  }
+  return textMarkerHelper_;
+}
+
 // Returns the accessibility value for the given attribute.  If the value isn't
 // supported this will return nil.
 - (id)accessibilityAttributeValue:(NSString*)attribute {
   if (![self instanceActive])
     return nil;
 
   SEL selector =
       NSSelectorFromString([self methodNameForAttribute:attribute]);
   if (selector)
     return [self performSelector:selector];
@@ skipping 96 matching lines @@
         }
         if (colIndex == column)
           return ToBrowserAccessibilityCocoa(cell);
         if (colIndex > column)
           break;
       }
     }
     return nil;
   }
 
-  if ([attribute isEqualToString:@"AXUIElementForTextMarker"]) {
-    AXPlatformPositionInstance position =
-        CreatePositionFromTextMarker(parameter);
-    if (!position->IsNullPosition())
-      return ToBrowserAccessibilityCocoa(position->GetAnchor());
-
-    return nil;
+  SEL selector = NSSelectorFromString([attribute stringByAppendingString:@":"]);
+  DCHECK(selector);
+  if ([TextMarkerHelperMac instancesRespondToSelector:selector]) {
+    return
+        [[self textMarkerHelper] performSelector:selector withObject:parameter];
   }
 
-  if ([attribute isEqualToString:@"AXTextMarkerRangeForUIElement"]) {
-    AXPlatformPositionInstance startPosition =
-        browserAccessibility_->CreatePositionAt(0);
-    AXPlatformPositionInstance endPosition =
-        startPosition->CreatePositionAtEndOfAnchor();
-    AXPlatformRange range =
-        AXPlatformRange(std::move(startPosition), std::move(endPosition));
-    return CreateTextMarkerRange(std::move(range));
-  }
-
+  // TODO(tapted): Move the next three to TextMarkerHelper.
   if ([attribute isEqualToString:@"AXStringForTextMarkerRange"])
     return GetTextForTextMarkerRange(parameter);
 
   if ([attribute isEqualToString:@"AXAttributedStringForTextMarkerRange"])
     return GetAttributedTextForTextMarkerRange(parameter);
 
-  if ([attribute isEqualToString:@"AXNextTextMarkerForTextMarker"]) {
-    AXPlatformPositionInstance position =
-        CreatePositionFromTextMarker(parameter);
-    if (position->IsNullPosition())
-      return nil;
-    return CreateTextMarker(position->CreateNextCharacterPosition());
-  }
-
-  if ([attribute isEqualToString:@"AXPreviousTextMarkerForTextMarker"]) {
-    AXPlatformPositionInstance position =
-        CreatePositionFromTextMarker(parameter);
-    if (position->IsNullPosition())
-      return nil;
-    return CreateTextMarker(position->CreatePreviousCharacterPosition());
-  }
-
-  if ([attribute isEqualToString:@"AXLeftWordTextMarkerRangeForTextMarker"]) {
-    AXPlatformPositionInstance endPosition =
-        CreatePositionFromTextMarker(parameter);
-    if (endPosition->IsNullPosition())
-      return nil;
-
-    AXPlatformPositionInstance startWordPosition =
-        endPosition->CreatePreviousWordStartPosition();
-    AXPlatformPositionInstance endWordPosition =
-        endPosition->CreatePreviousWordEndPosition();
-    AXPlatformPositionInstance startPosition =
-        *startWordPosition <= *endWordPosition ? std::move(endWordPosition)
-                                               : std::move(startWordPosition);
-    AXPlatformRange range(std::move(startPosition), std::move(endPosition));
-    return CreateTextMarkerRange(std::move(range));
-  }
-
-  if ([attribute isEqualToString:@"AXRightWordTextMarkerRangeForTextMarker"]) {
-    AXPlatformPositionInstance startPosition =
-        CreatePositionFromTextMarker(parameter);
-    if (startPosition->IsNullPosition())
-      return nil;
-
-    AXPlatformPositionInstance endWordPosition =
-        startPosition->CreateNextWordEndPosition();
-    AXPlatformPositionInstance startWordPosition =
-        startPosition->CreateNextWordStartPosition();
-    AXPlatformPositionInstance endPosition =
-        *startWordPosition <= *endWordPosition ? std::move(startWordPosition)
-                                               : std::move(endWordPosition);
-    AXPlatformRange range(std::move(startPosition), std::move(endPosition));
-    return CreateTextMarkerRange(std::move(range));
-  }
-
-  if ([attribute isEqualToString:@"AXNextWordEndTextMarkerForTextMarker"]) {
-    AXPlatformPositionInstance position =
-        CreatePositionFromTextMarker(parameter);
-    if (position->IsNullPosition())
-      return nil;
-    return CreateTextMarker(position->CreateNextWordEndPosition());
-  }
-
-  if ([attribute
-          isEqualToString:@"AXPreviousWordStartTextMarkerForTextMarker"]) {
-    AXPlatformPositionInstance position =
-        CreatePositionFromTextMarker(parameter);
-    if (position->IsNullPosition())
-      return nil;
-    return CreateTextMarker(position->CreatePreviousWordStartPosition());
-  }
-
-  if ([attribute isEqualToString:@"AXTextMarkerRangeForLine"]) {
-    AXPlatformPositionInstance position =
-        CreatePositionFromTextMarker(parameter);
-    if (position->IsNullPosition())
-      return nil;
-
-    AXPlatformPositionInstance startPosition =
-        position->CreatePreviousLineStartPosition();
-    AXPlatformPositionInstance endPosition =
-        position->CreateNextLineEndPosition();
-    AXPlatformRange range(std::move(startPosition), std::move(endPosition));
-    return CreateTextMarkerRange(std::move(range));
-  }
-
-  if ([attribute isEqualToString:@"AXLeftLineTextMarkerRangeForTextMarker"]) {
-    AXPlatformPositionInstance endPosition =
-        CreatePositionFromTextMarker(parameter);
-    if (endPosition->IsNullPosition())
-      return nil;
-
-    AXPlatformPositionInstance startLinePosition =
-        endPosition->CreatePreviousLineStartPosition();
-    AXPlatformPositionInstance endLinePosition =
-        endPosition->CreatePreviousLineEndPosition();
-    AXPlatformPositionInstance startPosition =
-        *startLinePosition <= *endLinePosition ? std::move(endLinePosition)
-                                               : std::move(startLinePosition);
-    AXPlatformRange range(std::move(startPosition), std::move(endPosition));
-    return CreateTextMarkerRange(std::move(range));
-  }
-
-  if ([attribute isEqualToString:@"AXRightLineTextMarkerRangeForTextMarker"]) {
-    AXPlatformPositionInstance startPosition =
-        CreatePositionFromTextMarker(parameter);
-    if (startPosition->IsNullPosition())
-      return nil;
-
-    AXPlatformPositionInstance startLinePosition =
-        startPosition->CreateNextLineStartPosition();
-    AXPlatformPositionInstance endLinePosition =
-        startPosition->CreateNextLineEndPosition();
-    AXPlatformPositionInstance endPosition =
-        *startLinePosition <= *endLinePosition ? std::move(startLinePosition)
-                                               : std::move(endLinePosition);
-    AXPlatformRange range(std::move(startPosition), std::move(endPosition));
-    return CreateTextMarkerRange(std::move(range));
-  }
-
-  if ([attribute isEqualToString:@"AXNextLineEndTextMarkerForTextMarker"]) {
-    AXPlatformPositionInstance position =
-        CreatePositionFromTextMarker(parameter);
-    if (position->IsNullPosition())
-      return nil;
-    return CreateTextMarker(position->CreateNextLineEndPosition());
-  }
-
-  if ([attribute
-          isEqualToString:@"AXPreviousLineStartTextMarkerForTextMarker"]) {
-    AXPlatformPositionInstance position =
-        CreatePositionFromTextMarker(parameter);
-    if (position->IsNullPosition())
-      return nil;
-    return CreateTextMarker(position->CreatePreviousLineStartPosition());
-  }
-
   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)
       return nil;
     NSRange range = [(NSValue*)parameter rangeValue];
@@ skipping 21 matching lines @@
       NSMutableArray* result = [NSMutableArray arrayWithCapacity:count];
       for (size_t i = 0; i < count; ++i) {
         BrowserAccessibility* match = search.GetMatchAtIndex(i);
         [result addObject:ToBrowserAccessibilityCocoa(match)];
       }
       return result;
     }
     return nil;
   }
 
-  if ([attribute isEqualToString:
-           NSAccessibilityLineTextMarkerRangeForTextMarkerParameterizedAttribute]) {
-    AXPlatformPositionInstance position =
-        CreatePositionFromTextMarker(parameter);
-    if (position->IsNullPosition())
-      return nil;
-
-    AXPlatformRange range(position->CreatePreviousLineStartPosition(),
-                          position->CreateNextLineEndPosition());
-    return CreateTextMarkerRange(std::move(range));
-  }
-
+  // TODO(tapted): Move this to TextMarkerHelper.
   if ([attribute isEqualToString:
            NSAccessibilityBoundsForTextMarkerRangeParameterizedAttribute]) {
     BrowserAccessibility* startObject;
     BrowserAccessibility* endObject;
     int startOffset, endOffset;
     AXPlatformRange range = CreateRangeFromTextMarkerRange(parameter);
     if (range.IsNull())
       return nil;
 
     startObject = range.anchor()->GetAnchor();
     endObject = range.focus()->GetAnchor();
     startOffset = range.anchor()->text_offset();
     endOffset = range.focus()->text_offset();
     DCHECK(startObject && endObject);
     DCHECK_GE(startOffset, 0);
     DCHECK_GE(endOffset, 0);
 
     gfx::Rect rect = BrowserAccessibilityManager::GetPageBoundsForRange(
         *startObject, startOffset, *endObject, endOffset);
     NSPoint origin = NSMakePoint(rect.x(), rect.y());
     NSSize size = NSMakeSize(rect.width(), rect.height());
     NSPoint pointInScreen = [self pointInScreen:origin size:size];
     NSRect nsrect = NSMakeRect(
         pointInScreen.x, pointInScreen.y, rect.width(), rect.height());
     return [NSValue valueWithRect:nsrect];
   }
 
   if ([attribute isEqualToString:
-           NSAccessibilityTextMarkerRangeForUnorderedTextMarkersParameterizedAttribute]) {
-    if (![parameter isKindOfClass:[NSArray class]])
-      return nil;
-
-    NSArray* text_marker_array = parameter;
-    if ([text_marker_array count] != 2)
-      return nil;
-
-    AXPlatformPositionInstance startPosition =
-        CreatePositionFromTextMarker([text_marker_array objectAtIndex:0]);
-    AXPlatformPositionInstance endPosition =
-        CreatePositionFromTextMarker([text_marker_array objectAtIndex:1]);
-    if (*startPosition <= *endPosition) {
-      return CreateTextMarkerRange(
-          AXPlatformRange(std::move(startPosition), std::move(endPosition)));
-    } else {
-      return CreateTextMarkerRange(
-          AXPlatformRange(std::move(endPosition), std::move(startPosition)));
-    }
-  }
-
-  if ([attribute isEqualToString:
            NSAccessibilityIndexForChildUIElementParameterizedAttribute]) {
     if (![parameter isKindOfClass:[BrowserAccessibilityCocoa class]])
       return nil;
 
     BrowserAccessibilityCocoa* childCocoaObj =
         (BrowserAccessibilityCocoa*)parameter;
     BrowserAccessibility* child = [childCocoaObj browserAccessibility];
     if (!child)
       return nil;
 
@@ skipping 476 matching lines @@
 }
 
 - (BOOL)accessibilityNotifiesWhenDestroyed {
   // Indicate that BrowserAccessibilityCocoa will post a notification when it's
   // destroyed (see -detach). This allows VoiceOver to do some internal things
   // more efficiently.
   return YES;
 }
 
 @end
+
+ui::AXPositionPointer BrowserPositionFactory::GetRoot() const {
+  const BrowserAccessibility* root =
+      browser_accessibility_->manager()->GetRoot();
+  if (!root)
+    return nullptr;
+
+  return root->CreatePositionAt(0);
+}
+
+ui::AXRangePointer BrowserPositionFactory::GetSelection() const {
+  if (!IsActive())
+    return ui::AXRangePointer(nullptr, nullptr);
+
+  BrowserAccessibilityManager* manager = browser_accessibility_->manager();
+  if (!manager)
+    return ui::AXRangePointer(nullptr, nullptr);
+
+  int32_t anchor_id = manager->GetTreeData().sel_anchor_object_id;
+  const BrowserAccessibility* anchor_object = manager->GetFromID(anchor_id);
+  if (!anchor_object)
+    return ui::AXRangePointer(nullptr, nullptr);
+
+  int32_t focus_id = manager->GetTreeData().sel_focus_object_id;
+  const BrowserAccessibility* focusObject = manager->GetFromID(focus_id);
+  if (!focusObject)
+    return ui::AXRangePointer(nullptr, nullptr);
+
+  int anchor_offset = manager->GetTreeData().sel_anchor_offset;
+  int focus_offset = manager->GetTreeData().sel_focus_offset;
+  if (anchor_offset < 0 || focus_offset < 0)
+    return ui::AXRangePointer(nullptr, nullptr);
+
+  ui::AXTextAffinity anchorAffinity =
+      manager->GetTreeData().sel_anchor_affinity;
+  ui::AXTextAffinity focusAffinity = manager->GetTreeData().sel_focus_affinity;
+
+  return CreateTextRange(*anchor_object, anchor_offset, anchorAffinity,
+                         *focusObject, focus_offset, focusAffinity);
+}
+
+ui::AXPositionPointer BrowserPositionFactory::GetFromData(
+    const ui::AXPositionData& data) const {
+  return AXPlatformPosition::CreateFromData(data);
+}
+
+id BrowserPositionFactory::GetAccessibilityObject(
+    const ui::AXPositionData& data) const {
+  AXPlatformPositionInstance position =
+      AXPlatformPosition::CreateFromData(data);
+  if (!position->IsNullPosition())
+    return ToBrowserAccessibilityCocoa(position->GetAnchor());
+
+  return nil;
+}