Introduce composed tree version of nextPositionOf()

Source/core/editing/VisibleUnits.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 190 matching lines @@
 static PositionInComposedTreeWithAffinity honorEditingBoundaryAtOrBeforeOf(const PositionInComposedTreeWithAffinity& pos, const PositionInComposedTree& anchor)
 {
     return honorEditingBoundaryAtOrBeforeAlgorithm(pos, anchor);
 }
 
 static VisiblePosition honorEditingBoundaryAtOrBefore(const VisiblePosition& pos, const Position& anchor)
 {
     return createVisiblePosition(honorEditingBoundaryAtOrBeforeOf(pos.toPositionWithAffinity(), anchor));
 }
 
-static VisiblePosition honorEditingBoundaryAtOrAfter(const VisiblePosition& pos, const Position& anchor)
+template <typename Strategy>
+static VisiblePositionTemplate<Strategy> honorEditingBoundaryAtOrAfter(const VisiblePositionTemplate<Strategy>& pos, const PositionAlgorithm<Strategy>& anchor)
 {
     if (pos.isNull())
         return pos;
 
     ContainerNode* highestRoot = highestEditableRoot(anchor);
 
     // Return empty position if |pos| is not somewhere inside the editable
-    // region // containing this position
+    // region containing this position
     if (highestRoot && !pos.deepEquivalent().anchorNode()->isDescendantOf(highestRoot))
-        return VisiblePosition();
+        return VisiblePositionTemplate<Strategy>();
 
     // Return |pos| itself if the two are from the very same editable region, or
     // both are non-editable
     // TODO(yosin) In the non-editable case, just because the new position is
     // non-editable doesn't mean movement to it is allowed.
     // |VisibleSelection::adjustForEditableContent()| has this problem too.
     if (highestEditableRoot(pos.deepEquivalent()) == highestRoot)
         return pos;
 
     // Return empty position if this position is non-editable, but |pos| is
-    // editable
+    // editable.
     // TODO(yosin) Move to the next non-editable region.
     if (!highestRoot)
-        return VisiblePosition();
+        return VisiblePositionTemplate<Strategy>();
 
     // Return the next position after |pos| that is in the same editable region
     // as this position
     return firstEditableVisiblePositionAfterPositionInRoot(pos.deepEquivalent(), highestRoot);
 }
 
 static Node* previousLeafWithSameEditability(Node* node, EditableType editableType)
 {
     bool editable = node->hasEditableStyle(editableType);
     node = previousAtomicLeafNode(*node);
@@ skipping 2273 matching lines @@
 IntRect absoluteCaretBoundsOf(const VisiblePosition& visiblePosition)
 {
     return absoluteCaretBoundsOfAlgorithm<EditingStrategy>(visiblePosition);
 }
 
 IntRect absoluteCaretBoundsOf(const VisiblePositionInComposedTree& visiblePosition)
 {
     return absoluteCaretBoundsOfAlgorithm<EditingInComposedTreeStrategy>(visiblePosition);
 }
 
-static VisiblePosition skipToEndOfEditingBoundary(const VisiblePosition& pos, const Position& anchor)
+template <typename Strategy>
+static VisiblePositionTemplate<Strategy> skipToEndOfEditingBoundary(const VisiblePositionTemplate<Strategy>& pos, const PositionAlgorithm<Strategy>& anchor)
 {
     if (pos.isNull())
         return pos;
 
     ContainerNode* highestRoot = highestEditableRoot(anchor);
     ContainerNode* highestRootOfPos = highestEditableRoot(pos.deepEquivalent());
 
-    // Return |pos| itself if the two are from the very same editable region, or
-    // both are non-editable.
+    // Return |pos| itself if the two are from the very same editable region,
+    // or both are non-editable.
     if (highestRootOfPos == highestRoot)
         return pos;
 
     // If this is not editable but |pos| has an editable root, skip to the end
     if (!highestRoot && highestRootOfPos)
-        return createVisiblePosition(Position(highestRootOfPos, PositionAnchorType::AfterAnchor).parentAnchoredEquivalent());
+        return createVisiblePosition(PositionAlgorithm<Strategy>(highestRootOfPos, PositionAnchorType::AfterAnchor).parentAnchoredEquivalent());
 
     // That must mean that |pos| is not editable. Return the next position after
     // |pos| that is in the same editable region as this position
     return firstEditableVisiblePositionAfterPositionInRoot(pos.deepEquivalent(), highestRoot);
 }
 
 template <typename Strategy>
 static UChar32 characterAfterAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
     // We canonicalize to the first of two equivalent candidates, but the second
@@ skipping 351 matching lines @@
     // TODO(yosin) Why can't we move left from the last position in a tree?
     if (pos.atStartOfTree() || pos.atEndOfTree())
         return VisiblePosition();
 
     VisiblePosition right = createVisiblePosition(pos);
     ASSERT(right.deepEquivalent() != visiblePosition.deepEquivalent());
 
     return directionOfEnclosingBlock(right.deepEquivalent()) == LTR ? honorEditingBoundaryAtOrAfter(right, visiblePosition.deepEquivalent()) : honorEditingBoundaryAtOrBefore(right, visiblePosition.deepEquivalent());
 }
 
-VisiblePosition nextPositionOf(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
+template <typename Strategy>
+static VisiblePositionTemplate<Strategy> nextPositionOfAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition, EditingBoundaryCrossingRule rule)
 {
-    VisiblePosition next = createVisiblePosition(nextVisuallyDistinctCandidate(visiblePosition.deepEquivalent()), visiblePosition.affinity());
+    const VisiblePositionTemplate<Strategy> next = createVisiblePosition(nextVisuallyDistinctCandidate(visiblePosition.deepEquivalent()), visiblePosition.affinity());
 
     switch (rule) {
     case CanCrossEditingBoundary:
         return next;
     case CannotCrossEditingBoundary:
         return honorEditingBoundaryAtOrAfter(next, visiblePosition.deepEquivalent());
     case CanSkipOverEditingBoundary:
         return skipToEndOfEditingBoundary(next, visiblePosition.deepEquivalent());
     }
     ASSERT_NOT_REACHED();
     return honorEditingBoundaryAtOrAfter(next, visiblePosition.deepEquivalent());
 }
 
+VisiblePosition nextPositionOf(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
+{
+    return nextPositionOfAlgorithm<EditingStrategy>(visiblePosition, rule);
+}
+
+VisiblePositionInComposedTree nextPositionOf(const VisiblePositionInComposedTree& visiblePosition, EditingBoundaryCrossingRule rule)
+{
+    return nextPositionOfAlgorithm<EditingInComposedTreeStrategy>(visiblePosition, rule);
+}
+
 static VisiblePosition skipToStartOfEditingBoundary(const VisiblePosition& pos, const Position& anchor)
 {
     if (pos.isNull())
         return pos;
 
     ContainerNode* highestRoot = highestEditableRoot(anchor);
     ContainerNode* highestRootOfPos = highestEditableRoot(pos.deepEquivalent());
 
     // Return |pos| itself if the two are from the very same editable region, or
     // both are non-editable.
@@ skipping 37 matching lines @@
         return honorEditingBoundaryAtOrBefore(prev, visiblePosition.deepEquivalent());
     case CanSkipOverEditingBoundary:
         return skipToStartOfEditingBoundary(prev, visiblePosition.deepEquivalent());
     }
 
     ASSERT_NOT_REACHED();
     return honorEditingBoundaryAtOrBefore(prev, visiblePosition.deepEquivalent());
 }
 
 } // namespace blink