Make VisiblePosition constructor private

Source/core/editing/commands/DeleteSelectionCommand.cpp

 /*
  * Copyright (C) 2005 Apple Computer, 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 32 matching lines @@
 #include "core/layout/LayoutTableCell.h"
 #include "core/layout/LayoutText.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 static bool isTableCellEmpty(Node* cell)
 {
     ASSERT(isTableCell(cell));
-    return VisiblePosition(firstPositionInNode(cell)).deepEquivalent() == VisiblePosition(lastPositionInNode(cell)).deepEquivalent();
+    return createVisiblePosition(firstPositionInNode(cell)).deepEquivalent() == createVisiblePosition(lastPositionInNode(cell)).deepEquivalent();
 }
 
 static bool isTableRowEmpty(Node* row)
 {
     if (!isHTMLTableRowElement(row))
         return false;
 
     for (Node* child = row->firstChild(); child; child = child->nextSibling()) {
         if (isTableCell(child) && !isTableCellEmpty(child))
             return false;
@@ skipping 58 matching lines @@
     while (1) {
         startSpecialContainer = 0;
         endSpecialContainer = 0;
 
         Position s = positionBeforeContainingSpecialElement(start, &startSpecialContainer);
         Position e = positionAfterContainingSpecialElement(end, &endSpecialContainer);
 
         if (!startSpecialContainer && !endSpecialContainer)
             break;
 
-        if (VisiblePosition(start).deepEquivalent() != m_selectionToDelete.visibleStart().deepEquivalent() || VisiblePosition(end).deepEquivalent() != m_selectionToDelete.visibleEnd().deepEquivalent())
+        if (createVisiblePosition(start).deepEquivalent() != m_selectionToDelete.visibleStart().deepEquivalent() || createVisiblePosition(end).deepEquivalent() != m_selectionToDelete.visibleEnd().deepEquivalent())
             break;
 
         // If we're going to expand to include the startSpecialContainer, it must be fully selected.
         if (startSpecialContainer && !endSpecialContainer && comparePositions(positionInParentAfterNode(*startSpecialContainer), end) > -1)
             break;
 
         // If we're going to expand to include the endSpecialContainer, it must be fully selected.
         if (endSpecialContainer && !startSpecialContainer && comparePositions(start, positionInParentBeforeNode(*endSpecialContainer)) > -1)
             break;
 
         if (startSpecialContainer && startSpecialContainer->isDescendantOf(endSpecialContainer)) {
             // Don't adjust the end yet, it is the end of a special element that contains the start
             // special element (which may or may not be fully selected).
             start = s;
         } else if (endSpecialContainer && endSpecialContainer->isDescendantOf(startSpecialContainer)) {
             // Don't adjust the start yet, it is the start of a special element that contains the end
             // special element (which may or may not be fully selected).
             end = e;
         } else {
             start = s;
             end = e;
         }
     }
 }
 
 void DeleteSelectionCommand::setStartingSelectionOnSmartDelete(const Position& start, const Position& end)
 {
     bool isBaseFirst = startingSelection().isBaseFirst();
-    VisiblePosition newBase(isBaseFirst ? start : end);
-    VisiblePosition newExtent(isBaseFirst ? end : start);
+    VisiblePosition newBase = createVisiblePosition(isBaseFirst ? start : end);
+    VisiblePosition newExtent = createVisiblePosition(isBaseFirst ? end : start);
     setStartingSelection(VisibleSelection(newBase, newExtent, startingSelection().isDirectional()));
 }
 
 void DeleteSelectionCommand::initializePositionData()
 {
     Position start, end;
     initializeStartEnd(start, end);
 
     ASSERT(isEditablePosition(start, ContentIsEditable, DoNotUpdateStyle));
     if (!isEditablePosition(end, ContentIsEditable, DoNotUpdateStyle))
@@ skipping 15 matching lines @@
     // tell that function that we don't care if it returns non-editable nodes.
     Node* startCell = enclosingNodeOfType(m_upstreamStart, &isTableCell, CanCrossEditingBoundary);
     Node* endCell = enclosingNodeOfType(m_downstreamEnd, &isTableCell, CanCrossEditingBoundary);
     // FIXME: This isn't right.  A borderless table with two rows and a single column would appear as two paragraphs.
     if (endCell && endCell != startCell)
         m_mergeBlocksAfterDelete = false;
 
     // Usually the start and the end of the selection to delete are pulled together as a result of the deletion.
     // Sometimes they aren't (like when no merge is requested), so we must choose one position to hold the caret
     // and receive the placeholder after deletion.
-    VisiblePosition visibleEnd(m_downstreamEnd);
+    VisiblePosition visibleEnd = createVisiblePosition(m_downstreamEnd);
     if (m_mergeBlocksAfterDelete && !isEndOfParagraph(visibleEnd))
         m_endingPosition = m_downstreamEnd;
     else
         m_endingPosition = m_downstreamStart;
 
     // We don't want to merge into a block if it will mean changing the quote level of content after deleting
     // selections that contain a whole number paragraphs plus a line break, since it is unclear to most users
     // that such a selection actually ends at the start of the next paragraph. This matches TextEdit behavior
     // for indented paragraphs.
     // Only apply this rule if the endingSelection is a range selection.  If it is a caret, then other operations have created
     // the selection we're deleting (like the process of creating a selection to delete during a backspace), and the user isn't in the situation described above.
     if (numEnclosingMailBlockquotes(start) != numEnclosingMailBlockquotes(end)
-        && isStartOfParagraph(visibleEnd) && isStartOfParagraph(VisiblePosition(start))
+        && isStartOfParagraph(visibleEnd) && isStartOfParagraph(createVisiblePosition(start))
         && endingSelection().isRange()) {
         m_mergeBlocksAfterDelete = false;
         m_pruneStartBlockIfNecessary = true;
     }
 
     // Handle leading and trailing whitespace, as well as smart delete adjustments to the selection
     m_leadingWhitespace = leadingWhitespacePosition(m_upstreamStart, m_selectionToDelete.affinity());
     m_trailingWhitespace = trailingWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY);
 
     if (m_smartDelete) {
 
         // skip smart delete if the selection to delete already starts or ends with whitespace
-        Position pos = VisiblePosition(m_upstreamStart, m_selectionToDelete.affinity()).deepEquivalent();
+        Position pos = createVisiblePosition(m_upstreamStart, m_selectionToDelete.affinity()).deepEquivalent();
         bool skipSmartDelete = trailingWhitespacePosition(pos, VP_DEFAULT_AFFINITY, ConsiderNonCollapsibleWhitespace).isNotNull();
         if (!skipSmartDelete)
             skipSmartDelete = leadingWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY, ConsiderNonCollapsibleWhitespace).isNotNull();
 
         // extend selection upstream if there is whitespace there
         bool hasLeadingWhitespaceBeforeAdjustment = leadingWhitespacePosition(m_upstreamStart, m_selectionToDelete.affinity(), ConsiderNonCollapsibleWhitespace).isNotNull();
         if (!skipSmartDelete && hasLeadingWhitespaceBeforeAdjustment) {
-            VisiblePosition visiblePos = previousPositionOf(VisiblePosition(m_upstreamStart, VP_DEFAULT_AFFINITY));
+            VisiblePosition visiblePos = previousPositionOf(createVisiblePosition(m_upstreamStart, VP_DEFAULT_AFFINITY));
             pos = visiblePos.deepEquivalent();
             // Expand out one character upstream for smart delete and recalculate
             // positions based on this change.
             m_upstreamStart = mostBackwardCaretPosition(pos);
             m_downstreamStart = mostForwardCaretPosition(pos);
             m_leadingWhitespace = leadingWhitespacePosition(m_upstreamStart, visiblePos.affinity());
 
             setStartingSelectionOnSmartDelete(m_upstreamStart, m_upstreamEnd);
         }
 
         // trailing whitespace is only considered for smart delete if there is no leading
         // whitespace, as in the case where you double-click the first word of a paragraph.
         if (!skipSmartDelete && !hasLeadingWhitespaceBeforeAdjustment && trailingWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY, ConsiderNonCollapsibleWhitespace).isNotNull()) {
             // Expand out one character downstream for smart delete and recalculate
             // positions based on this change.
-            pos = nextPositionOf(VisiblePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY)).deepEquivalent();
+            pos = nextPositionOf(createVisiblePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY)).deepEquivalent();
             m_upstreamEnd = mostBackwardCaretPosition(pos);
             m_downstreamEnd = mostForwardCaretPosition(pos);
             m_trailingWhitespace = trailingWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY);
 
             setStartingSelectionOnSmartDelete(m_downstreamStart, m_downstreamEnd);
         }
     }
 
     // We must pass call parentAnchoredEquivalent on the positions since some editing positions
     // that appear inside their nodes aren't really inside them.  [hr, 0] is one example.
@@ skipping 52 matching lines @@
     bool upstreamStartIsBR = isHTMLBRElement(*nodeAfterUpstreamStart);
     bool downstreamStartIsBR = isHTMLBRElement(*nodeAfterDownstreamStart);
     bool isBROnLineByItself = upstreamStartIsBR && downstreamStartIsBR && nodeAfterDownstreamStart == nodeAfterUpstreamEnd;
     if (isBROnLineByItself) {
         removeNode(nodeAfterDownstreamStart);
         return true;
     }
 
     // FIXME: This code doesn't belong in here.
     // We detect the case where the start is an empty line consisting of BR not wrapped in a block element.
-    if (upstreamStartIsBR && downstreamStartIsBR && !(isStartOfBlock(VisiblePosition(positionBeforeNode(nodeAfterUpstreamStart))) && isEndOfBlock(VisiblePosition(positionAfterNode(nodeAfterUpstreamStart))))) {
+    if (upstreamStartIsBR && downstreamStartIsBR && !(isStartOfBlock(createVisiblePosition(positionBeforeNode(nodeAfterUpstreamStart))) && isEndOfBlock(createVisiblePosition(positionAfterNode(nodeAfterUpstreamStart))))) {
         m_startsAtEmptyLine = true;
         m_endingPosition = m_downstreamEnd;
     }
 
     return false;
 }
 
 static Position firstEditablePositionInNode(Node* node)
 {
     ASSERT(node);
@@ skipping 45 matching lines @@
         LayoutObject* r = node->layoutObject();
         if (r && r->isTableCell() && toLayoutTableCell(r)->contentHeight() <= 0) {
             Position firstEditablePosition = firstEditablePositionInNode(node.get());
             if (firstEditablePosition.isNotNull())
                 insertBlockPlaceholder(firstEditablePosition);
         }
         return;
     }
 
     if (node == m_startBlock) {
-        VisiblePosition previous = previousPositionOf(VisiblePosition(firstPositionInNode(m_startBlock.get())));
+        VisiblePosition previous = previousPositionOf(createVisiblePosition(firstPositionInNode(m_startBlock.get())));
         if (previous.isNotNull() && !isEndOfBlock(previous))
             m_needPlaceholder = true;
     }
     if (node == m_endBlock) {
-        VisiblePosition next = nextPositionOf(VisiblePosition(lastPositionInNode(m_endBlock.get())));
+        VisiblePosition next = nextPositionOf(createVisiblePosition(lastPositionInNode(m_endBlock.get())));
         if (next.isNotNull() && !isStartOfBlock(next))
             m_needPlaceholder = true;
     }
 
     // FIXME: Update the endpoints of the range being deleted.
     updatePositionForNodeRemoval(m_endingPosition, *node);
     updatePositionForNodeRemoval(m_leadingWhitespace, *node);
     updatePositionForNodeRemoval(m_trailingWhitespace, *node);
 
     CompositeEditCommand::removeNode(node, shouldAssumeContentIsAlwaysEditable);
@@ skipping 205 matching lines @@
         return;
 
     // FIXME: The deletion algorithm shouldn't let this happen.
     if (comparePositions(m_upstreamStart, m_downstreamEnd) > 0)
         return;
 
     // There's nothing to merge.
     if (m_upstreamStart == m_downstreamEnd)
         return;
 
-    VisiblePosition startOfParagraphToMove(m_downstreamEnd);
-    VisiblePosition mergeDestination(m_upstreamStart);
+    VisiblePosition startOfParagraphToMove = createVisiblePosition(m_downstreamEnd);
+    VisiblePosition mergeDestination = createVisiblePosition(m_upstreamStart);
 
     // m_downstreamEnd's block has been emptied out by deletion.  There is no content inside of it to
     // move, so just remove it.
     Element* endBlock = enclosingBlock(m_downstreamEnd.anchorNode());
     if (!endBlock || !endBlock->contains(startOfParagraphToMove.deepEquivalent().anchorNode()) || !startOfParagraphToMove.deepEquivalent().anchorNode()) {
         removeNode(enclosingBlock(m_downstreamEnd.anchorNode()));
         return;
     }
 
     // We need to merge into m_upstreamStart's block, but it's been emptied out and collapsed by deletion.
     if (!mergeDestination.deepEquivalent().anchorNode() || (!mergeDestination.deepEquivalent().anchorNode()->isDescendantOf(enclosingBlock(m_upstreamStart.computeContainerNode())) && (!mergeDestination.deepEquivalent().anchorNode()->hasChildren() || !m_upstreamStart.computeContainerNode()->hasChildren())) || (m_startsAtEmptyLine && mergeDestination.deepEquivalent() != startOfParagraphToMove.deepEquivalent())) {
         insertNodeAt(createBreakElement(document()).get(), m_upstreamStart);
-        mergeDestination = VisiblePosition(m_upstreamStart);
+        mergeDestination = createVisiblePosition(m_upstreamStart);
     }
 
     if (mergeDestination.deepEquivalent() == startOfParagraphToMove.deepEquivalent())
         return;
 
     VisiblePosition endOfParagraphToMove = endOfParagraph(startOfParagraphToMove, CanSkipOverEditingBoundary);
 
     if (mergeDestination.deepEquivalent() == endOfParagraphToMove.deepEquivalent())
         return;
 
@@ skipping 166 matching lines @@
         if (Element* table = isLastPositionBeforeTable(m_selectionToDelete.visibleStart())) {
             if (m_selectionToDelete.end().anchorNode()->isDescendantOf(table))
                 m_needPlaceholder = false;
         }
     }
 
 
     // set up our state
     initializePositionData();
 
-    bool lineBreakBeforeStart = lineBreakExistsAtVisiblePosition(previousPositionOf(VisiblePosition(m_upstreamStart)));
+    bool lineBreakBeforeStart = lineBreakExistsAtVisiblePosition(previousPositionOf(createVisiblePosition(m_upstreamStart)));
 
     // Delete any text that may hinder our ability to fixup whitespace after the
     // delete
     deleteInsignificantTextDownstream(m_trailingWhitespace);
 
     saveTypingStyleState();
 
     // deleting just a BR is handled specially, at least because we do not
     // want to replace it with a placeholder BR!
     if (handleSpecialCaseBRDelete()) {
         calculateTypingStyleAfterDelete();
         setEndingSelection(VisibleSelection(m_endingPosition, affinity, endingSelection().isDirectional()));
         clearTransientState();
         rebalanceWhitespace();
         return;
     }
 
     handleGeneralDelete();
 
     fixupWhitespace();
 
     mergeParagraphs();
 
     removePreviouslySelectedEmptyTableRows();
 
     if (!m_needPlaceholder && rootWillStayOpenWithoutPlaceholder) {
-        VisiblePosition visualEnding(m_endingPosition);
+        VisiblePosition visualEnding = createVisiblePosition(m_endingPosition);
         bool hasPlaceholder = lineBreakExistsAtVisiblePosition(visualEnding)
             && nextPositionOf(visualEnding, CannotCrossEditingBoundary).isNull();
         m_needPlaceholder = hasPlaceholder && lineBreakBeforeStart && !lineBreakAtEndOfSelectionToDelete;
     }
 
     RefPtrWillBeRawPtr<HTMLBRElement> placeholder = m_needPlaceholder ? createBreakElement(document()) : nullptr;
 
     if (placeholder) {
         if (m_sanitizeMarkup)
             removeRedundantBlocks();
@@ skipping 43 matching lines @@
     visitor->trace(m_deleteIntoBlockquoteStyle);
     visitor->trace(m_startRoot);
     visitor->trace(m_endRoot);
     visitor->trace(m_startTableRow);
     visitor->trace(m_endTableRow);
     visitor->trace(m_temporaryPlaceholder);
     CompositeEditCommand::trace(visitor);
 }
 
 } // namespace blink