De-templatize ui::AXPosition

ui/accessibility/ax_range.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_RANGE_H_
 #define UI_ACCESSIBILITY_AX_RANGE_H_
 
 #include <memory>
 #include <utility>
 
 #include "base/strings/string16.h"
+#include "ui/accessibility/ax_export.h"
+#include "ui/accessibility/ax_position.h"
 
 namespace ui {
 
 // A range of ax positions.
 //
 // In order to avoid any confusion regarding whether a deep or a shallow copy is
 // being performed, this class can be moved but not copied.
-template <class AXPositionType>
-class AXRange {
+class AX_EXPORT AXAbstractRange {
  public:
-  AXRange()
-      : anchor_(AXPositionType::CreateNullPosition()),
-        focus_(AXPositionType::CreateNullPosition()) {}
+  AXAbstractRange(std::unique_ptr<AXPositionBase> anchor,
+                  std::unique_ptr<AXPositionBase> focus);
+  AXAbstractRange(AXAbstractRange&& other);
 
-  AXRange(std::unique_ptr<AXPositionType> anchor,
-          std::unique_ptr<AXPositionType> focus) {
-    if (anchor) {
-      anchor_ = std::move(anchor);
-    } else {
-      anchor_ = AXPositionType::CreateNullPosition();
-    }
-    if (focus) {
-      focus_ = std::move(focus);
-    } else {
-      focus = AXPositionType::CreateNullPosition();
-    }
-  }
+  AXAbstractRange(const AXAbstractRange& other) = delete;
+  AXAbstractRange& operator=(const AXAbstractRange& other) = delete;
+  AXAbstractRange& operator=(AXAbstractRange&& other) = delete;
 
-  AXRange(const AXRange& other) = delete;
-
-  AXRange(AXRange&& other) : AXRange() {
-    anchor_.swap(other.anchor_);
-    focus_.swap(other.focus_);
-  }
-
-  AXRange& operator=(const AXRange& other) = delete;
-
-  AXRange& operator=(const AXRange&& other) {
-    if (this != other) {

[tapted, 2017/06/15 11:57:44]

I removed this method since it's not currently instantiated (otherwise this line
fails since `this` is a pointer but `other` is a ref).

-      anchor_ = AXPositionType::CreateNullPosition();
-      focus_ = AXPositionType::CreateNullPosition();
-      anchor_.swap(other.anchor_);
-      focus_.swap(other.focus_);
-    }
-    return *this;
-  }
-
-  virtual ~AXRange() {}
+  ~AXAbstractRange();
 
   bool IsNull() const {
     return !anchor_ || !focus_ || anchor_->IsNullPosition() ||
            focus_->IsNullPosition();
   }
 
-  AXPositionType* anchor() const {
-    DCHECK(anchor_);
-    return anchor_.get();
-  }
-
-  AXPositionType* focus() const {
-    DCHECK(focus_);
-    return focus_.get();
-  }
-
   base::string16 GetText() const {
     base::string16 text;
     if (IsNull())
       return text;
 
-    std::unique_ptr<AXPositionType> start, end;
+    std::unique_ptr<AXPositionBase> start, end;
     if (*anchor_ < *focus_) {
       start = anchor_->AsLeafTextPosition();
       end = focus_->AsLeafTextPosition();
     } else {
       start = focus_->AsLeafTextPosition();
       end = anchor_->AsLeafTextPosition();
     }
 
     int start_offset = start->text_offset();
     DCHECK_GE(start_offset, 0);
     int end_offset = end->text_offset();
     DCHECK_GE(end_offset, 0);
 
     do {
       text += start->GetInnerText();
       start = start->CreateNextTextAnchorPosition();
     } while (!start->IsNullPosition() && *start <= *end);
 
     if (static_cast<size_t>(start_offset) > text.length())
       return base::string16();
 
     text = text.substr(start_offset, base::string16::npos);
     size_t text_length = text.length() - end->GetInnerText().length() +
                          static_cast<size_t>(end_offset);
     return text.substr(0, text_length);
   }
 
+  AXPositionBase* anchor() const { return anchor_.get(); }
+  AXPositionBase* focus() const { return focus_.get(); }
+
+ protected:
+  std::unique_ptr<AXPositionBase> anchor_;
+  std::unique_ptr<AXPositionBase> focus_;
+};
+
+template <class AXPositionType>
+class AXRange : public AXAbstractRange {
+ public:
+  AXRange() : AXAbstractRange(CreateNull(), CreateNull()) {}
+  AXRange(std::unique_ptr<AXPositionType> anchor,
+          std::unique_ptr<AXPositionType> focus)
+      : AXAbstractRange(anchor ? AsBase(std::move(anchor)) : CreateNull(),
+                        focus ? AsBase(std::move(focus)) : CreateNull()) {}
+  AXRange(AXRange&& other) = default;
+
+  AXRange(const AXRange& other) = delete;
+  AXRange& operator=(const AXRange& other) = delete;
+  AXRange& operator=(AXRange&& other) = delete;
+
+  typename AXPositionType::ConcreteNodeType* GetAnchorNode() const {
+    return static_cast<AXPositionType*>(anchor_.get())->GetAnchor();
+  }
+  typename AXPositionType::ConcreteNodeType* GetFocusNode() const {
+    return static_cast<AXPositionType*>(focus_.get())->GetAnchor();
+  }
+
  private:
-  std::unique_ptr<AXPositionType> anchor_;
-  std::unique_ptr<AXPositionType> focus_;
+  static std::unique_ptr<AXPositionBase> AsBase(
+      std::unique_ptr<AXPositionType> concrete) {
+    return base::WrapUnique<AXPositionBase>(concrete.release());
+  }
+
+  static std::unique_ptr<AXPositionBase> CreateNull() {
+    return AsBase(AXPositionType::CreateConcreteNullPosition());
+  }
 };
 
 }  // namespace ui
 
 #endif  // UI_ACCESSIBILITY_AX_RANGE_H_