Make VisiblePosition constructor private

Source/core/editing/FrameSelection.cpp

 /*
  * Copyright (C) 2004, 2008, 2009, 2010 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 151 matching lines @@
 {
     RenderedPosition base(visibleBase);
     RenderedPosition extent(visibleExtent);
 
     if (base.isNull() || extent.isNull() || base.isEquivalent(extent))
         return;
 
     if (base.atLeftBoundaryOfBidiRun()) {
         if (!extent.atRightBoundaryOfBidiRun(base.bidiLevelOnRight())
             && base.isEquivalent(extent.leftBoundaryOfBidiRun(base.bidiLevelOnRight()))) {
-            visibleBase = VisiblePosition(base.positionAtLeftBoundaryOfBiDiRun());
+            visibleBase = createVisiblePosition(base.positionAtLeftBoundaryOfBiDiRun());
             return;
         }
         return;
     }
 
     if (base.atRightBoundaryOfBidiRun()) {
         if (!extent.atLeftBoundaryOfBidiRun(base.bidiLevelOnLeft())
             && base.isEquivalent(extent.rightBoundaryOfBidiRun(base.bidiLevelOnLeft()))) {
-            visibleBase = VisiblePosition(base.positionAtRightBoundaryOfBiDiRun());
+            visibleBase = createVisiblePosition(base.positionAtRightBoundaryOfBiDiRun());
             return;
         }
         return;
     }
 
     if (extent.atLeftBoundaryOfBidiRun() && extent.isEquivalent(base.leftBoundaryOfBidiRun(extent.bidiLevelOnRight()))) {
-        visibleExtent = VisiblePosition(extent.positionAtLeftBoundaryOfBiDiRun());
+        visibleExtent = createVisiblePosition(extent.positionAtLeftBoundaryOfBiDiRun());
         return;
     }
 
     if (extent.atRightBoundaryOfBidiRun() && extent.isEquivalent(base.rightBoundaryOfBidiRun(extent.bidiLevelOnLeft()))) {
-        visibleExtent = VisiblePosition(extent.positionAtRightBoundaryOfBiDiRun());
+        visibleExtent = createVisiblePosition(extent.positionAtRightBoundaryOfBiDiRun());
         return;
     }
 }
 
 template <typename Strategy>
 void FrameSelection::setNonDirectionalSelectionIfNeededAlgorithm(const VisibleSelection& passedNewSelection, TextGranularity granularity,
     EndPointsAdjustmentMode endpointsAdjustmentMode)
 {
     VisibleSelection newSelection = passedNewSelection;
     bool isDirectional = shouldAlwaysUseDirectionalSelection(m_frame) || newSelection.isDirectional();
@@ skipping 440 matching lines @@
         bool movingBackwardsMovedPositionToStartOfCurrentWord = positionAfterCurrentWord.deepEquivalent() == previousWordPosition(nextWordPosition(originalPosition)).deepEquivalent();
         if (movingBackwardsMovedPositionToStartOfCurrentWord)
             positionAfterCurrentWord = positionAfterSpacingAndFollowingWord;
     }
     return positionAfterCurrentWord;
 }
 
 static void adjustPositionForUserSelectAll(VisiblePosition& pos, bool isForward)
 {
     if (Node* rootUserSelectAll = EditingStrategy::rootUserSelectAllForNode(pos.deepEquivalent().anchorNode()))
-        pos = VisiblePosition(isForward ? mostForwardCaretPosition(positionAfterNode(rootUserSelectAll), CanCrossEditingBoundary) : mostBackwardCaretPosition(positionBeforeNode(rootUserSelectAll), CanCrossEditingBoundary));
+        pos = createVisiblePosition(isForward ? mostForwardCaretPosition(positionAfterNode(rootUserSelectAll), CanCrossEditingBoundary) : mostBackwardCaretPosition(positionBeforeNode(rootUserSelectAll), CanCrossEditingBoundary));
 }
 
 VisiblePosition FrameSelection::modifyExtendingRight(TextGranularity granularity)
 {
-    VisiblePosition pos(m_selection.extent(), m_selection.affinity());
+    VisiblePosition pos = createVisiblePosition(m_selection.extent(), m_selection.affinity());
 
     // The difference between modifyExtendingRight and modifyExtendingForward is:
     // modifyExtendingForward always extends forward logically.
     // modifyExtendingRight behaves the same as modifyExtendingForward except for extending character or word,
     // it extends forward logically if the enclosing block is LTR direction,
     // but it extends backward logically if the enclosing block is RTL direction.
     switch (granularity) {
     case CharacterGranularity:
         if (directionOfEnclosingBlock() == LTR)
             pos = nextPositionOf(pos, CanSkipOverEditingBoundary);
@@ skipping 21 matching lines @@
         // FIXME: implement all of the above?
         pos = modifyExtendingForward(granularity);
         break;
     }
     adjustPositionForUserSelectAll(pos, directionOfEnclosingBlock() == LTR);
     return pos;
 }
 
 VisiblePosition FrameSelection::modifyExtendingForward(TextGranularity granularity)
 {
-    VisiblePosition pos(m_selection.extent(), m_selection.affinity());
+    VisiblePosition pos = createVisiblePosition(m_selection.extent(), m_selection.affinity());
     switch (granularity) {
     case CharacterGranularity:
         pos = nextPositionOf(pos, CanSkipOverEditingBoundary);
         break;
     case WordGranularity:
         pos = nextWordPositionForPlatform(pos);
         break;
     case SentenceGranularity:
         pos = nextSentencePosition(pos);
         break;
@@ skipping 24 matching lines @@
     return pos;
 }
 
 VisiblePosition FrameSelection::modifyMovingRight(TextGranularity granularity)
 {
     VisiblePosition pos;
     switch (granularity) {
     case CharacterGranularity:
         if (isRange()) {
             if (directionOfSelection() == LTR)
-                pos = VisiblePosition(m_selection.end(), m_selection.affinity());
+                pos = createVisiblePosition(m_selection.end(), m_selection.affinity());
             else
-                pos = VisiblePosition(m_selection.start(), m_selection.affinity());
+                pos = createVisiblePosition(m_selection.start(), m_selection.affinity());
         } else {
-            pos = rightPositionOf(VisiblePosition(m_selection.extent(), m_selection.affinity()));
+            pos = rightPositionOf(createVisiblePosition(m_selection.extent(), m_selection.affinity()));
         }
         break;
     case WordGranularity: {
         bool skipsSpaceWhenMovingRight = m_frame && m_frame->editor().behavior().shouldSkipSpaceWhenMovingRight();
-        pos = rightWordPosition(VisiblePosition(m_selection.extent(), m_selection.affinity()), skipsSpaceWhenMovingRight);
+        pos = rightWordPosition(createVisiblePosition(m_selection.extent(), m_selection.affinity()), skipsSpaceWhenMovingRight);
         break;
     }
     case SentenceGranularity:
     case LineGranularity:
     case ParagraphGranularity:
     case SentenceBoundary:
     case ParagraphBoundary:
     case DocumentBoundary:
         // FIXME: Implement all of the above.
         pos = modifyMovingForward(granularity);
         break;
     case LineBoundary:
         pos = rightBoundaryOfLine(startForPlatform(), directionOfEnclosingBlock());
         break;
     }
     return pos;
 }
 
 VisiblePosition FrameSelection::modifyMovingForward(TextGranularity granularity)
 {
     VisiblePosition pos;
     // FIXME: Stay in editable content for the less common granularities.
     switch (granularity) {
     case CharacterGranularity:
         if (isRange())
-            pos = VisiblePosition(m_selection.end(), m_selection.affinity());
+            pos = createVisiblePosition(m_selection.end(), m_selection.affinity());
         else
-            pos = nextPositionOf(VisiblePosition(m_selection.extent(), m_selection.affinity()), CanSkipOverEditingBoundary);
+            pos = nextPositionOf(createVisiblePosition(m_selection.extent(), m_selection.affinity()), CanSkipOverEditingBoundary);
         break;
     case WordGranularity:
-        pos = nextWordPositionForPlatform(VisiblePosition(m_selection.extent(), m_selection.affinity()));
+        pos = nextWordPositionForPlatform(createVisiblePosition(m_selection.extent(), m_selection.affinity()));
         break;
     case SentenceGranularity:
-        pos = nextSentencePosition(VisiblePosition(m_selection.extent(), m_selection.affinity()));
+        pos = nextSentencePosition(createVisiblePosition(m_selection.extent(), m_selection.affinity()));
         break;
     case LineGranularity: {
         // down-arrowing from a range selection that ends at the start of a line needs
         // to leave the selection at that line start (no need to call nextLinePosition!)
         pos = endForPlatform();
         if (!isRange() || !isStartOfLine(pos))
             pos = nextLinePosition(pos, lineDirectionPointForBlockDirectionNavigation(START));
         break;
     }
     case ParagraphGranularity:
@@ skipping 14 matching lines @@
             pos = endOfEditableContent(pos);
         else
             pos = endOfDocument(pos);
         break;
     }
     return pos;
 }
 
 VisiblePosition FrameSelection::modifyExtendingLeft(TextGranularity granularity)
 {
-    VisiblePosition pos(m_selection.extent(), m_selection.affinity());
+    VisiblePosition pos = createVisiblePosition(m_selection.extent(), m_selection.affinity());
 
     // The difference between modifyExtendingLeft and modifyExtendingBackward is:
     // modifyExtendingBackward always extends backward logically.
     // modifyExtendingLeft behaves the same as modifyExtendingBackward except for extending character or word,
     // it extends backward logically if the enclosing block is LTR direction,
     // but it extends forward logically if the enclosing block is RTL direction.
     switch (granularity) {
     case CharacterGranularity:
         if (directionOfEnclosingBlock() == LTR)
             pos = previousPositionOf(pos, CanSkipOverEditingBoundary);
@@ skipping 20 matching lines @@
     case DocumentBoundary:
         pos = modifyExtendingBackward(granularity);
         break;
     }
     adjustPositionForUserSelectAll(pos, !(directionOfEnclosingBlock() == LTR));
     return pos;
 }
 
 VisiblePosition FrameSelection::modifyExtendingBackward(TextGranularity granularity)
 {
-    VisiblePosition pos(m_selection.extent(), m_selection.affinity());
+    VisiblePosition pos = createVisiblePosition(m_selection.extent(), m_selection.affinity());
 
     // Extending a selection backward by word or character from just after a table selects
     // the table.  This "makes sense" from the user perspective, esp. when deleting.
     // It was done here instead of in VisiblePosition because we want VPs to iterate
     // over everything.
     switch (granularity) {
     case CharacterGranularity:
         pos = previousPositionOf(pos, CanSkipOverEditingBoundary);
         break;
     case WordGranularity:
@@ skipping 29 matching lines @@
     return pos;
 }
 
 VisiblePosition FrameSelection::modifyMovingLeft(TextGranularity granularity)
 {
     VisiblePosition pos;
     switch (granularity) {
     case CharacterGranularity:
         if (isRange()) {
             if (directionOfSelection() == LTR)
-                pos = VisiblePosition(m_selection.start(), m_selection.affinity());
+                pos = createVisiblePosition(m_selection.start(), m_selection.affinity());
             else
-                pos = VisiblePosition(m_selection.end(), m_selection.affinity());
+                pos = createVisiblePosition(m_selection.end(), m_selection.affinity());
         } else {
-            pos = leftPositionOf(VisiblePosition(m_selection.extent(), m_selection.affinity()));
+            pos = leftPositionOf(createVisiblePosition(m_selection.extent(), m_selection.affinity()));
         }
         break;
     case WordGranularity: {
         bool skipsSpaceWhenMovingRight = m_frame && m_frame->editor().behavior().shouldSkipSpaceWhenMovingRight();
-        pos = leftWordPosition(VisiblePosition(m_selection.extent(), m_selection.affinity()), skipsSpaceWhenMovingRight);
+        pos = leftWordPosition(createVisiblePosition(m_selection.extent(), m_selection.affinity()), skipsSpaceWhenMovingRight);
         break;
     }
     case SentenceGranularity:
     case LineGranularity:
     case ParagraphGranularity:
     case SentenceBoundary:
     case ParagraphBoundary:
     case DocumentBoundary:
         // FIXME: Implement all of the above.
         pos = modifyMovingBackward(granularity);
         break;
     case LineBoundary:
         pos = leftBoundaryOfLine(startForPlatform(), directionOfEnclosingBlock());
         break;
     }
     return pos;
 }
 
 VisiblePosition FrameSelection::modifyMovingBackward(TextGranularity granularity)
 {
     VisiblePosition pos;
     switch (granularity) {
     case CharacterGranularity:
         if (isRange())
-            pos = VisiblePosition(m_selection.start(), m_selection.affinity());
+            pos = createVisiblePosition(m_selection.start(), m_selection.affinity());
         else
-            pos = previousPositionOf(VisiblePosition(m_selection.extent(), m_selection.affinity()), CanSkipOverEditingBoundary);
+            pos = previousPositionOf(createVisiblePosition(m_selection.extent(), m_selection.affinity()), CanSkipOverEditingBoundary);
         break;
     case WordGranularity:
-        pos = previousWordPosition(VisiblePosition(m_selection.extent(), m_selection.affinity()));
+        pos = previousWordPosition(createVisiblePosition(m_selection.extent(), m_selection.affinity()));
         break;
     case SentenceGranularity:
-        pos = previousSentencePosition(VisiblePosition(m_selection.extent(), m_selection.affinity()));
+        pos = previousSentencePosition(createVisiblePosition(m_selection.extent(), m_selection.affinity()));
         break;
     case LineGranularity:
         pos = previousLinePosition(startForPlatform(), lineDirectionPointForBlockDirectionNavigation(START));
         break;
     case ParagraphGranularity:
         pos = previousParagraphPosition(startForPlatform(), lineDirectionPointForBlockDirectionNavigation(START));
         break;
     case SentenceBoundary:
         pos = startOfSentence(startForPlatform());
         break;
@@ skipping 144 matching lines @@
         trialFrameSelection->setSelection(m_selection);
         trialFrameSelection->modify(alter, verticalDistance, direction, NotUserTriggered);
     }
 
     willBeModified(alter, direction == DirectionUp ? DirectionBackward : DirectionForward);
 
     VisiblePosition pos;
     LayoutUnit xPos = 0;
     switch (alter) {
     case AlterationMove:
-        pos = VisiblePosition(direction == DirectionUp ? m_selection.start() : m_selection.end(), m_selection.affinity());
+        pos = createVisiblePosition(direction == DirectionUp ? m_selection.start() : m_selection.end(), m_selection.affinity());
         xPos = lineDirectionPointForBlockDirectionNavigation(direction == DirectionUp ? START : END);
         m_selection.setAffinity(direction == DirectionUp ? TextAffinity::Upstream : TextAffinity::Downstream);
         break;
     case AlterationExtend:
-        pos = VisiblePosition(m_selection.extent(), m_selection.affinity());
+        pos = createVisiblePosition(m_selection.extent(), m_selection.affinity());
         xPos = lineDirectionPointForBlockDirectionNavigation(EXTENT);
         m_selection.setAffinity(TextAffinity::Downstream);
         break;
     }
 
     int startY;
     if (!absoluteCaretY(pos, startY))
         return false;
     if (direction == DirectionUp)
         startY = -startY;
@@ skipping 85 matching lines @@
     case EXTENT:
         pos = m_selection.extent();
         break;
     }
 
     LocalFrame* frame = pos.document()->frame();
     if (!frame)
         return x;
 
     if (m_xPosForVerticalArrowNavigation == NoXPosForVerticalArrowNavigation()) {
-        VisiblePosition visiblePosition(pos, m_selection.affinity());
+        VisiblePosition visiblePosition = createVisiblePosition(pos, m_selection.affinity());
         // VisiblePosition creation can fail here if a node containing the selection becomes visibility:hidden
         // after the selection is created and before this function is called.
         x = lineDirectionPointForBlockDirectionNavigationOf(visiblePosition);
         m_xPosForVerticalArrowNavigation = x;
     } else {
         x = m_xPosForVerticalArrowNavigation;
     }
 
     return x;
 }
@@ skipping 66 matching lines @@
 IntRect FrameSelection::absoluteCaretBounds()
 {
     ASSERT(m_frame->document()->lifecycle().state() != DocumentLifecycle::InPaintInvalidation);
     m_frame->document()->updateLayoutIgnorePendingStylesheets();
     if (!isNonOrphanedCaret(m_selection)) {
         clearCaretRect();
     } else {
         if (isTextFormControl(m_selection))
             updateCaretRect(PositionWithAffinity(isVisuallyEquivalentCandidate(m_selection.start()) ? m_selection.start() : Position(), m_selection.affinity()));
         else
-            updateCaretRect(VisiblePosition(m_selection.start(), m_selection.affinity()));
+            updateCaretRect(createVisiblePosition(m_selection.start(), m_selection.affinity()));
     }
     return absoluteBoundsForLocalRect(m_selection.start().anchorNode(), localCaretRectWithoutUpdate());
 }
 
 static LayoutRect localCaretRect(const VisibleSelection& m_selection, const PositionWithAffinity& caretPosition, LayoutObject*& layoutObject)
 {
     layoutObject = nullptr;
     if (!isNonOrphanedCaret(m_selection))
         return LayoutRect();
 
@@ skipping 112 matching lines @@
     ContainerNode* ownerElementParent = ownerElement->parentNode();
     if (!ownerElementParent)
         return;
 
     // This method's purpose is it to make it easier to select iframes (in order to delete them).  Don't do anything if the iframe isn't deletable.
     if (!ownerElementParent->hasEditableStyle())
         return;
 
     // Create compute positions before and after the element.
     unsigned ownerElementNodeIndex = ownerElement->nodeIndex();
-    VisiblePosition beforeOwnerElement(VisiblePosition(Position(ownerElementParent, ownerElementNodeIndex)));
-    VisiblePosition afterOwnerElement(VisiblePosition(Position(ownerElementParent, ownerElementNodeIndex + 1), VP_UPSTREAM_IF_POSSIBLE));
+    VisiblePosition beforeOwnerElement = createVisiblePosition(Position(ownerElementParent, ownerElementNodeIndex));
+    VisiblePosition afterOwnerElement = createVisiblePosition(Position(ownerElementParent, ownerElementNodeIndex + 1), VP_UPSTREAM_IF_POSSIBLE);
 
     // Focus on the parent frame, and then select from before this element to after.
     VisibleSelection newSelection(beforeOwnerElement, afterOwnerElement);
     page->focusController().setFocusedFrame(parent);
     toLocalFrame(parent)->selection().setSelection(newSelection);
 }
 
 void FrameSelection::selectAll()
 {
     Document* document = m_frame->document();
@@ skipping 411 matching lines @@
 {
     LayoutRect rect;
 
     switch (selectionType()) {
     case NoSelection:
         return;
     case CaretSelection:
         rect = LayoutRect(absoluteCaretBounds());
         break;
     case RangeSelection:
-        rect = LayoutRect(revealExtentOption == RevealExtent ? absoluteCaretBoundsOf(VisiblePosition(extent())) : enclosingIntRect(unclippedBounds()));
+        rect = LayoutRect(revealExtentOption == RevealExtent ? absoluteCaretBoundsOf(createVisiblePosition(extent())) : enclosingIntRect(unclippedBounds()));
         break;
     }
 
     Position start = this->start();
     ASSERT(start.anchorNode());
     if (start.anchorNode() && start.anchorNode()->layoutObject()) {
         // FIXME: This code only handles scrolling the startContainer's layer, but
         // the selection rect could intersect more than just that.
         if (DocumentLoader* documentLoader = m_frame->loader().documentLoader())
             documentLoader->initialScrollState().wasScrolledByUser = true;
@@ skipping 194 matching lines @@
 
 void showTree(const blink::FrameSelection* sel)
 {
     if (sel)
         sel->showTreeForThis();
     else
         fprintf(stderr, "Cannot showTree for (nil) FrameSelection.\n");
 }
 
 #endif