Introduce nextPositionOf() 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 654 matching lines @@
 VisiblePosition startOfWord(const VisiblePosition& c, EWordSide side)
 {
     // FIXME: This returns a null VP for c at the start of the document
     // and side == LeftWordIfOnBoundary
     VisiblePosition p = c;
     if (side == RightWordIfOnBoundary) {
         // at paragraph end, the startofWord is the current position
         if (isEndOfParagraph(c))
             return c;
 
-        p = c.next();
+        p = nextPositionOf(c);
         if (p.isNull())
             return c;
     }
     return previousBoundary(p, startWordBoundary);
 }
 
 static unsigned endWordBoundary(const UChar* characters, unsigned length, unsigned offset, BoundarySearchContextAvailability mayHaveMoreContext, bool& needMoreContext)
 {
     ASSERT(offset <= length);
     if (mayHaveMoreContext && endOfFirstWordBoundaryContext(characters + offset, length - offset) == static_cast<int>(length - offset)) {
@@ skipping 613 matching lines @@
     if (type == PositionAnchorType::OffsetInAnchor)
         return VisiblePosition(Position(node, offset));
 
     return VisiblePosition(Position(node, type));
 }
 
 // FIXME: isStartOfParagraph(startOfNextParagraph(pos)) is not always true
 VisiblePosition startOfNextParagraph(const VisiblePosition& visiblePosition)
 {
     VisiblePosition paragraphEnd(endOfParagraph(visiblePosition, CanSkipOverEditingBoundary));
-    VisiblePosition afterParagraphEnd(paragraphEnd.next(CannotCrossEditingBoundary));
+    VisiblePosition afterParagraphEnd(nextPositionOf(paragraphEnd, CannotCrossEditingBoundary));
     // The position after the last position in the last cell of a table
     // is not the start of the next paragraph.
     if (isFirstPositionAfterTable(afterParagraphEnd))
-        return afterParagraphEnd.next(CannotCrossEditingBoundary);
+        return nextPositionOf(afterParagraphEnd, CannotCrossEditingBoundary);
     return afterParagraphEnd;
 }
 
 bool inSameParagraph(const VisiblePosition& a, const VisiblePosition& b, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     return a.isNotNull() && startOfParagraph(a, boundaryCrossingRule).deepEquivalent() == startOfParagraph(b, boundaryCrossingRule).deepEquivalent();
 }
 
 bool isStartOfParagraph(const VisiblePosition& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
@@ skipping 89 matching lines @@
     return endOfDocument(c.deepEquivalent().anchorNode());
 }
 
 bool isStartOfDocument(const VisiblePosition& p)
 {
     return p.isNotNull() && previousPositionOf(p, CanCrossEditingBoundary).isNull();
 }
 
 bool isEndOfDocument(const VisiblePosition& p)
 {
-    return p.isNotNull() && p.next(CanCrossEditingBoundary).isNull();
+    return p.isNotNull() && nextPositionOf(p, CanCrossEditingBoundary).isNull();
 }
 
 // ---------
 
 VisiblePosition startOfEditableContent(const VisiblePosition& visiblePosition)
 {
     ContainerNode* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent());
     if (!highestRoot)
         return VisiblePosition();
 
     return VisiblePosition(firstPositionInNode(highestRoot));
 }
 
 VisiblePosition endOfEditableContent(const VisiblePosition& visiblePosition)
 {
     ContainerNode* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent());
     if (!highestRoot)
         return VisiblePosition();
 
     return VisiblePosition(lastPositionInNode(highestRoot));
 }
 
 bool isEndOfEditableOrNonEditableContent(const VisiblePosition& p)
 {
-    return p.isNotNull() && p.next().isNull();
+    return p.isNotNull() && nextPositionOf(p).isNull();
 }
 
 VisiblePosition leftBoundaryOfLine(const VisiblePosition& c, TextDirection direction)
 {
     return direction == LTR ? logicalStartOfLine(c) : logicalEndOfLine(c);
 }
 
 VisiblePosition rightBoundaryOfLine(const VisiblePosition& c, TextDirection direction)
 {
     return direction == LTR ? logicalEndOfLine(c) : logicalStartOfLine(c);
@@ skipping 872 matching lines @@
 {
     return isVisuallyEquivalentCandidateAlgorithm<EditingStrategy>(position);
 }
 
 bool isVisuallyEquivalentCandidate(const PositionInComposedTree& position)
 {
     return isVisuallyEquivalentCandidateAlgorithm<EditingInComposedTreeStrategy>(position);
 }
 
 } // namespace blink