Introduce composed tree version of characterAfter()

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 2530 matching lines @@
 
     // If this is not editable but |pos| has an editable root, skip to the end
     if (!highestRoot && highestRootOfPos)
         return createVisiblePosition(Position(highestRootOfPos, PositionAnchorType::AfterAnchor).parentAnchoredEquivalent());
 
     // That must mean that |pos| is not editable. Return the next position after
     // |pos| that is in the same editable region as this position
     return firstEditableVisiblePositionAfterPositionInRoot(pos.deepEquivalent(), highestRoot);
 }
 
-UChar32 characterAfter(const VisiblePosition& visiblePosition)
+template <typename Strategy>
+static UChar32 characterAfterAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
     // We canonicalize to the first of two equivalent candidates, but the second
     // of the two candidates is the one that will be inside the text node
     // containing the character after this visible position.
-    Position pos = mostForwardCaretPosition(visiblePosition.deepEquivalent());
+    const PositionAlgorithm<Strategy> pos = mostForwardCaretPosition(visiblePosition.deepEquivalent());
     if (!pos.isOffsetInAnchor())
         return 0;
     Node* containerNode = pos.computeContainerNode();
     if (!containerNode || !containerNode->isTextNode())
         return 0;
     unsigned offset = static_cast<unsigned>(pos.offsetInContainerNode());
     Text* textNode = toText(containerNode);
     unsigned length = textNode->length();
     if (offset >= length)
         return 0;
 
     return textNode->data().characterStartingAt(offset);
 }
 
+UChar32 characterAfter(const VisiblePosition& visiblePosition)
+{
+    return characterAfterAlgorithm<EditingStrategy>(visiblePosition);
+}
+
+UChar32 characterAfter(const VisiblePositionInComposedTree& visiblePosition)
+{
+    return characterAfterAlgorithm<EditingInComposedTreeStrategy>(visiblePosition);
+}
+
 UChar32 characterBefore(const VisiblePosition& visiblePosition)
 {
     return characterAfter(previousPositionOf(visiblePosition));
 }
 
 static Position leftVisuallyDistinctCandidate(const VisiblePosition& visiblePosition)
 {
     const Position deepPosition = visiblePosition.deepEquivalent();
     Position p = deepPosition;
     if (p.isNull())
@@ skipping 387 matching lines @@
         return honorEditingBoundaryAtOrBefore(prev, visiblePosition.deepEquivalent());
     case CanSkipOverEditingBoundary:
         return skipToStartOfEditingBoundary(prev, visiblePosition.deepEquivalent());
     }
 
     ASSERT_NOT_REACHED();
     return honorEditingBoundaryAtOrBefore(prev, visiblePosition.deepEquivalent());
 }
 
 } // namespace blink