Introduce composed tree version of endOfParagraph()

This patch introduces composed tree version of |endOfParagraph()|
by templatizing original |endOfParagraph()| to work both DOM tree
position and composed tree position version for introducing composed tree
version of |VisibleSelection| class.

This patch is a preparation of making selection to handle granularity for web
component, http://crrev.com/1277863002

BUG=513568
TEST=n/a; no behavior changes

Review URL: https://codereview.chromium.org/1326323002

git-svn-id: svn://svn.chromium.org/blink/trunk@201912 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/Source/core/editing/VisibleUnits.cpp

@@ -1394,18 +1394,19 @@ VisiblePosition startOfParagraph(const VisiblePosition& c, EditingBoundaryCrossi
     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;
@@ -1420,19 +1421,19 @@ VisiblePosition endOfParagraph(const VisiblePosition& c, EditingBoundaryCrossing
             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;
         }
 
@@ -1449,25 +1450,35 @@ VisiblePosition endOfParagraph(const VisiblePosition& c, EditingBoundaryCrossing
                 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

third_party/WebKit/Source/core/editing/VisibleUnits.h

@@ -136,7 +136,8 @@ VisiblePosition rightBoundaryOfLine(const VisiblePosition&, TextDirection);
 
 // paragraphs (perhaps a misnomer, can be divided by line break elements)
 VisiblePosition startOfParagraph(const VisiblePosition&, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
-VisiblePosition endOfParagraph(const VisiblePosition&, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
+CORE_EXPORT VisiblePosition endOfParagraph(const VisiblePosition&, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
+CORE_EXPORT VisiblePositionInComposedTree endOfParagraph(const VisiblePositionInComposedTree&, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
 VisiblePosition startOfNextParagraph(const VisiblePosition&);
 VisiblePosition previousParagraphPosition(const VisiblePosition&, LayoutUnit x);
 VisiblePosition nextParagraphPosition(const VisiblePosition&, LayoutUnit x);

third_party/WebKit/Source/core/editing/VisibleUnitsTest.cpp

@@ -74,6 +74,25 @@ TEST_F(VisibleUnitsTest, characterAfter)
     EXPECT_EQ('1', characterAfter(createVisiblePositionInComposedTree(*two->firstChild(), 2)));
 }
 
+TEST_F(VisibleUnitsTest, endOfParagraph)
+{
+    const char* bodyContent = "<a id=host><b id=one>1</b><b id=two>22</b></a><b id=three>333</b>";
+    const char* shadowContent = "<p><content select=#two></content></p><p><content select=#one></content></p>";
+    setBodyContent(bodyContent);
+    setShadowContent(shadowContent, "host");
+    updateLayoutAndStyleForPainting();
+
+    Element* one = document().getElementById("one");
+    Element* two = document().getElementById("two");
+    Element* three = document().getElementById("three");
+
+    EXPECT_EQ(Position(three->firstChild(), 3), endOfParagraph(createVisiblePositionInDOMTree(*one->firstChild(), 1)).deepEquivalent());
+    EXPECT_EQ(PositionInComposedTree(one->firstChild(), 1), endOfParagraph(createVisiblePositionInComposedTree(*one->firstChild(), 1)).deepEquivalent());
+
+    EXPECT_EQ(Position(three->firstChild(), 3), endOfParagraph(createVisiblePositionInDOMTree(*two->firstChild(), 2)).deepEquivalent());
+    EXPECT_EQ(PositionInComposedTree(two->firstChild(), 2), endOfParagraph(createVisiblePositionInComposedTree(*two->firstChild(), 2)).deepEquivalent());
+}
+
 TEST_F(VisibleUnitsTest, inSameLine)
 {
     const char* bodyContent = "<p id='host'>00<b id='one'>11</b><b id='two'>22</b>33</p>";