Mark paragraph-related functions deprecated in VisibleUnits

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

 /*
  * Copyright (C) 2005, 2006, 2007, 2008 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 726 matching lines @@
 
     String string = text.substring(upstream, length);
     // FIXME: Because of the problem mentioned at the top of this function, we
     // must also use nbsps at the start/end of the string because this function
     // doesn't get all surrounding whitespace, just the whitespace in the
     // current text node. However, if the next sibling node is a text node
     // (not empty, see http://crbug.com/632300), we should use a plain space.
     // See http://crbug.com/310149
     const bool nextSiblingIsTextNode = textNode->nextSibling() && textNode->nextSibling()->isTextNode()
         && toText(textNode->nextSibling())->data().length();
-    const bool shouldEmitNBSPbeforeEnd =(isEndOfParagraph(visibleDownstreamPos) || (unsigned)downstream == text.length()) && !nextSiblingIsTextNode;
+    const bool shouldEmitNBSPbeforeEnd =(isEndOfParagraphDeprecated(visibleDownstreamPos) || (unsigned)downstream == text.length()) && !nextSiblingIsTextNode;
     String rebalancedString = stringWithRebalancedWhitespace(string,
-        isStartOfParagraph(visibleUpstreamPos) || !upstream, shouldEmitNBSPbeforeEnd);
+        isStartOfParagraphDeprecated(visibleUpstreamPos) || !upstream, shouldEmitNBSPbeforeEnd);
 
     if (string != rebalancedString)
         replaceTextInNodePreservingMarkers(textNode, upstream, length, rebalancedString);
 }
 
 void CompositeEditCommand::prepareWhitespaceAtPositionForSplit(Position& position)
 {
     if (!isRichlyEditablePosition(position))
         return;
     Node* node = position.anchorNode();
@@ skipping 230 matching lines @@
 
 // If the paragraph is not entirely within it's own block, create one and move the paragraph into
 // it, and return that block.  Otherwise return 0.
 HTMLElement* CompositeEditCommand::moveParagraphContentsToNewBlockIfNecessary(const Position& pos, EditingState* editingState)
 {
     DCHECK(isEditablePosition(pos)) << pos;
 
     // It's strange that this function is responsible for verifying that pos has not been invalidated
     // by an earlier call to this function.  The caller, applyBlockStyle, should do this.
     VisiblePosition visiblePos = createVisiblePositionDeprecated(pos, VP_DEFAULT_AFFINITY);
-    VisiblePosition visibleParagraphStart = startOfParagraph(visiblePos);
-    VisiblePosition visibleParagraphEnd = endOfParagraph(visiblePos);
+    VisiblePosition visibleParagraphStart = startOfParagraphDeprecated(visiblePos);
+    VisiblePosition visibleParagraphEnd = endOfParagraphDeprecated(visiblePos);
     VisiblePosition next = nextPositionOf(visibleParagraphEnd);
     VisiblePosition visibleEnd = next.isNotNull() ? next : visibleParagraphEnd;
 
     Position upstreamStart = mostBackwardCaretPosition(visibleParagraphStart.deepEquivalent());
     Position upstreamEnd = mostBackwardCaretPosition(visibleEnd.deepEquivalent());
 
     // If there are no VisiblePositions in the same block as pos then
     // upstreamStart will be outside the paragraph
     if (comparePositions(pos, upstreamStart) < 0)
         return nullptr;
@@ skipping 28 matching lines @@
 
     HTMLElement* newBlock = insertNewDefaultParagraphElementAt(upstreamStart, editingState);
     if (editingState->isAborted())
         return nullptr;
 
     bool endWasBr = isHTMLBRElement(*visibleParagraphEnd.deepEquivalent().anchorNode());
 
     // Inserting default paragraph element can change visible position. We
     // should update visible positions before use them.
     visiblePos = createVisiblePositionDeprecated(pos, VP_DEFAULT_AFFINITY);
-    visibleParagraphStart = startOfParagraph(visiblePos);
-    visibleParagraphEnd = endOfParagraph(visiblePos);
+    visibleParagraphStart = startOfParagraphDeprecated(visiblePos);
+    visibleParagraphEnd = endOfParagraphDeprecated(visiblePos);
     moveParagraphs(visibleParagraphStart, visibleParagraphEnd, VisiblePosition::firstPositionInNode(newBlock), editingState);
     if (editingState->isAborted())
         return nullptr;
 
     if (newBlock->lastChild() && isHTMLBRElement(*newBlock->lastChild()) && !endWasBr) {
         removeNode(newBlock->lastChild(), editingState);
         if (editingState->isAborted())
             return nullptr;
     }
 
@@ skipping 107 matching lines @@
 // There are bugs in deletion when it removes a fully selected table/list.
 // It expands and removes the entire table/list, but will let content
 // before and after the table/list collapse onto one line.
 // Deleting a paragraph will leave a placeholder. Remove it (and prune
 // empty or unrendered parents).
 
 void CompositeEditCommand::cleanupAfterDeletion(EditingState* editingState, VisiblePosition destination)
 {
     VisiblePosition caretAfterDelete = endingSelection().visibleStart();
     Node* destinationNode = destination.deepEquivalent().anchorNode();
-    if (caretAfterDelete.deepEquivalent() != destination.deepEquivalent() && isStartOfParagraph(caretAfterDelete) && isEndOfParagraph(caretAfterDelete)) {
+    if (caretAfterDelete.deepEquivalent() != destination.deepEquivalent() && isStartOfParagraphDeprecated(caretAfterDelete) && isEndOfParagraphDeprecated(caretAfterDelete)) {
         // Note: We want the rightmost candidate.
         Position position = mostForwardCaretPosition(caretAfterDelete.deepEquivalent());
         Node* node = position.anchorNode();
 
         // Bail if we'd remove an ancestor of our destination.
         if (destinationNode && destinationNode->isDescendantOf(node))
             return;
 
         // Normally deletion will leave a br as a placeholder.
         if (isHTMLBRElement(*node)) {
@@ skipping 69 matching lines @@
     // TODO(yosin): We should abort when |beforeParagraph| is a orphan when
     // we have a sample.
     beforeParagraph = createVisiblePositionDeprecated(beforeParagraph.deepEquivalent());
     if (afterParagraph.isOrphan()) {
         editingState->abort();
         return;
     }
     afterParagraph = createVisiblePositionDeprecated(afterParagraph.deepEquivalent());
 
     if (beforeParagraph.isNotNull() && !isDisplayInsideTable(beforeParagraph.deepEquivalent().anchorNode())
-        && ((!isEndOfParagraph(beforeParagraph) && !isStartOfParagraph(beforeParagraph)) || beforeParagraph.deepEquivalent() == afterParagraph.deepEquivalent())) {
+        && ((!isEndOfParagraphDeprecated(beforeParagraph) && !isStartOfParagraphDeprecated(beforeParagraph)) || beforeParagraph.deepEquivalent() == afterParagraph.deepEquivalent())) {
         // FIXME: Trim text between beforeParagraph and afterParagraph if they aren't equal.
         insertNodeAt(HTMLBRElement::create(document()), beforeParagraph.deepEquivalent(), editingState);
     }
 }
 
 void CompositeEditCommand::moveParagraph(const VisiblePosition& startOfParagraphToMove, const VisiblePosition& endOfParagraphToMove, const VisiblePosition& destination, EditingState* editingState, ShouldPreserveSelection shouldPreserveSelection, ShouldPreserveStyle shouldPreserveStyle, Node* constrainingAncestor)
 {
-    DCHECK(isStartOfParagraph(startOfParagraphToMove)) << startOfParagraphToMove;
-    DCHECK(isEndOfParagraph(endOfParagraphToMove)) << endOfParagraphToMove;
+    DCHECK(isStartOfParagraphDeprecated(startOfParagraphToMove)) << startOfParagraphToMove;
+    DCHECK(isEndOfParagraphDeprecated(endOfParagraphToMove)) << endOfParagraphToMove;
     moveParagraphs(startOfParagraphToMove, endOfParagraphToMove, destination, editingState, shouldPreserveSelection, shouldPreserveStyle, constrainingAncestor);
 }
 
 void CompositeEditCommand::moveParagraphs(const VisiblePosition& startOfParagraphToMove, const VisiblePosition& endOfParagraphToMove, const VisiblePosition& destination, EditingState* editingState, ShouldPreserveSelection shouldPreserveSelection, ShouldPreserveStyle shouldPreserveStyle, Node* constrainingAncestor)
 {
     if (startOfParagraphToMove.deepEquivalent() == destination.deepEquivalent() || startOfParagraphToMove.isNull())
         return;
 
     int startIndex = -1;
     int endIndex = -1;
@@ skipping 63 matching lines @@
 
     // Add a br if pruning an empty block level element caused a collapse. For example:
     // foo^
     // <div>bar</div>
     // baz
     // Imagine moving 'bar' to ^. 'bar' will be deleted and its div pruned. That would
     // cause 'baz' to collapse onto the line with 'foobar' unless we insert a br.
     // Must recononicalize these two VisiblePositions after the pruning above.
     VisiblePosition beforeParagraph = createVisiblePositionDeprecated(beforeParagraphPosition.position());
     VisiblePosition afterParagraph = createVisiblePositionDeprecated(afterParagraphPosition.position());
-    if (beforeParagraph.isNotNull() && (!isEndOfParagraph(beforeParagraph) || beforeParagraph.deepEquivalent() == afterParagraph.deepEquivalent())) {
+    if (beforeParagraph.isNotNull() && (!isEndOfParagraphDeprecated(beforeParagraph) || beforeParagraph.deepEquivalent() == afterParagraph.deepEquivalent())) {
         // FIXME: Trim text between beforeParagraph and afterParagraph if they aren't equal.
         insertNodeAt(HTMLBRElement::create(document()), beforeParagraph.deepEquivalent(), editingState);
         if (editingState->isAborted())
             return;
         // Need an updateLayout here in case inserting the br has split a text node.
         document().updateStyleAndLayoutIgnorePendingStylesheets();
     }
 
     destinationIndex = TextIterator::rangeLength(Position::firstPositionInNode(document().documentElement()), destination.toParentAnchoredPosition(), true);
 
     VisibleSelection destinationSelection(destination, originalIsDirectional);
     if (endingSelection().isNone()) {
         // We abort executing command since |destination| becomes invisible.
         editingState->abort();
         return;
     }
     setEndingSelection(destinationSelection);
     ReplaceSelectionCommand::CommandOptions options = ReplaceSelectionCommand::SelectReplacement | ReplaceSelectionCommand::MovingParagraph;
     if (shouldPreserveStyle == DoNotPreserveStyle)
         options |= ReplaceSelectionCommand::MatchStyle;
     applyCommandToComposite(ReplaceSelectionCommand::create(document(), fragment, options), editingState);
     if (editingState->isAborted())
         return;
 
     document().frame()->spellChecker().markMisspellingsAndBadGrammarForMovingParagraphs(endingSelection());
 
     // If the selection is in an empty paragraph, restore styles from the old empty paragraph to the new empty paragraph.
-    bool selectionIsEmptyParagraph = endingSelection().isCaret() && isStartOfParagraph(endingSelection().visibleStart()) && isEndOfParagraph(endingSelection().visibleStart());
+    bool selectionIsEmptyParagraph = endingSelection().isCaret() && isStartOfParagraphDeprecated(endingSelection().visibleStart()) && isEndOfParagraphDeprecated(endingSelection().visibleStart());
     if (styleInEmptyParagraph && selectionIsEmptyParagraph) {
         applyStyle(styleInEmptyParagraph, editingState);
         if (editingState->isAborted())
             return;
     }
 
     if (shouldPreserveSelection ==  DoNotPreserveSelection || startIndex == -1)
         return;
     Element* documentElement = document().documentElement();
     if (!documentElement)
@@ skipping 103 matching lines @@
 bool CompositeEditCommand::breakOutOfEmptyMailBlockquotedParagraph(EditingState* editingState)
 {
     if (!endingSelection().isCaret())
         return false;
 
     VisiblePosition caret = endingSelection().visibleStart();
     HTMLQuoteElement* highestBlockquote = toHTMLQuoteElement(highestEnclosingNodeOfType(caret.deepEquivalent(), &isMailHTMLBlockquoteElement));
     if (!highestBlockquote)
         return false;
 
-    if (!isStartOfParagraph(caret) || !isEndOfParagraph(caret))
+    if (!isStartOfParagraphDeprecated(caret) || !isEndOfParagraphDeprecated(caret))
         return false;
 
     VisiblePosition previous = previousPositionOf(caret, CannotCrossEditingBoundary);
     // Only move forward if there's nothing before the caret, or if there's unquoted content before it.
     if (enclosingNodeOfType(previous.deepEquivalent(), &isMailHTMLBlockquoteElement))
         return false;
 
     HTMLBRElement* br = HTMLBRElement::create(document());
     // We want to replace this quoted paragraph with an unquoted one, so insert a br
     // to hold the caret before the highest blockquote.
     insertNodeBefore(br, highestBlockquote, editingState);
     if (editingState->isAborted())
         return false;
     VisiblePosition atBR = VisiblePosition::beforeNode(br);
     // If the br we inserted collapsed, for example foo<br><blockquote>...</blockquote>, insert
     // a second one.
-    if (!isStartOfParagraph(atBR)) {
+    if (!isStartOfParagraphDeprecated(atBR)) {
         insertNodeBefore(HTMLBRElement::create(document()), br, editingState);
         if (editingState->isAborted())
             return false;
     }
     setEndingSelection(VisibleSelection(atBR, endingSelection().isDirectional()));
 
     // If this is an empty paragraph there must be a line break here.
     if (!lineBreakExistsAtVisiblePosition(caret))
         return false;
 
@@ skipping 115 matching lines @@
 }
 
 DEFINE_TRACE(CompositeEditCommand)
 {
     visitor->trace(m_commands);
     visitor->trace(m_composition);
     EditCommand::trace(visitor);
 }
 
 } // namespace blink