Make VisiblePosition constructor private

Source/core/editing/commands/InsertParagraphSeparatorCommand.cpp

 /*
  * Copyright (C) 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 60 matching lines @@
 bool InsertParagraphSeparatorCommand::preservesTypingStyle() const
 {
     return true;
 }
 
 void InsertParagraphSeparatorCommand::calculateStyleBeforeInsertion(const Position &pos)
 {
     // It is only important to set a style to apply later if we're at the boundaries of
     // a paragraph. Otherwise, content that is moved as part of the work of the command
     // will lend their styles to the new paragraph without any extra work needed.
-    VisiblePosition visiblePos(pos, VP_DEFAULT_AFFINITY);
+    VisiblePosition visiblePos = createVisiblePosition(pos, VP_DEFAULT_AFFINITY);
     if (!isStartOfParagraph(visiblePos) && !isEndOfParagraph(visiblePos))
         return;
 
     ASSERT(pos.isNotNull());
     m_style = EditingStyle::create(pos);
     m_style->mergeTypingStyle(pos.document());
 }
 
 void InsertParagraphSeparatorCommand::applyStyleAfterInsertion(Element* originalEnclosingBlock)
 {
@@ skipping 71 matching lines @@
         calculateStyleBeforeInsertion(insertionPosition);
         deleteSelection(false, true);
         insertionPosition = endingSelection().start();
         affinity = endingSelection().affinity();
     }
 
     // FIXME: The parentAnchoredEquivalent conversion needs to be moved into enclosingBlock.
     RefPtrWillBeRawPtr<Element> startBlock = enclosingBlock(insertionPosition.parentAnchoredEquivalent().computeContainerNode());
     Node* listChildNode = enclosingListChild(insertionPosition.parentAnchoredEquivalent().computeContainerNode());
     RefPtrWillBeRawPtr<HTMLElement> listChild = listChildNode && listChildNode->isHTMLElement() ? toHTMLElement(listChildNode) : 0;
-    Position canonicalPos = VisiblePosition(insertionPosition).deepEquivalent();
+    Position canonicalPos = createVisiblePosition(insertionPosition).deepEquivalent();
     if (!startBlock
         || !startBlock->nonShadowBoundaryParentNode()
         || isTableCell(startBlock.get())
         || isHTMLFormElement(*startBlock)
         // FIXME: If the node is hidden, we don't have a canonical position so we will do the wrong thing for tables and <hr>. https://bugs.webkit.org/show_bug.cgi?id=40342
         || (!canonicalPos.isNull() && isRenderedTableElement(canonicalPos.anchorNode()))
         || (!canonicalPos.isNull() && isHTMLHRElement(*canonicalPos.anchorNode()))) {
         applyCommandToComposite(InsertLineBreakCommand::create(document()));
         return;
     }
 
     // Use the leftmost candidate.
     insertionPosition = mostBackwardCaretPosition(insertionPosition);
     if (!isVisuallyEquivalentCandidate(insertionPosition))
         insertionPosition = mostForwardCaretPosition(insertionPosition);
 
     // Adjust the insertion position after the delete
     insertionPosition = positionAvoidingSpecialElementBoundary(insertionPosition);
-    VisiblePosition visiblePos(insertionPosition, affinity);
+    VisiblePosition visiblePos = createVisiblePosition(insertionPosition, affinity);
     calculateStyleBeforeInsertion(insertionPosition);
 
     //---------------------------------------------------------------------
     // Handle special case of typing return on an empty list item
     if (breakOutOfEmptyListItem())
         return;
 
     //---------------------------------------------------------------------
     // Prepare for more general cases.
 
@@ skipping 123 matching lines @@
         }
     }
 
     // Move downstream. Typing style code will take care of carrying along the
     // style of the upstream position.
     insertionPosition = mostForwardCaretPosition(insertionPosition);
 
     // At this point, the insertionPosition's node could be a container, and we want to make sure we include
     // all of the correct nodes when building the ancestor list.  So this needs to be the deepest representation of the position
     // before we walk the DOM tree.
-    insertionPosition = positionOutsideTabSpan(VisiblePosition(insertionPosition).deepEquivalent());
+    insertionPosition = positionOutsideTabSpan(createVisiblePosition(insertionPosition).deepEquivalent());
 
     // If the returned position lies either at the end or at the start of an element that is ignored by editing
     // we should move to its upstream or downstream position.
     if (editingIgnoresContent(insertionPosition.anchorNode())) {
         if (insertionPosition.atLastEditingPositionForNode())
             insertionPosition = mostForwardCaretPosition(insertionPosition);
         else if (insertionPosition.atFirstEditingPositionForNode())
             insertionPosition = mostBackwardCaretPosition(insertionPosition);
     }
 
@@ skipping 11 matching lines @@
     // Split at pos if in the middle of a text node.
     Position positionAfterSplit;
     if (insertionPosition.isOffsetInAnchor() && insertionPosition.computeContainerNode()->isTextNode()) {
         RefPtrWillBeRawPtr<Text> textNode = toText(insertionPosition.computeContainerNode());
         int textOffset = insertionPosition.offsetInContainerNode();
         bool atEnd = static_cast<unsigned>(textOffset) >= textNode->length();
         if (textOffset > 0 && !atEnd) {
             splitTextNode(textNode, textOffset);
             positionAfterSplit = firstPositionInNode(textNode.get());
             insertionPosition = Position(textNode->previousSibling(), textOffset);
-            visiblePos = VisiblePosition(insertionPosition);
+            visiblePos = createVisiblePosition(insertionPosition);
         }
     }
 
     // If we got detached due to mutation events, just bail out.
     if (!startBlock->parentNode())
         return;
 
     // Put the added block in the tree.
     if (nestNewBlock) {
         appendNode(blockToInsert.get(), startBlock);
     } else if (listChild && listChild != startBlock) {
         RefPtrWillBeRawPtr<Element> listChildToInsert = listChild->cloneElementWithoutChildren();
         appendNode(blockToInsert.get(), listChildToInsert.get());
         insertNodeAfter(listChildToInsert.get(), listChild);
     } else {
         insertNodeAfter(blockToInsert.get(), startBlock);
     }
 
     document().updateLayoutIgnorePendingStylesheets();
 
     // If the paragraph separator was inserted at the end of a paragraph, an empty line must be
     // created.  All of the nodes, starting at visiblePos, are about to be added to the new paragraph
     // element.  If the first node to be inserted won't be one that will hold an empty line open, add a br.
     if (isEndOfParagraph(visiblePos) && !lineBreakExistsAtVisiblePosition(visiblePos))
         appendNode(createBreakElement(document()).get(), blockToInsert.get());
 
     // Move the start node and the siblings of the start node.
-    if (VisiblePosition(insertionPosition).deepEquivalent() != VisiblePosition(positionBeforeNode(blockToInsert.get())).deepEquivalent()) {
+    if (createVisiblePosition(insertionPosition).deepEquivalent() != createVisiblePosition(positionBeforeNode(blockToInsert.get())).deepEquivalent()) {
         Node* n;
         if (insertionPosition.computeContainerNode() == startBlock) {
             n = insertionPosition.computeNodeAfterPosition();
         } else {
             Node* splitTo = insertionPosition.computeContainerNode();
             if (splitTo->isTextNode() && insertionPosition.offsetInContainerNode() >= caretMaxOffset(splitTo))
                 splitTo = NodeTraversal::next(*splitTo, startBlock.get());
             ASSERT(splitTo);
             splitTreeToNode(splitTo, startBlock.get());
 
             for (n = startBlock->firstChild(); n; n = n->nextSibling()) {
-                VisiblePosition beforeNodePosition(positionBeforeNode(n));
-                if (!beforeNodePosition.isNull() && comparePositions(VisiblePosition(insertionPosition), beforeNodePosition) <= 0)
+                VisiblePosition beforeNodePosition = createVisiblePosition(positionBeforeNode(n));
+                if (!beforeNodePosition.isNull() && comparePositions(createVisiblePosition(insertionPosition), beforeNodePosition) <= 0)
                     break;
             }
         }
 
         moveRemainingSiblingsToNewParent(n, blockToInsert.get(), blockToInsert);
     }
 
     // Handle whitespace that occurs after the split
     if (positionAfterSplit.isNotNull()) {
         document().updateLayoutIgnorePendingStylesheets();
@@ skipping 13 matching lines @@
 }
 
 DEFINE_TRACE(InsertParagraphSeparatorCommand)
 {
     visitor->trace(m_style);
     CompositeEditCommand::trace(visitor);
 }
 
 
 } // namespace blink