Editing: Pass failure information of RemoveNodeCommand to ReplaceSelectionCommand.

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 320 matching lines @@
 
 static Position firstEditablePositionInNode(Node* node)
 {
     ASSERT(node);
     Node* next = node;
     while (next && !next->hasEditableStyle())
         next = NodeTraversal::next(*next, node);
     return next ? firstPositionInOrBeforeNode(next) : Position();
 }
 
-void DeleteSelectionCommand::removeNode(PassRefPtrWillBeRawPtr<Node> node, ShouldAssumeContentIsAlwaysEditable shouldAssumeContentIsAlwaysEditable)
+void DeleteSelectionCommand::removeNode(PassRefPtrWillBeRawPtr<Node> node, EditingState* editingState, ShouldAssumeContentIsAlwaysEditable shouldAssumeContentIsAlwaysEditable)
 {
     if (!node)
         return;
 
     if (m_startRoot != m_endRoot && !(node->isDescendantOf(m_startRoot.get()) && node->isDescendantOf(m_endRoot.get()))) {
         // If a node is not in both the start and end editable roots, remove it only if its inside an editable region.
         if (!node->parentNode()->hasEditableStyle()) {
             // Don't remove non-editable atomic nodes.
             if (!node->hasChildren())
                 return;
             // Search this non-editable region for editable regions to empty.
             RefPtrWillBeRawPtr<Node> child = node->firstChild();
             while (child) {
                 RefPtrWillBeRawPtr<Node> nextChild = child->nextSibling();
-                removeNode(child.get(), shouldAssumeContentIsAlwaysEditable);
+                removeNode(child.get(), editingState, shouldAssumeContentIsAlwaysEditable);
+                if (editingState->isAborted())
+                    return;
                 // Bail if nextChild is no longer node's child.
                 if (nextChild && nextChild->parentNode() != node)
                     return;
                 child = nextChild;
             }
 
             // Don't remove editable regions that are inside non-editable ones, just clear them.
             return;
         }
     }
 
     if (isTableStructureNode(node.get()) || node->isRootEditableElement()) {
         // Do not remove an element of table structure; remove its contents.
         // Likewise for the root editable element.
         Node* child = node->firstChild();
         while (child) {
             Node* remove = child;
             child = child->nextSibling();
-            removeNode(remove, shouldAssumeContentIsAlwaysEditable);
+            removeNode(remove, editingState, shouldAssumeContentIsAlwaysEditable);
+            if (editingState->isAborted())
+                return;
         }
 
         // Make sure empty cell has some height, if a placeholder can be inserted.
         document().updateLayoutIgnorePendingStylesheets();
         LayoutObject* r = node->layoutObject();
         if (r && r->isTableCell() && toLayoutTableCell(r)->contentHeight() <= 0) {
             Position firstEditablePosition = firstEditablePositionInNode(node.get());
             if (firstEditablePosition.isNotNull())
                 insertBlockPlaceholder(firstEditablePosition);
         }
         return;
     }
 
     if (node == m_startBlock) {
         VisiblePosition previous = previousPositionOf(createVisiblePosition(firstPositionInNode(m_startBlock.get())));
         if (previous.isNotNull() && !isEndOfBlock(previous))
             m_needPlaceholder = true;
     }
     if (node == m_endBlock) {
         VisiblePosition next = nextPositionOf(createVisiblePosition(lastPositionInNode(m_endBlock.get())));
         if (next.isNotNull() && !isStartOfBlock(next))
             m_needPlaceholder = true;
     }
 
     // FIXME: Update the endpoints of the range being deleted.
     updatePositionForNodeRemoval(m_endingPosition, *node);
     updatePositionForNodeRemoval(m_leadingWhitespace, *node);
     updatePositionForNodeRemoval(m_trailingWhitespace, *node);
 
-    CompositeEditCommand::removeNode(node, shouldAssumeContentIsAlwaysEditable);
+    CompositeEditCommand::removeNode(node, editingState, shouldAssumeContentIsAlwaysEditable);
 }
 
 static void updatePositionForTextRemoval(Text* node, int offset, int count, Position& position)
 {
     if (!position.isOffsetInAnchor() || position.computeContainerNode() != node)
         return;
 
     if (position.offsetInContainerNode() > offset + count)
         position = Position(position.computeContainerNode(), position.offsetInContainerNode() - count);
     else if (position.offsetInContainerNode() > offset)
@@ skipping 22 matching lines @@
             RefPtrWillBeRawPtr<Element> rootEditableElement = node->rootEditableElement();
             if (rootEditableElement.get()) {
                 removeNode(node);
                 appendNode(node, rootEditableElement);
             }
         }
         node = nextNode;
     }
 }
 
-void DeleteSelectionCommand::handleGeneralDelete()
+void DeleteSelectionCommand::handleGeneralDelete(EditingState* editingState)
 {
     if (m_upstreamStart.isNull())
         return;
 
     int startOffset = m_upstreamStart.computeEditingOffset();
     Node* startNode = m_upstreamStart.anchorNode();
     ASSERT(startNode);
 
     makeStylingElementsDirectChildrenOfEditableRootToPreventStyleLoss();
 
@@ skipping 26 matching lines @@
                 // 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());
                 m_endingPosition = m_upstreamStart;
             }
         }
 
         // The selection to delete is all in one node.
-        if (!startNode->layoutObject() || (!startOffset && m_downstreamEnd.atLastEditingPositionForNode()))
-            removeNode(startNode);
+        if (!startNode->layoutObject() || (!startOffset && m_downstreamEnd.atLastEditingPositionForNode())) {
+            removeNode(startNode, editingState);
+            if (editingState->isAborted())
+                return;
+        }
     } else {
         bool startNodeWasDescendantOfEndNode = m_upstreamStart.anchorNode()->isDescendantOf(m_downstreamEnd.anchorNode());
         // The selection to delete spans more than one node.
         RefPtrWillBeRawPtr<Node> node(startNode);
 
         if (startOffset > 0) {
             if (startNode->isTextNode()) {
                 // in a text node that needs to be trimmed
                 Text* text = toText(node);
                 deleteTextFromNode(text, startOffset, text->length() - startOffset);
                 node = NodeTraversal::next(*node);
             } else {
                 node = NodeTraversal::childAt(*startNode, startOffset);
             }
         } else if (startNode == m_upstreamEnd.anchorNode() && startNode->isTextNode()) {
             Text* text = toText(m_upstreamEnd.anchorNode());
             deleteTextFromNode(text, 0, m_upstreamEnd.computeOffsetInContainerNode());
         }
 
         // handle deleting all nodes that are completely selected
         while (node && node != m_downstreamEnd.anchorNode()) {
             if (comparePositions(firstPositionInOrBeforeNode(node.get()), m_downstreamEnd) >= 0) {
                 // NodeTraversal::nextSkippingChildren just blew past the end position, so stop deleting
                 node = nullptr;
             } else if (!m_downstreamEnd.anchorNode()->isDescendantOf(node.get())) {
                 RefPtrWillBeRawPtr<Node> nextNode = NodeTraversal::nextSkippingChildren(*node);
                 // if we just removed a node from the end container, update end position so the
                 // check above will work
                 updatePositionForNodeRemoval(m_downstreamEnd, *node);
-                removeNode(node.get());
+                removeNode(node.get(), editingState);
+                if (editingState->isAborted())
+                    return;
                 node = nextNode.get();
             } else {
                 Node& n = NodeTraversal::lastWithinOrSelf(*node);
                 if (m_downstreamEnd.anchorNode() == n && m_downstreamEnd.computeEditingOffset() >= caretMaxOffset(&n)) {
-                    removeNode(node.get());
+                    removeNode(node.get(), editingState);
+                    if (editingState->isAborted())
+                        return;
                     node = nullptr;
                 } else {
                     node = NodeTraversal::next(*node);
                 }
             }
         }
 
         if (m_downstreamEnd.anchorNode() != startNode && !m_upstreamStart.anchorNode()->isDescendantOf(m_downstreamEnd.anchorNode()) && m_downstreamEnd.inDocument() && m_downstreamEnd.computeEditingOffset() >= caretMinOffset(m_downstreamEnd.anchorNode())) {
             if (m_downstreamEnd.atLastEditingPositionForNode() && !canHaveChildrenForEditing(m_downstreamEnd.anchorNode())) {
                 // The node itself is fully selected, not just its contents.  Delete it.
-                removeNode(m_downstreamEnd.anchorNode());
+                removeNode(m_downstreamEnd.anchorNode(), editingState);
             } else {
                 if (m_downstreamEnd.anchorNode()->isTextNode()) {
                     // in a text node that needs to be trimmed
                     Text* text = toText(m_downstreamEnd.anchorNode());
                     if (m_downstreamEnd.computeEditingOffset() > 0) {
                         deleteTextFromNode(text, 0, m_downstreamEnd.computeEditingOffset());
                     }
                 // Remove children of m_downstreamEnd.anchorNode() that come after m_upstreamStart.
                 // Don't try to remove children if m_upstreamStart was inside m_downstreamEnd.anchorNode()
                 // and m_upstreamStart has been removed from the document, because then we don't
@@ skipping 279 matching lines @@
     // deleting just a BR is handled specially, at least because we do not
     // want to replace it with a placeholder BR!
     if (handleSpecialCaseBRDelete()) {
         calculateTypingStyleAfterDelete();
         setEndingSelection(VisibleSelection(m_endingPosition, affinity, endingSelection().isDirectional()));
         clearTransientState();
         rebalanceWhitespace();
         return;
     }
 
-    handleGeneralDelete();
+    handleGeneralDelete(editingState);
+    if (editingState->isAborted())
+        return;
 
     fixupWhitespace();
 
     mergeParagraphs();
 
     removePreviouslySelectedEmptyTableRows();
 
     if (!m_needPlaceholder && rootWillStayOpenWithoutPlaceholder) {
         VisiblePosition visualEnding = createVisiblePosition(m_endingPosition);
         bool hasPlaceholder = lineBreakExistsAtVisiblePosition(visualEnding)
@@ skipping 55 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