Introduce {next,previous}PositionOf() as replacement of {next,previous}() member functions in Positi

Source/core/editing/Position.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 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 281 matching lines @@
     int offsetB = positionB.computeOffsetInContainerNode();
     return comparePositionsInComposedTree(containerA, offsetA, containerB, offsetB);
 }
 
 template <typename Strategy>
 int PositionAlgorithm<Strategy>::compareTo(const PositionAlgorithm<Strategy>& other) const
 {
     return comparePositions(*this, other);
 }
 
+// TODO(yosin) We should move |uncheckedPreviousOffsetForBackwardDeletion()|
+// to "EditingUtilities.cpp" with |previousPositionOf()|.
 // TODO(yosin) To avoid forward declaration, we should move implementation of
 // |uncheckedPreviousOffsetForBackwardDeletion()| here.
 static int uncheckedPreviousOffsetForBackwardDeletion(const Node*, int current);
 
 template <typename Strategy>
-PositionAlgorithm<Strategy> PositionAlgorithm<Strategy>::previous(PositionMoveType moveType) const
+PositionAlgorithm<Strategy> previousPositionOfAlgorithm(const PositionAlgorithm<Strategy>& position, PositionMoveType moveType)
 {
-    Node* node = anchorNode();
+    Node* const node = position.anchorNode();
     if (!node)
-        return PositionAlgorithm<Strategy>(*this);
+        return position;
 
-    int offset = computeEditingOffset();
+    const int offset = position.computeEditingOffset();
 
     if (offset > 0) {
         if (editingIgnoresContent(node))
-            return beforeNode(node);
+            return PositionAlgorithm<Strategy>::beforeNode(node);
         if (Node* child = Strategy::childAt(*node, offset - 1))
-            return lastPositionInOrAfterNode(child);
+            return PositionAlgorithm<Strategy>::lastPositionInOrAfterNode(child);
 
         // There are two reasons child might be 0:
-        //   1) The node is node like a text node that is not an element, and therefore has no children.
-        //      Going backward one character at a time is correct.
-        //   2) The old offset was a bogus offset like (<br>, 1), and there is no child.
-        //      Going from 1 to 0 is correct.
+        //   1) The node is node like a text node that is not an element, and
+        //      therefore has no children. Going backward one character at a
+        //      time is correct.
+        //   2) The old offset was a bogus offset like (<br>, 1), and there is
+        //      no child. Going from 1 to 0 is correct.
         switch (moveType) {
-        case CodePoint:
+        case PositionMoveType::CodePoint:
             return PositionAlgorithm<Strategy>(node, offset - 1);
-        case Character:
+        case PositionMoveType::Character:
             return PositionAlgorithm<Strategy>(node, uncheckedPreviousOffset(node, offset));
-        case BackwardDeletion:
+        case PositionMoveType::BackwardDeletion:
             return PositionAlgorithm<Strategy>(node, uncheckedPreviousOffsetForBackwardDeletion(node, offset));
         }
     }
 
     if (ContainerNode* parent = Strategy::parent(*node)) {
         if (editingIgnoresContent(parent))
-            return beforeNode(parent);
+            return PositionAlgorithm<Strategy>::beforeNode(parent);
         // TODO(yosin) We should use |Strategy::index(Node&)| instead of
         // |Node::nodeIndex()|.
         return PositionAlgorithm<Strategy>(parent, node->nodeIndex());
     }
-    return PositionAlgorithm<Strategy>(*this);
+    return position;
+}
+
+Position previousPositionOf(const Position& position, PositionMoveType moveType)
+{
+    return previousPositionOfAlgorithm<EditingStrategy>(position, moveType);
+}
+
+PositionInComposedTree previousPositionOf(const PositionInComposedTree& position, PositionMoveType moveType)
+{
+    return previousPositionOfAlgorithm<EditingInComposedTreeStrategy>(position, moveType);
 }
 
 template <typename Strategy>
-PositionAlgorithm<Strategy> PositionAlgorithm<Strategy>::next(PositionMoveType moveType) const
+PositionAlgorithm<Strategy> nextPositionOfAlgorithm(const PositionAlgorithm<Strategy>& position, PositionMoveType moveType)
 {
-    ASSERT(moveType != BackwardDeletion);
+    ASSERT(moveType != PositionMoveType::BackwardDeletion);
 
-    Node* node = anchorNode();
+    Node* node = position.anchorNode();
     if (!node)
-        return PositionAlgorithm<Strategy>(*this);
+        return position;
 
-    int offset = computeEditingOffset();
+    const int offset = position.computeEditingOffset();
 
     if (Node* child = Strategy::childAt(*node, offset))
-        return firstPositionInOrBeforeNode(child);
+        return PositionAlgorithm<Strategy>::firstPositionInOrBeforeNode(child);
 
     // TODO(yosin) We should use |Strategy::lastOffsetForEditing()| instead of
     // DOM tree version.
     if (!Strategy::hasChildren(*node) && offset < EditingStrategy::lastOffsetForEditing(node)) {
         // There are two reasons child might be 0:
-        //   1) The node is node like a text node that is not an element, and therefore has no children.
-        //      Going forward one character at a time is correct.
-        //   2) The new offset is a bogus offset like (<br>, 1), and there is no child.
-        //      Going from 0 to 1 is correct.
-        return editingPositionOf(node, (moveType == Character) ? uncheckedNextOffset(node, offset) : offset + 1);
+        //   1) The node is node like a text node that is not an element, and
+        //      therefore has no children. Going forward one character at a time
+        //      is correct.
+        //   2) The new offset is a bogus offset like (<br>, 1), and there is no
+        //      child. Going from 0 to 1 is correct.
+        return PositionAlgorithm<Strategy>::editingPositionOf(node, (moveType == PositionMoveType::Character) ? uncheckedNextOffset(node, offset) : offset + 1);
     }
 
     if (ContainerNode* parent = Strategy::parent(*node))
-        return editingPositionOf(parent, Strategy::index(*node) + 1);
-    return PositionAlgorithm<Strategy>(*this);
+        return PositionAlgorithm<Strategy>::editingPositionOf(parent, Strategy::index(*node) + 1);
+    return position;
+}
+
+Position nextPositionOf(const Position& position, PositionMoveType moveType)
+{
+    return nextPositionOfAlgorithm<EditingStrategy>(position, moveType);
+}
+
+PositionInComposedTree nextPositionOf(const PositionInComposedTree& position, PositionMoveType moveType)
+{
+    return nextPositionOfAlgorithm<EditingInComposedTreeStrategy>(position, moveType);
 }
 
 int uncheckedPreviousOffset(const Node* n, int current)
 {
     return n->layoutObject() ? n->layoutObject()->previousOffset(current) : current - 1;
 }
 
 static int uncheckedPreviousOffsetForBackwardDeletion(const Node* n, int current)
 {
     return n->layoutObject() ? n->layoutObject()->previousOffsetForBackwardDeletion(current) : current - 1;
@@ skipping 246 matching lines @@
 
 void showTree(const blink::Position* pos)
 {
     if (pos)
         pos->showTreeForThis();
     else
         fprintf(stderr, "Cannot showTree for (nil)\n");
 }
 
 #endif