Make VisiblePosition constructor private

Source/core/editing/EditingUtilities.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007 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 430 matching lines @@
     return previousVisuallyDistinctCandidateAlgorithm<EditingStrategy>(position);
 }
 
 PositionInComposedTree previousVisuallyDistinctCandidate(const PositionInComposedTree& position)
 {
     return previousVisuallyDistinctCandidateAlgorithm<EditingInComposedTreeStrategy>(position);
 }
 
 VisiblePosition firstEditableVisiblePositionAfterPositionInRoot(const Position& position, ContainerNode* highestRoot)
 {
-    return VisiblePosition(firstEditablePositionAfterPositionInRoot(position, highestRoot));
+    return createVisiblePosition(firstEditablePositionAfterPositionInRoot(position, highestRoot));
 }
 
 template <typename Strategy>
 PositionAlgorithm<Strategy> firstEditablePositionAfterPositionInRootAlgorithm(const PositionAlgorithm<Strategy>& position, Node* highestRoot)
 {
     // position falls before highestRoot.
     if (position.compareTo(PositionAlgorithm<Strategy>::firstPositionInNode(highestRoot)) == -1 && highestRoot->hasEditableStyle())
         return PositionAlgorithm<Strategy>::firstPositionInNode(highestRoot);
 
     PositionAlgorithm<Strategy> editablePosition = position;
@@ skipping 20 matching lines @@
     return firstEditablePositionAfterPositionInRootAlgorithm<EditingStrategy>(position, highestRoot);
 }
 
 PositionInComposedTree firstEditablePositionAfterPositionInRoot(const PositionInComposedTree& position, Node* highestRoot)
 {
     return firstEditablePositionAfterPositionInRootAlgorithm<EditingInComposedTreeStrategy>(position, highestRoot);
 }
 
 VisiblePosition lastEditableVisiblePositionBeforePositionInRoot(const Position& position, ContainerNode* highestRoot)
 {
-    return VisiblePosition(lastEditablePositionBeforePositionInRoot(position, highestRoot));
+    return createVisiblePosition(lastEditablePositionBeforePositionInRoot(position, highestRoot));
 }
 
 template <typename Strategy>
 PositionAlgorithm<Strategy> lastEditablePositionBeforePositionInRootAlgorithm(const PositionAlgorithm<Strategy>& position, Node* highestRoot)
 {
     // When position falls after highestRoot, the result is easy to compute.
     if (position.compareTo(PositionAlgorithm<Strategy>::lastPositionInNode(highestRoot)) == 1)
         return PositionAlgorithm<Strategy>::lastPositionInNode(highestRoot);
 
     PositionAlgorithm<Strategy> editablePosition = position;
@@ skipping 293 matching lines @@
 
     return false;
 }
 
 static HTMLElement* firstInSpecialElement(const Position& pos)
 {
     Element* rootEditableElement = pos.computeContainerNode()->rootEditableElement();
     for (Node* n = pos.anchorNode(); n && n->rootEditableElement() == rootEditableElement; n = n->parentNode()) {
         if (isSpecialHTMLElement(*n)) {
             HTMLElement* specialElement = toHTMLElement(n);
-            VisiblePosition vPos = VisiblePosition(pos);
-            VisiblePosition firstInElement = VisiblePosition(firstPositionInOrBeforeNode(specialElement));
+            VisiblePosition vPos = createVisiblePosition(pos);
+            VisiblePosition firstInElement = createVisiblePosition(firstPositionInOrBeforeNode(specialElement));
             if (isRenderedTableElement(specialElement) && vPos.deepEquivalent() == nextPositionOf(firstInElement).deepEquivalent())
                 return specialElement;
             if (vPos.deepEquivalent() == firstInElement.deepEquivalent())
                 return specialElement;
         }
     }
     return 0;
 }
 
 static HTMLElement* lastInSpecialElement(const Position& pos)
 {
     Element* rootEditableElement = pos.computeContainerNode()->rootEditableElement();
     for (Node* n = pos.anchorNode(); n && n->rootEditableElement() == rootEditableElement; n = n->parentNode()) {
         if (isSpecialHTMLElement(*n)) {
             HTMLElement* specialElement = toHTMLElement(n);
-            VisiblePosition vPos = VisiblePosition(pos);
-            VisiblePosition lastInElement = VisiblePosition(lastPositionInOrAfterNode(specialElement));
+            VisiblePosition vPos = createVisiblePosition(pos);
+            VisiblePosition lastInElement = createVisiblePosition(lastPositionInOrAfterNode(specialElement));
             if (isRenderedTableElement(specialElement) && vPos.deepEquivalent() == previousPositionOf(lastInElement).deepEquivalent())
                 return specialElement;
             if (vPos.deepEquivalent() == lastInElement.deepEquivalent())
                 return specialElement;
         }
     }
     return 0;
 }
 
 Position positionBeforeContainingSpecialElement(const Position& pos, HTMLElement** containingSpecialElement)
@@ skipping 84 matching lines @@
             return node;
         node = nextNodeConsideringAtomicNodes(*node);
     }
     return nullptr;
 }
 
 // Returns the visible position at the beginning of a node
 VisiblePosition visiblePositionBeforeNode(Node& node)
 {
     if (node.hasChildren())
-        return VisiblePosition(firstPositionInOrBeforeNode(&node));
+        return createVisiblePosition(firstPositionInOrBeforeNode(&node));
     ASSERT(node.parentNode());
     ASSERT(!node.parentNode()->isShadowRoot());
-    return VisiblePosition(positionInParentBeforeNode(node));
+    return createVisiblePosition(positionInParentBeforeNode(node));
 }
 
 // Returns the visible position at the ending of a node
 VisiblePosition visiblePositionAfterNode(Node& node)
 {
     if (node.hasChildren())
-        return VisiblePosition(lastPositionInOrAfterNode(&node));
+        return createVisiblePosition(lastPositionInOrAfterNode(&node));
     ASSERT(node.parentNode());
     ASSERT(!node.parentNode()->isShadowRoot());
-    return VisiblePosition(positionInParentAfterNode(node));
+    return createVisiblePosition(positionInParentAfterNode(node));
 }
 
 bool isHTMLListElement(Node* n)
 {
     return (n && (isHTMLUListElement(*n) || isHTMLOListElement(*n) || isHTMLDListElement(*n)));
 }
 
 bool isListItem(const Node* n)
 {
     return n && n->layoutObject() && n->layoutObject()->isListItem();
@@ skipping 158 matching lines @@
 }
 
 // FIXME: This method should not need to call isStartOfParagraph/isEndOfParagraph
 Node* enclosingEmptyListItem(const VisiblePosition& visiblePos)
 {
     // Check that position is on a line by itself inside a list item
     Node* listChildNode = enclosingListChild(visiblePos.deepEquivalent().anchorNode());
     if (!listChildNode || !isStartOfParagraph(visiblePos) || !isEndOfParagraph(visiblePos))
         return 0;
 
-    VisiblePosition firstInListChild(firstPositionInOrBeforeNode(listChildNode));
-    VisiblePosition lastInListChild(lastPositionInOrAfterNode(listChildNode));
+    VisiblePosition firstInListChild = createVisiblePosition(firstPositionInOrBeforeNode(listChildNode));
+    VisiblePosition lastInListChild = createVisiblePosition(lastPositionInOrAfterNode(listChildNode));
 
     if (firstInListChild.deepEquivalent() != visiblePos.deepEquivalent() || lastInListChild.deepEquivalent() != visiblePos.deepEquivalent())
         return 0;
 
     return listChildNode;
 }
 
 HTMLElement* outermostEnclosingList(Node* node, HTMLElement* rootList)
 {
     HTMLElement* list = enclosingList(node);
     if (!list)
         return 0;
 
     while (HTMLElement* nextList = enclosingList(list)) {
         if (nextList == rootList)
             break;
         list = nextList;
     }
 
     return list;
 }
 
 // Determines whether two positions are visibly next to each other (first then second)
 // while ignoring whitespaces and unrendered nodes
 static bool isVisiblyAdjacent(const Position& first, const Position& second)
 {
-    return VisiblePosition(first).deepEquivalent() == VisiblePosition(mostBackwardCaretPosition(second)).deepEquivalent();
+    return createVisiblePosition(first).deepEquivalent() == createVisiblePosition(mostBackwardCaretPosition(second)).deepEquivalent();
 }
 
 bool canMergeLists(Element* firstList, Element* secondList)
 {
     if (!firstList || !secondList || !firstList->isHTMLElement() || !secondList->isHTMLElement())
         return false;
 
     return firstList->hasTagName(secondList->tagQName()) // make sure the list types match (ol vs. ul)
     && firstList->hasEditableStyle() && secondList->hasEditableStyle() // both lists are editable
     && firstList->rootEditableElement() == secondList->rootEditableElement() // don't cross editing boundaries
@@ skipping 149 matching lines @@
 }
 
 // return first preceding DOM position rendered at a different location, or "this"
 static Position previousCharacterPosition(const Position& position, TextAffinity affinity)
 {
     if (position.isNull())
         return Position();
 
     Element* fromRootEditableElement = position.anchorNode()->rootEditableElement();
 
-    bool atStartOfLine = isStartOfLine(VisiblePosition(position, affinity));
+    bool atStartOfLine = isStartOfLine(createVisiblePosition(position, affinity));
     bool rendered = isVisuallyEquivalentCandidate(position);
 
     Position currentPos = position;
     while (!currentPos.atStartOfTree()) {
         // TODO(yosin) When we use |previousCharacterPosition()| other than
         // finding leading whitespace, we should use |Character| instead of
         // |CodePoint|.
         currentPos = previousPositionOf(currentPos, PositionMoveType::CodePoint);
 
         if (currentPos.anchorNode()->rootEditableElement() != fromRootEditableElement)
@@ skipping 32 matching lines @@
     return Position();
 }
 
 // This assumes that it starts in editable content.
 Position trailingWhitespacePosition(const Position& position, TextAffinity, WhitespacePositionOption option)
 {
     ASSERT(isEditablePosition(position, ContentIsEditable, DoNotUpdateStyle));
     if (position.isNull())
         return Position();
 
-    VisiblePosition visiblePosition(position);
+    VisiblePosition visiblePosition = createVisiblePosition(position);
     UChar characterAfterVisiblePosition = characterAfter(visiblePosition);
     bool isSpace = option == ConsiderNonCollapsibleWhitespace ? (isSpaceOrNewline(characterAfterVisiblePosition) || characterAfterVisiblePosition == noBreakSpaceCharacter) : isCollapsibleWhitespace(characterAfterVisiblePosition);
     // The space must not be in another paragraph and it must be editable.
     if (isSpace && !isEndOfParagraph(visiblePosition) && nextPositionOf(visiblePosition, CannotCrossEditingBoundary).isNotNull())
         return position;
     return Position();
 }
 
 unsigned numEnclosingMailBlockquotes(const Position& p)
 {
@@ skipping 178 matching lines @@
 VisiblePosition visiblePositionForIndex(int index, ContainerNode* scope)
 {
     if (!scope)
         return VisiblePosition();
     EphemeralRange range = PlainTextRange(index).createRangeForSelection(*scope);
     // Check for an invalid index. Certain editing operations invalidate indices
     // because of problems with
     // TextIteratorEmitsCharactersBetweenAllVisiblePositions.
     if (range.isNull())
         return VisiblePosition();
-    return VisiblePosition(range.startPosition());
+    return createVisiblePosition(range.startPosition());
 }
 
 // Determines whether a node is inside a range or visibly starts and ends at the boundaries of the range.
 // Call this function to determine whether a node is visibly fit inside selectedRange
 bool isNodeVisiblyContainedWithin(Node& node, const Range& selectedRange)
 {
     if (selectedRange.isNodeFullyContained(node))
         return true;
 
-    bool startIsVisuallySame = visiblePositionBeforeNode(node).deepEquivalent() == VisiblePosition(selectedRange.startPosition()).deepEquivalent();
+    bool startIsVisuallySame = visiblePositionBeforeNode(node).deepEquivalent() == createVisiblePosition(selectedRange.startPosition()).deepEquivalent();
     if (startIsVisuallySame && comparePositions(positionInParentAfterNode(node), selectedRange.endPosition()) < 0)
         return true;
 
-    bool endIsVisuallySame = visiblePositionAfterNode(node).deepEquivalent() == VisiblePosition(selectedRange.endPosition()).deepEquivalent();
+    bool endIsVisuallySame = visiblePositionAfterNode(node).deepEquivalent() == createVisiblePosition(selectedRange.endPosition()).deepEquivalent();
     if (endIsVisuallySame && comparePositions(selectedRange.startPosition(), positionInParentBeforeNode(node)) < 0)
         return true;
 
     return startIsVisuallySame && endIsVisuallySame;
 }
 
 bool isRenderedAsNonInlineTableImageOrHR(const Node* node)
 {
     if (!node)
         return false;
@@ skipping 39 matching lines @@
     return node.isElementNode() && layoutObject && layoutObject->isLayoutBlockFlow();
 }
 
 Position adjustedSelectionStartForStyleComputation(const VisibleSelection& selection)
 {
     // This function is used by range style computations to avoid bugs like:
     // <rdar://problem/4017641> REGRESSION (Mail): you can only bold/unbold a selection starting from end of line once
     // It is important to skip certain irrelevant content at the start of the selection, so we do not wind up
     // with a spurious "mixed" style.
 
-    VisiblePosition visiblePosition(selection.start());
+    VisiblePosition visiblePosition = createVisiblePosition(selection.start());
     if (visiblePosition.isNull())
         return Position();
 
     // if the selection is a caret, just return the position, since the style
     // behind us is relevant
     if (selection.isCaret())
         return visiblePosition.deepEquivalent();
 
     // if the selection starts just before a paragraph break, skip over it
     if (isEndOfParagraph(visiblePosition))
         return mostForwardCaretPosition(nextPositionOf(visiblePosition).deepEquivalent());
 
     // otherwise, make sure to be at the start of the first selected node,
     // instead of possibly at the end of the last node before the selection
     return mostForwardCaretPosition(visiblePosition.deepEquivalent());
 }
 
 } // namespace blink