Introduce composed tree version of endOfParagraph()

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 1375 matching lines @@
             n = NodeTraversal::previousPostOrder(*n, startBlock);
         }
     }
 
     if (type == PositionAnchorType::OffsetInAnchor)
         return createVisiblePosition(Position(node, offset));
 
     return createVisiblePosition(Position(node, type));
 }
 
-VisiblePosition endOfParagraph(const VisiblePosition& c, EditingBoundaryCrossingRule boundaryCrossingRule)
+template <typename Strategy>
+static VisiblePositionTemplate<Strategy> endOfParagraphAlgorithm(const VisiblePositionTemplate<Strategy>& c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     if (c.isNull())
-        return VisiblePosition();
+        return VisiblePositionTemplate<Strategy>();
 
-    Position p = c.deepEquivalent();
+    const PositionAlgorithm<Strategy> p = c.deepEquivalent();
     Node* startNode = p.anchorNode();
 
     if (isRenderedAsNonInlineTableImageOrHR(startNode))
-        return createVisiblePosition(positionAfterNode(startNode));
+        return createVisiblePosition(PositionAlgorithm<Strategy>::afterNode(startNode));
 
-    Element* startBlock = enclosingBlock(startNode);
+    Element* startBlock = enclosingBlock(PositionAlgorithm<Strategy>::firstPositionInOrBeforeNode(startNode), CannotCrossEditingBoundary);
     Element* stayInsideBlock = startBlock;
 
     Node* node = startNode;
     ContainerNode* highestRoot = highestEditableRoot(p);
     int offset = p.computeEditingOffset();
     PositionAnchorType type = p.anchorType();
 
     Node* n = startNode;
     bool startNodeIsEditable = startNode->hasEditableStyle();
     while (n) {
         if (boundaryCrossingRule == CannotCrossEditingBoundary && !nodeIsUserSelectAll(n) && n->hasEditableStyle() != startNodeIsEditable)
             break;
         if (boundaryCrossingRule == CanSkipOverEditingBoundary) {
             while (n && n->hasEditableStyle() != startNodeIsEditable)
-                n = NodeTraversal::next(*n, stayInsideBlock);
+                n = Strategy::next(*n, stayInsideBlock);
             if (!n || !n->isDescendantOf(highestRoot))
                 break;
         }
 
         LayoutObject* r = n->layoutObject();
         if (!r) {
-            n = NodeTraversal::next(*n, stayInsideBlock);
+            n = Strategy::next(*n, stayInsideBlock);
             continue;
         }
         const ComputedStyle& style = r->styleRef();
         if (style.visibility() != VISIBLE) {
-            n = NodeTraversal::next(*n, stayInsideBlock);
+            n = Strategy::next(*n, stayInsideBlock);
             continue;
         }
 
         if (r->isBR() || isEnclosingBlock(n))
             break;
 
         // FIXME: We avoid returning a position where the layoutObject can't accept the caret.
         if (r->isText() && toLayoutText(r)->resolvedTextLength()) {
             ASSERT_WITH_SECURITY_IMPLICATION(n->isTextNode());
             int length = toLayoutText(r)->textLength();
             type = PositionAnchorType::OffsetInAnchor;
             if (style.preserveNewline()) {
                 LayoutText* text = toLayoutText(r);
                 int o = n == startNode ? offset : 0;
                 for (int i = o; i < length; ++i) {
                     if ((*text)[i] == '\n')
-                        return createVisiblePosition(Position(toText(n), i));
+                        return createVisiblePosition(PositionAlgorithm<Strategy>(toText(n), i));
                 }
             }
             node = n;
             offset = r->caretMaxOffset();
-            n = NodeTraversal::next(*n, stayInsideBlock);
-        } else if (editingIgnoresContent(n) || isRenderedTableElement(n)) {
+            n = Strategy::next(*n, stayInsideBlock);
+        } else if (Strategy::editingIgnoresContent(n) || isRenderedTableElement(n)) {
             node = n;
             type = PositionAnchorType::AfterAnchor;
-            n = NodeTraversal::nextSkippingChildren(*n, stayInsideBlock);
+            n = Strategy::nextSkippingChildren(*n, stayInsideBlock);
         } else {
-            n = NodeTraversal::next(*n, stayInsideBlock);
+            n = Strategy::next(*n, stayInsideBlock);
         }
     }
 
     if (type == PositionAnchorType::OffsetInAnchor)
-        return createVisiblePosition(Position(node, offset));
+        return createVisiblePosition(PositionAlgorithm<Strategy>(node, offset));
 
-    return createVisiblePosition(Position(node, type));
+    return createVisiblePosition(PositionAlgorithm<Strategy>(node, type));
+}
+
+VisiblePosition endOfParagraph(const VisiblePosition& c, EditingBoundaryCrossingRule boundaryCrossingRule)
+{
+    return endOfParagraphAlgorithm<EditingStrategy>(c, boundaryCrossingRule);
+}
+
+VisiblePositionInComposedTree endOfParagraph(const VisiblePositionInComposedTree& c, EditingBoundaryCrossingRule boundaryCrossingRule)
+{
+    return endOfParagraphAlgorithm<EditingInComposedTreeStrategy>(c, boundaryCrossingRule);
 }
 
 // FIXME: isStartOfParagraph(startOfNextParagraph(pos)) is not always true
 VisiblePosition startOfNextParagraph(const VisiblePosition& visiblePosition)
 {
     VisiblePosition paragraphEnd(endOfParagraph(visiblePosition, CanSkipOverEditingBoundary));
     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))
@@ skipping 1499 matching lines @@
         return honorEditingBoundaryAtOrBefore(prev, visiblePosition.deepEquivalent());
     case CanSkipOverEditingBoundary:
         return skipToStartOfEditingBoundary(prev, visiblePosition.deepEquivalent());
     }
 
     ASSERT_NOT_REACHED();
     return honorEditingBoundaryAtOrBefore(prev, visiblePosition.deepEquivalent());
 }
 
 } // namespace blink