Make VisiblePosition constructor private

Source/core/editing/commands/InsertListCommand.cpp

 /*
  * Copyright (C) 2006, 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 220 matching lines @@
             switchListType = true;
         }
 
         // If the list is of the desired type, and we are not removing the list,
         // then exit early.
         if (!switchListType && forceCreateList)
             return true;
 
         // If the entire list is selected, then convert the whole list.
         if (switchListType && isNodeVisiblyContainedWithin(*listElement, currentSelection)) {
-            bool rangeStartIsInList = visiblePositionBeforeNode(*listElement).deepEquivalent() == VisiblePosition(currentSelection.startPosition()).deepEquivalent();
-            bool rangeEndIsInList = visiblePositionAfterNode(*listElement).deepEquivalent() == VisiblePosition(currentSelection.endPosition()).deepEquivalent();
+            bool rangeStartIsInList = visiblePositionBeforeNode(*listElement).deepEquivalent() == createVisiblePosition(currentSelection.startPosition()).deepEquivalent();
+            bool rangeEndIsInList = visiblePositionAfterNode(*listElement).deepEquivalent() == createVisiblePosition(currentSelection.endPosition()).deepEquivalent();
 
             RefPtrWillBeRawPtr<HTMLElement> newList = createHTMLElement(document(), listTag);
             insertNodeBefore(newList, listElement);
 
-            Node* firstChildInList = enclosingListChild(VisiblePosition(firstPositionInNode(listElement.get())).deepEquivalent().anchorNode(), listElement.get());
+            Node* firstChildInList = enclosingListChild(createVisiblePosition(firstPositionInNode(listElement.get())).deepEquivalent().anchorNode(), listElement.get());
             Element* outerBlock = firstChildInList && isBlockFlowElement(*firstChildInList) ? toElement(firstChildInList) : listElement.get();
 
-            moveParagraphWithClones(VisiblePosition(firstPositionInNode(listElement.get())), VisiblePosition(lastPositionInNode(listElement.get())), newList.get(), outerBlock);
+            moveParagraphWithClones(createVisiblePosition(firstPositionInNode(listElement.get())), createVisiblePosition(lastPositionInNode(listElement.get())), newList.get(), outerBlock);
 
             // Manually remove listNode because moveParagraphWithClones sometimes leaves it behind in the document.
             // See the bug 33668 and editing/execCommand/insert-list-orphaned-item-with-nested-lists.html.
             // FIXME: This might be a bug in moveParagraphWithClones or deleteSelection.
             if (listElement && listElement->inDocument())
                 removeNode(listElement);
 
             newList = mergeWithNeighboringLists(newList);
 
             // Restore the start and the end of current selection if they started inside listNode
             // because moveParagraphWithClones could have removed them.
             if (rangeStartIsInList && newList)
                 currentSelection.setStart(newList, 0, IGNORE_EXCEPTION);
             if (rangeEndIsInList && newList)
                 currentSelection.setEnd(newList, lastOffsetInNode(newList.get()), IGNORE_EXCEPTION);
 
-            setEndingSelection(VisiblePosition(firstPositionInNode(newList.get())));
+            setEndingSelection(createVisiblePosition(firstPositionInNode(newList.get())));
 
             return true;
         }
 
         unlistifyParagraph(endingSelection().visibleStart(), listElement.get(), listChildNode);
     }
 
     if (!listChildNode || switchListType || forceCreateList)
         m_listElement = listifyParagraph(endingSelection().visibleStart(), listTag);
 
     return true;
 }
 
 void InsertListCommand::unlistifyParagraph(const VisiblePosition& originalStart, HTMLElement* listElement, Node* listChildNode)
 {
     Node* nextListChild;
     Node* previousListChild;
     VisiblePosition start;
     VisiblePosition end;
     ASSERT(listChildNode);
     if (isHTMLLIElement(*listChildNode)) {
-        start = VisiblePosition(firstPositionInNode(listChildNode));
-        end = VisiblePosition(lastPositionInNode(listChildNode));
+        start = createVisiblePosition(firstPositionInNode(listChildNode));
+        end = createVisiblePosition(lastPositionInNode(listChildNode));
         nextListChild = listChildNode->nextSibling();
         previousListChild = listChildNode->previousSibling();
     } else {
         // A paragraph is visually a list item minus a list marker.  The paragraph will be moved.
         start = startOfParagraph(originalStart, CanSkipOverEditingBoundary);
         end = endOfParagraph(start, CanSkipOverEditingBoundary);
         nextListChild = enclosingListChild(nextPositionOf(end).deepEquivalent().anchorNode(), listElement);
         ASSERT(nextListChild != listChildNode);
         previousListChild = enclosingListChild(previousPositionOf(start).deepEquivalent().anchorNode(), listElement);
         ASSERT(previousListChild != listChildNode);
@@ skipping 24 matching lines @@
         // in listNode that comes before listChildNode, as listChildNode could have ancestors
         // between it and listNode. So, we split up to listNode before inserting the placeholder
         // where we're about to move listChildNode to.
         if (listChildNode->parentNode() != listElement)
             splitElement(listElement, splitTreeToNode(listChildNode, listElement).get());
         insertNodeBefore(elementToInsert, listElement);
     } else {
         insertNodeAfter(elementToInsert, listElement);
     }
 
-    VisiblePosition insertionPoint = VisiblePosition(positionBeforeNode(placeholder.get()));
+    VisiblePosition insertionPoint = createVisiblePosition(positionBeforeNode(placeholder.get()));
     moveParagraphs(start, end, insertionPoint, /* preserveSelection */ true, /* preserveStyle */ true, listChildNode);
 }
 
 static HTMLElement* adjacentEnclosingList(const VisiblePosition& pos, const VisiblePosition& adjacentPos, const HTMLQualifiedName& listTag)
 {
     HTMLElement* listElement = outermostEnclosingList(adjacentPos.deepEquivalent().anchorNode());
 
     if (!listElement)
         return 0;
 
@@ skipping 33 matching lines @@
     } else {
         // Create the list.
         listElement = createHTMLElement(document(), listTag);
         appendNode(listItemElement, listElement);
 
         if (start.deepEquivalent() == end.deepEquivalent() && isEnclosingBlock(start.deepEquivalent().anchorNode())) {
             // Inserting the list into an empty paragraph that isn't held open
             // by a br or a '\n', will invalidate start and end.  Insert
             // a placeholder and then recompute start and end.
             RefPtrWillBeRawPtr<HTMLBRElement> placeholder = insertBlockPlaceholder(start.deepEquivalent());
-            start = VisiblePosition(positionBeforeNode(placeholder.get()));
+            start = createVisiblePosition(positionBeforeNode(placeholder.get()));
             end = start;
         }
 
         // Insert the list at a position visually equivalent to start of the
         // paragraph that is being moved into the list.
         // Try to avoid inserting it somewhere where it will be surrounded by
         // inline ancestors of start, since it is easier for editing to produce
         // clean markup when inline elements are pushed down as far as possible.
         Position insertionPos(mostBackwardCaretPosition(start.deepEquivalent()));
         // Also avoid the containing list item.
         Node* listChild = enclosingListChild(insertionPos.anchorNode());
         if (isHTMLLIElement(listChild))
             insertionPos = positionInParentBeforeNode(*listChild);
 
         insertNodeAt(listElement, insertionPos);
 
         // We inserted the list at the start of the content we're about to move
         // Update the start of content, so we don't try to move the list into itself.  bug 19066
         // Layout is necessary since start's node's inline layoutObjects may have been destroyed by the insertion
         // The end of the content may have changed after the insertion and layout so update it as well.
         if (insertionPos == start.deepEquivalent())
             start = originalStart;
     }
 
     // Inserting list element and list item list may change start of pargraph
     // to move. We calculate start of paragraph again.
     document().updateLayoutIgnorePendingStylesheets();
     start = startOfParagraph(start, CanSkipOverEditingBoundary);
     end = endOfParagraph(start, CanSkipOverEditingBoundary);
-    moveParagraph(start, end, VisiblePosition(positionBeforeNode(placeholder.get())), true);
+    moveParagraph(start, end, createVisiblePosition(positionBeforeNode(placeholder.get())), true);
 
     if (listElement)
         return mergeWithNeighboringLists(listElement);
 
     if (canMergeLists(previousList, nextList))
         mergeIdenticalElements(previousList, nextList);
 
     return listElement;
 }
 
 DEFINE_TRACE(InsertListCommand)
 {
     visitor->trace(m_listElement);
     CompositeEditCommand::trace(visitor);
 }
 
 }