Mark paragraph-related functions deprecated in VisibleUnits

third_party/WebKit/Source/core/editing/commands/ReplaceSelectionCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009, 2010, 2011 Google 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
@@ skipping 418 matching lines @@
     VisiblePosition startOfInsertedContent = positionAtStartOfInsertedContent();
     VisiblePosition prev = previousPositionOf(startOfInsertedContent, CannotCrossEditingBoundary);
     if (prev.isNull())
         return false;
 
     // When we have matching quote levels, its ok to merge more frequently.
     // For a successful merge, we still need to make sure that the inserted content starts with the beginning of a paragraph.
     // And we should only merge here if the selection start was inside a mail blockquote.  This prevents against removing a
     // blockquote from newly pasted quoted content that was pasted into an unquoted position.  If that unquoted position happens
     // to be right after another blockquote, we don't want to merge and risk stripping a valid block (and newline) from the pasted content.
-    if (isStartOfParagraph(startOfInsertedContent) && selectionStartWasInsideMailBlockquote && hasMatchingQuoteLevel(prev, positionAtEndOfInsertedContent()))
+    if (isStartOfParagraphDeprecated(startOfInsertedContent) && selectionStartWasInsideMailBlockquote && hasMatchingQuoteLevel(prev, positionAtEndOfInsertedContent()))
         return true;
 
     return !selectionStartWasStartOfParagraph
         && !fragmentHasInterchangeNewlineAtStart
-        && isStartOfParagraph(startOfInsertedContent)
+        && isStartOfParagraphDeprecated(startOfInsertedContent)
         && !isHTMLBRElement(*startOfInsertedContent.deepEquivalent().anchorNode())
         && shouldMerge(startOfInsertedContent, prev);
 }
 
 bool ReplaceSelectionCommand::shouldMergeEnd(bool selectionEndWasEndOfParagraph)
 {
     VisiblePosition endOfInsertedContent(positionAtEndOfInsertedContent());
     VisiblePosition next = nextPositionOf(endOfInsertedContent, CannotCrossEditingBoundary);
     if (next.isNull())
         return false;
 
     return !selectionEndWasEndOfParagraph
-        && isEndOfParagraph(endOfInsertedContent)
+        && isEndOfParagraphDeprecated(endOfInsertedContent)
         && !isHTMLBRElement(*endOfInsertedContent.deepEquivalent().anchorNode())
         && shouldMerge(endOfInsertedContent, next);
 }
 
 static bool isMailPasteAsQuotationHTMLBlockQuoteElement(const Node* node)
 {
     if (!node || !node->isHTMLElement())
         return false;
     const HTMLElement& element = toHTMLElement(*node);
     if (!element.hasTagName(blockquoteTag) || element.getAttribute(classAttr) != ApplePasteAsQuotation)
@@ skipping 460 matching lines @@
     // Bail to avoid infinite recursion.
     if (m_movingParagraph) {
         NOTREACHED();
         return;
     }
 
     // Merging two paragraphs will destroy the moved one's block styles.  Always move the end of inserted forward
     // to preserve the block style of the paragraph already in the document, unless the paragraph to move would
     // include the what was the start of the selection that was pasted into, so that we preserve that paragraph's
     // block styles.
-    bool mergeForward = !(inSameParagraph(startOfInsertedContent, endOfInsertedContent) && !isStartOfParagraph(startOfInsertedContent));
+    bool mergeForward = !(inSameParagraphDeprecated(startOfInsertedContent, endOfInsertedContent) && !isStartOfParagraphDeprecated(startOfInsertedContent));
 
     VisiblePosition destination = mergeForward ? nextPositionOf(endOfInsertedContent) : endOfInsertedContent;
-    VisiblePosition startOfParagraphToMove = mergeForward ? startOfParagraph(endOfInsertedContent) : nextPositionOf(endOfInsertedContent);
+    VisiblePosition startOfParagraphToMove = mergeForward ? startOfParagraphDeprecated(endOfInsertedContent) : nextPositionOf(endOfInsertedContent);
 
     // Merging forward could result in deleting the destination anchor node.
     // To avoid this, we add a placeholder node before the start of the paragraph.
-    if (endOfParagraph(startOfParagraphToMove).deepEquivalent() == destination.deepEquivalent()) {
+    if (endOfParagraphDeprecated(startOfParagraphToMove).deepEquivalent() == destination.deepEquivalent()) {
         HTMLBRElement* placeholder = HTMLBRElement::create(document());
         insertNodeBefore(placeholder, startOfParagraphToMove.deepEquivalent().anchorNode(), editingState);
         if (editingState->isAborted())
             return;
         destination = VisiblePosition::beforeNode(placeholder);
     }
 
-    moveParagraph(startOfParagraphToMove, endOfParagraph(startOfParagraphToMove), destination, editingState);
+    moveParagraph(startOfParagraphToMove, endOfParagraphDeprecated(startOfParagraphToMove), destination, editingState);
     if (editingState->isAborted())
         return;
 
     // Merging forward will remove m_endOfInsertedContent from the document.
     if (mergeForward) {
         if (m_startOfInsertedContent.isOrphan())
             m_startOfInsertedContent = endingSelection().visibleStart().deepEquivalent();
         m_endOfInsertedContent = endingSelection().visibleEnd().deepEquivalent();
         // If we merged text nodes, m_endOfInsertedContent could be null. If
         // this is the case, we use m_startOfInsertedContent.
@@ skipping 77 matching lines @@
         m_matchStyle = false;
 
     if (m_matchStyle) {
         m_insertionStyle = EditingStyle::create(selection.start());
         m_insertionStyle->mergeTypingStyle(&document());
     }
 
     const VisiblePosition visibleStart = selection.visibleStart();
     const VisiblePosition visibleEnd = selection.visibleEnd();
 
-    const bool selectionEndWasEndOfParagraph = isEndOfParagraph(visibleEnd);
-    const bool selectionStartWasStartOfParagraph = isStartOfParagraph(visibleStart);
+    const bool selectionEndWasEndOfParagraph = isEndOfParagraphDeprecated(visibleEnd);
+    const bool selectionStartWasStartOfParagraph = isStartOfParagraphDeprecated(visibleStart);
 
     Element* enclosingBlockOfVisibleStart = enclosingBlock(visibleStart.deepEquivalent().anchorNode());
 
     const bool startIsInsideMailBlockquote = enclosingNodeOfType(selection.start(), isMailHTMLBlockquoteElement, CanCrossEditingBoundary);
     const bool selectionIsPlainText = !selection.isContentRichlyEditable();
     Element* currentRoot = selection.rootEditableElement();
 
     if ((selectionStartWasStartOfParagraph && selectionEndWasEndOfParagraph && !startIsInsideMailBlockquote)
         || enclosingBlockOfVisibleStart == currentRoot
         || isListItem(enclosingBlockOfVisibleStart)
         || selectionIsPlainText) {
         m_preventNesting = false;
     }
 
     if (selection.isRange()) {
         // When the end of the selection being pasted into is at the end of a paragraph, and that selection
         // spans multiple blocks, not merging may leave an empty line.
         // When the start of the selection being pasted into is at the start of a block, not merging
         // will leave hanging block(s).
         // Merge blocks if the start of the selection was in a Mail blockquote, since we handle
         // that case specially to prevent nesting.
-        bool mergeBlocksAfterDelete = startIsInsideMailBlockquote || isEndOfParagraph(visibleEnd) || isStartOfBlock(visibleStart);
+        bool mergeBlocksAfterDelete = startIsInsideMailBlockquote || isEndOfParagraphDeprecated(visibleEnd) || isStartOfBlock(visibleStart);
         // FIXME: We should only expand to include fully selected special elements if we are copying a
         // selection and pasting it on top of itself.
         deleteSelection(editingState, false, mergeBlocksAfterDelete, false);
         if (editingState->isAborted())
             return;
         if (fragment.hasInterchangeNewlineAtStart()) {
             VisiblePosition startAfterDelete = endingSelection().visibleStart();
-            if (isEndOfParagraph(startAfterDelete) && !isStartOfParagraph(startAfterDelete) && !isEndOfEditableOrNonEditableContent(startAfterDelete))
+            if (isEndOfParagraphDeprecated(startAfterDelete) && !isStartOfParagraphDeprecated(startAfterDelete) && !isEndOfEditableOrNonEditableContent(startAfterDelete))
                 setEndingSelection(nextPositionOf(startAfterDelete));
             else
                 insertParagraphSeparator(editingState);
             if (editingState->isAborted())
                 return;
         }
     } else {
         DCHECK(selection.isCaret());
         if (fragment.hasInterchangeNewlineAtStart()) {
             const VisiblePosition next = nextPositionOf(visibleStart, CannotCrossEditingBoundary);
-            if (isEndOfParagraph(visibleStart) && !isStartOfParagraph(visibleStart) && next.isNotNull())
+            if (isEndOfParagraphDeprecated(visibleStart) && !isStartOfParagraphDeprecated(visibleStart) && next.isNotNull())
                 setEndingSelection(next);
             else
                 insertParagraphSeparator(editingState);
             if (editingState->isAborted())
                 return;
         }
         // We split the current paragraph in two to avoid nesting the blocks from the fragment inside the current block.
         // For example paste <div>foo</div><div>bar</div><div>baz</div> into <div>x^x</div>, where ^ is the caret.
         // As long as the  div styles are the same, visually you'd expect: <div>xbar</div><div>bar</div><div>bazx</div>,
         // not <div>xbar<div>bar</div><div>bazx</div></div>.
         // Don't do this if the selection started in a Mail blockquote.
-        if (m_preventNesting && !startIsInsideMailBlockquote && !isEndOfParagraph(endingSelection().visibleStart()) && !isStartOfParagraph(endingSelection().visibleStart())) {
+        if (m_preventNesting && !startIsInsideMailBlockquote && !isEndOfParagraphDeprecated(endingSelection().visibleStart()) && !isStartOfParagraphDeprecated(endingSelection().visibleStart())) {
             insertParagraphSeparator(editingState);
             if (editingState->isAborted())
                 return;
             setEndingSelection(previousPositionOf(endingSelection().visibleStart()));
         }
     }
 
     Position insertionPos = endingSelection().start();
     // We don't want any of the pasted content to end up nested in a Mail blockquote, so first break
     // out of any surrounding Mail blockquotes. Unless we're inserting in a table, in which case
@@ skipping 161 matching lines @@
 
     // Scripts specified in javascript protocol may remove |enclosingBlockOfInsertionPos|
     // during insertion, e.g. <iframe src="javascript:...">
     if (enclosingBlockOfInsertionPos && !enclosingBlockOfInsertionPos->isConnected())
         enclosingBlockOfInsertionPos = nullptr;
 
     VisiblePosition startOfInsertedContent = createVisiblePositionDeprecated(firstPositionInOrBeforeNode(insertedNodes.firstNodeInserted()));
 
     // We inserted before the enclosingBlockOfInsertionPos to prevent nesting, and the content before the enclosingBlockOfInsertionPos wasn't in its own block and
     // didn't have a br after it, so the inserted content ended up in the same paragraph.
-    if (!startOfInsertedContent.isNull() && enclosingBlockOfInsertionPos && insertionPos.anchorNode() == enclosingBlockOfInsertionPos->parentNode() && (unsigned)insertionPos.computeEditingOffset() < enclosingBlockOfInsertionPos->nodeIndex() && !isStartOfParagraph(startOfInsertedContent)) {
+    if (!startOfInsertedContent.isNull() && enclosingBlockOfInsertionPos && insertionPos.anchorNode() == enclosingBlockOfInsertionPos->parentNode() && (unsigned)insertionPos.computeEditingOffset() < enclosingBlockOfInsertionPos->nodeIndex() && !isStartOfParagraphDeprecated(startOfInsertedContent)) {
         insertNodeAt(HTMLBRElement::create(document()), startOfInsertedContent.deepEquivalent(), editingState);
         if (editingState->isAborted())
             return;
     }
 
     if (endBR && (plainTextFragment || (shouldRemoveEndBR(endBR, originalVisPosBeforeEndBR) && !(fragment.hasInterchangeNewlineAtEnd() && selectionIsPlainText)))) {
         ContainerNode* parent = endBR->parentNode();
         insertedNodes.willRemoveNode(*endBR);
         removeNode(endBR, editingState);
         if (editingState->isAborted())
@@ skipping 42 matching lines @@
         }
 
         // Merging the the first paragraph of inserted content with the content that came
         // before the selection that was pasted into would also move content after
         // the selection that was pasted into if: only one paragraph was being pasted,
         // and it was not wrapped in a block, the selection that was pasted into ended
         // at the end of a block and the next paragraph didn't start at the start of a block.
         // Insert a line break just after the inserted content to separate it from what
         // comes after and prevent that from happening.
         VisiblePosition endOfInsertedContent = positionAtEndOfInsertedContent();
-        if (startOfParagraph(endOfInsertedContent).deepEquivalent() == startOfParagraphToMove.deepEquivalent()) {
+        if (startOfParagraphDeprecated(endOfInsertedContent).deepEquivalent() == startOfParagraphToMove.deepEquivalent()) {
             insertNodeAt(HTMLBRElement::create(document()), endOfInsertedContent.deepEquivalent(), editingState);
             if (editingState->isAborted())
                 return;
             // Mutation events (bug 22634) triggered by inserting the <br> might have removed the content we're about to move
             if (!startOfParagraphToMove.deepEquivalent().isConnected())
                 return;
         }
 
         // FIXME: Maintain positions for the start and end of inserted content instead of keeping nodes.  The nodes are
         // only ever used to create positions where inserted content starts/ends.
-        moveParagraph(startOfParagraphToMove, endOfParagraph(startOfParagraphToMove), destination, editingState);
+        moveParagraph(startOfParagraphToMove, endOfParagraphDeprecated(startOfParagraphToMove), destination, editingState);
         if (editingState->isAborted())
             return;
         m_startOfInsertedContent = mostForwardCaretPosition(endingSelection().visibleStart().deepEquivalent());
         if (m_endOfInsertedContent.isOrphan())
             m_endOfInsertedContent = mostBackwardCaretPosition(endingSelection().visibleEnd().deepEquivalent());
     }
 
     Position lastPositionToSelect;
     if (fragment.hasInterchangeNewlineAtEnd()) {
         VisiblePosition endOfInsertedContent = positionAtEndOfInsertedContent();
         VisiblePosition next = nextPositionOf(endOfInsertedContent, CannotCrossEditingBoundary);
 
-        if (selectionEndWasEndOfParagraph || !isEndOfParagraph(endOfInsertedContent) || next.isNull()) {
+        if (selectionEndWasEndOfParagraph || !isEndOfParagraphDeprecated(endOfInsertedContent) || next.isNull()) {
             if (HTMLTextFormControlElement* textControl = enclosingTextFormControl(currentRoot)) {
                 if (!insertedNodes.lastLeafInserted()->nextSibling()) {
                     insertNodeAfter(textControl->createPlaceholderBreakElement(), insertedNodes.lastLeafInserted(), editingState);
                     if (editingState->isAborted())
                         return;
                 }
                 setEndingSelection(VisiblePosition::afterNode(insertedNodes.lastLeafInserted()));
                 // Select up to the paragraph separator that was added.
                 lastPositionToSelect = endingSelection().visibleStart().deepEquivalent();
-            } else if (!isStartOfParagraph(endOfInsertedContent)) {
+            } else if (!isStartOfParagraphDeprecated(endOfInsertedContent)) {
                 setEndingSelection(endOfInsertedContent);
                 Element* enclosingBlockElement = enclosingBlock(endOfInsertedContent.deepEquivalent().anchorNode());
                 if (isListItem(enclosingBlockElement)) {
                     HTMLLIElement* newListItem = HTMLLIElement::create(document());
                     insertNodeAfter(newListItem, enclosingBlockElement, editingState);
                     if (editingState->isAborted())
                         return;
                     setEndingSelection(VisiblePosition::firstPositionInNode(newListItem));
                 } else {
                     // Use a default paragraph element (a plain div) for the empty paragraph, using the last paragraph
@@ skipping 40 matching lines @@
     if (!endBR || !endBR->isConnected())
         return false;
 
     VisiblePosition visiblePos = VisiblePosition::beforeNode(endBR);
 
     // Don't remove the br if nothing was inserted.
     if (previousPositionOf(visiblePos).deepEquivalent() == originalVisPosBeforeEndBR.deepEquivalent())
         return false;
 
     // Remove the br if it is collapsed away and so is unnecessary.
-    if (!document().inNoQuirksMode() && isEndOfBlock(visiblePos) && !isStartOfParagraph(visiblePos))
+    if (!document().inNoQuirksMode() && isEndOfBlock(visiblePos) && !isStartOfParagraphDeprecated(visiblePos))
         return true;
 
     // A br that was originally holding a line open should be displaced by inserted content or turned into a line break.
     // A br that was originally acting as a line break should still be acting as a line break, not as a placeholder.
-    return isStartOfParagraph(visiblePos) && isEndOfParagraph(visiblePos);
+    return isStartOfParagraphDeprecated(visiblePos) && isEndOfParagraphDeprecated(visiblePos);
 }
 
 bool ReplaceSelectionCommand::shouldPerformSmartReplace() const
 {
     if (!m_smartReplace)
         return false;
 
     HTMLTextFormControlElement* textControl = enclosingTextFormControl(positionAtStartOfInsertedContent().deepEquivalent());
     if (isHTMLInputElement(textControl) && toHTMLInputElement(textControl)->type() == InputTypeNames::password)
         return false; // Disable smart replace for password fields.
@@ skipping 12 matching lines @@
     VisiblePosition endOfInsertedContent = positionAtEndOfInsertedContent();
 
     Position endUpstream = mostBackwardCaretPosition(endOfInsertedContent.deepEquivalent());
     Node* endNode = endUpstream.computeNodeBeforePosition();
     int endOffset = endNode && endNode->isTextNode() ? toText(endNode)->length() : 0;
     if (endUpstream.isOffsetInAnchor()) {
         endNode = endUpstream.computeContainerNode();
         endOffset = endUpstream.offsetInContainerNode();
     }
 
-    bool needsTrailingSpace = !isEndOfParagraph(endOfInsertedContent) && !isCharacterSmartReplaceExemptConsideringNonBreakingSpace(characterAfter(endOfInsertedContent), false);
+    bool needsTrailingSpace = !isEndOfParagraphDeprecated(endOfInsertedContent) && !isCharacterSmartReplaceExemptConsideringNonBreakingSpace(characterAfter(endOfInsertedContent), false);
     if (needsTrailingSpace && endNode) {
         bool collapseWhiteSpace = !endNode->layoutObject() || endNode->layoutObject()->style()->collapseWhiteSpace();
         if (endNode->isTextNode()) {
             insertTextIntoNode(toText(endNode), endOffset, collapseWhiteSpace ? nonBreakingSpaceString() : " ");
             if (m_endOfInsertedContent.computeContainerNode() == endNode)
                 m_endOfInsertedContent = Position(endNode, m_endOfInsertedContent.offsetInContainerNode() + 1);
         } else {
             Text* node = document().createEditingTextNode(collapseWhiteSpace ? nonBreakingSpaceString() : " ");
             insertNodeAfter(node, endNode, editingState);
             if (editingState->isAborted())
                 return;
             updateNodesInserted(node);
         }
     }
 
     document().updateStyleAndLayout();
 
     Position startDownstream = mostForwardCaretPosition(startOfInsertedContent.deepEquivalent());
     Node* startNode = startDownstream.computeNodeAfterPosition();
     unsigned startOffset = 0;
     if (startDownstream.isOffsetInAnchor()) {
         startNode = startDownstream.computeContainerNode();
         startOffset = startDownstream.offsetInContainerNode();
     }
 
-    bool needsLeadingSpace = !isStartOfParagraph(startOfInsertedContent) && !isCharacterSmartReplaceExemptConsideringNonBreakingSpace(characterBefore(startOfInsertedContent), true);
+    bool needsLeadingSpace = !isStartOfParagraphDeprecated(startOfInsertedContent) && !isCharacterSmartReplaceExemptConsideringNonBreakingSpace(characterBefore(startOfInsertedContent), true);
     if (needsLeadingSpace && startNode) {
         bool collapseWhiteSpace = !startNode->layoutObject() || startNode->layoutObject()->style()->collapseWhiteSpace();
         if (startNode->isTextNode()) {
             insertTextIntoNode(toText(startNode), startOffset, collapseWhiteSpace ? nonBreakingSpaceString() : " ");
             if (m_endOfInsertedContent.computeContainerNode() == startNode && m_endOfInsertedContent.offsetInContainerNode())
                 m_endOfInsertedContent = Position(startNode, m_endOfInsertedContent.offsetInContainerNode() + 1);
         } else {
             Text* node = document().createEditingTextNode(collapseWhiteSpace ? nonBreakingSpaceString() : " ");
             // Don't updateNodesInserted. Doing so would set m_endOfInsertedContent to be the node containing the leading space,
             // but m_endOfInsertedContent is supposed to mark the end of pasted content.
@@ skipping 124 matching lines @@
     return m_inputType;
 }
 
 // If the user is inserting a list into an existing list, instead of nesting the list,
 // we put the list items into the existing list.
 Node* ReplaceSelectionCommand::insertAsListItems(HTMLElement* listElement, Element* insertionBlock, const Position& insertPos, InsertedNodes& insertedNodes, EditingState* editingState)
 {
     while (listElement->hasOneChild() && isHTMLListElement(listElement->firstChild()))
         listElement = toHTMLElement(listElement->firstChild());
 
-    bool isStart = isStartOfParagraph(createVisiblePositionDeprecated(insertPos));
-    bool isEnd = isEndOfParagraph(createVisiblePositionDeprecated(insertPos));
+    bool isStart = isStartOfParagraphDeprecated(createVisiblePositionDeprecated(insertPos));
+    bool isEnd = isEndOfParagraphDeprecated(createVisiblePositionDeprecated(insertPos));
     bool isMiddle = !isStart && !isEnd;
     Node* lastNode = insertionBlock;
 
     // If we're in the middle of a list item, we should split it into two separate
     // list items and insert these nodes between them.
     if (isMiddle) {
         int textNodeOffset = insertPos.offsetInContainerNode();
         if (insertPos.anchorNode()->isTextNode() && textNodeOffset > 0)
             splitTextNode(toText(insertPos.anchorNode()), textNodeOffset);
         splitTreeToNode(insertPos.anchorNode(), lastNode, true);
@@ skipping 92 matching lines @@
     visitor->trace(m_startOfInsertedContent);
     visitor->trace(m_endOfInsertedContent);
     visitor->trace(m_insertionStyle);
     visitor->trace(m_documentFragment);
     visitor->trace(m_startOfInsertedRange);
     visitor->trace(m_endOfInsertedRange);
     CompositeEditCommand::trace(visitor);
 }
 
 } // namespace blink