a11y: Move CreateTextMarker[Range] to TextMarkerHelperMac.

ui/accessibility/ax_position.h

 // Copyright 2016 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.
 
 #ifndef UI_ACCESSIBILITY_AX_POSITION_H_
 #define UI_ACCESSIBILITY_AX_POSITION_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <stack>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/stl_util.h"
 #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;
 template <class AXPositionType, class AXNodeType>
 bool operator==(const AXPosition<AXPositionType, AXNodeType>& first,
                 const AXPosition<AXPositionType, AXNodeType>& second);
 template <class AXPositionType, class AXNodeType>
 bool operator!=(const AXPosition<AXPositionType, AXNodeType>& first,
                 const AXPosition<AXPositionType, AXNodeType>& second);
 
@@ skipping 20 matching lines @@
 // This class template uses static polymorphism in order to allow sub-classes to
 // be created from the base class without the base class knowing the type of the
 // sub-class in advance.
 // The template argument |AXPositionType| should always be set to the type of
 // any class that inherits from this template, making this a
 // "curiously recursive template".
 //
 // 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,
                                                int32_t anchor_id,
                                                int child_index) {
     AXPositionInstance new_position(new AXPositionType());
     new_position->Initialize(AXPositionKind::TREE_POSITION, tree_id, anchor_id,
                              child_index, INVALID_OFFSET,
                              AX_TEXT_AFFINITY_DOWNSTREAM);
     return new_position;
   }
 
   static AXPositionInstance CreateTextPosition(int tree_id,
                                                int32_t anchor_id,
                                                int text_offset,
                                                AXTextAffinity affinity) {
     AXPositionInstance new_position(new AXPositionType());
     new_position->Initialize(AXPositionKind::TEXT_POSITION, tree_id, anchor_id,
                              INVALID_INDEX, text_offset, affinity);
     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() {}
 
   virtual AXPositionInstance Clone() const = 0;
 
   std::string ToString() const {
     std::string str;
     switch (kind_) {
       case AXPositionKind::NULL_POSITION:
         return "NullPosition";
@@ skipping 842 matching lines @@
 
   // Returns the text that is present inside the anchor node, including any text
   // found in descendant nodes.
   virtual base::string16 GetInnerText() const = 0;
 
  protected:
   AXPosition(const AXPosition<AXPositionType, AXNodeType>& other) = default;
   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;
     child_index_ = child_index;
     text_offset_ = text_offset;
     affinity_ = affinity;
 
     if (!GetAnchor() || kind_ == AXPositionKind::NULL_POSITION ||
         (kind_ == AXPositionKind::TREE_POSITION &&
          (child_index_ != BEFORE_TEXT &&
@@ skipping 109 matching lines @@
   // On some platforms, embedded objects are represented in their parent with a
   // single embedded object character.
   virtual int MaxTextOffsetInParent() const { return MaxTextOffset(); }
   virtual bool IsInLineBreak() const = 0;
   virtual std::vector<int32_t> GetWordStartOffsets() const = 0;
   virtual std::vector<int32_t> GetWordEndOffsets() const = 0;
   virtual int32_t GetNextOnLineID(int32_t node_id) const = 0;
   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_;
 
   // For text positions, |child_index_| is initially set to |-1| and only
   // computed on demand. The same with tree positions and |text_offset_|.
   int child_index_;
   int text_offset_;
 
   // TODO(nektar): Get rid of affinity and make Blink handle affinity
   // internally since inline text objects don't span lines.
   AXTextAffinity affinity_;
 };
 
 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())
     return true;
   return first.tree_id() == second.tree_id() &&
          first.anchor_id() == second.anchor_id() &&
          first.child_index() == second.child_index() &&
          first.text_offset() == second.text_offset() &&
          first.affinity() == second.affinity();
 }
@@ skipping 44 matching lines @@
 
 template <class AXPositionType, class AXNodeType>
 bool operator>=(const AXPosition<AXPositionType, AXNodeType>& first,
                 const AXPosition<AXPositionType, AXNodeType>& second) {
   return first == second || first > second;
 }
 
 }  // namespace ui
 
 #endif  // UI_ACCESSIBILITY_AX_POSITION_H_