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

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 11 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/editing/Position.h"
 
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/TextAffinity.h"
-#include "core/editing/VisibleUnits.h"
-#include "core/layout/LayoutObject.h"
 #include "wtf/text/CString.h"
 #include <stdio.h>
 
 namespace blink {
 
 #if ENABLE(ASSERT)
 static bool canBeAnchorNode(Node* node)
 {
     if (!node || node->isFirstLetterPseudoElement())
         return true;
@@ skipping 248 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> 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);
-}
-
-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>
 bool PositionAlgorithm<Strategy>::atFirstEditingPositionForNode() const
 {
     if (isNull())
         return true;
     // FIXME: Position before anchor shouldn't be considered as at the first editing position for node
     // since that position resides outside of the node.
     switch (m_anchorType) {
     case PositionAnchorType::OffsetInAnchor:
         return m_offset == 0;
@@ skipping 217 matching lines @@
 
 void showTree(const blink::Position* pos)
 {
     if (pos)
         pos->showTreeForThis();
     else
         fprintf(stderr, "Cannot showTree for (nil)\n");
 }
 
 #endif