Introduce PositionAlgorithm<Strategy>::editingPositionOf()

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 83 matching lines @@
     Node* previousNode = previousLeafWithSameEditability(node, editableType);
 
     while (previousNode && (!previousNode->layoutObject() || inSameLine(VisiblePosition(firstPositionInOrBeforeNode(previousNode)), visiblePosition)))
         previousNode = previousLeafWithSameEditability(previousNode, editableType);
 
     while (previousNode && !previousNode->isShadowRoot()) {
         if (highestEditableRoot(firstPositionInOrBeforeNode(previousNode), editableType) != highestRoot)
             break;
 
         Position pos = isHTMLBRElement(*previousNode) ? positionBeforeNode(previousNode) :
-            createLegacyEditingPosition(previousNode, caretMaxOffset(previousNode));
+            Position::editingPositionOf(previousNode, caretMaxOffset(previousNode));
 
         if (pos.isCandidate())
             return pos;
 
         previousNode = previousLeafWithSameEditability(previousNode, editableType);
     }
     return Position();
 }
 
 static Position nextRootInlineBoxCandidatePosition(Node* node, const VisiblePosition& visiblePosition, EditableType editableType)
 {
     ContainerNode* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent(), editableType);
     Node* nextNode = nextLeafWithSameEditability(node, editableType);
     while (nextNode && (!nextNode->layoutObject() || inSameLine(VisiblePosition(firstPositionInOrBeforeNode(nextNode)), visiblePosition)))
         nextNode = nextLeafWithSameEditability(nextNode, ContentIsEditable);
 
     while (nextNode && !nextNode->isShadowRoot()) {
         if (highestEditableRoot(firstPositionInOrBeforeNode(nextNode), editableType) != highestRoot)
             break;
 
         Position pos;
-        pos = createLegacyEditingPosition(nextNode, caretMinOffset(nextNode));
+        pos = Position::editingPositionOf(nextNode, caretMinOffset(nextNode));
 
         if (pos.isCandidate())
             return pos;
 
         nextNode = nextLeafWithSameEditability(nextNode, editableType);
     }
     return Position();
 }
 
 class CachedLogicallyOrderedLeafBoxes {
@@ skipping 320 matching lines @@
 typedef unsigned (*BoundarySearchFunction)(const UChar*, unsigned length, unsigned offset, BoundarySearchContextAvailability, bool& needMoreContext);
 
 static VisiblePosition previousBoundary(const VisiblePosition& c, BoundarySearchFunction searchFunction)
 {
     Position pos = c.deepEquivalent();
     Node* boundary = pos.parentEditingBoundary();
     if (!boundary)
         return VisiblePosition();
 
     Document& d = boundary->document();
-    Position start = createLegacyEditingPosition(boundary, 0).parentAnchoredEquivalent();
+    Position start = Position::editingPositionOf(boundary, 0).parentAnchoredEquivalent();
     Position end = pos.parentAnchoredEquivalent();
 
     Vector<UChar, 1024> string;
     unsigned suffixLength = 0;
 
     TrackExceptionState exceptionState;
     if (requiresContextForWordBoundary(c.characterBefore())) {
         RefPtrWillBeRawPtr<Range> forwardsScanRange(d.createRange());
         forwardsScanRange->setEndAfter(boundary, exceptionState);
         forwardsScanRange->setStart(end.anchorNode(), end.offsetInContainerNode(), exceptionState);
@@ skipping 77 matching lines @@
             int length = characters.size();
             int i = startOfLastWordBoundaryContext(characters.data(), length);
             string.prepend(characters.data() + i, length - i);
             prefixLength += length - i;
             if (i > 0)
                 break;
             backwardsIterator.advance();
         }
     }
 
-    Position searchStart = createLegacyEditingPosition(start.anchorNode(), start.offsetInContainerNode());
+    Position searchStart = Position::editingPositionOf(start.anchorNode(), start.offsetInContainerNode());
     RangeBoundaryPoint searchEndPoint(boundary);
     searchEndPoint.setToEndOfNode(*boundary);
     Position searchEnd = searchEndPoint.toPosition();
     TextIterator it(searchStart, searchEnd, TextIteratorEmitsCharactersBetweenAllVisiblePositions);
     const unsigned invalidOffset = static_cast<unsigned>(-1);
     unsigned next = invalidOffset;
     bool needMoreContext = false;
     while (!it.atEnd()) {
         // Keep asking the iterator for chunks until the search function
         // returns an end value not equal to the length of the string passed to it.
@@ skipping 1019 matching lines @@
 
     if (previousRenderedEditable(position1.anchorNode()) == position2.anchorNode()
         && !renderedOffset1 && renderedOffset2 == caretMaxOffset(position2.anchorNode())) {
         return false;
     }
 
     return true;
 }
 
 }