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

Source/core/editing/VisibleSelection.cpp

 /*
  * Copyright (C) 2004, 2005, 2006 Apple Computer, 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 238 matching lines @@
 }
 
 template <typename Strategy>
 static EphemeralRangeTemplate<Strategy> normalizeRangeAlgorithm(const EphemeralRangeTemplate<Strategy>& range)
 {
     ASSERT(range.isNotNull());
     range.document().updateLayoutIgnorePendingStylesheets();
 
     // TODO(yosin) We should not call |parentAnchoredEquivalent()|, it is
     // redundant.
-    const PositionAlgorithm<Strategy> normalizedStart = range.startPosition().downstream().parentAnchoredEquivalent();
-    const PositionAlgorithm<Strategy> normalizedEnd = range.endPosition().upstream().parentAnchoredEquivalent();
+    const PositionAlgorithm<Strategy> normalizedStart = mostForwardCaretPosition(range.startPosition()).parentAnchoredEquivalent();
+    const PositionAlgorithm<Strategy> normalizedEnd = mostBackwardCaretPosition(range.endPosition()).parentAnchoredEquivalent();
     // The order of the positions of |start| and |end| can be swapped after
     // upstream/downstream. e.g. editing/pasteboard/copy-display-none.html
     if (normalizedStart.compareTo(normalizedEnd) > 0)
         return EphemeralRangeTemplate<Strategy>(normalizedEnd, normalizedStart);
     return EphemeralRangeTemplate<Strategy>(normalizedStart, normalizedEnd);
 }
 
 EphemeralRange VisibleSelection::normalizeRange(const EphemeralRange& range)
 {
     return normalizeRangeAlgorithm<EditingStrategy>(range);
@@ skipping 16 matching lines @@
     m_start.document()->updateLayout();
 
     // Check again, because updating layout can clear the selection.
     if (isNone())
         return EphemeralRange();
 
     if (isCaret()) {
         // If the selection is a caret, move the range start upstream. This
         // helps us match the conventions of text editors tested, which make
         // style determinations based on the character before the caret, if any.
-        const Position start = m_start.upstream().parentAnchoredEquivalent();
+        const Position start = mostBackwardCaretPosition(m_start).parentAnchoredEquivalent();
         return EphemeralRange(start, start);
     }
     // If the selection is a range, select the minimum range that encompasses
     // the selection. Again, this is to match the conventions of text editors
     // tested, which make style determinations based on the first character of
     // the selection. For instance, this operation helps to make sure that the
     // "X" selected below is the only thing selected. The range should not be
     // allowed to "leak" out to the end of the previous text node, or to the
     // beginning of the next text node, each of which has a different style.
     //
@@ skipping 266 matching lines @@
         m_end = m_baseIsFirst ? m_extent : m_base;
     resetPositionsInComposedTree();
 }
 
 SelectionType VisibleSelection::selectionType(const Position& start, const Position& end)
 {
     if (start.isNull()) {
         ASSERT(end.isNull());
         return NoSelection;
     }
-    if (start == end || start.upstream() == end.upstream())
+    if (start == end || mostBackwardCaretPosition(start) == mostBackwardCaretPosition(end))
         return CaretSelection;
     return RangeSelection;
 }
 
 SelectionType VisibleSelection::selectionType(const PositionInComposedTree& start, const PositionInComposedTree& end)
 {
     if (start.isNull()) {
         ASSERT(end.isNull());
         return NoSelection;
     }
-    if (start == end || start.upstream() == end.upstream())
+    if (start == end || mostBackwardCaretPosition(start) == mostBackwardCaretPosition(end))
         return CaretSelection;
     return RangeSelection;
 }
 
 void VisibleSelection::updateSelectionType()
 {
     m_selectionType = selectionType(m_start, m_end);
 
     // Affinity only makes sense for a caret
     if (m_selectionType != CaretSelection)
@@ skipping 86 matching lines @@
 
     if (selectionType() == RangeSelection) {
         // "Constrain" the selection to be the smallest equivalent range of nodes.
         // This is a somewhat arbitrary choice, but experience shows that it is
         // useful to make to make the selection "canonical" (if only for
         // purposes of comparing selections). This is an ideal point of the code
         // to do this operation, since all selection changes that result in a RANGE
         // come through here before anyone uses it.
         // FIXME: Canonicalizing is good, but haven't we already done it (when we
         // set these two positions to VisiblePosition deepEquivalent()s above)?
-        m_start = m_start.downstream();
-        m_end = m_end.upstream();
+        m_start = mostForwardCaretPosition(m_start);
+        m_end = mostBackwardCaretPosition(m_end);
 
         // Even by downstreaming, |m_start| can be moved to the upper place from
         // the original position, same as |m_end|.
         // e.g.) editing/shadow/select-contenteditable-shadowhost.html
-        m_startInComposedTree = m_startInComposedTree.downstream();
-        m_endInComposedTree = m_endInComposedTree.upstream();
+        m_startInComposedTree = mostForwardCaretPosition(m_startInComposedTree);
+        m_endInComposedTree = mostBackwardCaretPosition(m_endInComposedTree);
         adjustStartAndEndInComposedTree();
 
         if (isCrossingSelectionBoundary(m_startInComposedTree, m_endInComposedTree))
             resetPositionsInComposedTree();
 
         // FIXME: Position::downstream() or Position::upStream() might violate editing boundaries
         // if an anchor node has a Shadow DOM. So we adjust selection to avoid crossing editing
         // boundaries again. See https://bugs.webkit.org/show_bug.cgi?id=87463
         origExtent = m_extent;
         origEnd = m_end;
@@ skipping 532 matching lines @@
     sel.showTreeForThis();
 }
 
 void showTree(const blink::VisibleSelection* sel)
 {
     if (sel)
         sel->showTreeForThis();
 }
 
 #endif