Introduce previousPositionOf() for VisiblePosition

Source/core/editing/VisibleUnits.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 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 679 matching lines @@
     return findWordEndBoundary(characters, length, offset);
 }
 
 VisiblePosition endOfWord(const VisiblePosition& c, EWordSide side)
 {
     VisiblePosition p = c;
     if (side == LeftWordIfOnBoundary) {
         if (isStartOfParagraph(c))
             return c;
 
-        p = c.previous();
+        p = previousPositionOf(c);
         if (p.isNull())
             return c;
     } else if (isEndOfParagraph(c)) {
         return c;
     }
 
     return nextBoundary(p, endWordBoundary);
 }
 
 static unsigned previousWordPositionBoundary(const UChar* characters, unsigned length, unsigned offset, BoundarySearchContextAvailability mayHaveMoreContext, bool& needMoreContext)
@@ skipping 175 matching lines @@
     // Please refer to https://bugs.webkit.org/show_bug.cgi?id=49107 for detail.
     VisiblePosition visPos = endPositionForLine(c, mode);
 
     if (mode == UseLogicalOrdering) {
         // Make sure the end of line is at the same line as the given input position. For a wrapping line, the logical end
         // position for the not-last-2-lines might incorrectly hand back the logical beginning of the next line.
         // For example, <div contenteditable dir="rtl" style="line-break:before-white-space">abcdefg abcdefg abcdefg
         // a abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg </div>
         // In this case, use the previous position of the computed logical end position.
         if (!inSameLogicalLine(c, visPos))
-            visPos = visPos.previous();
+            visPos = previousPositionOf(visPos);
 
         if (ContainerNode* editableRoot = highestEditableRoot(c.deepEquivalent())) {
             if (!editableRoot->contains(visPos.deepEquivalent().computeContainerNode()))
                 return VisiblePosition(lastPositionInNode(editableRoot));
         }
 
         return c.honorEditingBoundaryAtOrAfter(visPos);
     }
 
     // Make sure the end of line is at the same line as the given input position. Else use the previous position to
     // obtain end of line. This condition happens when the input position is before the space character at the end
     // of a soft-wrapped non-editable line. In this scenario, endPositionForLine would incorrectly hand back a position
     // in the next line instead. This fix is to account for the discrepancy between lines with webkit-line-break:after-white-space style
     // versus lines without that style, which would break before a space by default.
     if (!inSameLine(c, visPos)) {
-        visPos = c.previous();
+        visPos = previousPositionOf(c);
         if (visPos.isNull())
             return VisiblePosition();
         visPos = endPositionForLine(visPos, UseInlineBoxOrdering);
     }
 
     return c.honorEditingBoundaryAtOrAfter(visPos);
 }
 
 // FIXME: Rename this function to reflect the fact it ignores bidi levels.
 VisiblePosition endOfLine(const VisiblePosition& currentPosition)
@@ skipping 485 matching lines @@
     return VisiblePosition(lastPositionInNode(doc));
 }
 
 VisiblePosition endOfDocument(const VisiblePosition& c)
 {
     return endOfDocument(c.deepEquivalent().anchorNode());
 }
 
 bool isStartOfDocument(const VisiblePosition& p)
 {
-    return p.isNotNull() && p.previous(CanCrossEditingBoundary).isNull();
+    return p.isNotNull() && previousPositionOf(p, CanCrossEditingBoundary).isNull();
 }
 
 bool isEndOfDocument(const VisiblePosition& p)
 {
     return p.isNotNull() && p.next(CanCrossEditingBoundary).isNull();
 }
 
 // ---------
 
 VisiblePosition startOfEditableContent(const VisiblePosition& visiblePosition)
@@ skipping 902 matching lines @@
 {
     return isVisuallyEquivalentCandidateAlgorithm<EditingStrategy>(position);
 }
 
 bool isVisuallyEquivalentCandidate(const PositionInComposedTree& position)
 {
     return isVisuallyEquivalentCandidateAlgorithm<EditingInComposedTreeStrategy>(position);
 }
 
 } // namespace blink