Move honorEditingBoundaryAtOr{Before,After}() out from VisiblePosition class

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 416 matching lines @@
             return adjacentCharacterPosition;
 
         current = adjacentCharacterPosition;
     }
     return VisiblePosition();
 }
 
 VisiblePosition leftWordPosition(const VisiblePosition& visiblePosition, bool skipsSpaceWhenMovingRight)
 {
     VisiblePosition leftWordBreak = visualWordPosition(visiblePosition, MoveLeft, skipsSpaceWhenMovingRight);
-    leftWordBreak = visiblePosition.honorEditingBoundaryAtOrBefore(leftWordBreak);
+    leftWordBreak = honorEditingBoundaryAtOrBefore(leftWordBreak, visiblePosition.deepEquivalent());
 
     // FIXME: How should we handle a non-editable position?
     if (leftWordBreak.isNull() && isEditablePosition(visiblePosition.deepEquivalent())) {
         TextDirection blockDirection = directionOfEnclosingBlock(visiblePosition.deepEquivalent());
         leftWordBreak = blockDirection == LTR ? startOfEditableContent(visiblePosition) : endOfEditableContent(visiblePosition);
     }
     return leftWordBreak;
 }
 
 VisiblePosition rightWordPosition(const VisiblePosition& visiblePosition, bool skipsSpaceWhenMovingRight)
 {
     VisiblePosition rightWordBreak = visualWordPosition(visiblePosition, MoveRight, skipsSpaceWhenMovingRight);
-    rightWordBreak = visiblePosition.honorEditingBoundaryAtOrBefore(rightWordBreak);
+    rightWordBreak = honorEditingBoundaryAtOrBefore(rightWordBreak, visiblePosition.deepEquivalent());
 
     // FIXME: How should we handle a non-editable position?
     if (rightWordBreak.isNull() && isEditablePosition(visiblePosition.deepEquivalent())) {
         TextDirection blockDirection = directionOfEnclosingBlock(visiblePosition.deepEquivalent());
         rightWordBreak = blockDirection == LTR ? endOfEditableContent(visiblePosition) : startOfEditableContent(visiblePosition);
     }
     return rightWordBreak;
 }
 
 template <typename Strategy>
@@ skipping 252 matching lines @@
         needMoreContext = true;
         return 0;
     }
     needMoreContext = false;
     return findNextWordFromIndex(characters, length, offset, false);
 }
 
 VisiblePosition previousWordPosition(const VisiblePosition& c)
 {
     VisiblePosition prev = previousBoundary(c, previousWordPositionBoundary);
-    return c.honorEditingBoundaryAtOrBefore(prev);
+    return honorEditingBoundaryAtOrBefore(prev, c.deepEquivalent());
 }
 
 static unsigned nextWordPositionBoundary(const UChar* characters, unsigned length, unsigned offset, BoundarySearchContextAvailability mayHaveMoreContext, bool& needMoreContext)
 {
     if (mayHaveMoreContext && endOfFirstWordBoundaryContext(characters + offset, length - offset) == static_cast<int>(length - offset)) {
         needMoreContext = true;
         return length;
     }
     needMoreContext = false;
     return findNextWordFromIndex(characters, length, offset, true);
 }
 
 VisiblePosition nextWordPosition(const VisiblePosition& c)
 {
     VisiblePosition next = nextBoundary(c, nextWordPositionBoundary);
-    return c.honorEditingBoundaryAtOrAfter(next);
+    return honorEditingBoundaryAtOrAfter(next, c.deepEquivalent());
 }
 
 // ---------
 
 enum LineEndpointComputationMode { UseLogicalOrdering, UseInlineBoxOrdering };
 template <typename Strategy>
 static PositionWithAffinityTemplate<Strategy> startPositionForLine(const PositionWithAffinityTemplate<Strategy>& c, LineEndpointComputationMode mode)
 {
     if (c.isNull())
         return PositionWithAffinityTemplate<Strategy>();
@@ skipping 143 matching lines @@
         // 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 = previousPositionOf(visPos);
 
         if (ContainerNode* editableRoot = highestEditableRoot(c.deepEquivalent())) {
             if (!editableRoot->contains(visPos.deepEquivalent().computeContainerNode()))
                 return VisiblePosition(lastPositionInNode(editableRoot));
         }
 
-        return c.honorEditingBoundaryAtOrAfter(visPos);
+        return honorEditingBoundaryAtOrAfter(visPos, c.deepEquivalent());
     }
 
     // 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 = previousPositionOf(c);
         if (visPos.isNull())
             return VisiblePosition();
         visPos = endPositionForLine(visPos, UseInlineBoxOrdering);
     }
 
-    return c.honorEditingBoundaryAtOrAfter(visPos);
+    return honorEditingBoundaryAtOrAfter(visPos, c.deepEquivalent());
 }
 
 // FIXME: Rename this function to reflect the fact it ignores bidi levels.
 VisiblePosition endOfLine(const VisiblePosition& currentPosition)
 {
     return endOfLine(currentPosition, UseInlineBoxOrdering);
 }
 
 VisiblePosition logicalEndOfLine(const VisiblePosition& currentPosition)
 {
@@ skipping 198 matching lines @@
 {
     // FIXME: This is identical to startSentenceBoundary. I'm pretty sure that's not right.
     TextBreakIterator* iterator = sentenceBreakIterator(characters, length);
     // FIXME: The following function can return -1; we don't handle that.
     return iterator->preceding(length);
 }
 
 VisiblePosition previousSentencePosition(const VisiblePosition& c)
 {
     VisiblePosition prev = previousBoundary(c, previousSentencePositionBoundary);
-    return c.honorEditingBoundaryAtOrBefore(prev);
+    return honorEditingBoundaryAtOrBefore(prev, c.deepEquivalent());
 }
 
 static unsigned nextSentencePositionBoundary(const UChar* characters, unsigned length, unsigned, BoundarySearchContextAvailability, bool&)
 {
     // FIXME: This is identical to endSentenceBoundary. This isn't right, it needs to
     // move to the equivlant position in the following sentence.
     TextBreakIterator* iterator = sentenceBreakIterator(characters, length);
     return iterator->following(0);
 }
 
 VisiblePosition nextSentencePosition(const VisiblePosition& c)
 {
     VisiblePosition next = nextBoundary(c, nextSentencePositionBoundary);
-    return c.honorEditingBoundaryAtOrAfter(next);
+    return honorEditingBoundaryAtOrAfter(next, c.deepEquivalent());
 }
 
 VisiblePosition startOfParagraph(const VisiblePosition& c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     Position p = c.deepEquivalent();
     Node* startNode = p.anchorNode();
 
     if (!startNode)
         return VisiblePosition();
 
@@ skipping 1169 matching lines @@
 {
     return isVisuallyEquivalentCandidateAlgorithm<EditingStrategy>(position);
 }
 
 bool isVisuallyEquivalentCandidate(const PositionInComposedTree& position)
 {
     return isVisuallyEquivalentCandidateAlgorithm<EditingInComposedTreeStrategy>(position);
 }
 
 } // namespace blink