a11y: Move CreateTextMarker[Range] to TextMarkerHelperMac.

ui/accessibility/ax_position.h

Index: ui/accessibility/ax_position.h
diff --git a/ui/accessibility/ax_position.h b/ui/accessibility/ax_position.h
index c38d9511128976a2f0f726799a4a89ff6c464d06..2cd3b5dccdc9ecb6433957909411565bad318378 100644
--- a/ui/accessibility/ax_position.h
+++ b/ui/accessibility/ax_position.h
@@ -17,19 +17,11 @@
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
+#include "ui/accessibility/ax_abstract_position.h"
 #include "ui/accessibility/ax_enums.h"
 
 namespace ui {
 
-// Defines the type of position in the accessibility tree.
-// A tree position is used when referring to a specific child of a node in the
-// accessibility tree.
-// A text position is used when referring to a specific character of text inside
-// a particular node.
-// A null position is used to signify that the provided data is invalid or that
-// a boundary has been reached.
-enum class AXPositionKind { NULL_POSITION, TREE_POSITION, TEXT_POSITION };
-
 // Forward declarations.
 template <class AXPositionType, class AXNodeType>
 class AXPosition;
@@ -70,23 +62,13 @@ bool operator!=(const AXPosition<AXPositionType, AXNodeType>& first,
 // This class can be copied using the |Clone| method. It is designed to be
 // immutable.
 template <class AXPositionType, class AXNodeType>
-class AXPosition {
+class AXPosition : public AXAbstractPosition {
  public:
   using AXPositionInstance =
       std::unique_ptr<AXPosition<AXPositionType, AXNodeType>>;
 
-  static const int INVALID_TREE_ID = -1;
-  static const int32_t INVALID_ANCHOR_ID = -1;
-  static const int BEFORE_TEXT = -1;
-  static const int INVALID_INDEX = -2;
-  static const int INVALID_OFFSET = -1;
-
   static AXPositionInstance CreateNullPosition() {
-    AXPositionInstance new_position(new AXPositionType());
-    new_position->Initialize(AXPositionKind::NULL_POSITION, INVALID_TREE_ID,
-                             INVALID_ANCHOR_ID, INVALID_INDEX, INVALID_OFFSET,
-                             AX_TEXT_AFFINITY_DOWNSTREAM);
-    return new_position;
+    return CreateFromData(kNullData);
   }
 
   static AXPositionInstance CreateTreePosition(int tree_id,
@@ -109,6 +91,18 @@ class AXPosition {
     return new_position;
   }
 
+  static AXPositionInstance CreateFromData(const AXPositionData& data) {
+    AXPositionInstance new_position(new AXPositionType());
+    // Skip Initialize() when creating from data.
+    new_position->kind_ = data.kind;
+    new_position->tree_id_ = data.tree_id;
+    new_position->anchor_id_ = data.anchor_id;
+    new_position->child_index_ = data.child_index;
+    new_position->text_offset_ = data.text_offset;
+    new_position->affinity_ = data.affinity;
+    return new_position;
+  }
+
   AXPosition() {}
   virtual ~AXPosition() {}
 
@@ -971,12 +965,12 @@ class AXPosition {
   virtual AXPosition<AXPositionType, AXNodeType>& operator=(
       const AXPosition<AXPositionType, AXNodeType>& other) = default;
 
-  virtual void Initialize(AXPositionKind kind,
-                          int tree_id,
-                          int32_t anchor_id,
-                          int child_index,
-                          int text_offset,
-                          AXTextAffinity affinity) {
+  void Initialize(AXPositionKind kind,
+                  int tree_id,
+                  int32_t anchor_id,
+                  int child_index,
+                  int text_offset,
+                  AXTextAffinity affinity) {
     kind_ = kind;
     tree_id_ = tree_id;
     anchor_id_ = anchor_id;
@@ -1106,6 +1100,56 @@ class AXPosition {
   virtual int32_t GetPreviousOnLineID(int32_t node_id) const = 0;
 
  private:
+  // AXAbstractPosition:
+  void ToData(AXPositionData* data) const override {
+    *data = {kind_,        tree_id_,     anchor_id_,
+             child_index_, text_offset_, affinity_};
+  }
+  bool IsNull() const override { return IsNullPosition(); }
+  bool Compare(const AXPositionPointer& other) const override {
+    return *this < *other.DownCastTo<AXPosition>();
+  }
+
+  AXPositionPointer PositionAtEndOfAnchor() const override {
+    return CreatePositionAtEndOfAnchor();
+  }
+  AXPositionPointer PositionAtStartOfAnchor() const override {
+    return CreatePositionAtStartOfAnchor();
+  }
+
+  AXPositionPointer NextCharacterPosition() const override {
+    return CreateNextCharacterPosition();
+  }
+  AXPositionPointer PreviousCharacterPosition() const override {
+    return CreatePreviousCharacterPosition();
+  }
+
+  AXPositionPointer NextWordStartPosition() const override {
+    return CreateNextWordStartPosition();
+  }
+  AXPositionPointer PreviousWordStartPosition() const override {
+    return CreatePreviousWordStartPosition();
+  }
+  AXPositionPointer NextWordEndPosition() const override {
+    return CreateNextWordEndPosition();
+  }
+  AXPositionPointer PreviousWordEndPosition() const override {
+    return CreatePreviousWordEndPosition();
+  }
+
+  AXPositionPointer NextLineStartPosition() const override {
+    return CreateNextLineStartPosition();
+  }
+  AXPositionPointer PreviousLineStartPosition() const override {
+    return CreatePreviousLineStartPosition();
+  }
+  AXPositionPointer NextLineEndPosition() const override {
+    return CreateNextLineEndPosition();
+  }
+  AXPositionPointer PreviousLineEndPosition() const override {
+    return CreatePreviousLineEndPosition();
+  }
+
   AXPositionKind kind_;
   int tree_id_;
   int32_t anchor_id_;
@@ -1121,17 +1165,6 @@ class AXPosition {
 };
 
 template <class AXPositionType, class AXNodeType>
-const int AXPosition<AXPositionType, AXNodeType>::INVALID_TREE_ID;
-template <class AXPositionType, class AXNodeType>
-const int32_t AXPosition<AXPositionType, AXNodeType>::INVALID_ANCHOR_ID;
-template <class AXPositionType, class AXNodeType>
-const int AXPosition<AXPositionType, AXNodeType>::BEFORE_TEXT;
-template <class AXPositionType, class AXNodeType>
-const int AXPosition<AXPositionType, AXNodeType>::INVALID_INDEX;
-template <class AXPositionType, class AXNodeType>
-const int AXPosition<AXPositionType, AXNodeType>::INVALID_OFFSET;
-
-template <class AXPositionType, class AXNodeType>
 bool operator==(const AXPosition<AXPositionType, AXNodeType>& first,
                 const AXPosition<AXPositionType, AXNodeType>& second) {
   if (first.IsNullPosition() && second.IsNullPosition())