Make VisiblePosition constructor private

Source/core/editing/VisibleSelection.cpp

 /*
  * Copyright (C) 2004, 2005, 2006 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 324 matching lines @@
     }
     if (changed)
         didChange();
 }
 
 void VisibleSelection::setBaseAndExtentToDeepEquivalents()
 {
     // Move the selection to rendered positions, if possible.
     bool baseAndExtentEqual = m_base == m_extent;
     if (m_base.isNotNull()) {
-        m_base = VisiblePosition(m_base, m_affinity).deepEquivalent();
+        m_base = createVisiblePosition(m_base, m_affinity).deepEquivalent();
         if (baseAndExtentEqual)
             m_extent = m_base;
     }
     if (m_extent.isNotNull() && !baseAndExtentEqual)
-        m_extent = VisiblePosition(m_extent, m_affinity).deepEquivalent();
+        m_extent = createVisiblePosition(m_extent, m_affinity).deepEquivalent();
 
     // Make sure we do not have a dangling base or extent.
     if (m_base.isNull() && m_extent.isNull()) {
         m_baseIsFirst = true;
     } else if (m_base.isNull()) {
         m_base = m_extent;
         m_baseIsFirst = true;
     } else if (m_extent.isNull()) {
         m_extent = m_base;
         m_baseIsFirst = true;
@@ skipping 13 matching lines @@
     case CharacterGranularity:
         // Don't do any expansion.
         break;
     case WordGranularity: {
         // General case: Select the word the caret is positioned inside of.
         // If the caret is on the word boundary, select the word according to |wordSide|.
         // Edge case: If the caret is after the last word in a soft-wrapped line or the last word in
         // the document, select that last word (LeftWordIfOnBoundary).
         // Edge case: If the caret is after the last word in a paragraph, select from the the end of the
         // last word to the line break (also RightWordIfOnBoundary);
-        VisiblePosition visibleStart = VisiblePosition(m_start, m_affinity);
+        VisiblePosition visibleStart = createVisiblePosition(m_start, m_affinity);
         EWordSide side = wordSide;
         if (isEndOfEditableOrNonEditableContent(visibleStart) || (isEndOfLine(visibleStart) && !isStartOfLine(visibleStart) && !isEndOfParagraph(visibleStart)))
             side = LeftWordIfOnBoundary;
         m_start = startOfWord(visibleStart, side).deepEquivalent();
         break;
     }
     case SentenceGranularity: {
-        m_start = startOfSentence(VisiblePosition(m_start, m_affinity)).deepEquivalent();
+        m_start = startOfSentence(createVisiblePosition(m_start, m_affinity)).deepEquivalent();
         break;
     }
     case LineGranularity: {
-        m_start = startOfLine(VisiblePosition(m_start, m_affinity)).deepEquivalent();
+        m_start = startOfLine(createVisiblePosition(m_start, m_affinity)).deepEquivalent();
         break;
     }
     case LineBoundary:
-        m_start = startOfLine(VisiblePosition(m_start, m_affinity)).deepEquivalent();
+        m_start = startOfLine(createVisiblePosition(m_start, m_affinity)).deepEquivalent();
         break;
     case ParagraphGranularity: {
-        VisiblePosition pos(m_start, m_affinity);
+        VisiblePosition pos = createVisiblePosition(m_start, m_affinity);
         if (isStartOfLine(pos) && isEndOfEditableOrNonEditableContent(pos))
             pos = previousPositionOf(pos);
         m_start = startOfParagraph(pos).deepEquivalent();
         break;
     }
     case DocumentBoundary:
-        m_start = startOfDocument(VisiblePosition(m_start, m_affinity)).deepEquivalent();
+        m_start = startOfDocument(createVisiblePosition(m_start, m_affinity)).deepEquivalent();
         break;
     case ParagraphBoundary:
-        m_start = startOfParagraph(VisiblePosition(m_start, m_affinity)).deepEquivalent();
+        m_start = startOfParagraph(createVisiblePosition(m_start, m_affinity)).deepEquivalent();
         break;
     case SentenceBoundary:
-        m_start = startOfSentence(VisiblePosition(m_start, m_affinity)).deepEquivalent();
+        m_start = startOfSentence(createVisiblePosition(m_start, m_affinity)).deepEquivalent();
         break;
     }
 
     // Make sure we do not have a Null position.
     if (m_start.isNull())
         m_start = m_baseIsFirst ? m_base : m_extent;
     resetPositionsInComposedTree();
 }
 
 void VisibleSelection::setEndRespectingGranularity(TextGranularity granularity, EWordSide wordSide)
 {
     ASSERT(m_base.isNotNull());
     ASSERT(m_extent.isNotNull());
 
     m_end = m_baseIsFirst ? m_extent : m_base;
 
     switch (granularity) {
     case CharacterGranularity:
         // Don't do any expansion.
         break;
     case WordGranularity: {
         // General case: Select the word the caret is positioned inside of.
         // If the caret is on the word boundary, select the word according to |wordSide|.
         // Edge case: If the caret is after the last word in a soft-wrapped line or the last word in
         // the document, select that last word (LeftWordIfOnBoundary).
         // Edge case: If the caret is after the last word in a paragraph, select from the the end of the
         // last word to the line break (also RightWordIfOnBoundary);
-        VisiblePosition originalEnd(m_end, m_affinity);
+        VisiblePosition originalEnd = createVisiblePosition(m_end, m_affinity);
         EWordSide side = wordSide;
         if (isEndOfEditableOrNonEditableContent(originalEnd) || (isEndOfLine(originalEnd) && !isStartOfLine(originalEnd) && !isEndOfParagraph(originalEnd)))
             side = LeftWordIfOnBoundary;
 
-        VisiblePosition wordEnd(endOfWord(originalEnd, side));
-        VisiblePosition end(wordEnd);
+        VisiblePosition wordEnd = endOfWord(originalEnd, side);
+        VisiblePosition end = wordEnd;
 
         if (isEndOfParagraph(originalEnd) && !isEmptyTableCell(m_start.anchorNode())) {
             // Select the paragraph break (the space from the end of a paragraph to the start of
             // the next one) to match TextEdit.
             end = nextPositionOf(wordEnd);
 
             if (Element* table = isFirstPositionAfterTable(end)) {
                 // The paragraph break after the last paragraph in the last cell of a block table ends
                 // at the start of the paragraph after the table.
                 if (isEnclosingBlock(table))
                     end = nextPositionOf(end, CannotCrossEditingBoundary);
                 else
                     end = wordEnd;
             }
 
             if (end.isNull())
                 end = wordEnd;
 
         }
 
         m_end = end.deepEquivalent();
         break;
     }
     case SentenceGranularity: {
-        m_end = endOfSentence(VisiblePosition(m_end, m_affinity)).deepEquivalent();
+        m_end = endOfSentence(createVisiblePosition(m_end, m_affinity)).deepEquivalent();
         break;
     }
     case LineGranularity: {
-        VisiblePosition end = endOfLine(VisiblePosition(m_end, m_affinity));
+        VisiblePosition end = endOfLine(createVisiblePosition(m_end, m_affinity));
         // If the end of this line is at the end of a paragraph, include the space
         // after the end of the line in the selection.
         if (isEndOfParagraph(end)) {
             VisiblePosition next = nextPositionOf(end);
             if (next.isNotNull())
                 end = next;
         }
         m_end = end.deepEquivalent();
         break;
     }
     case LineBoundary:
-        m_end = endOfLine(VisiblePosition(m_end, m_affinity)).deepEquivalent();
+        m_end = endOfLine(createVisiblePosition(m_end, m_affinity)).deepEquivalent();
         break;
     case ParagraphGranularity: {
-        VisiblePosition visibleParagraphEnd = endOfParagraph(VisiblePosition(m_end, m_affinity));
+        VisiblePosition visibleParagraphEnd = endOfParagraph(createVisiblePosition(m_end, m_affinity));
 
         // Include the "paragraph break" (the space from the end of this paragraph to the start
         // of the next one) in the selection.
-        VisiblePosition end(nextPositionOf(visibleParagraphEnd));
+        VisiblePosition end = nextPositionOf(visibleParagraphEnd);
 
         if (Element* table = isFirstPositionAfterTable(end)) {
             // The paragraph break after the last paragraph in the last cell of a block table ends
             // at the start of the paragraph after the table, not at the position just after the table.
             if (isEnclosingBlock(table))
                 end = nextPositionOf(end, CannotCrossEditingBoundary);
             // There is no parargraph break after the last paragraph in the last cell of an inline table.
             else
                 end = visibleParagraphEnd;
         }
 
         if (end.isNull())
             end = visibleParagraphEnd;
 
         m_end = end.deepEquivalent();
         break;
     }
     case DocumentBoundary:
-        m_end = endOfDocument(VisiblePosition(m_end, m_affinity)).deepEquivalent();
+        m_end = endOfDocument(createVisiblePosition(m_end, m_affinity)).deepEquivalent();
         break;
     case ParagraphBoundary:
-        m_end = endOfParagraph(VisiblePosition(m_end, m_affinity)).deepEquivalent();
+        m_end = endOfParagraph(createVisiblePosition(m_end, m_affinity)).deepEquivalent();
         break;
     case SentenceBoundary:
-        m_end = endOfSentence(VisiblePosition(m_end, m_affinity)).deepEquivalent();
+        m_end = endOfSentence(createVisiblePosition(m_end, m_affinity)).deepEquivalent();
         break;
     }
 
     // Make sure we do not have a Null position.
     if (m_end.isNull())
         m_end = m_baseIsFirst ? m_extent : m_base;
     resetPositionsInComposedTree();
 }
 
 SelectionType VisibleSelection::selectionType(const Position& start, const Position& end)
@@ skipping 112 matching lines @@
     updateSelectionType();
 
     if (selectionType() == RangeSelection) {
         // "Constrain" the selection to be the smallest equivalent range of nodes.
         // This is a somewhat arbitrary choice, but experience shows that it is
         // useful to make to make the selection "canonical" (if only for
         // purposes of comparing selections). This is an ideal point of the code
         // to do this operation, since all selection changes that result in a RANGE
         // come through here before anyone uses it.
         // FIXME: Canonicalizing is good, but haven't we already done it (when we
-        // set these two positions to VisiblePosition deepEquivalent()s above)?
+        // set these two positions to VisiblePosition deepEquivalent = createVisiblePosition()s above)?
         m_start = mostForwardCaretPosition(m_start);
         m_end = mostBackwardCaretPosition(m_end);
 
         // Even by downstreaming, |m_start| can be moved to the upper place from
         // the original position, same as |m_end|.
         // e.g.) editing/shadow/select-contenteditable-shadowhost.html
         m_startInComposedTree = mostForwardCaretPosition(m_startInComposedTree);
         m_endInComposedTree = mostBackwardCaretPosition(m_endInComposedTree);
         adjustStartAndEndInComposedTree();
 
@@ skipping 265 matching lines @@
             Element* shadowAncestor = endRoot ? endRoot->shadowHost() : 0;
             if (p.isNull() && shadowAncestor)
                 p = positionAfterNode(shadowAncestor);
             while (p.isNotNull() && !(lowestEditableAncestor(p.computeContainerNode()) == baseEditableAncestor && !isEditablePosition(p))) {
                 Element* root = editableRootForPosition(p);
                 shadowAncestor = root ? root->shadowHost() : 0;
                 p = isAtomicNode(p.computeContainerNode()) ? positionInParentBeforeNode(*p.computeContainerNode()) : previousVisuallyDistinctCandidate(p);
                 if (p.isNull() && shadowAncestor)
                     p = positionAfterNode(shadowAncestor);
             }
-            VisiblePosition previous(p);
+            VisiblePosition previous = createVisiblePosition(p);
 
             if (previous.isNull()) {
                 // The selection crosses an Editing boundary.  This is a
                 // programmer error in the editing code.  Happy debugging!
                 ASSERT_NOT_REACHED();
                 m_base = Position();
                 m_extent = Position();
                 validate();
                 return;
             }
             m_end = previous.deepEquivalent();
         }
 
         // The selection starts in editable content or non-editable content inside a different editable ancestor,
         // move forward until non-editable content inside the same lowest editable ancestor is reached.
         Element* startEditableAncestor = lowestEditableAncestor(m_start.computeContainerNode());
         if (startRoot || startEditableAncestor != baseEditableAncestor) {
             Position p = nextVisuallyDistinctCandidate(m_start);
             Element* shadowAncestor = startRoot ? startRoot->shadowHost() : 0;
             if (p.isNull() && shadowAncestor)
                 p = positionBeforeNode(shadowAncestor);
             while (p.isNotNull() && !(lowestEditableAncestor(p.computeContainerNode()) == baseEditableAncestor && !isEditablePosition(p))) {
                 Element* root = editableRootForPosition(p);
                 shadowAncestor = root ? root->shadowHost() : 0;
                 p = isAtomicNode(p.computeContainerNode()) ? positionInParentAfterNode(*p.computeContainerNode()) : nextVisuallyDistinctCandidate(p);
                 if (p.isNull() && shadowAncestor)
                     p = positionBeforeNode(shadowAncestor);
             }
-            VisiblePosition next(p);
+            VisiblePosition next = createVisiblePosition(p);
 
             if (next.isNull()) {
                 // The selection crosses an Editing boundary.  This is a
                 // programmer error in the editing code.  Happy debugging!
                 ASSERT_NOT_REACHED();
                 m_base = Position();
                 m_extent = Position();
                 validate();
                 return;
             }
@@ skipping 238 matching lines @@
     sel.showTreeForThis();
 }
 
 void showTree(const blink::VisibleSelection* sel)
 {
     if (sel)
         sel->showTreeForThis();
 }
 
 #endif