Move member functions skipTo{Start,End}OfEditingBoundary() out from VisiblePosition

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 46 matching lines @@
 VisiblePosition::VisiblePosition(const PositionInComposedTree& pos, TextAffinity affinity)
 {
     init(pos, affinity);
 }
 
 VisiblePosition::VisiblePosition(const PositionWithAffinity& positionWithAffinity)
 {
     init(positionWithAffinity.position(), positionWithAffinity.affinity());
 }
 
+// TODO(yosin) We should move implementation of |skipToEndOfEditingBoundary()|
+// here to avoid forward declaration.
+static VisiblePosition skipToEndOfEditingBoundary(const VisiblePosition&, const Position& anchor);
+
 // 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);
     case CanSkipOverEditingBoundary:
-        return visiblePosition.skipToEndOfEditingBoundary(next);
+        return skipToEndOfEditingBoundary(next, visiblePosition.deepEquivalent());
     }
     ASSERT_NOT_REACHED();
     return visiblePosition.honorEditingBoundaryAtOrAfter(next);
 }
 
+// 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());
 
     // return null visible position if there is no previous visible position
     if (pos.atStartOfTree())
         return VisiblePosition();
 
     VisiblePosition prev = VisiblePosition(pos);
     ASSERT(prev.deepEquivalent() != visiblePosition.deepEquivalent());
 
 #if ENABLE(ASSERT)
     // we should always be able to make the affinity |TextAffinity::Downstream|,
     // because going previous from an |TextAffinity::Upstream| position can
     // never yield another |TextAffinity::Upstream position| (unless line wrap
     // 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);
     case CanSkipOverEditingBoundary:
-        return visiblePosition.skipToStartOfEditingBoundary(prev);
+        return skipToStartOfEditingBoundary(prev, visiblePosition.deepEquivalent());
     }
 
     ASSERT_NOT_REACHED();
     return visiblePosition.honorEditingBoundaryAtOrBefore(prev);
 }
 
 // TODO(yosin) We should move |rightVisuallyDistinctCandidate()| with
 // |rightPositionOf()| to "VisibleUnits.cpp".
 static Position leftVisuallyDistinctCandidate(const VisiblePosition& visiblePosition)
 {
@@ skipping 385 matching lines @@
 
     // Return empty position if this position is non-editable, but pos is editable
     // FIXME: Move to the next non-editable region.
     if (!highestRoot)
         return VisiblePosition();
 
     // Return the next position after pos that is in the same editable region as this position
     return firstEditableVisiblePositionAfterPositionInRoot(pos.deepEquivalent(), highestRoot);
 }
 
-VisiblePosition VisiblePosition::skipToStartOfEditingBoundary(const VisiblePosition &pos) const
+// TODO(yosin) We should move implementation of |skipToStartOfEditingBoundary()|
+// at forward declaration and re-format comments to fit 80 chars.
+static VisiblePosition skipToStartOfEditingBoundary(const VisiblePosition& pos, const Position& anchor)
 {
     if (pos.isNull())
         return pos;
 
-    ContainerNode* highestRoot = highestEditableRoot(deepEquivalent());
+    ContainerNode* highestRoot = highestEditableRoot(anchor);
     ContainerNode* highestRootOfPos = highestEditableRoot(pos.deepEquivalent());
 
     // Return pos itself if the two are from the very same editable region, or both are non-editable.
     if (highestRootOfPos == highestRoot)
         return pos;
 
     // If this is not editable but |pos| has an editable root, skip to the start
     if (!highestRoot && highestRootOfPos)
         return VisiblePosition(previousVisuallyDistinctCandidate(Position(highestRootOfPos, PositionAnchorType::BeforeAnchor).parentAnchoredEquivalent()));
 
     // That must mean that |pos| is not editable. Return the last position before pos that is in the same editable region as this position
     return lastEditableVisiblePositionBeforePositionInRoot(pos.deepEquivalent(), highestRoot);
 }
 
-VisiblePosition VisiblePosition::skipToEndOfEditingBoundary(const VisiblePosition &pos) const
+// TODO(yosin) We should move implementation of |skipToEndOfEditingBoundary()|
+// at forward declaration and re-format comments to fit 80 chars.
+static VisiblePosition skipToEndOfEditingBoundary(const VisiblePosition& pos, const Position& anchor)
 {
     if (pos.isNull())
         return pos;
 
-    ContainerNode* highestRoot = highestEditableRoot(deepEquivalent());
+    ContainerNode* highestRoot = highestEditableRoot(anchor);
     ContainerNode* highestRootOfPos = highestEditableRoot(pos.deepEquivalent());
 
     // Return pos itself if the two are from the very same editable region, or both are non-editable.
     if (highestRootOfPos == highestRoot)
         return pos;
 
     // If this is not editable but |pos| has an editable root, skip to the end
     if (!highestRoot && highestRootOfPos)
         return VisiblePosition(Position(highestRootOfPos, PositionAnchorType::AfterAnchor).parentAnchoredEquivalent());
 
@@ skipping 236 matching lines @@
     else
         fprintf(stderr, "Cannot showTree for (nil) VisiblePosition.\n");
 }
 
 void showTree(const blink::VisiblePosition& vpos)
 {
     vpos.showTreeForThis();
 }
 
 #endif