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

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 615 matching lines @@
         elements.add(tfootTag.localName());
         elements.add(thTag.localName());
         elements.add(theadTag.localName());
         elements.add(trTag.localName());
         elements.add(ulTag.localName());
         elements.add(xmpTag.localName());
     }
     return elements.contains(name);
 }
 
-void ReplaceSelectionCommand::makeInsertedContentRoundTrippableWithHTMLTreeBuilder(const InsertedNodes& insertedNodes)
+void ReplaceSelectionCommand::makeInsertedContentRoundTrippableWithHTMLTreeBuilder(const InsertedNodes& insertedNodes, EditingState* editingState)
 {
     RefPtrWillBeRawPtr<Node> pastEndNode = insertedNodes.pastLastLeaf();
     RefPtrWillBeRawPtr<Node> next = nullptr;
     for (RefPtrWillBeRawPtr<Node> node = insertedNodes.firstNodeInserted(); node && node != pastEndNode; node = next) {
         next = NodeTraversal::next(*node);
 
         if (!node->isHTMLElement())
             continue;
         // moveElementOutOfAncestor() in a previous iteration might have failed,
         // and |node| might have been detached from the document tree.
         if (!node->inDocument())
             continue;
 
         HTMLElement& element = toHTMLElement(*node);
         if (isProhibitedParagraphChild(element.localName())) {
-            if (HTMLElement* paragraphElement = toHTMLElement(enclosingElementWithTag(positionInParentBeforeNode(element), pTag)))
-                moveElementOutOfAncestor(&element, paragraphElement);
+            if (HTMLElement* paragraphElement = toHTMLElement(enclosingElementWithTag(positionInParentBeforeNode(element), pTag))) {
+                moveElementOutOfAncestor(&element, paragraphElement, editingState);
+                if (editingState->isAborted())
+                    return;
+            }
         }
 
         if (isHTMLHeaderElement(&element)) {
-            if (HTMLElement* headerElement = toHTMLElement(highestEnclosingNodeOfType(positionInParentBeforeNode(element), isHTMLHeaderElement)))
-                moveElementOutOfAncestor(&element, headerElement);
+            if (HTMLElement* headerElement = toHTMLElement(highestEnclosingNodeOfType(positionInParentBeforeNode(element), isHTMLHeaderElement))) {
+                moveElementOutOfAncestor(&element, headerElement, editingState);
+                if (editingState->isAborted())
+                    return;
+            }
         }
     }
 }
 
-void ReplaceSelectionCommand::moveElementOutOfAncestor(PassRefPtrWillBeRawPtr<Element> prpElement, PassRefPtrWillBeRawPtr<Element> prpAncestor)
+void ReplaceSelectionCommand::moveElementOutOfAncestor(PassRefPtrWillBeRawPtr<Element> prpElement, PassRefPtrWillBeRawPtr<Element> prpAncestor, EditingState* editingState)
 {
     RefPtrWillBeRawPtr<Element> element = prpElement;
     RefPtrWillBeRawPtr<Element> ancestor = prpAncestor;
 
     if (!ancestor->parentNode()->hasEditableStyle())
         return;
 
     VisiblePosition positionAtEndOfNode = createVisiblePosition(lastPositionInOrAfterNode(element.get()));
     VisiblePosition lastPositionInParagraph = createVisiblePosition(lastPositionInNode(ancestor.get()));
     if (positionAtEndOfNode.deepEquivalent() == lastPositionInParagraph.deepEquivalent()) {
-        removeNode(element);
+        removeNode(element, editingState);
+        if (editingState->isAborted())
+            return;
         if (ancestor->nextSibling())
-            insertNodeBefore(element, ancestor->nextSibling());
+            insertNodeBefore(element, ancestor->nextSibling(), editingState);
         else
-            appendNode(element, ancestor->parentNode());
+            appendNode(element, ancestor->parentNode(), editingState);
+        if (editingState->isAborted())
+            return;
     } else {
         RefPtrWillBeRawPtr<Node> nodeToSplitTo = splitTreeToNode(element.get(), ancestor.get(), true);
-        removeNode(element);
-        insertNodeBefore(element, nodeToSplitTo);
+        removeNode(element, editingState);
+        if (editingState->isAborted())
+            return;
+        insertNodeBefore(element, nodeToSplitTo, editingState);
+        if (editingState->isAborted())
+            return;
     }
     if (!ancestor->hasChildren())
-        removeNode(ancestor.release());
+        removeNode(ancestor.release(), editingState);
 }
 
 static inline bool nodeHasVisibleLayoutText(Text& text)
 {
     return text.layoutObject() && text.layoutObject()->resolvedTextLength() > 0;
 }
 
 void ReplaceSelectionCommand::removeUnrenderedTextNodesAtEnds(InsertedNodes& insertedNodes)
 {
     document().updateLayoutIgnorePendingStylesheets();
 
     Node* lastLeafInserted = insertedNodes.lastLeafInserted();
     if (lastLeafInserted && lastLeafInserted->isTextNode() && !nodeHasVisibleLayoutText(toText(*lastLeafInserted))
         && !enclosingElementWithTag(firstPositionInOrBeforeNode(lastLeafInserted), selectTag)
         && !enclosingElementWithTag(firstPositionInOrBeforeNode(lastLeafInserted), scriptTag)) {
         insertedNodes.willRemoveNode(*lastLeafInserted);
-        removeNode(lastLeafInserted);
+        // Removing a Text node won't dispatch synchronous events.
+        removeNode(lastLeafInserted, ASSERT_NO_EDITING_ABORT);
     }
 
     // We don't have to make sure that firstNodeInserted isn't inside a select or script element, because
     // it is a top level node in the fragment and the user can't insert into those elements.
     Node* firstNodeInserted = insertedNodes.firstNodeInserted();
     if (firstNodeInserted && firstNodeInserted->isTextNode() && !nodeHasVisibleLayoutText(toText(*firstNodeInserted))) {
         insertedNodes.willRemoveNode(*firstNodeInserted);
-        removeNode(firstNodeInserted);
+        // Removing a Text node won't dispatch synchronous events.
+        removeNode(firstNodeInserted, ASSERT_NO_EDITING_ABORT);
     }
 }
 
 VisiblePosition ReplaceSelectionCommand::positionAtEndOfInsertedContent() const
 {
     // FIXME: Why is this hack here?  What's special about <select> tags?
     HTMLSelectElement* enclosingSelect = toHTMLSelectElement(enclosingElementWithTag(m_endOfInsertedContent, selectTag));
     return createVisiblePosition(enclosingSelect ? lastPositionInOrAfterNode(enclosingSelect) : m_endOfInsertedContent);
 }
 
@@ skipping 204 matching lines @@
     const VisibleSelection selection = endingSelection();
     ASSERT(selection.isCaretOrRange());
     ASSERT(selection.start().anchorNode());
     if (!selection.isNonOrphanedCaretOrRange() || !selection.start().anchorNode())
         return;
 
     if (!selection.rootEditableElement())
         return;
 
     ReplacementFragment fragment(&document(), m_documentFragment.get(), selection);
-    if (performTrivialReplace(fragment))
+    bool trivialReplaceResult = performTrivialReplace(fragment, editingState);
+    if (editingState->isAborted())
+        return;
+    if (trivialReplaceResult)
         return;
 
     // We can skip matching the style if the selection is plain text.
     if ((selection.start().anchorNode()->layoutObject() && selection.start().anchorNode()->layoutObject()->style()->userModify() == READ_WRITE_PLAINTEXT_ONLY)
         && (selection.end().anchorNode()->layoutObject() && selection.end().anchorNode()->layoutObject()->style()->userModify() == READ_WRITE_PLAINTEXT_ONLY))
         m_matchStyle = false;
 
     if (m_matchStyle) {
         m_insertionStyle = EditingStyle::create(selection.start());
         m_insertionStyle->mergeTypingStyle(&document());
@@ skipping 62 matching lines @@
     // 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
     // breaking the blockquote will prevent the content from actually being inserted in the table.
     if (enclosingNodeOfType(insertionPos, isMailHTMLBlockquoteElement, CanCrossEditingBoundary) && m_preventNesting && !(enclosingNodeOfType(insertionPos, &isTableStructureNode))) {
         applyCommandToComposite(BreakBlockquoteCommand::create(document()));
         // This will leave a br between the split.
         Node* br = endingSelection().start().anchorNode();
         ASSERT(isHTMLBRElement(br));
         // Insert content between the two blockquotes, but remove the br (since it was just a placeholder).
         insertionPos = positionInParentBeforeNode(*br);
-        removeNode(br);
+        removeNode(br, editingState);
+        if (editingState->isAborted())
+            return;
     }
 
     // Inserting content could cause whitespace to collapse, e.g. inserting <div>foo</div> into hello^ world.
     prepareWhitespaceAtPositionForSplit(insertionPos);
 
     // If the downstream node has been removed there's no point in continuing.
     if (!mostForwardCaretPosition(insertionPos).anchorNode())
         return;
 
     // NOTE: This would be an incorrect usage of downstream() if downstream() were changed to mean the last position after
@@ skipping 134 matching lines @@
     VisiblePosition startOfInsertedContent = createVisiblePosition(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))
         insertNodeAt(HTMLBRElement::create(document()).get(), startOfInsertedContent.deepEquivalent());
 
     if (endBR && (plainTextFragment || (shouldRemoveEndBR(endBR, originalVisPosBeforeEndBR) && !(fragment.hasInterchangeNewlineAtEnd() && selectionIsPlainText)))) {
         RefPtrWillBeRawPtr<ContainerNode> parent = endBR->parentNode();
         insertedNodes.willRemoveNode(*endBR);
-        removeNode(endBR);
+        removeNode(endBR, editingState);
+        if (editingState->isAborted())
+            return;
         if (Node* nodeToRemove = highestNodeToRemoveInPruning(parent.get())) {
             insertedNodes.willRemoveNode(*nodeToRemove);
-            removeNode(nodeToRemove);
+            removeNode(nodeToRemove, editingState);
+            if (editingState->isAborted())
+                return;
         }
     }
 
-    makeInsertedContentRoundTrippableWithHTMLTreeBuilder(insertedNodes);
+    makeInsertedContentRoundTrippableWithHTMLTreeBuilder(insertedNodes, editingState);
+    if (editingState->isAborted())
+        return;
 
     removeRedundantStylesAndKeepStyleSpanInline(insertedNodes);
 
     if (m_sanitizeFragment)
         applyCommandToComposite(SimplifyMarkupCommand::create(document(), insertedNodes.firstNodeInserted(), insertedNodes.pastLastLeaf()));
 
     // Setup m_startOfInsertedContent and m_endOfInsertedContent. This should be the last two lines of code that access insertedNodes.
     m_startOfInsertedContent = firstPositionInOrBeforeNode(insertedNodes.firstNodeInserted());
     m_endOfInsertedContent = lastPositionInOrAfterNode(insertedNodes.lastLeafInserted());
 
@@ skipping 70 matching lines @@
         removeElementAttribute(mailBlockquote, classAttr);
 
     if (shouldPerformSmartReplace())
         addSpacesForSmartReplace();
 
     // If we are dealing with a fragment created from plain text
     // no style matching is necessary.
     if (plainTextFragment)
         m_matchStyle = false;
 
-    completeHTMLReplacement(lastPositionToSelect);
+    completeHTMLReplacement(lastPositionToSelect, editingState);
 }
 
 bool ReplaceSelectionCommand::shouldRemoveEndBR(HTMLBRElement* endBR, const VisiblePosition& originalVisPosBeforeEndBR)
 {
     if (!endBR || !endBR->inDocument())
         return false;
 
     VisiblePosition visiblePos = createVisiblePosition(positionBeforeNode(endBR));
 
     // Don't remove the br if nothing was inserted.
@@ skipping 73 matching lines @@
         } else {
             RefPtrWillBeRawPtr<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.
             insertNodeBefore(node, startNode);
             m_startOfInsertedContent = firstPositionInNode(node.get());
         }
     }
 }
 
-void ReplaceSelectionCommand::completeHTMLReplacement(const Position &lastPositionToSelect)
+void ReplaceSelectionCommand::completeHTMLReplacement(const Position &lastPositionToSelect, EditingState* editingState)
 {
     Position start = positionAtStartOfInsertedContent().deepEquivalent();
     Position end = positionAtEndOfInsertedContent().deepEquivalent();
 
     // Mutation events may have deleted start or end
     if (start.isNotNull() && !start.isOrphan() && end.isNotNull() && !end.isOrphan()) {
         // FIXME (11475): Remove this and require that the creator of the fragment to use nbsps.
         rebalanceWhitespaceAt(start);
         rebalanceWhitespaceAt(end);
 
         if (m_matchStyle) {
             ASSERT(m_insertionStyle);
             applyStyle(m_insertionStyle.get(), start, end);
         }
 
         if (lastPositionToSelect.isNotNull())
             end = lastPositionToSelect;
 
-        mergeTextNodesAroundPosition(start, end);
+        mergeTextNodesAroundPosition(start, end, editingState);
+        if (editingState->isAborted())
+            return;
     } else if (lastPositionToSelect.isNotNull()) {
         start = end = lastPositionToSelect;
     } else {
         return;
     }
 
     m_startOfInsertedRange = start;
     m_endOfInsertedRange = end;
 
     if (m_selectReplacement)
         setEndingSelection(VisibleSelection(start, end, SelDefaultAffinity, endingSelection().isDirectional()));
     else
         setEndingSelection(VisibleSelection(end, SelDefaultAffinity, endingSelection().isDirectional()));
 }
 
-void ReplaceSelectionCommand::mergeTextNodesAroundPosition(Position& position, Position& positionOnlyToBeUpdated)
+void ReplaceSelectionCommand::mergeTextNodesAroundPosition(Position& position, Position& positionOnlyToBeUpdated, EditingState* editingState)
 {
     bool positionIsOffsetInAnchor = position.isOffsetInAnchor();
     bool positionOnlyToBeUpdatedIsOffsetInAnchor = positionOnlyToBeUpdated.isOffsetInAnchor();
     RefPtrWillBeRawPtr<Text> text = nullptr;
     if (positionIsOffsetInAnchor && position.computeContainerNode() && position.computeContainerNode()->isTextNode()) {
         text = toText(position.computeContainerNode());
     } else {
         Node* before = position.computeNodeBeforePosition();
         if (before && before->isTextNode()) {
             text = toText(before);
@@ skipping 17 matching lines @@
 
         if (positionOnlyToBeUpdatedIsOffsetInAnchor) {
             if (positionOnlyToBeUpdated.computeContainerNode() == text)
                 positionOnlyToBeUpdated = Position(text, previous->length() + positionOnlyToBeUpdated.offsetInContainerNode());
             else if (positionOnlyToBeUpdated.computeContainerNode() == previous)
                 positionOnlyToBeUpdated = Position(text, positionOnlyToBeUpdated.offsetInContainerNode());
         } else {
             updatePositionForNodeRemoval(positionOnlyToBeUpdated, *previous);
         }
 
-        removeNode(previous);
+        removeNode(previous, editingState);
+        if (editingState->isAborted())
+            return;
     }
     if (text->nextSibling() && text->nextSibling()->isTextNode()) {
         RefPtrWillBeRawPtr<Text> next = toText(text->nextSibling());
         unsigned originalLength = text->length();
         insertTextIntoNode(text, originalLength, next->data());
 
         if (!positionIsOffsetInAnchor)
             updatePositionForNodeRemoval(position, *next);
 
         if (positionOnlyToBeUpdatedIsOffsetInAnchor && positionOnlyToBeUpdated.computeContainerNode() == next)
             positionOnlyToBeUpdated = Position(text, originalLength + positionOnlyToBeUpdated.offsetInContainerNode());
         else
             updatePositionForNodeRemoval(positionOnlyToBeUpdated, *next);
 
-        removeNode(next);
+        removeNode(next, editingState);
+        if (editingState->isAborted())
+            return;
     }
 }
 
 EditAction ReplaceSelectionCommand::editingAction() const
 {
     return m_editAction;
 }
 
 // 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.
@@ skipping 46 matching lines @@
     if (m_startOfInsertedContent.isNull())
         m_startOfInsertedContent = firstPositionInOrBeforeNode(node);
 
     m_endOfInsertedContent = lastPositionInOrAfterNode(&NodeTraversal::lastWithinOrSelf(*node));
 }
 
 // During simple pastes, where we're just pasting a text node into a run of text, we insert the text node
 // directly into the text node that holds the selection.  This is much faster than the generalized code in
 // ReplaceSelectionCommand, and works around <https://bugs.webkit.org/show_bug.cgi?id=6148> since we don't
 // split text nodes.
-bool ReplaceSelectionCommand::performTrivialReplace(const ReplacementFragment& fragment)
+bool ReplaceSelectionCommand::performTrivialReplace(const ReplacementFragment& fragment, EditingState* editingState)
 {
     if (!fragment.firstChild() || fragment.firstChild() != fragment.lastChild() || !fragment.firstChild()->isTextNode())
         return false;
 
     // FIXME: Would be nice to handle smart replace in the fast path.
     if (m_smartReplace || fragment.hasInterchangeNewlineAtStart() || fragment.hasInterchangeNewlineAtEnd())
         return false;
 
     // e.g. when "bar" is inserted after "foo" in <div><u>foo</u></div>, "bar" should not be underlined.
     if (elementToSplitToAvoidPastingIntoInlineElementsWithStyle(endingSelection().start()))
         return false;
 
     RefPtrWillBeRawPtr<Node> nodeAfterInsertionPos = mostForwardCaretPosition(endingSelection().end()).anchorNode();
     Text* textNode = toText(fragment.firstChild());
     // Our fragment creation code handles tabs, spaces, and newlines, so we don't have to worry about those here.
 
     Position start = endingSelection().start();
     Position end = replaceSelectedTextInNode(textNode->data());
     if (end.isNull())
         return false;
 
     if (nodeAfterInsertionPos && nodeAfterInsertionPos->parentNode() && isHTMLBRElement(*nodeAfterInsertionPos)
-        && shouldRemoveEndBR(toHTMLBRElement(nodeAfterInsertionPos.get()), createVisiblePosition(positionBeforeNode(nodeAfterInsertionPos.get()))))
-        removeNodeAndPruneAncestors(nodeAfterInsertionPos.get());
+        && shouldRemoveEndBR(toHTMLBRElement(nodeAfterInsertionPos.get()), createVisiblePosition(positionBeforeNode(nodeAfterInsertionPos.get())))) {
+        removeNodeAndPruneAncestors(nodeAfterInsertionPos.get(), editingState);
+        if (editingState->isAborted())
+            return false;
+    }
 
     m_startOfInsertedRange = start;
     m_endOfInsertedRange = end;
 
     VisibleSelection selectionAfterReplace(m_selectReplacement ? start : end, end);
 
     setEndingSelection(selectionAfterReplace);
 
     return true;
 }
@@ skipping 13 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