Make VisiblePosition constructor private

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 181 matching lines @@
     }
     return 0;
 }
 
 // FIXME: consolidate with code in previousLinePosition.
 static Position previousRootInlineBoxCandidatePosition(Node* node, const VisiblePosition& visiblePosition, EditableType editableType)
 {
     ContainerNode* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent(), editableType);
     Node* previousNode = previousLeafWithSameEditability(node, editableType);
 
-    while (previousNode && (!previousNode->layoutObject() || inSameLine(VisiblePosition(firstPositionInOrBeforeNode(previousNode)), visiblePosition)))
+    while (previousNode && (!previousNode->layoutObject() || inSameLine(createVisiblePosition(firstPositionInOrBeforeNode(previousNode)), visiblePosition)))
         previousNode = previousLeafWithSameEditability(previousNode, editableType);
 
     while (previousNode && !previousNode->isShadowRoot()) {
         if (highestEditableRoot(firstPositionInOrBeforeNode(previousNode), editableType) != highestRoot)
             break;
 
         Position pos = isHTMLBRElement(*previousNode) ? positionBeforeNode(previousNode) :
             Position::editingPositionOf(previousNode, caretMaxOffset(previousNode));
 
         if (isVisuallyEquivalentCandidate(pos))
             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)))
+    while (nextNode && (!nextNode->layoutObject() || inSameLine(createVisiblePosition(firstPositionInOrBeforeNode(nextNode)), visiblePosition)))
         nextNode = nextLeafWithSameEditability(nextNode, ContentIsEditable);
 
     while (nextNode && !nextNode->isShadowRoot()) {
         if (highestEditableRoot(firstPositionInOrBeforeNode(nextNode), editableType) != highestRoot)
             break;
 
         Position pos;
         pos = Position::editingPositionOf(nextNode, caretMinOffset(nextNode));
 
         if (isVisuallyEquivalentCandidate(pos))
@@ skipping 407 matching lines @@
         it.advance();
     }
     if (needMoreContext) {
         // The last search returned the beginning of the buffer and asked for more context,
         // but there is no earlier text. Force a search with what's available.
         next = searchFunction(string.data(), string.size(), string.size() - suffixLength, DontHaveMoreContext, needMoreContext);
         ASSERT(!needMoreContext);
     }
 
     if (!next)
-        return VisiblePosition(it.atEnd() ? it.startPosition() : pos);
+        return createVisiblePosition(it.atEnd() ? it.startPosition() : pos);
 
     Node* node = it.startContainer();
     if (node->isTextNode() && static_cast<int>(next) <= node->maxCharacterOffset()) {
         // The next variable contains a usable index into a text node
-        return VisiblePosition(Position(node, next));
+        return createVisiblePosition(Position(node, next));
     }
 
     // Use the character iterator to translate the next value into a DOM position.
     BackwardsCharacterIterator charIt(start, end);
     charIt.advance(string.size() - suffixLength - next);
     // FIXME: charIt can get out of shadow host.
-    return VisiblePosition(charIt.endPosition());
+    return createVisiblePosition(charIt.endPosition());
 }
 
 static VisiblePosition nextBoundary(const VisiblePosition& c, BoundarySearchFunction searchFunction)
 {
     Position pos = c.deepEquivalent();
     Node* boundary = parentEditingBoundary(pos);
     if (!boundary)
         return VisiblePosition();
 
     Document& d = boundary->document();
@@ skipping 52 matching lines @@
     if (it.atEnd() && next == string.size()) {
         pos = it.startPositionInCurrentContainer();
     } else if (next != invalidOffset && next != prefixLength) {
         // Use the character iterator to translate the next value into a DOM position.
         CharacterIterator charIt(searchStart, searchEnd, TextIteratorEmitsCharactersBetweenAllVisiblePositions);
         charIt.advance(next - prefixLength - 1);
         pos = charIt.endPosition();
 
         if (charIt.characterAt(0) == '\n') {
             // FIXME: workaround for collapsed range (where only start position is correct) emitted for some emitted newlines (see rdar://5192593)
-            VisiblePosition visPos = VisiblePosition(pos);
-            if (visPos.deepEquivalent() == VisiblePosition(charIt.startPosition()).deepEquivalent()) {
+            VisiblePosition visPos = createVisiblePosition(pos);
+            if (visPos.deepEquivalent() == createVisiblePosition(charIt.startPosition()).deepEquivalent()) {
                 charIt.advance(1);
                 pos = charIt.startPosition();
             }
         }
     }
 
     // generate VisiblePosition, use TextAffinity::Upstream affinity if possible
-    return VisiblePosition(pos, VP_UPSTREAM_IF_POSSIBLE);
+    return createVisiblePosition(pos, VP_UPSTREAM_IF_POSSIBLE);
 }
 
 // ---------
 
 static unsigned startWordBoundary(const UChar* characters, unsigned length, unsigned offset, BoundarySearchContextAvailability mayHaveMoreContext, bool& needMoreContext)
 {
     ASSERT(offset);
     if (mayHaveMoreContext && !startOfLastWordBoundaryContext(characters, offset)) {
         needMoreContext = true;
         return 0;
@@ skipping 208 matching lines @@
     } else if (endBox->isInlineTextBox() && endNode->isTextNode()) {
         InlineTextBox* endTextBox = toInlineTextBox(endBox);
         int endOffset = endTextBox->start();
         if (!endTextBox->isLineBreak())
             endOffset += endTextBox->len();
         pos = Position(toText(endNode), endOffset);
     } else {
         pos = positionAfterNode(endNode);
     }
 
-    return VisiblePosition(pos, VP_UPSTREAM_IF_POSSIBLE);
+    return createVisiblePosition(pos, VP_UPSTREAM_IF_POSSIBLE);
 }
 
 static bool inSameLogicalLine(const VisiblePosition& a, const VisiblePosition& b)
 {
     return a.isNotNull() && logicalStartOfLine(a).deepEquivalent() == logicalStartOfLine(b).deepEquivalent();
 }
 
 static VisiblePosition endOfLine(const VisiblePosition& c, LineEndpointComputationMode mode)
 {
     // TODO: this is the current behavior that might need to be fixed.
     // Please refer to https://bugs.webkit.org/show_bug.cgi?id=49107 for detail.
     VisiblePosition visPos = endPositionForLine(c, mode);
 
     if (mode == UseLogicalOrdering) {
         // Make sure the end of line is at the same line as the given input position. For a wrapping line, the logical end
         // position for the not-last-2-lines might incorrectly hand back the logical beginning of the next line.
         // For example, <div contenteditable dir="rtl" style="line-break:before-white-space">abcdefg abcdefg abcdefg
         // a abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg </div>
         // In this case, use the previous position of the computed logical end position.
         if (!inSameLogicalLine(c, visPos))
             visPos = previousPositionOf(visPos);
 
         if (ContainerNode* editableRoot = highestEditableRoot(c.deepEquivalent())) {
             if (!editableRoot->contains(visPos.deepEquivalent().computeContainerNode()))
-                return VisiblePosition(lastPositionInNode(editableRoot));
+                return createVisiblePosition(lastPositionInNode(editableRoot));
         }
 
         return honorEditingBoundaryAtOrAfter(visPos, c.deepEquivalent());
     }
 
     // Make sure the end of line is at the same line as the given input position. Else use the previous position to
     // obtain end of line. This condition happens when the input position is before the space character at the end
     // of a soft-wrapped non-editable line. In this scenario, endPositionForLine would incorrectly hand back a position
     // in the next line instead. This fix is to account for the discrepancy between lines with webkit-line-break:after-white-space style
     // versus lines without that style, which would break before a space by default.
@@ skipping 97 matching lines @@
         root = box->root().prevRootBox();
         // We want to skip zero height boxes.
         // This could happen in case it is a TrailingFloatsRootInlineBox.
         if (!root || !root->logicalHeight() || !root->firstLeafChild())
             root = 0;
     }
 
     if (!root) {
         Position position = previousRootInlineBoxCandidatePosition(node, visiblePosition, editableType);
         if (position.isNotNull()) {
-            RenderedPosition renderedPosition((VisiblePosition(position)));
+            RenderedPosition renderedPosition((createVisiblePosition(position)));
             root = renderedPosition.rootBox();
             if (!root)
-                return VisiblePosition(position);
+                return createVisiblePosition(position);
         }
     }
 
     if (root) {
         // FIXME: Can be wrong for multi-column layout and with transforms.
         LayoutPoint pointInLine = absoluteLineDirectionPointToLocalPointInBlock(root, lineDirectionPoint);
         LayoutObject& layoutObject = root->closestLeafChildForPoint(pointInLine, isEditablePosition(p))->layoutObject();
         Node* node = layoutObject.node();
         if (node && editingIgnoresContent(node))
-            return VisiblePosition(positionInParentBeforeNode(*node));
+            return createVisiblePosition(positionInParentBeforeNode(*node));
         return createVisiblePosition(layoutObject.positionForPoint(pointInLine));
     }
 
     // Could not find a previous line. This means we must already be on the first line.
     // Move to the start of the content in this block, which effectively moves us
     // to the start of the line we're on.
     Element* rootElement = node->hasEditableStyle(editableType) ? node->rootEditableElement(editableType) : node->document().documentElement();
     if (!rootElement)
         return VisiblePosition();
-    return VisiblePosition(firstPositionInNode(rootElement));
+    return createVisiblePosition(firstPositionInNode(rootElement));
 }
 
 VisiblePosition nextLinePosition(const VisiblePosition& visiblePosition, LayoutUnit lineDirectionPoint, EditableType editableType)
 {
     Position p = visiblePosition.deepEquivalent();
     Node* node = p.anchorNode();
 
     if (!node)
         return VisiblePosition();
 
@@ skipping 12 matching lines @@
         if (!root || !root->logicalHeight() || !root->firstLeafChild())
             root = 0;
     }
 
     if (!root) {
         // FIXME: We need do the same in previousLinePosition.
         Node* child = NodeTraversal::childAt(*node, p.computeEditingOffset());
         node = child ? child : &NodeTraversal::lastWithinOrSelf(*node);
         Position position = nextRootInlineBoxCandidatePosition(node, visiblePosition, editableType);
         if (position.isNotNull()) {
-            RenderedPosition renderedPosition((VisiblePosition(position)));
+            RenderedPosition renderedPosition((createVisiblePosition(position)));
             root = renderedPosition.rootBox();
             if (!root)
-                return VisiblePosition(position);
+                return createVisiblePosition(position);
         }
     }
 
     if (root) {
         // FIXME: Can be wrong for multi-column layout and with transforms.
         LayoutPoint pointInLine = absoluteLineDirectionPointToLocalPointInBlock(root, lineDirectionPoint);
         LayoutObject& layoutObject = root->closestLeafChildForPoint(pointInLine, isEditablePosition(p))->layoutObject();
         Node* node = layoutObject.node();
         if (node && editingIgnoresContent(node))
-            return VisiblePosition(positionInParentBeforeNode(*node));
+            return createVisiblePosition(positionInParentBeforeNode(*node));
         return createVisiblePosition(layoutObject.positionForPoint(pointInLine));
     }
 
     // Could not find a next line. This means we must already be on the last line.
     // Move to the end of the content in this block, which effectively moves us
     // to the end of the line we're on.
     Element* rootElement = node->hasEditableStyle(editableType) ? node->rootEditableElement(editableType) : node->document().documentElement();
     if (!rootElement)
         return VisiblePosition();
-    return VisiblePosition(lastPositionInNode(rootElement));
+    return createVisiblePosition(lastPositionInNode(rootElement));
 }
 
 // ---------
 
 static unsigned startSentenceBoundary(const UChar* characters, unsigned length, unsigned, BoundarySearchContextAvailability, bool&)
 {
     TextBreakIterator* iterator = sentenceBreakIterator(characters, length);
     // FIXME: The following function can return -1; we don't handle that.
     return iterator->preceding(length);
 }
@@ skipping 45 matching lines @@
 
 VisiblePosition startOfParagraph(const VisiblePosition& c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     Position p = c.deepEquivalent();
     Node* startNode = p.anchorNode();
 
     if (!startNode)
         return VisiblePosition();
 
     if (isRenderedAsNonInlineTableImageOrHR(startNode))
-        return VisiblePosition(positionBeforeNode(startNode));
+        return createVisiblePosition(positionBeforeNode(startNode));
 
     Element* startBlock = enclosingBlock(startNode);
 
     Node* node = startNode;
     ContainerNode* highestRoot = highestEditableRoot(p);
     int offset = p.computeEditingOffset();
     PositionAnchorType type = p.anchorType();
 
     Node* n = startNode;
     bool startNodeIsEditable = startNode->hasEditableStyle();
@@ skipping 24 matching lines @@
             ASSERT_WITH_SECURITY_IMPLICATION(n->isTextNode());
             type = PositionAnchorType::OffsetInAnchor;
             if (style.preserveNewline()) {
                 LayoutText* text = toLayoutText(r);
                 int i = text->textLength();
                 int o = offset;
                 if (n == startNode && o < i)
                     i = max(0, o);
                 while (--i >= 0) {
                     if ((*text)[i] == '\n')
-                        return VisiblePosition(Position(toText(n), i + 1));
+                        return createVisiblePosition(Position(toText(n), i + 1));
                 }
             }
             node = n;
             offset = 0;
             n = NodeTraversal::previousPostOrder(*n, startBlock);
         } else if (editingIgnoresContent(n) || isRenderedTableElement(n)) {
             node = n;
             type = PositionAnchorType::BeforeAnchor;
             n = n->previousSibling() ? n->previousSibling() : NodeTraversal::previousPostOrder(*n, startBlock);
         } else {
             n = NodeTraversal::previousPostOrder(*n, startBlock);
         }
     }
 
     if (type == PositionAnchorType::OffsetInAnchor)
-        return VisiblePosition(Position(node, offset));
+        return createVisiblePosition(Position(node, offset));
 
-    return VisiblePosition(Position(node, type));
+    return createVisiblePosition(Position(node, type));
 }
 
 VisiblePosition endOfParagraph(const VisiblePosition& c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     if (c.isNull())
         return VisiblePosition();
 
     Position p = c.deepEquivalent();
     Node* startNode = p.anchorNode();
 
     if (isRenderedAsNonInlineTableImageOrHR(startNode))
-        return VisiblePosition(positionAfterNode(startNode));
+        return createVisiblePosition(positionAfterNode(startNode));
 
     Element* startBlock = enclosingBlock(startNode);
     Element* stayInsideBlock = startBlock;
 
     Node* node = startNode;
     ContainerNode* highestRoot = highestEditableRoot(p);
     int offset = p.computeEditingOffset();
     PositionAnchorType type = p.anchorType();
 
     Node* n = startNode;
@@ skipping 25 matching lines @@
         // 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 VisiblePosition(Position(toText(n), i));
+                        return createVisiblePosition(Position(toText(n), i));
                 }
             }
             node = n;
             offset = r->caretMaxOffset();
             n = NodeTraversal::next(*n, stayInsideBlock);
         } else if (editingIgnoresContent(n) || isRenderedTableElement(n)) {
             node = n;
             type = PositionAnchorType::AfterAnchor;
             n = NodeTraversal::nextSkippingChildren(*n, stayInsideBlock);
         } else {
             n = NodeTraversal::next(*n, stayInsideBlock);
         }
     }
 
     if (type == PositionAnchorType::OffsetInAnchor)
-        return VisiblePosition(Position(node, offset));
+        return createVisiblePosition(Position(node, offset));
 
-    return VisiblePosition(Position(node, type));
+    return createVisiblePosition(Position(node, type));
 }
 
 // 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 39 matching lines @@
     } while (inSameParagraph(p, pos));
     return pos;
 }
 
 // ---------
 
 VisiblePosition startOfBlock(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     Position position = visiblePosition.deepEquivalent();
     Element* startBlock = position.computeContainerNode() ? enclosingBlock(position.computeContainerNode(), rule) : 0;
-    return startBlock ? VisiblePosition(firstPositionInNode(startBlock)) : VisiblePosition();
+    return startBlock ? createVisiblePosition(firstPositionInNode(startBlock)) : VisiblePosition();
 }
 
 VisiblePosition endOfBlock(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     Position position = visiblePosition.deepEquivalent();
     Element* endBlock = position.computeContainerNode() ? enclosingBlock(position.computeContainerNode(), rule) : 0;
-    return endBlock ? VisiblePosition(lastPositionInNode(endBlock)) : VisiblePosition();
+    return endBlock ? createVisiblePosition(lastPositionInNode(endBlock)) : VisiblePosition();
 }
 
 bool inSameBlock(const VisiblePosition& a, const VisiblePosition& b)
 {
     return !a.isNull() && enclosingBlock(a.deepEquivalent().computeContainerNode()) == enclosingBlock(b.deepEquivalent().computeContainerNode());
 }
 
 bool isStartOfBlock(const VisiblePosition& pos)
 {
     return pos.isNotNull() && pos.deepEquivalent() == startOfBlock(pos, CanCrossEditingBoundary).deepEquivalent();
 }
 
 bool isEndOfBlock(const VisiblePosition& pos)
 {
     return pos.isNotNull() && pos.deepEquivalent() == endOfBlock(pos, CanCrossEditingBoundary).deepEquivalent();
 }
 
 // ---------
 
 VisiblePosition startOfDocument(const Node* node)
 {
     if (!node || !node->document().documentElement())
         return VisiblePosition();
 
-    return VisiblePosition(firstPositionInNode(node->document().documentElement()));
+    return createVisiblePosition(firstPositionInNode(node->document().documentElement()));
 }
 
 VisiblePosition startOfDocument(const VisiblePosition& c)
 {
     return startOfDocument(c.deepEquivalent().anchorNode());
 }
 
 VisiblePosition endOfDocument(const Node* node)
 {
     if (!node || !node->document().documentElement())
         return VisiblePosition();
 
     Element* doc = node->document().documentElement();
-    return VisiblePosition(lastPositionInNode(doc));
+    return createVisiblePosition(lastPositionInNode(doc));
 }
 
 VisiblePosition endOfDocument(const VisiblePosition& c)
 {
     return endOfDocument(c.deepEquivalent().anchorNode());
 }
 
 bool isStartOfDocument(const VisiblePosition& p)
 {
     return p.isNotNull() && previousPositionOf(p, CanCrossEditingBoundary).isNull();
 }
 
 bool isEndOfDocument(const VisiblePosition& p)
 {
     return p.isNotNull() && nextPositionOf(p, CanCrossEditingBoundary).isNull();
 }
 
 // ---------
 
 VisiblePosition startOfEditableContent(const VisiblePosition& visiblePosition)
 {
     ContainerNode* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent());
     if (!highestRoot)
         return VisiblePosition();
 
-    return VisiblePosition(firstPositionInNode(highestRoot));
+    return createVisiblePosition(firstPositionInNode(highestRoot));
 }
 
 VisiblePosition endOfEditableContent(const VisiblePosition& visiblePosition)
 {
     ContainerNode* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent());
     if (!highestRoot)
         return VisiblePosition();
 
-    return VisiblePosition(lastPositionInNode(highestRoot));
+    return createVisiblePosition(lastPositionInNode(highestRoot));
 }
 
 bool isEndOfEditableOrNonEditableContent(const VisiblePosition& p)
 {
     return p.isNotNull() && nextPositionOf(p).isNull();
 }
 
 VisiblePosition leftBoundaryOfLine(const VisiblePosition& c, TextDirection direction)
 {
     return direction == LTR ? logicalStartOfLine(c) : logicalEndOfLine(c);
@@ skipping 69 matching lines @@
     int caretOffset = position.computeEditingOffset();
     Node* const anchorNode = position.anchorNode();
     LayoutObject* layoutObject = anchorNode->isShadowRoot() ? toShadowRoot(anchorNode)->host()->layoutObject() : anchorNode->layoutObject();
 
     if (!layoutObject->isText()) {
         inlineBox = 0;
         if (canHaveChildrenForEditing(anchorNode) && layoutObject->isLayoutBlockFlow() && hasRenderedNonAnonymousDescendantsWithHeight(layoutObject)) {
             // Try a visually equivalent position with possibly opposite
             // editability. This helps in case |this| is in an editable block
             // but surrounded by non-editable positions. It acts to negate the
-            // logic at the beginning of LayoutObject::createVisiblePosition().
+            // logic at the beginning of LayoutObject::VisiblePosition().

[tkent, 2015/09/01 23:21:17]

LayoutObject has neither createVisiblePosition nor VisiblePosition.

[yosin_UTC9, 2015/09/02 03:46:20]

Good catch. It should be |LayoutObject::createPositionWithAffinity()|
when I introduced |PositionWithAffinity| two years ago.

             PositionAlgorithm<Strategy> equivalent = downstreamIgnoringEditingBoundaries(position);
             if (equivalent == position) {
                 equivalent = upstreamIgnoringEditingBoundaries(position);
                 if (equivalent == position || downstreamIgnoringEditingBoundaries(equivalent) == position)
                     return InlineBoxPosition(inlineBox, caretOffset);
             }
 
             return computeInlineBoxPosition(equivalent, TextAffinity::Upstream, primaryDirection);
         }
         if (layoutObject->isBox()) {
@@ skipping 801 matching lines @@
     ContainerNode* highestRoot = highestEditableRoot(anchor);
     ContainerNode* highestRootOfPos = highestEditableRoot(pos.deepEquivalent());
 
     // Return |pos| itself if the two are from the very same editable region, or
     // both are non-editable.
     if (highestRootOfPos == highestRoot)
         return pos;
 
     // If this is not editable but |pos| has an editable root, skip to the end
     if (!highestRoot && highestRootOfPos)
-        return VisiblePosition(Position(highestRootOfPos, PositionAnchorType::AfterAnchor).parentAnchoredEquivalent());
+        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)
 {
     // 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
@@ skipping 13 matching lines @@
     return textNode->data().characterStartingAt(offset);
 }
 
 UChar32 characterBefore(const VisiblePosition& visiblePosition)
 {
     return characterAfter(previousPositionOf(visiblePosition));
 }
 
 VisiblePosition nextPositionOf(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
 {
-    VisiblePosition next(nextVisuallyDistinctCandidate(visiblePosition.deepEquivalent()), visiblePosition.affinity());
+    VisiblePosition next = createVisiblePosition(nextVisuallyDistinctCandidate(visiblePosition.deepEquivalent()), visiblePosition.affinity());
 
     switch (rule) {
     case CanCrossEditingBoundary:
         return next;
     case CannotCrossEditingBoundary:
         return honorEditingBoundaryAtOrAfter(next, visiblePosition.deepEquivalent());
     case CanSkipOverEditingBoundary:
         return skipToEndOfEditingBoundary(next, visiblePosition.deepEquivalent());
     }
     ASSERT_NOT_REACHED();
     return honorEditingBoundaryAtOrAfter(next, visiblePosition.deepEquivalent());
 }
 
 static VisiblePosition skipToStartOfEditingBoundary(const VisiblePosition& pos, const Position& anchor)
 {
     if (pos.isNull())
         return pos;
 
     ContainerNode* highestRoot = highestEditableRoot(anchor);
     ContainerNode* highestRootOfPos = highestEditableRoot(pos.deepEquivalent());
 
     // Return |pos| itself if the two are from the very same editable region, or
     // both are non-editable.
     if (highestRootOfPos == highestRoot)
         return pos;
 
     // If this is not editable but |pos| has an editable root, skip to the start
     if (!highestRoot && highestRootOfPos)
-        return VisiblePosition(previousVisuallyDistinctCandidate(Position(highestRootOfPos, PositionAnchorType::BeforeAnchor).parentAnchoredEquivalent()));
+        return createVisiblePosition(previousVisuallyDistinctCandidate(Position(highestRootOfPos, PositionAnchorType::BeforeAnchor).parentAnchoredEquivalent()));
 
     // That must mean that |pos| is not editable. Return the last position
     // before |pos| that is in the same editable region as this position
     return lastEditableVisiblePositionBeforePositionInRoot(pos.deepEquivalent(), highestRoot);
 }
 
 VisiblePosition previousPositionOf(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     Position pos = previousVisuallyDistinctCandidate(visiblePosition.deepEquivalent());
 
     // return null visible position if there is no previous visible position
     if (pos.atStartOfTree())
         return VisiblePosition();
 
-    VisiblePosition prev = VisiblePosition(pos);
+    VisiblePosition prev = createVisiblePosition(pos);
     ASSERT(prev.deepEquivalent() != visiblePosition.deepEquivalent());
 
 #if ENABLE(ASSERT)
     // we should always be able to make the affinity |TextAffinity::Downstream|,
     // because going previous from an |TextAffinity::Upstream| position can
     // never yield another |TextAffinity::Upstream position| (unless line wrap
     // length is 0!).
     if (prev.isNotNull() && visiblePosition.affinity() == TextAffinity::Upstream) {
         ASSERT(inSameLine(PositionWithAffinity(prev.deepEquivalent()), PositionWithAffinity(prev.deepEquivalent(), TextAffinity::Upstream)));
     }
 #endif
 
     switch (rule) {
     case CanCrossEditingBoundary:
         return prev;
     case CannotCrossEditingBoundary:
         return honorEditingBoundaryAtOrBefore(prev, visiblePosition.deepEquivalent());
     case CanSkipOverEditingBoundary:
         return skipToStartOfEditingBoundary(prev, visiblePosition.deepEquivalent());
     }
 
     ASSERT_NOT_REACHED();
     return honorEditingBoundaryAtOrBefore(prev, visiblePosition.deepEquivalent());
 }
 
 } // namespace blink