Move {next,previous}PositionOf() to EditingUtilities.{cpp,h} from Position.{cpp,h}

Source/core/editing/EditingUtilities.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007 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 488 matching lines @@
 Position lastEditablePositionBeforePositionInRoot(const Position& position, Node* highestRoot)
 {
     return lastEditablePositionBeforePositionInRootAlgorithm<Position>(position, highestRoot);
 }
 
 PositionInComposedTree lastEditablePositionBeforePositionInRoot(const PositionInComposedTree& position, Node* highestRoot)
 {
     return lastEditablePositionBeforePositionInRootAlgorithm<PositionInComposedTree>(position, highestRoot);
 }
 
+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;
+}
+
+int uncheckedNextOffset(const Node* n, int current)
+{
+    return n->layoutObject() ? n->layoutObject()->nextOffset(current) : current + 1;
+}
+
+template <typename Strategy>
+PositionAlgorithm<Strategy> previousPositionOfAlgorithm(const PositionAlgorithm<Strategy>& position, PositionMoveType moveType)
+{
+    Node* const node = position.anchorNode();
+    if (!node)
+        return position;
+
+    const int offset = position.computeEditingOffset();
+
+    if (offset > 0) {
+        if (editingIgnoresContent(node))
+            return PositionAlgorithm<Strategy>::beforeNode(node);
+        if (Node* child = Strategy::childAt(*node, offset - 1))
+            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.
+        switch (moveType) {
+        case PositionMoveType::CodePoint:
+            return PositionAlgorithm<Strategy>(node, offset - 1);
+        case PositionMoveType::Character:
+            return PositionAlgorithm<Strategy>(node, uncheckedPreviousOffset(node, offset));
+        case PositionMoveType::BackwardDeletion:
+            return PositionAlgorithm<Strategy>(node, uncheckedPreviousOffsetForBackwardDeletion(node, offset));
+        }
+    }
+
+    if (ContainerNode* parent = Strategy::parent(*node)) {
+        if (editingIgnoresContent(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 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> nextPositionOfAlgorithm(const PositionAlgorithm<Strategy>& position, PositionMoveType moveType)
+{
+    ASSERT(moveType != PositionMoveType::BackwardDeletion);
+
+    Node* node = position.anchorNode();
+    if (!node)
+        return position;
+
+    const int offset = position.computeEditingOffset();
+
+    if (Node* child = Strategy::childAt(*node, offset))
+        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 PositionAlgorithm<Strategy>::editingPositionOf(node, (moveType == PositionMoveType::Character) ? uncheckedNextOffset(node, offset) : offset + 1);
+    }
+
+    if (ContainerNode* parent = Strategy::parent(*node))
+        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);
+}
+
 // FIXME: The method name, comment, and code say three different things here!
 // Whether or not content before and after this node will collapse onto the same line as it.
 bool isBlock(const Node* node)
 {
     return node && node->layoutObject() && !node->layoutObject()->isInline() && !node->layoutObject()->isRubyText();
 }
 
 bool isInline(const Node* node)
 {
     return node && node->layoutObject() && node->layoutObject()->isInline();
@@ skipping 929 matching lines @@
     // if the selection starts just before a paragraph break, skip over it
     if (isEndOfParagraph(visiblePosition))
         return mostForwardCaretPosition(visiblePosition.next().deepEquivalent());
 
     // otherwise, make sure to be at the start of the first selected node,
     // instead of possibly at the end of the last node before the selection
     return mostForwardCaretPosition(visiblePosition.deepEquivalent());
 }
 
 } // namespace blink