De-templatize ui::AXPosition

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>
@@ skipping 11 matching lines @@
 #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"
 
+using AXAbstractPositionInstance =
+    content::AXPlatformPosition::AXPositionInstance;
 using AXPlatformPositionInstance =
-    content::AXPlatformPosition::AXPositionInstance;
+    content::AXPlatformPosition::ConcreteInstance;
 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;
@@ skipping 89 matching lines @@
 AXTextMarkerRef AXTextMarkerRangeCopyStartMarker(
     AXTextMarkerRangeRef text_marker_range);
 
 AXTextMarkerRef AXTextMarkerRangeCopyEndMarker(
     AXTextMarkerRangeRef text_marker_range);
 
 #endif  // MAC_OS_X_VERSION_10_11
 
 }  // extern "C"
 
+static_assert(sizeof(AXPlatformPosition) == sizeof(ui::AXPositionBase),
+              "AXPosition size mismatch");
+constexpr size_t kAXPositionSize = sizeof(ui::AXPositionBase);
+
 // to call |release| on it to transfer ownership of the position to the text
 // marker object.
-id CreateTextMarker(AXPlatformPositionInstance position) {
+id CreateTextMarker(AXAbstractPositionInstance position) {
   AXTextMarkerRef text_marker = AXTextMarkerCreate(
       kCFAllocatorDefault, reinterpret_cast<const UInt8*>(position.release()),
-      sizeof(AXPlatformPosition));
+      kAXPositionSize);
   return static_cast<id>(
       base::mac::CFTypeRefToNSObjectAutorelease(text_marker));
 }
 
 // |range| is destructed at the end of this method and ownership of its |anchor|
 // and |focus| are transfered to the marker range object.
-id CreateTextMarkerRange(const AXPlatformRange range) {
+id CreateTextMarkerRange(const ui::AXAbstractRange range) {
   AXTextMarkerRef start_marker = AXTextMarkerCreate(
       kCFAllocatorDefault, reinterpret_cast<const UInt8*>(range.anchor()),
-      sizeof(AXPlatformPosition));
+      kAXPositionSize);
   AXTextMarkerRef end_marker = AXTextMarkerCreate(
       kCFAllocatorDefault, reinterpret_cast<const UInt8*>(range.focus()),
-      sizeof(AXPlatformPosition));
+      kAXPositionSize);
   AXTextMarkerRangeRef marker_range =
       AXTextMarkerRangeCreate(kCFAllocatorDefault, start_marker, end_marker);
   return static_cast<id>(
       base::mac::CFTypeRefToNSObjectAutorelease(marker_range));
 }
 
-AXPlatformPositionInstance CreatePositionFromTextMarker(
+AXPlatformPositionInstance CreateConcretePositionFromTextMarker(
     AXTextMarkerRef text_marker) {
   DCHECK(text_marker);
-  if (AXTextMarkerGetLength(text_marker) != sizeof(AXPlatformPosition))
-    return AXPlatformPosition::CreateNullPosition();
+  if (AXTextMarkerGetLength(text_marker) != kAXPositionSize)
+    return AXPlatformPosition::CreateConcreteNullPosition();
   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>(
+    return AXPlatformPosition::CreateConcreteNullPosition();
+  UInt8* destination_buffer = new UInt8[kAXPositionSize];
+  std::memcpy(destination_buffer, source_buffer, kAXPositionSize);
+  AXPlatformPositionInstance position(
+      reinterpret_cast<AXPlatformPositionInstance::pointer>(
           destination_buffer));
   if (!position)
-    return AXPlatformPosition::CreateNullPosition();
+    return AXPlatformPosition::CreateConcreteNullPosition();
   return position;
 }
 
+AXAbstractPositionInstance CreatePositionFromTextMarker(
+    AXTextMarkerRef text_marker) {
+  return base::WrapUnique(
+      CreateConcretePositionFromTextMarker(text_marker).release());
+}
+
 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());
+      CreateConcretePositionFromTextMarker(start_marker.get());
   AXPlatformPositionInstance focus =
-      CreatePositionFromTextMarker(end_marker.get());
+      CreateConcretePositionFromTextMarker(end_marker.get());
   // |AXPlatformRange| takes ownership of its anchor and focus.
   return AXPlatformRange(std::move(anchor), std::move(focus));
 }
 
 AXPlatformPositionInstance CreateTextPosition(
     const BrowserAccessibility& object,
     int offset,
     ui::AXTextAffinity affinity) {
   if (!object.instance_active())
-    return AXPlatformPosition::CreateNullPosition();
+    return AXPlatformPosition::CreateConcreteNullPosition();
 
   const BrowserAccessibilityManager* manager = object.manager();
   DCHECK(manager);
-  return AXPlatformPosition::CreateTextPosition(
+  return AXPlatformPosition::CreateConcreteTextPosition(
       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) {
   AXPlatformPositionInstance anchor =
@@ skipping 43 matching lines @@
 
 NSAttributedString* GetAttributedTextForTextMarkerRange(
     AXTextMarkerRangeRef 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_object = ax_range.GetAnchorNode();
+  end_object = ax_range.GetFocusNode();
   start_offset = ax_range.anchor()->text_offset();
   end_offset = ax_range.focus()->text_offset();
   start_affinity = ax_range.anchor()->affinity();
   end_affinity = ax_range.focus()->affinity();
 
   NSString* text = base::SysUTF16ToNSString(
       BrowserAccessibilityManager::GetTextForRange(*start_object, *end_object));
   if ([text length] == 0)
     return nil;
 
@@ skipping 679 matching lines @@
 }
 
 // Returns a text marker that points to the last character in the document that
 // can be selected with VoiceOver.
 - (id)endTextMarker {
   const BrowserAccessibility* root =
       browserAccessibility_->manager()->GetRoot();
   if (!root)
     return nil;
 
-  AXPlatformPositionInstance position = root->CreatePositionAt(0);
+  AXAbstractPositionInstance position = root->CreatePositionAt(0);
   return CreateTextMarker(position->CreatePositionAtEndOfAnchor());
 }
 
 - (NSNumber*)expanded {
   if (![self instanceActive])
     return nil;
   return [NSNumber numberWithBool:
       GetState(browserAccessibility_, ui::AX_STATE_EXPANDED)];
 }
 
@@ skipping 744 matching lines @@
 }
 
 // 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);
+  AXAbstractPositionInstance 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)) {
@@ skipping 371 matching lines @@
           return ToBrowserAccessibilityCocoa(cell);
         if (colIndex > column)
           break;
       }
     }
     return nil;
   }
 
   if ([attribute isEqualToString:@"AXUIElementForTextMarker"]) {
     AXPlatformPositionInstance position =
-        CreatePositionFromTextMarker(parameter);
+        CreateConcretePositionFromTextMarker(parameter);
     if (!position->IsNullPosition())
       return ToBrowserAccessibilityCocoa(position->GetAnchor());
 
     return nil;
   }
 
   if ([attribute isEqualToString:@"AXTextMarkerRangeForUIElement"]) {
-    AXPlatformPositionInstance startPosition =
+    AXAbstractPositionInstance startPosition =
         browserAccessibility_->CreatePositionAt(0);
-    AXPlatformPositionInstance endPosition =
+    AXAbstractPositionInstance endPosition =
         startPosition->CreatePositionAtEndOfAnchor();
-    AXPlatformRange range =
-        AXPlatformRange(std::move(startPosition), std::move(endPosition));
+    ui::AXAbstractRange range =
+        ui::AXAbstractRange(std::move(startPosition), std::move(endPosition));
     return CreateTextMarkerRange(std::move(range));
   }
 
   if ([attribute isEqualToString:@"AXStringForTextMarkerRange"])
     return GetTextForTextMarkerRange(parameter);
 
   if ([attribute isEqualToString:@"AXAttributedStringForTextMarkerRange"])
     return GetAttributedTextForTextMarkerRange(parameter);
 
   if ([attribute isEqualToString:@"AXNextTextMarkerForTextMarker"]) {
-    AXPlatformPositionInstance position =
+    AXAbstractPositionInstance position =
         CreatePositionFromTextMarker(parameter);
     if (position->IsNullPosition())
       return nil;
     return CreateTextMarker(position->CreateNextCharacterPosition());
   }
 
   if ([attribute isEqualToString:@"AXPreviousTextMarkerForTextMarker"]) {
-    AXPlatformPositionInstance position =
+    AXAbstractPositionInstance position =
         CreatePositionFromTextMarker(parameter);
     if (position->IsNullPosition())
       return nil;
     return CreateTextMarker(position->CreatePreviousCharacterPosition());
   }
 
   if ([attribute isEqualToString:@"AXLeftWordTextMarkerRangeForTextMarker"]) {
-    AXPlatformPositionInstance endPosition =
+    AXAbstractPositionInstance endPosition =
         CreatePositionFromTextMarker(parameter);
     if (endPosition->IsNullPosition())
       return nil;
 
-    AXPlatformPositionInstance startWordPosition =
+    AXAbstractPositionInstance startWordPosition =
         endPosition->CreatePreviousWordStartPosition();
-    AXPlatformPositionInstance endWordPosition =
+    AXAbstractPositionInstance endWordPosition =
         endPosition->CreatePreviousWordEndPosition();
-    AXPlatformPositionInstance startPosition =
+    AXAbstractPositionInstance startPosition =
         *startWordPosition <= *endWordPosition ? std::move(endWordPosition)
                                                : std::move(startWordPosition);
-    AXPlatformRange range(std::move(startPosition), std::move(endPosition));
+    ui::AXAbstractRange range(std::move(startPosition), std::move(endPosition));
     return CreateTextMarkerRange(std::move(range));
   }
 
   if ([attribute isEqualToString:@"AXRightWordTextMarkerRangeForTextMarker"]) {
-    AXPlatformPositionInstance startPosition =
+    AXAbstractPositionInstance startPosition =
         CreatePositionFromTextMarker(parameter);
     if (startPosition->IsNullPosition())
       return nil;
 
-    AXPlatformPositionInstance endWordPosition =
+    AXAbstractPositionInstance endWordPosition =
         startPosition->CreateNextWordEndPosition();
-    AXPlatformPositionInstance startWordPosition =
+    AXAbstractPositionInstance startWordPosition =
         startPosition->CreateNextWordStartPosition();
-    AXPlatformPositionInstance endPosition =
+    AXAbstractPositionInstance endPosition =
         *startWordPosition <= *endWordPosition ? std::move(startWordPosition)
                                                : std::move(endWordPosition);
-    AXPlatformRange range(std::move(startPosition), std::move(endPosition));
+    ui::AXAbstractRange range(std::move(startPosition), std::move(endPosition));
     return CreateTextMarkerRange(std::move(range));
   }
 
   if ([attribute isEqualToString:@"AXNextWordEndTextMarkerForTextMarker"]) {
-    AXPlatformPositionInstance position =
+    AXAbstractPositionInstance position =
         CreatePositionFromTextMarker(parameter);
     if (position->IsNullPosition())
       return nil;
     return CreateTextMarker(position->CreateNextWordEndPosition());
   }
 
   if ([attribute
           isEqualToString:@"AXPreviousWordStartTextMarkerForTextMarker"]) {
-    AXPlatformPositionInstance position =
+    AXAbstractPositionInstance position =
         CreatePositionFromTextMarker(parameter);
     if (position->IsNullPosition())
       return nil;
     return CreateTextMarker(position->CreatePreviousWordStartPosition());
   }
 
   if ([attribute isEqualToString:@"AXTextMarkerRangeForLine"]) {
-    AXPlatformPositionInstance position =
+    AXAbstractPositionInstance position =
         CreatePositionFromTextMarker(parameter);
     if (position->IsNullPosition())
       return nil;
 
-    AXPlatformPositionInstance startPosition =
+    AXAbstractPositionInstance startPosition =
         position->CreatePreviousLineStartPosition();
-    AXPlatformPositionInstance endPosition =
+    AXAbstractPositionInstance endPosition =
         position->CreateNextLineEndPosition();
-    AXPlatformRange range(std::move(startPosition), std::move(endPosition));
+    ui::AXAbstractRange range(std::move(startPosition), std::move(endPosition));
     return CreateTextMarkerRange(std::move(range));
   }
 
   if ([attribute isEqualToString:@"AXLeftLineTextMarkerRangeForTextMarker"]) {
-    AXPlatformPositionInstance endPosition =
+    AXAbstractPositionInstance endPosition =
         CreatePositionFromTextMarker(parameter);
     if (endPosition->IsNullPosition())
       return nil;
 
-    AXPlatformPositionInstance startLinePosition =
+    AXAbstractPositionInstance startLinePosition =
         endPosition->CreatePreviousLineStartPosition();
-    AXPlatformPositionInstance endLinePosition =
+    AXAbstractPositionInstance endLinePosition =
         endPosition->CreatePreviousLineEndPosition();
-    AXPlatformPositionInstance startPosition =
+    AXAbstractPositionInstance startPosition =
         *startLinePosition <= *endLinePosition ? std::move(endLinePosition)
                                                : std::move(startLinePosition);
-    AXPlatformRange range(std::move(startPosition), std::move(endPosition));
+    ui::AXAbstractRange range(std::move(startPosition), std::move(endPosition));
     return CreateTextMarkerRange(std::move(range));
   }
 
   if ([attribute isEqualToString:@"AXRightLineTextMarkerRangeForTextMarker"]) {
-    AXPlatformPositionInstance startPosition =
+    AXAbstractPositionInstance startPosition =
         CreatePositionFromTextMarker(parameter);
     if (startPosition->IsNullPosition())
       return nil;
 
-    AXPlatformPositionInstance startLinePosition =
+    AXAbstractPositionInstance startLinePosition =
         startPosition->CreateNextLineStartPosition();
-    AXPlatformPositionInstance endLinePosition =
+    AXAbstractPositionInstance endLinePosition =
         startPosition->CreateNextLineEndPosition();
-    AXPlatformPositionInstance endPosition =
+    AXAbstractPositionInstance endPosition =
         *startLinePosition <= *endLinePosition ? std::move(startLinePosition)
                                                : std::move(endLinePosition);
-    AXPlatformRange range(std::move(startPosition), std::move(endPosition));
+    ui::AXAbstractRange range(std::move(startPosition), std::move(endPosition));
     return CreateTextMarkerRange(std::move(range));
   }
 
   if ([attribute isEqualToString:@"AXNextLineEndTextMarkerForTextMarker"]) {
-    AXPlatformPositionInstance position =
+    AXAbstractPositionInstance position =
         CreatePositionFromTextMarker(parameter);
     if (position->IsNullPosition())
       return nil;
     return CreateTextMarker(position->CreateNextLineEndPosition());
   }
 
   if ([attribute
           isEqualToString:@"AXPreviousLineStartTextMarkerForTextMarker"]) {
-    AXPlatformPositionInstance position =
+    AXAbstractPositionInstance 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]];
   }
@@ skipping 29 matching lines @@
         BrowserAccessibility* match = search.GetMatchAtIndex(i);
         [result addObject:ToBrowserAccessibilityCocoa(match)];
       }
       return result;
     }
     return nil;
   }
 
   if ([attribute isEqualToString:
            NSAccessibilityLineTextMarkerRangeForTextMarkerParameterizedAttribute]) {
-    AXPlatformPositionInstance position =
+    AXAbstractPositionInstance position =
         CreatePositionFromTextMarker(parameter);
     if (position->IsNullPosition())
       return nil;
 
-    AXPlatformRange range(position->CreatePreviousLineStartPosition(),
-                          position->CreateNextLineEndPosition());
+    ui::AXAbstractRange range(position->CreatePreviousLineStartPosition(),
+                              position->CreateNextLineEndPosition());
     return CreateTextMarkerRange(std::move(range));
   }
 
   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();
+    startObject = range.GetAnchorNode();
+    endObject = range.GetFocusNode();
     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 =
+    AXAbstractPositionInstance startPosition =
         CreatePositionFromTextMarker([text_marker_array objectAtIndex:0]);
-    AXPlatformPositionInstance endPosition =
+    AXAbstractPositionInstance endPosition =
         CreatePositionFromTextMarker([text_marker_array objectAtIndex:1]);
     if (*startPosition <= *endPosition) {
-      return CreateTextMarkerRange(
-          AXPlatformRange(std::move(startPosition), std::move(endPosition)));
+      return CreateTextMarkerRange(ui::AXAbstractRange(std::move(startPosition),
+                                                       std::move(endPosition)));
     } else {
-      return CreateTextMarkerRange(
-          AXPlatformRange(std::move(endPosition), std::move(startPosition)));
+      return CreateTextMarkerRange(ui::AXAbstractRange(
+          std::move(endPosition), std::move(startPosition)));
     }
   }
 
   if ([attribute isEqualToString:
            NSAccessibilityIndexForChildUIElementParameterizedAttribute]) {
     if (![parameter isKindOfClass:[BrowserAccessibilityCocoa class]])
       return nil;
 
     BrowserAccessibilityCocoa* childCocoaObj =
         (BrowserAccessibilityCocoa*)parameter;
@@ skipping 480 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