Get rid of redundant member function PositionAlgorithm<Strategy>::{upstream,downstream}

Source/core/editing/commands/CompositeEditCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 2007, 2008 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 682 matching lines @@
         return;
     Text* textNode = toText(node);
 
     if (textNode->length() == 0)
         return;
     LayoutText* layoutText = textNode->layoutObject();
     if (layoutText && !layoutText->style()->collapseWhiteSpace())
         return;
 
     // Delete collapsed whitespace so that inserting nbsps doesn't uncollapse it.
-    Position upstreamPos = position.upstream();
-    deleteInsignificantText(upstreamPos, position.downstream());
-    position = upstreamPos.downstream();
+    Position upstreamPos = mostBackwardCaretPosition(position);
+    deleteInsignificantText(upstreamPos, mostForwardCaretPosition(position));
+    position = mostForwardCaretPosition(upstreamPos);
 
     VisiblePosition visiblePos(position);
     VisiblePosition previousVisiblePos(visiblePos.previous());
     replaceCollapsibleWhitespaceWithNonBreakingSpaceIfNeeded(previousVisiblePos);
     replaceCollapsibleWhitespaceWithNonBreakingSpaceIfNeeded(visiblePos);
 }
 
 void CompositeEditCommand::replaceCollapsibleWhitespaceWithNonBreakingSpaceIfNeeded(const VisiblePosition& visiblePosition)
 {
     if (!isCollapsibleWhitespace(visiblePosition.characterAfter()))
         return;
-    Position pos = visiblePosition.deepEquivalent().downstream();
+    Position pos = mostForwardCaretPosition(visiblePosition.deepEquivalent());
     if (!pos.computeContainerNode() || !pos.computeContainerNode()->isTextNode())
         return;
     replaceTextInNodePreservingMarkers(toText(pos.computeContainerNode()), pos.offsetInContainerNode(), 1, nonBreakingSpaceString());
 }
 
 void CompositeEditCommand::rebalanceWhitespace()
 {
     VisibleSelection selection = endingSelection();
     if (selection.isNone())
         return;
@@ skipping 103 matching lines @@
     for (const auto& node : nodes) {
         Text* textNode = node.get();
         int startOffset = textNode == start.anchorNode() ? start.computeOffsetInContainerNode() : 0;
         int endOffset = textNode == end.anchorNode() ? end.computeOffsetInContainerNode() : static_cast<int>(textNode->length());
         deleteInsignificantText(textNode, startOffset, endOffset);
     }
 }
 
 void CompositeEditCommand::deleteInsignificantTextDownstream(const Position& pos)
 {
-    Position end = VisiblePosition(pos, VP_DEFAULT_AFFINITY).next().deepEquivalent().downstream();
+    Position end = mostForwardCaretPosition(VisiblePosition(pos, VP_DEFAULT_AFFINITY).next().deepEquivalent());
     deleteInsignificantText(pos, end);
 }
 
 PassRefPtrWillBeRawPtr<HTMLBRElement> CompositeEditCommand::appendBlockPlaceholder(PassRefPtrWillBeRawPtr<Element> container)
 {
     if (!container)
         return nullptr;
 
     document().updateLayoutIgnorePendingStylesheets();
 
@@ skipping 67 matching lines @@
     ASSERT(isEditablePosition(pos, ContentIsEditable, DoNotUpdateStyle));
 
     // It's strange that this function is responsible for verifying that pos has not been invalidated
     // by an earlier call to this function.  The caller, applyBlockStyle, should do this.
     VisiblePosition visiblePos(pos, VP_DEFAULT_AFFINITY);
     VisiblePosition visibleParagraphStart(startOfParagraph(visiblePos));
     VisiblePosition visibleParagraphEnd = endOfParagraph(visiblePos);
     VisiblePosition next = visibleParagraphEnd.next();
     VisiblePosition visibleEnd = next.isNotNull() ? next : visibleParagraphEnd;
 
-    Position upstreamStart = visibleParagraphStart.deepEquivalent().upstream();
-    Position upstreamEnd = visibleEnd.deepEquivalent().upstream();
+    Position upstreamStart = mostBackwardCaretPosition(visibleParagraphStart.deepEquivalent());
+    Position upstreamEnd = mostBackwardCaretPosition(visibleEnd.deepEquivalent());
 
     // If there are no VisiblePositions in the same block as pos then
     // upstreamStart will be outside the paragraph
     if (comparePositions(pos, upstreamStart) < 0)
         return nullptr;
 
     // Perform some checks to see if we need to perform work in this function.
     if (isBlock(upstreamStart.anchorNode())) {
         // If the block is the root editable element, always move content to a new block,
         // since it is illegal to modify attributes on the root editable element for editing.
@@ skipping 136 matching lines @@
 // before and after the table/list collapse onto one line.
 // Deleting a paragraph will leave a placeholder. Remove it (and prune
 // empty or unrendered parents).
 
 void CompositeEditCommand::cleanupAfterDeletion(VisiblePosition destination)
 {
     VisiblePosition caretAfterDelete = endingSelection().visibleStart();
     Node* destinationNode = destination.deepEquivalent().anchorNode();
     if (caretAfterDelete.deepEquivalent() != destination.deepEquivalent() && isStartOfParagraph(caretAfterDelete) && isEndOfParagraph(caretAfterDelete)) {
         // Note: We want the rightmost candidate.
-        Position position = caretAfterDelete.deepEquivalent().downstream();
+        Position position = mostForwardCaretPosition(caretAfterDelete.deepEquivalent());
         Node* node = position.anchorNode();
 
         // Bail if we'd remove an ancestor of our destination.
         if (destinationNode && destinationNode->isDescendantOf(node))
             return;
 
         // Normally deletion will leave a br as a placeholder.
         if (isHTMLBRElement(*node)) {
             removeNodeAndPruneAncestors(node, destinationNode);
 
@@ skipping 30 matching lines @@
 void CompositeEditCommand::moveParagraphWithClones(const VisiblePosition& startOfParagraphToMove, const VisiblePosition& endOfParagraphToMove, HTMLElement* blockElement, Node* outerNode)
 {
     ASSERT(outerNode);
     ASSERT(blockElement);
 
     VisiblePosition beforeParagraph = startOfParagraphToMove.previous();
     VisiblePosition afterParagraph(endOfParagraphToMove.next());
 
     // We upstream() the end and downstream() the start so that we don't include collapsed whitespace in the move.
     // When we paste a fragment, spaces after the end and before the start are treated as though they were rendered.
-    Position start = startOfParagraphToMove.deepEquivalent().downstream();
-    Position end = startOfParagraphToMove.deepEquivalent() == endOfParagraphToMove.deepEquivalent() ? start : endOfParagraphToMove.deepEquivalent().upstream();
+    Position start = mostForwardCaretPosition(startOfParagraphToMove.deepEquivalent());
+    Position end = startOfParagraphToMove.deepEquivalent() == endOfParagraphToMove.deepEquivalent() ? start : mostBackwardCaretPosition(endOfParagraphToMove.deepEquivalent());
     if (comparePositions(start, end) > 0)
         end = start;
 
     cloneParagraphUnderNewElement(start, end, outerNode, blockElement);
 
     setEndingSelection(VisibleSelection(start, end));
     deleteSelection(false, false, false);
 
     // There are bugs in deletion when it removes a fully selected table/list.
     // It expands and removes the entire table/list, but will let content
@@ skipping 53 matching lines @@
             if (endInParagraph)
                 endIndex = TextIterator::rangeLength(startOfParagraphToMove.toParentAnchoredPosition(), visibleEnd.toParentAnchoredPosition(), true);
         }
     }
 
     VisiblePosition beforeParagraph = startOfParagraphToMove.previous(CannotCrossEditingBoundary);
     VisiblePosition afterParagraph(endOfParagraphToMove.next(CannotCrossEditingBoundary));
 
     // We upstream() the end and downstream() the start so that we don't include collapsed whitespace in the move.
     // When we paste a fragment, spaces after the end and before the start are treated as though they were rendered.
-    Position start = startOfParagraphToMove.deepEquivalent().downstream();
-    Position end = endOfParagraphToMove.deepEquivalent().upstream();
+    Position start = mostForwardCaretPosition(startOfParagraphToMove.deepEquivalent());
+    Position end = mostBackwardCaretPosition(endOfParagraphToMove.deepEquivalent());
 
     // FIXME: This is an inefficient way to preserve style on nodes in the paragraph to move. It
     // shouldn't matter though, since moved paragraphs will usually be quite small.
     RefPtrWillBeRawPtr<DocumentFragment> fragment = startOfParagraphToMove.deepEquivalent() != endOfParagraphToMove.deepEquivalent() ?
         createFragmentFromMarkup(document(), createMarkup(start.parentAnchoredEquivalent(), end.parentAnchoredEquivalent(), DoNotAnnotateForInterchange, ConvertBlocksToInlines::Convert, DoNotResolveURLs, constrainingAncestor), "") : nullptr;
 
     // A non-empty paragraph's style is moved when we copy and move it.  We don't move
     // anything if we're given an empty paragraph, but an empty paragraph can have style
     // too, <div><b><br></b></div> for example.  Save it so that we can preserve it later.
     RefPtrWillBeRawPtr<EditingStyle> styleInEmptyParagraph = nullptr;
@@ skipping 160 matching lines @@
     // If the br we inserted collapsed, for example foo<br><blockquote>...</blockquote>, insert
     // a second one.
     if (!isStartOfParagraph(atBR))
         insertNodeBefore(createBreakElement(document()), br);
     setEndingSelection(VisibleSelection(atBR, endingSelection().isDirectional()));
 
     // If this is an empty paragraph there must be a line break here.
     if (!lineBreakExistsAtVisiblePosition(caret))
         return false;
 
-    Position caretPos(caret.deepEquivalent().downstream());
+    Position caretPos(mostForwardCaretPosition(caret.deepEquivalent()));
     // A line break is either a br or a preserved newline.
     ASSERT(isHTMLBRElement(caretPos.anchorNode()) || (caretPos.anchorNode()->isTextNode() && caretPos.anchorNode()->layoutObject()->style()->preserveNewline()));
 
     if (isHTMLBRElement(*caretPos.anchorNode())) {
         removeNodeAndPruneAncestors(caretPos.anchorNode());
     } else if (caretPos.anchorNode()->isTextNode()) {
         ASSERT(caretPos.computeOffsetInContainerNode() == 0);
         Text* textNode = toText(caretPos.anchorNode());
         ContainerNode* parentNode = textNode->parentNode();
         // The preserved newline must be the first thing in the node, since otherwise the previous
@@ skipping 31 matching lines @@
             // Make sure anchors are pushed down before avoiding them so that we don't
             // also avoid structural elements like lists and blocks (5142012).
             if (original.anchorNode() != enclosingAnchor && original.anchorNode()->parentNode() != enclosingAnchor) {
                 pushAnchorElementDown(enclosingAnchor);
                 enclosingAnchor = enclosingAnchorElement(original);
                 if (!enclosingAnchor)
                     return original;
             }
             // Don't insert outside an anchor if doing so would skip over a line break.  It would
             // probably be safe to move the line break so that we could still avoid the anchor here.
-            Position downstream(visiblePos.deepEquivalent().downstream());
+            Position downstream(mostForwardCaretPosition(visiblePos.deepEquivalent()));
             if (lineBreakExistsAtVisiblePosition(visiblePos) && downstream.anchorNode()->isDescendantOf(enclosingAnchor))
                 return original;
 
             result = positionInParentAfterNode(*enclosingAnchor);
         }
         // If visually just before an anchor, insert *outside* the anchor unless it's the first
         // VisiblePosition in a paragraph, to match NSTextView.
         if (visiblePos.deepEquivalent() == firstInAnchor.deepEquivalent()) {
             // Make sure anchors are pushed down before avoiding them so that we don't
             // also avoid structural elements like lists and blocks (5142012).
@@ skipping 44 matching lines @@
 }
 
 DEFINE_TRACE(CompositeEditCommand)
 {
     visitor->trace(m_commands);
     visitor->trace(m_composition);
     EditCommand::trace(visitor);
 }
 
 } // namespace blink