Editing: Make the |EditingState*| argument of CompositeEditCommand::removeNode mandatory.

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

 /*
  * Copyright (C) 2005 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 282 matching lines @@
     m_typingStyle->removeStyleAddedByElement(enclosingAnchorElement(m_selectionToDelete.start()));
 
     // If we're deleting into a Mail blockquote, save the style at end() instead of start()
     // We'll use this later in computeTypingStyleAfterDelete if we end up outside of a Mail blockquote
     if (enclosingNodeOfType(m_selectionToDelete.start(), isMailHTMLBlockquoteElement))
         m_deleteIntoBlockquoteStyle = EditingStyle::create(m_selectionToDelete.end());
     else
         m_deleteIntoBlockquoteStyle = nullptr;
 }
 
-bool DeleteSelectionCommand::handleSpecialCaseBRDelete()
+bool DeleteSelectionCommand::handleSpecialCaseBRDelete(EditingState* editingState)
 {
     Node* nodeAfterUpstreamStart = m_upstreamStart.computeNodeAfterPosition();
     Node* nodeAfterDownstreamStart = m_downstreamStart.computeNodeAfterPosition();
     // Upstream end will appear before BR due to canonicalization
     Node* nodeAfterUpstreamEnd = m_upstreamEnd.computeNodeAfterPosition();
 
     if (!nodeAfterUpstreamStart || !nodeAfterDownstreamStart)
         return false;
 
     // Check for special-case where the selection contains only a BR on a line by itself after another BR.
     bool upstreamStartIsBR = isHTMLBRElement(*nodeAfterUpstreamStart);
     bool downstreamStartIsBR = isHTMLBRElement(*nodeAfterDownstreamStart);
     bool isBROnLineByItself = upstreamStartIsBR && downstreamStartIsBR && nodeAfterDownstreamStart == nodeAfterUpstreamEnd;
     if (isBROnLineByItself) {
-        removeNode(nodeAfterDownstreamStart);
+        removeNode(nodeAfterDownstreamStart, editingState);
         return true;
     }
 
     // FIXME: This code doesn't belong in here.
     // We detect the case where the start is an empty line consisting of BR not wrapped in a block element.
     if (upstreamStartIsBR && downstreamStartIsBR && !(isStartOfBlock(createVisiblePosition(positionBeforeNode(nodeAfterUpstreamStart))) && isEndOfBlock(createVisiblePosition(positionAfterNode(nodeAfterUpstreamStart))))) {
         m_startsAtEmptyLine = true;
         m_endingPosition = m_downstreamEnd;
     }
 
@@ skipping 95 matching lines @@
 {
     // FIXME: Update the endpoints of the range being deleted.
     updatePositionForTextRemoval(node.get(), offset, count, m_endingPosition);
     updatePositionForTextRemoval(node.get(), offset, count, m_leadingWhitespace);
     updatePositionForTextRemoval(node.get(), offset, count, m_trailingWhitespace);
     updatePositionForTextRemoval(node.get(), offset, count, m_downstreamEnd);
 
     CompositeEditCommand::deleteTextFromNode(node, offset, count);
 }
 
-void DeleteSelectionCommand::makeStylingElementsDirectChildrenOfEditableRootToPreventStyleLoss()
+void DeleteSelectionCommand::makeStylingElementsDirectChildrenOfEditableRootToPreventStyleLoss(EditingState* editingState)
 {
     RefPtrWillBeRawPtr<Range> range = createRange(m_selectionToDelete.toNormalizedEphemeralRange());
     RefPtrWillBeRawPtr<Node> node = range->firstNode();
     while (node && node != range->pastLastNode()) {
         RefPtrWillBeRawPtr<Node> nextNode = NodeTraversal::next(*node);
         if (isHTMLStyleElement(*node) || isHTMLLinkElement(*node)) {
             nextNode = NodeTraversal::nextSkippingChildren(*node);
             RefPtrWillBeRawPtr<Element> rootEditableElement = node->rootEditableElement();
             if (rootEditableElement.get()) {
-                removeNode(node);
-                appendNode(node, rootEditableElement);
+                removeNode(node, editingState);
+                if (editingState->isAborted())
+                    return;
+                appendNode(node, rootEditableElement, editingState);
+                if (editingState->isAborted())
+                    return;
             }
         }
         node = nextNode;
     }
 }
 
 void DeleteSelectionCommand::handleGeneralDelete(EditingState* editingState)
 {
     if (m_upstreamStart.isNull())
         return;
 
     int startOffset = m_upstreamStart.computeEditingOffset();
     Node* startNode = m_upstreamStart.anchorNode();
     ASSERT(startNode);
 
-    makeStylingElementsDirectChildrenOfEditableRootToPreventStyleLoss();
+    makeStylingElementsDirectChildrenOfEditableRootToPreventStyleLoss(editingState);
+    if (editingState->isAborted())
+        return;
 
     // Never remove the start block unless it's a table, in which case we won't merge content in.
     if (startNode->isSameNode(m_startBlock.get()) && !startOffset && canHaveChildrenForEditing(startNode) && !isHTMLTableElement(*startNode)) {
         startOffset = 0;
         startNode = NodeTraversal::next(*startNode);
         if (!startNode)
             return;
     }
 
     if (startOffset >= caretMaxOffset(startNode) && startNode->isTextNode()) {
@@ skipping 11 matching lines @@
     if (!startNode)
         return;
 
     if (startNode == m_downstreamEnd.anchorNode()) {
         if (m_downstreamEnd.computeEditingOffset() - startOffset > 0) {
             if (startNode->isTextNode()) {
                 // in a text node that needs to be trimmed
                 Text* text = toText(startNode);
                 deleteTextFromNode(text, startOffset, m_downstreamEnd.computeOffsetInContainerNode() - startOffset);
             } else {
-                removeChildrenInRange(startNode, startOffset, m_downstreamEnd.computeEditingOffset());
+                removeChildrenInRange(startNode, startOffset, m_downstreamEnd.computeEditingOffset(), editingState);
+                if (editingState->isAborted())
+                    return;
                 m_endingPosition = m_upstreamStart;
             }
         }
 
         // The selection to delete is all in one node.
         if (!startNode->layoutObject() || (!startOffset && m_downstreamEnd.atLastEditingPositionForNode())) {
             removeNode(startNode, editingState);
             if (editingState->isAborted())
                 return;
         }
@@ skipping 62 matching lines @@
                 // always know which children to remove.
                 } else if (!(startNodeWasDescendantOfEndNode && !m_upstreamStart.inDocument())) {
                     int offset = 0;
                     if (m_upstreamStart.anchorNode()->isDescendantOf(m_downstreamEnd.anchorNode())) {
                         Node* n = m_upstreamStart.anchorNode();
                         while (n && n->parentNode() != m_downstreamEnd.anchorNode())
                             n = n->parentNode();
                         if (n)
                             offset = n->nodeIndex() + 1;
                     }
-                    removeChildrenInRange(m_downstreamEnd.anchorNode(), offset, m_downstreamEnd.computeEditingOffset());
+                    removeChildrenInRange(m_downstreamEnd.anchorNode(), offset, m_downstreamEnd.computeEditingOffset(), editingState);
+                    if (editingState->isAborted())
+                        return;
                     m_downstreamEnd = Position::editingPositionOf(m_downstreamEnd.anchorNode(), offset);
                 }
             }
         }
     }
 }
 
 void DeleteSelectionCommand::fixupWhitespace()
 {
     document().updateLayoutIgnorePendingStylesheets();
     // TODO(yosin) |isRenderedCharacter()| should be removed, and we should use
     // |VisiblePosition::characterAfter()| and
     // |VisiblePosition::characterBefore()|
     if (m_leadingWhitespace.isNotNull() && !isRenderedCharacter(m_leadingWhitespace) && m_leadingWhitespace.anchorNode()->isTextNode()) {
         Text* textNode = toText(m_leadingWhitespace.anchorNode());
         ASSERT(!textNode->layoutObject() || textNode->layoutObject()->style()->collapseWhiteSpace());
         replaceTextInNodePreservingMarkers(textNode, m_leadingWhitespace.computeOffsetInContainerNode(), 1, nonBreakingSpaceString());
     }
     if (m_trailingWhitespace.isNotNull() && !isRenderedCharacter(m_trailingWhitespace) && m_trailingWhitespace.anchorNode()->isTextNode()) {
         Text* textNode = toText(m_trailingWhitespace.anchorNode());
         ASSERT(!textNode->layoutObject() || textNode->layoutObject()->style()->collapseWhiteSpace());
         replaceTextInNodePreservingMarkers(textNode, m_trailingWhitespace.computeOffsetInContainerNode(), 1, nonBreakingSpaceString());
     }
 }
 
 // If a selection starts in one block and ends in another, we have to merge to bring content before the
 // start together with content after the end.
-void DeleteSelectionCommand::mergeParagraphs()
+void DeleteSelectionCommand::mergeParagraphs(EditingState* editingState)
 {
     if (!m_mergeBlocksAfterDelete) {
         if (m_pruneStartBlockIfNecessary) {
             // We aren't going to merge into the start block, so remove it if it's empty.
-            prune(m_startBlock);
+            prune(m_startBlock, editingState);
+            if (editingState->isAborted())
+                return;
             // Removing the start block during a deletion is usually an indication that we need
             // a placeholder, but not in this case.
             m_needPlaceholder = false;
         }
         return;
     }
 
     // It shouldn't have been asked to both try and merge content into the start block and prune it.
     ASSERT(!m_pruneStartBlockIfNecessary);
 
     // FIXME: Deletion should adjust selection endpoints as it removes nodes so that we never get into this state (4099839).
     if (!m_downstreamEnd.inDocument() || !m_upstreamStart.inDocument())
         return;
 
     // FIXME: The deletion algorithm shouldn't let this happen.
     if (comparePositions(m_upstreamStart, m_downstreamEnd) > 0)
         return;
 
     // There's nothing to merge.
     if (m_upstreamStart == m_downstreamEnd)
         return;
 
     VisiblePosition startOfParagraphToMove = createVisiblePosition(m_downstreamEnd);
     VisiblePosition mergeDestination = createVisiblePosition(m_upstreamStart);
 
     // m_downstreamEnd's block has been emptied out by deletion.  There is no content inside of it to
     // move, so just remove it.
     Element* endBlock = enclosingBlock(m_downstreamEnd.anchorNode());
     if (!endBlock || !endBlock->contains(startOfParagraphToMove.deepEquivalent().anchorNode()) || !startOfParagraphToMove.deepEquivalent().anchorNode()) {
-        removeNode(enclosingBlock(m_downstreamEnd.anchorNode()));
+        removeNode(enclosingBlock(m_downstreamEnd.anchorNode()), editingState);
         return;
     }
 
     // We need to merge into m_upstreamStart's block, but it's been emptied out and collapsed by deletion.
     if (!mergeDestination.deepEquivalent().anchorNode() || (!mergeDestination.deepEquivalent().anchorNode()->isDescendantOf(enclosingBlock(m_upstreamStart.computeContainerNode())) && (!mergeDestination.deepEquivalent().anchorNode()->hasChildren() || !m_upstreamStart.computeContainerNode()->hasChildren())) || (m_startsAtEmptyLine && mergeDestination.deepEquivalent() != startOfParagraphToMove.deepEquivalent())) {
-        insertNodeAt(HTMLBRElement::create(document()).get(), m_upstreamStart);
+        insertNodeAt(HTMLBRElement::create(document()).get(), m_upstreamStart, editingState);
+        if (editingState->isAborted())
+            return;
         mergeDestination = createVisiblePosition(m_upstreamStart);
     }
 
     if (mergeDestination.deepEquivalent() == startOfParagraphToMove.deepEquivalent())
         return;
 
     VisiblePosition endOfParagraphToMove = endOfParagraph(startOfParagraphToMove, CanSkipOverEditingBoundary);
 
     if (mergeDestination.deepEquivalent() == endOfParagraphToMove.deepEquivalent())
         return;
 
     // If the merge destination and source to be moved are both list items of different lists, merge them into single list.
     Node* listItemInFirstParagraph = enclosingNodeOfType(m_upstreamStart, isListItem);
     Node* listItemInSecondParagraph = enclosingNodeOfType(m_downstreamEnd, isListItem);
     if (listItemInFirstParagraph && listItemInSecondParagraph
         && listItemInFirstParagraph->parentElement() != listItemInSecondParagraph->parentElement()
         && canMergeLists(listItemInFirstParagraph->parentElement(), listItemInSecondParagraph->parentElement())) {
-        mergeIdenticalElements(listItemInFirstParagraph->parentElement(), listItemInSecondParagraph->parentElement());
+        mergeIdenticalElements(listItemInFirstParagraph->parentElement(), listItemInSecondParagraph->parentElement(), editingState);
+        if (editingState->isAborted())
+            return;
         m_endingPosition = mergeDestination.deepEquivalent();
         return;
     }
 
     // The rule for merging into an empty block is: only do so if its farther to the right.
     // FIXME: Consider RTL.
     if (!m_startsAtEmptyLine && isStartOfParagraph(mergeDestination) && absoluteCaretBoundsOf(startOfParagraphToMove).x() > absoluteCaretBoundsOf(mergeDestination).x()) {
         if (isHTMLBRElement(*mostForwardCaretPosition(mergeDestination.deepEquivalent()).anchorNode())) {
-            removeNodeAndPruneAncestors(mostForwardCaretPosition(mergeDestination.deepEquivalent()).anchorNode());
+            removeNodeAndPruneAncestors(mostForwardCaretPosition(mergeDestination.deepEquivalent()).anchorNode(), editingState);
+            if (editingState->isAborted())
+                return;
             m_endingPosition = startOfParagraphToMove.deepEquivalent();
             return;
         }
     }
 
     // Block images, tables and horizontal rules cannot be made inline with content at mergeDestination.  If there is
     // any (!isStartOfParagraph(mergeDestination)), don't merge, just move the caret to just before the selection we deleted.
     // See https://bugs.webkit.org/show_bug.cgi?id=25439
     if (isRenderedAsNonInlineTableImageOrHR(startOfParagraphToMove.deepEquivalent().anchorNode()) && !isStartOfParagraph(mergeDestination)) {
         m_endingPosition = m_upstreamStart;
         return;
     }
 
     // moveParagraphs will insert placeholders if it removes blocks that would require their use, don't let block
     // removals that it does cause the insertion of *another* placeholder.
     bool needPlaceholder = m_needPlaceholder;
     bool paragraphToMergeIsEmpty = startOfParagraphToMove.deepEquivalent() == endOfParagraphToMove.deepEquivalent();
-    moveParagraph(startOfParagraphToMove, endOfParagraphToMove, mergeDestination, ASSERT_NO_EDITING_ABORT, false, !paragraphToMergeIsEmpty);
+    moveParagraph(startOfParagraphToMove, endOfParagraphToMove, mergeDestination, editingState, false, !paragraphToMergeIsEmpty);
+    if (editingState->isAborted())
+        return;
     m_needPlaceholder = needPlaceholder;
     // The endingPosition was likely clobbered by the move, so recompute it (moveParagraph selects the moved paragraph).
     m_endingPosition = endingSelection().start();
 }
 
-void DeleteSelectionCommand::removePreviouslySelectedEmptyTableRows()
+void DeleteSelectionCommand::removePreviouslySelectedEmptyTableRows(EditingState* editingState)
 {
     if (m_endTableRow && m_endTableRow->inDocument() && m_endTableRow != m_startTableRow) {
         Node* row = m_endTableRow->previousSibling();
         while (row && row != m_startTableRow) {
             RefPtrWillBeRawPtr<Node> previousRow = row->previousSibling();
             if (isTableRowEmpty(row)) {
                 // Use a raw removeNode, instead of DeleteSelectionCommand's,
                 // because that won't remove rows, it only empties them in
                 // preparation for this function.
-                CompositeEditCommand::removeNode(row);
+                CompositeEditCommand::removeNode(row, editingState);
+                if (editingState->isAborted())
+                    return;
             }
             row = previousRow.get();
         }
     }
 
     // Remove empty rows after the start row.
     if (m_startTableRow && m_startTableRow->inDocument() && m_startTableRow != m_endTableRow) {
         Node* row = m_startTableRow->nextSibling();
         while (row && row != m_endTableRow) {
             RefPtrWillBeRawPtr<Node> nextRow = row->nextSibling();
-            if (isTableRowEmpty(row))
-                CompositeEditCommand::removeNode(row);
+            if (isTableRowEmpty(row)) {
+                CompositeEditCommand::removeNode(row, editingState);
+                if (editingState->isAborted())
+                    return;
+            }
             row = nextRow.get();
         }
     }
 
     if (m_endTableRow && m_endTableRow->inDocument() && m_endTableRow != m_startTableRow) {
         if (isTableRowEmpty(m_endTableRow.get())) {
             // Don't remove m_endTableRow if it's where we're putting the ending
             // selection.
             if (!m_endingPosition.anchorNode()->isDescendantOf(m_endTableRow.get())) {
                 // FIXME: We probably shouldn't remove m_endTableRow unless it's
                 // fully selected, even if it is empty. We'll need to start
                 // adjusting the selection endpoints during deletion to know
                 // whether or not m_endTableRow was fully selected here.
-                CompositeEditCommand::removeNode(m_endTableRow.get());
+                CompositeEditCommand::removeNode(m_endTableRow.get(), editingState);
+                if (editingState->isAborted())
+                    return;
             }
         }
     }
 }
 
 void DeleteSelectionCommand::calculateTypingStyleAfterDelete()
 {
     // Clearing any previously set typing style and doing an early return.
     if (!m_typingStyle) {
         document().frame()->selection().clearTypingStyle();
@@ skipping 92 matching lines @@
     bool lineBreakBeforeStart = lineBreakExistsAtVisiblePosition(previousPositionOf(createVisiblePosition(m_upstreamStart)));
 
     // Delete any text that may hinder our ability to fixup whitespace after the
     // delete
     deleteInsignificantTextDownstream(m_trailingWhitespace);
 
     saveTypingStyleState();
 
     // deleting just a BR is handled specially, at least because we do not
     // want to replace it with a placeholder BR!
-    if (handleSpecialCaseBRDelete()) {
+    bool brResult = handleSpecialCaseBRDelete(editingState);
+    if (editingState->isAborted())
+        return;
+    if (brResult) {
         calculateTypingStyleAfterDelete();
         setEndingSelection(VisibleSelection(m_endingPosition, affinity, endingSelection().isDirectional()));
         clearTransientState();
         rebalanceWhitespace();
         return;
     }
 
     handleGeneralDelete(editingState);
     if (editingState->isAborted())
         return;
 
     fixupWhitespace();
 
-    mergeParagraphs();
+    mergeParagraphs(editingState);
+    if (editingState->isAborted())
+        return;
 
-    removePreviouslySelectedEmptyTableRows();
+    removePreviouslySelectedEmptyTableRows(editingState);
+    if (editingState->isAborted())
+        return;
 
     if (!m_needPlaceholder && rootWillStayOpenWithoutPlaceholder) {
         VisiblePosition visualEnding = createVisiblePosition(m_endingPosition);
         bool hasPlaceholder = lineBreakExistsAtVisiblePosition(visualEnding)
             && nextPositionOf(visualEnding, CannotCrossEditingBoundary).isNull();
         m_needPlaceholder = hasPlaceholder && lineBreakBeforeStart && !lineBreakAtEndOfSelectionToDelete;
     }
 
     RefPtrWillBeRawPtr<HTMLBRElement> placeholder = m_needPlaceholder ? HTMLBRElement::create(document()) : nullptr;
 
@@ skipping 49 matching lines @@
     visitor->trace(m_deleteIntoBlockquoteStyle);
     visitor->trace(m_startRoot);
     visitor->trace(m_endRoot);
     visitor->trace(m_startTableRow);
     visitor->trace(m_endTableRow);
     visitor->trace(m_temporaryPlaceholder);
     CompositeEditCommand::trace(visitor);
 }
 
 } // namespace blink