Move honorEditingBoundaryAtOr{Before,After}() for VisiblePosition to VisibleUnits.cpp

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 148 matching lines @@
 Position canonicalPositionOf(const Position& position)
 {
     return canonicalPosition(position);
 }
 
 PositionInComposedTree canonicalPositionOf(const PositionInComposedTree& position)
 {
     return canonicalPosition(position);
 }
 
+template <typename Strategy>
+static PositionWithAffinityTemplate<Strategy> honorEditingBoundaryAtOrBeforeAlgorithm(const PositionWithAffinityTemplate<Strategy>& pos, const PositionAlgorithm<Strategy>& anchor)
+{
+    if (pos.isNull())
+        return pos;
+
+    ContainerNode* highestRoot = highestEditableRoot(anchor);
+
+    // Return empty position if |pos| is not somewhere inside the editable
+    // region containing this position
+    if (highestRoot && !pos.position().anchorNode()->isDescendantOf(highestRoot))
+        return PositionWithAffinityTemplate<Strategy>();
+
+    // Return |pos| itself if the two are from the very same editable region, or
+    // both are non-editable
+    // TODO(yosin) 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.position()) == highestRoot)
+        return pos;
+
+    // Return empty position if this position is non-editable, but |pos| is
+    // editable.
+    // TODO(yosin) Move to the previous non-editable region.
+    if (!highestRoot)
+        return PositionWithAffinityTemplate<Strategy>();
+
+    // Return the last position before |pos| that is in the same editable region
+    // as this position
+    return lastEditablePositionBeforePositionInRoot(pos.position(), highestRoot);
+}
+
+static PositionWithAffinity honorEditingBoundaryAtOrBeforeOf(const PositionWithAffinity& pos, const Position& anchor)
+{
+    return honorEditingBoundaryAtOrBeforeAlgorithm(pos, anchor);
+}
+
+static PositionInComposedTreeWithAffinity honorEditingBoundaryAtOrBeforeOf(const PositionInComposedTreeWithAffinity& pos, const PositionInComposedTree& anchor)
+{
+    return honorEditingBoundaryAtOrBeforeAlgorithm(pos, anchor);
+}
+
+static VisiblePosition honorEditingBoundaryAtOrBefore(const VisiblePosition& pos, const Position& anchor)
+{
+    return createVisiblePosition(honorEditingBoundaryAtOrBeforeOf(pos.toPositionWithAffinity(), anchor));
+}
+
+static VisiblePosition honorEditingBoundaryAtOrAfter(const VisiblePosition& pos, const Position& anchor)
+{
+    if (pos.isNull())
+        return pos;
+
+    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
+    // TODO(yosin) 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;
+
+    // Return empty position if this position is non-editable, but |pos| is
+    // editable
+    // TODO(yosin) 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);
+}
+
 static Node* previousLeafWithSameEditability(Node* node, EditableType editableType)
 {
     bool editable = node->hasEditableStyle(editableType);
     node = previousAtomicLeafNode(*node);
     while (node) {
         if (editable == node->hasEditableStyle(editableType))
             return node;
         node = previousAtomicLeafNode(*node);
     }
     return 0;
@@ skipping 2711 matching lines @@
         return honorEditingBoundaryAtOrBefore(prev, visiblePosition.deepEquivalent());
     case CanSkipOverEditingBoundary:
         return skipToStartOfEditingBoundary(prev, visiblePosition.deepEquivalent());
     }
 
     ASSERT_NOT_REACHED();
     return honorEditingBoundaryAtOrBefore(prev, visiblePosition.deepEquivalent());
 }
 
 } // namespace blink