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

Source/core/editing/VisiblePosition.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Portions Copyright (c) 2011 Motorola Mobility, 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
@@ skipping 59 matching lines @@
 
 // TODO(yosin) We should move |nextPositionOf()| to "VisibleUnits.cpp".
 VisiblePosition nextPositionOf(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     VisiblePosition next(nextVisuallyDistinctCandidate(visiblePosition.deepEquivalent()), visiblePosition.affinity());
 
     switch (rule) {
     case CanCrossEditingBoundary:
         return next;
     case CannotCrossEditingBoundary:
-        return visiblePosition.honorEditingBoundaryAtOrAfter(next);
+        return honorEditingBoundaryAtOrAfter(next, visiblePosition.deepEquivalent());
     case CanSkipOverEditingBoundary:
         return skipToEndOfEditingBoundary(next, visiblePosition.deepEquivalent());
     }
     ASSERT_NOT_REACHED();
-    return visiblePosition.honorEditingBoundaryAtOrAfter(next);
+    return honorEditingBoundaryAtOrAfter(next, visiblePosition.deepEquivalent());
 }
 
 // TODO(yosin) We should move implementation of |skipToStartOfEditingBoundary()|
 // here to avoid forward declaration.
 static VisiblePosition skipToStartOfEditingBoundary(const VisiblePosition&, const Position& anchor);
 
 VisiblePosition previousPositionOf(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     Position pos = previousVisuallyDistinctCandidate(visiblePosition.deepEquivalent());
 
@@ skipping 11 matching lines @@
     // length is 0!).
     if (prev.isNotNull() && visiblePosition.affinity() == TextAffinity::Upstream) {
         ASSERT(inSameLine(PositionWithAffinity(prev.deepEquivalent()), PositionWithAffinity(prev.deepEquivalent(), TextAffinity::Upstream)));
     }
 #endif
 
     switch (rule) {
     case CanCrossEditingBoundary:
         return prev;
     case CannotCrossEditingBoundary:
-        return visiblePosition.honorEditingBoundaryAtOrBefore(prev);
+        return honorEditingBoundaryAtOrBefore(prev, visiblePosition.deepEquivalent());
     case CanSkipOverEditingBoundary:
         return skipToStartOfEditingBoundary(prev, visiblePosition.deepEquivalent());
     }
 
     ASSERT_NOT_REACHED();
-    return visiblePosition.honorEditingBoundaryAtOrBefore(prev);
+    return honorEditingBoundaryAtOrBefore(prev, visiblePosition.deepEquivalent());
 }
 
 // TODO(yosin) We should move |rightVisuallyDistinctCandidate()| with
 // |rightPositionOf()| to "VisibleUnits.cpp".
 static Position leftVisuallyDistinctCandidate(const VisiblePosition& visiblePosition)
 {
     const Position deepPosition = visiblePosition.deepEquivalent();
     Position p = deepPosition;
     if (p.isNull())
         return Position();
@@ skipping 143 matching lines @@
 VisiblePosition leftPositionOf(const VisiblePosition& visiblePosition)
 {
     const Position pos = leftVisuallyDistinctCandidate(visiblePosition);
     // TODO(yosin) Why can't we move left from the last position in a tree?
     if (pos.atStartOfTree() || pos.atEndOfTree())
         return VisiblePosition();
 
     VisiblePosition left = VisiblePosition(pos);
     ASSERT(left.deepEquivalent() != visiblePosition.deepEquivalent());
 
-    return directionOfEnclosingBlock(left.deepEquivalent()) == LTR ? visiblePosition.honorEditingBoundaryAtOrBefore(left) : visiblePosition.honorEditingBoundaryAtOrAfter(left);
+    return directionOfEnclosingBlock(left.deepEquivalent()) == LTR ? honorEditingBoundaryAtOrBefore(left, visiblePosition.deepEquivalent()) : honorEditingBoundaryAtOrAfter(left, visiblePosition.deepEquivalent());
 }
 
 // TODO(yosin) We should move |rightVisuallyDistinctCandidate()| with
 // |rightPositionOf()| to "VisibleUnits.cpp".
 static Position rightVisuallyDistinctCandidate(const VisiblePosition& visiblePosition)
 {
     const Position deepPosition = visiblePosition.deepEquivalent();
     Position p = deepPosition;
     if (p.isNull())
         return Position();
@@ skipping 146 matching lines @@
 VisiblePosition rightPositionOf(const VisiblePosition& visiblePosition)
 {
     const Position pos = rightVisuallyDistinctCandidate(visiblePosition);
     // TODO(yosin) Why can't we move left from the last position in a tree?
     if (pos.atStartOfTree() || pos.atEndOfTree())
         return VisiblePosition();
 
     VisiblePosition right = VisiblePosition(pos);
     ASSERT(right.deepEquivalent() != visiblePosition.deepEquivalent());
 
-    return directionOfEnclosingBlock(right.deepEquivalent()) == LTR ? visiblePosition.honorEditingBoundaryAtOrAfter(right) : visiblePosition.honorEditingBoundaryAtOrBefore(right);
+    return directionOfEnclosingBlock(right.deepEquivalent()) == LTR ? honorEditingBoundaryAtOrAfter(right, visiblePosition.deepEquivalent()) : honorEditingBoundaryAtOrBefore(right, visiblePosition.deepEquivalent());
 }
 
 template <typename Strategy>
 PositionWithAffinityTemplate<Strategy> honorEditingBoundaryAtOrBeforeAlgorithm(const PositionWithAffinityTemplate<Strategy>& pos, const PositionAlgorithm<Strategy>& anchor)
 {
     if (pos.isNull())
         return pos;
 
     ContainerNode* highestRoot = highestEditableRoot(anchor);
 
@@ skipping 19 matching lines @@
 PositionWithAffinity honorEditingBoundaryAtOrBeforeOf(const PositionWithAffinity& pos, const Position& anchor)
 {
     return honorEditingBoundaryAtOrBeforeAlgorithm(pos, anchor);
 }
 
 PositionInComposedTreeWithAffinity honorEditingBoundaryAtOrBeforeOf(const PositionInComposedTreeWithAffinity& pos, const PositionInComposedTree& anchor)
 {
     return honorEditingBoundaryAtOrBeforeAlgorithm(pos, anchor);
 }
 
-VisiblePosition VisiblePosition::honorEditingBoundaryAtOrBefore(const VisiblePosition &pos) const
+VisiblePosition honorEditingBoundaryAtOrBefore(const VisiblePosition& pos, const Position& anchor)
 {
-    return VisiblePosition(honorEditingBoundaryAtOrBeforeOf(pos.toPositionWithAffinity(), deepEquivalent()));
+    return VisiblePosition(honorEditingBoundaryAtOrBeforeOf(pos.toPositionWithAffinity(), anchor));
 }
 
-VisiblePosition VisiblePosition::honorEditingBoundaryAtOrAfter(const VisiblePosition &pos) const
+VisiblePosition honorEditingBoundaryAtOrAfter(const VisiblePosition& pos, const Position& anchor)
 {
     if (pos.isNull())
         return pos;
 
-    ContainerNode* highestRoot = highestEditableRoot(deepEquivalent());
+    ContainerNode* highestRoot = highestEditableRoot(anchor);
 
     // Return empty position if pos is not somewhere inside the editable region containing this position
     if (highestRoot && !pos.deepEquivalent().anchorNode()->isDescendantOf(highestRoot))
         return VisiblePosition();
 
     // Return pos itself if the two are from the very same editable region, or both are non-editable
     // FIXME: In the non-editable case, just because the new position is non-editable doesn't mean movement
     // to it is allowed.  VisibleSelection::adjustForEditableContent has this problem too.
     if (highestEditableRoot(pos.deepEquivalent()) == highestRoot)
         return pos;
@@ skipping 286 matching lines @@
     else
         fprintf(stderr, "Cannot showTree for (nil) VisiblePosition.\n");
 }
 
 void showTree(const blink::VisiblePosition& vpos)
 {
     vpos.showTreeForThis();
 }
 
 #endif