Introduce composed tree version of leftPositionOf()

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 144 matching lines @@
 {
     return canonicalPosition(position);
 }
 
 PositionInComposedTree canonicalPositionOf(const PositionInComposedTree& position)
 {
     return canonicalPosition(position);
 }
 
 template <typename Strategy>
-static PositionWithAffinityTemplate<Strategy> honorEditingBoundaryAtOrBeforeAlgorithm(const PositionWithAffinityTemplate<Strategy>& pos, const PositionAlgorithm<Strategy>& anchor)
+static PositionWithAffinityTemplate<Strategy> honorEditingBoundaryAtOrBefore(const PositionWithAffinityTemplate<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
     if (highestRoot && !pos.position().anchorNode()->isDescendantOf(highestRoot))
         return PositionWithAffinityTemplate<Strategy>();
@@ skipping 10 matching lines @@
     // editable.
     // TODO(yosin) Move to the previous non-editable region.
     if (!highestRoot)
         return PositionWithAffinityTemplate<Strategy>();
 
     // Return the last position before |pos| that is in the same editable region
     // as this position
     return lastEditablePositionBeforePositionInRoot(pos.position(), highestRoot);
 }
 
-static PositionWithAffinity honorEditingBoundaryAtOrBeforeOf(const PositionWithAffinity& pos, const Position& anchor)
+template <typename Strategy>
+static VisiblePositionTemplate<Strategy> honorEditingBoundaryAtOrBefore(const VisiblePositionTemplate<Strategy>& pos, const PositionAlgorithm<Strategy>& anchor)
 {
-    return honorEditingBoundaryAtOrBeforeAlgorithm(pos, anchor);
+    return createVisiblePosition(honorEditingBoundaryAtOrBefore(pos.toPositionWithAffinity(), anchor));
 }
 
-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 707 matching lines @@
     // Please refer to https://bugs.webkit.org/show_bug.cgi?id=49107 for detail.
     PositionWithAffinityTemplate<Strategy> visPos = startPositionForLine(c, mode);
 
     if (mode == UseLogicalOrdering) {
         if (ContainerNode* editableRoot = highestEditableRoot(c.position())) {
             if (!editableRoot->contains(visPos.position().computeContainerNode()))
                 return PositionWithAffinityTemplate<Strategy>(PositionAlgorithm<Strategy>::firstPositionInNode(editableRoot));
         }
     }
 
-    return honorEditingBoundaryAtOrBeforeOf(visPos, c.position());
+    return honorEditingBoundaryAtOrBefore(visPos, c.position());
 }
 
 static PositionWithAffinity startOfLine(const PositionWithAffinity& currentPosition)
 {
     return startOfLine(currentPosition, UseInlineBoxOrdering);
 }
 
 static PositionInComposedTreeWithAffinity startOfLine(const PositionInComposedTreeWithAffinity& currentPosition)
 {
     return startOfLine(currentPosition, UseInlineBoxOrdering);
@@ skipping 1603 matching lines @@
 UChar32 characterAfter(const VisiblePositionInComposedTree& visiblePosition)
 {
     return characterAfterAlgorithm<EditingInComposedTreeStrategy>(visiblePosition);
 }
 
 UChar32 characterBefore(const VisiblePosition& visiblePosition)
 {
     return characterAfter(previousPositionOf(visiblePosition));
 }
 
-static Position leftVisuallyDistinctCandidate(const VisiblePosition& visiblePosition)
+template <typename Strategy>
+static PositionAlgorithm<Strategy> leftVisuallyDistinctCandidate(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
-    const Position deepPosition = visiblePosition.deepEquivalent();
-    Position p = deepPosition;
+    const PositionAlgorithm<Strategy> deepPosition = visiblePosition.deepEquivalent();
+    PositionAlgorithm<Strategy> p = deepPosition;
+
     if (p.isNull())
-        return Position();
+        return PositionAlgorithm<Strategy>();
 
-    Position downstreamStart = mostForwardCaretPosition(p);
+    const PositionAlgorithm<Strategy> downstreamStart = mostForwardCaretPosition(p);
     TextDirection primaryDirection = primaryDirectionOf(*p.anchorNode());
     const TextAffinity affinity = visiblePosition.affinity();
 
     while (true) {
         InlineBoxPosition boxPosition = computeInlineBoxPosition(p, affinity, primaryDirection);
         InlineBox* box = boxPosition.inlineBox;
         int offset = boxPosition.offsetInBox;
         if (!box)
             return primaryDirection == LTR ? previousVisuallyDistinctCandidate(deepPosition) : nextVisuallyDistinctCandidate(deepPosition);
 
@@ skipping 17 matching lines @@
             int caretMinOffset = box->caretMinOffset();
             int caretMaxOffset = box->caretMaxOffset();
 
             if (offset > caretMinOffset && offset < caretMaxOffset)
                 break;
 
             if (box->isLeftToRightDirection() ? offset < caretMinOffset : offset > caretMaxOffset) {
                 // Overshot to the left.
                 InlineBox* prevBox = box->prevLeafChildIgnoringLineBreak();
                 if (!prevBox) {
-                    Position positionOnLeft = primaryDirection == LTR ? previousVisuallyDistinctCandidate(deepPosition) : nextVisuallyDistinctCandidate(deepPosition);
+                    PositionAlgorithm<Strategy> positionOnLeft = primaryDirection == LTR ? previousVisuallyDistinctCandidate(visiblePosition.deepEquivalent()) : nextVisuallyDistinctCandidate(visiblePosition.deepEquivalent());
                     if (positionOnLeft.isNull())
-                        return Position();
+                        return PositionAlgorithm<Strategy>();
 
                     InlineBox* boxOnLeft = computeInlineBoxPosition(positionOnLeft, affinity, primaryDirection).inlineBox;
                     if (boxOnLeft && boxOnLeft->root() == box->root())
-                        return Position();
+                        return PositionAlgorithm<Strategy>();
                     return positionOnLeft;
                 }
 
                 // Reposition at the other logical position corresponding to our
                 // edge's visual position and go for another round.
                 box = prevBox;
                 layoutObject = &box->layoutObject();
                 offset = prevBox->caretRightmostOffset();
                 continue;
             }
@@ skipping 43 matching lines @@
                 offset = box->caretRightmostOffset();
                 if (box->bidiLevel() > level) {
                     do {
                         prevBox = prevBox->prevLeafChild();
                     } while (prevBox && prevBox->bidiLevel() > level);
 
                     if (!prevBox || prevBox->bidiLevel() < level)
                         continue;
                 }
             } else {
-                // Trailing edge of a secondary run. Set to the leading edge of the entire run.
+                // Trailing edge of a secondary run. Set to the leading edge of
+                // the entire run.
                 while (true) {
                     while (InlineBox* nextBox = box->nextLeafChild()) {
                         if (nextBox->bidiLevel() < level)
                             break;
                         box = nextBox;
                     }
                     if (box->bidiLevel() == level)
                         break;
                     level = box->bidiLevel();
                     while (InlineBox* prevBox = box->prevLeafChild()) {
                         if (prevBox->bidiLevel() < level)
                             break;
                         box = prevBox;
                     }
                     if (box->bidiLevel() == level)
                         break;
                     level = box->bidiLevel();
                 }
                 layoutObject = &box->layoutObject();
                 offset = primaryDirection == LTR ? box->caretMinOffset() : box->caretMaxOffset();
             }
             break;
         }
 
-        p = Position::editingPositionOf(layoutObject->node(), offset);
+        p = PositionAlgorithm<Strategy>::editingPositionOf(layoutObject->node(), offset);
 
         if ((isVisuallyEquivalentCandidate(p) && mostForwardCaretPosition(p) != downstreamStart) || p.atStartOfTree() || p.atEndOfTree())
             return p;
 
         ASSERT(p != deepPosition);
     }
 }
 
-VisiblePosition leftPositionOf(const VisiblePosition& visiblePosition)
+template <typename Strategy>
+VisiblePositionTemplate<Strategy> leftPositionOfAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
-    const Position pos = leftVisuallyDistinctCandidate(visiblePosition);
+    const PositionAlgorithm<Strategy> pos = leftVisuallyDistinctCandidate(visiblePosition);
     // TODO(yosin) Why can't we move left from the last position in a tree?
     if (pos.atStartOfTree() || pos.atEndOfTree())
-        return VisiblePosition();
+        return VisiblePositionTemplate<Strategy>();
 
-    VisiblePosition left = createVisiblePosition(pos);
+    const VisiblePositionTemplate<Strategy> left = createVisiblePosition(pos);
     ASSERT(left.deepEquivalent() != visiblePosition.deepEquivalent());
 
     return directionOfEnclosingBlock(left.deepEquivalent()) == LTR ? honorEditingBoundaryAtOrBefore(left, visiblePosition.deepEquivalent()) : honorEditingBoundaryAtOrAfter(left, visiblePosition.deepEquivalent());
 }
 
+VisiblePosition leftPositionOf(const VisiblePosition& visiblePosition)
+{
+    return leftPositionOfAlgorithm<EditingStrategy>(visiblePosition);
+}
+
+VisiblePositionInComposedTree leftPositionOf(const VisiblePositionInComposedTree& visiblePosition)
+{
+    return leftPositionOfAlgorithm<EditingInComposedTreeStrategy>(visiblePosition);
+}
+
 static Position rightVisuallyDistinctCandidate(const VisiblePosition& visiblePosition)
 {
     const Position deepPosition = visiblePosition.deepEquivalent();
     Position p = deepPosition;
     if (p.isNull())
         return Position();
 
     Position downstreamStart = mostForwardCaretPosition(p);
     TextDirection primaryDirection = primaryDirectionOf(*p.anchorNode());
     const TextAffinity affinity = visiblePosition.affinity();
@@ skipping 220 matching lines @@
         return honorEditingBoundaryAtOrBefore(prev, visiblePosition.deepEquivalent());
     case CanSkipOverEditingBoundary:
         return skipToStartOfEditingBoundary(prev, visiblePosition.deepEquivalent());
     }
 
     ASSERT_NOT_REACHED();
     return honorEditingBoundaryAtOrBefore(prev, visiblePosition.deepEquivalent());
 }
 
 } // namespace blink