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

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

 /*
  * Copyright (C) 2005, 2006, 2008, 2009 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 618 matching lines @@
             embeddingRemoveStart = positionInParentAfterNode(*startUnsplitAncestor);
 
         Position embeddingRemoveEnd = end;
         if (endUnsplitAncestor && elementFullySelected(*endUnsplitAncestor, removeStart, end))
             embeddingRemoveEnd = mostForwardCaretPosition(positionInParentBeforeNode(*endUnsplitAncestor));
 
         if (embeddingRemoveEnd != removeStart || embeddingRemoveEnd != end) {
             styleWithoutEmbedding = style->copy();
             embeddingStyle = styleWithoutEmbedding->extractAndRemoveTextDirection();
 
-            if (comparePositions(embeddingRemoveStart, embeddingRemoveEnd) <= 0)
-                removeInlineStyle(embeddingStyle.get(), embeddingRemoveStart, embeddingRemoveEnd);
+            if (comparePositions(embeddingRemoveStart, embeddingRemoveEnd) <= 0) {
+                removeInlineStyle(embeddingStyle.get(), embeddingRemoveStart, embeddingRemoveEnd, editingState);
+                if (editingState->isAborted())
+                    return;
+            }
         }
     }
 
-    removeInlineStyle(styleWithoutEmbedding ? styleWithoutEmbedding.get() : style, removeStart, end);
+    removeInlineStyle(styleWithoutEmbedding ? styleWithoutEmbedding.get() : style, removeStart, end, editingState);
+    if (editingState->isAborted())
+        return;
     start = startPosition();
     end = endPosition();
     if (start.isNull() || start.isOrphan() || end.isNull() || end.isOrphan())
         return;
 
-    if (splitStart && mergeStartWithPreviousIfIdentical(start, end)) {
+    if (splitStart) {
+        bool mergeResult = mergeStartWithPreviousIfIdentical(start, end, editingState);
+        if (editingState->isAborted())
+            return;
+        if (splitStart && mergeResult) {
+            start = startPosition();
+            end = endPosition();
+        }
+    }
+
+    if (splitEnd) {
+        mergeEndWithNextIfIdentical(start, end, editingState);
+        if (editingState->isAborted())
+            return;
         start = startPosition();
         end = endPosition();
     }
-
-    if (splitEnd) {
-        mergeEndWithNextIfIdentical(start, end);
-        start = startPosition();
-        end = endPosition();
-    }
 
     // update document layout once before running the rest of the function
     // so that we avoid the expense of updating before each and every call
     // to check a computed style
     document().updateLayoutIgnorePendingStylesheets();
 
     RefPtrWillBeRawPtr<EditingStyle> styleToApply = style;
     if (hasTextDirection) {
         // Avoid applying the unicode-bidi and direction properties beneath ancestors that already have them.
         HTMLElement* embeddingStartElement = highestEmbeddingAncestor(start.anchorNode(), enclosingBlock(start.anchorNode()));
@@ skipping 356 matching lines @@
             result = toHTMLElement(n);
         // Should stop at the editable root (cannot cross editing boundary) and
         // also stop at the unsplittable element to be consistent with other UAs
         if (n == unsplittableElement)
             break;
     }
 
     return result;
 }
 
-void ApplyStyleCommand::applyInlineStyleToPushDown(Node* node, EditingStyle* style)
+void ApplyStyleCommand::applyInlineStyleToPushDown(Node* node, EditingStyle* style, EditingState* editingState)
 {
     ASSERT(node);
 
     node->document().updateLayoutTreeIfNeeded();
 
     if (!style || style->isEmpty() || !node->layoutObject() || isHTMLIFrameElement(*node))
         return;
 
     RefPtrWillBeRawPtr<EditingStyle> newInlineStyle = style;
     if (node->isHTMLElement() && toHTMLElement(node)->inlineStyle()) {
         newInlineStyle = style->copy();
         newInlineStyle->mergeInlineStyleOfElement(toHTMLElement(node), EditingStyle::OverrideValues);
     }
 
     // Since addInlineStyleIfNeeded can't add styles to block-flow layout objects, add style attribute instead.
     // FIXME: applyInlineStyleToRange should be used here instead.
     if ((node->layoutObject()->isLayoutBlockFlow() || node->hasChildren()) && node->isHTMLElement()) {
         setNodeAttribute(toHTMLElement(node), styleAttr, AtomicString(newInlineStyle->style()->asText()));
         return;
     }
 
     if (node->layoutObject()->isText() && toLayoutText(node->layoutObject())->isAllCollapsibleWhitespace())
         return;
 
     // We can't wrap node with the styled element here because new styled element will never be removed if we did.
     // If we modified the child pointer in pushDownInlineStyleAroundNode to point to new style element
     // then we fall into an infinite loop where we keep removing and adding styled element wrapping node.
-    addInlineStyleIfNeeded(newInlineStyle.get(), node, node, DoNotAddStyledElement);
+    addInlineStyleIfNeeded(newInlineStyle.get(), node, node, editingState, DoNotAddStyledElement);
 }
 
-void ApplyStyleCommand::pushDownInlineStyleAroundNode(EditingStyle* style, Node* targetNode)
+void ApplyStyleCommand::pushDownInlineStyleAroundNode(EditingStyle* style, Node* targetNode, EditingState* editingState)
 {
     HTMLElement* highestAncestor = highestAncestorWithConflictingInlineStyle(style, targetNode);
     if (!highestAncestor)
         return;
 
     // The outer loop is traversing the tree vertically from highestAncestor to targetNode
     RefPtrWillBeRawPtr<Node> current = highestAncestor;
     // Along the way, styled elements that contain targetNode are removed and accumulated into elementsToPushDown.
     // Each child of the removed element, exclusing ancestors of targetNode, is then wrapped by clones of elements in elementsToPushDown.
     WillBeHeapVector<RefPtrWillBeMember<Element>> elementsToPushDown;
@@ skipping 23 matching lines @@
                     // Delete id attribute from the second element because the same id cannot be used for more than one element
                     element->removeAttribute(HTMLNames::idAttr);
                     if (isHTMLAnchorElement(element))
                         element->removeAttribute(HTMLNames::nameAttr);
                     surroundNodeRangeWithElement(child, child, wrapper, ASSERT_NO_EDITING_ABORT);
                 }
             }
 
             // Apply style to all nodes containing targetNode and their siblings but NOT to targetNode
             // But if we've removed styledElement then go ahead and always apply the style.
-            if (child != targetNode || styledElement)
-                applyInlineStyleToPushDown(child, styleToPushDown.get());
+            if (child != targetNode || styledElement) {
+                applyInlineStyleToPushDown(child, styleToPushDown.get(), editingState);
+                if (editingState->isAborted())
+                    return;
+            }
 
             // We found the next node for the outer loop (contains targetNode)
             // When reached targetNode, stop the outer loop upon the completion of the current inner loop
             if (child == targetNode || child->contains(targetNode))
                 current = child;
         }
     }
 }
 
-void ApplyStyleCommand::removeInlineStyle(EditingStyle* style, const Position &start, const Position &end)
+void ApplyStyleCommand::removeInlineStyle(EditingStyle* style, const Position &start, const Position &end, EditingState* editingState)
 {
     ASSERT(start.isNotNull());
     ASSERT(end.isNotNull());
     ASSERT(start.inDocument());
     ASSERT(end.inDocument());
     ASSERT(Position::commonAncestorTreeScope(start, end));
     ASSERT(comparePositions(start, end) <= 0);
     // FIXME: We should assert that start/end are not in the middle of a text node.
 
     Position pushDownStart = mostForwardCaretPosition(start);
     // If the pushDownStart is at the end of a text node, then this node is not fully selected.
     // Move it to the next deep quivalent position to avoid removing the style from this node.
     // e.g. if pushDownStart was at Position("hello", 5) in <b>hello<div>world</div></b>, we want Position("world", 0) instead.
     Node* pushDownStartContainer = pushDownStart.computeContainerNode();
     if (pushDownStartContainer && pushDownStartContainer->isTextNode()
         && pushDownStart.computeOffsetInContainerNode() == pushDownStartContainer->maxCharacterOffset())
         pushDownStart = nextVisuallyDistinctCandidate(pushDownStart);
     Position pushDownEnd = mostBackwardCaretPosition(end);
     // If pushDownEnd is at the start of a text node, then this node is not fully selected.
     // Move it to the previous deep equivalent position to avoid removing the style from this node.
     Node* pushDownEndContainer = pushDownEnd.computeContainerNode();
     if (pushDownEndContainer && pushDownEndContainer->isTextNode() && !pushDownEnd.computeOffsetInContainerNode())
         pushDownEnd = previousVisuallyDistinctCandidate(pushDownEnd);
 
-    pushDownInlineStyleAroundNode(style, pushDownStart.anchorNode());
-    pushDownInlineStyleAroundNode(style, pushDownEnd.anchorNode());
+    pushDownInlineStyleAroundNode(style, pushDownStart.anchorNode(), editingState);
+    if (editingState->isAborted())
+        return;
+    pushDownInlineStyleAroundNode(style, pushDownEnd.anchorNode(), editingState);
+    if (editingState->isAborted())
+        return;
 
     // The s and e variables store the positions used to set the ending selection after style removal
     // takes place. This will help callers to recognize when either the start node or the end node
     // are removed from the document during the work of this function.
     // If pushDownInlineStyleAroundNode has pruned start.anchorNode() or end.anchorNode(),
     // use pushDownStart or pushDownEnd instead, which pushDownInlineStyleAroundNode won't prune.
     Position s = start.isNull() || start.isOrphan() ? pushDownStart : start;
     Position e = end.isNull() || end.isOrphan() ? pushDownEnd : end;
 
     // Current ending selection resetting algorithm assumes |start| and |end|
@@ skipping 32 matching lines @@
                 if (e.anchorNode() == elem) {
                     // Since elem must have been fully selected, and it is at the end
                     // of the selection, it is clear we can set the new e offset to
                     // the max range offset of prev.
                     ASSERT(s.isAfterAnchor() || !offsetIsBeforeLastNodeOffset(s.offsetInContainerNode(), s.computeContainerNode()));
                     e = lastPositionInOrAfterNode(prev.get());
                 }
             }
 
             if (styleToPushDown) {
-                for (; childNode; childNode = childNode->nextSibling())
-                    applyInlineStyleToPushDown(childNode.get(), styleToPushDown.get());
+                for (; childNode; childNode = childNode->nextSibling()) {
+                    applyInlineStyleToPushDown(childNode.get(), styleToPushDown.get(), editingState);
+                    if (editingState->isAborted())
+                        return;
+                }
             }
         }
         if (node == end.anchorNode())
             break;
         node = next;
     }
 
     updateStartEnd(s, e);
 }
 
@@ skipping 81 matching lines @@
 {
     ASSERT(position.isNotNull());
 
     Node* node = position.computeContainerNode();
     if (!position.isOffsetInAnchor() || !node->isTextNode())
         return false;
     int offsetInText = position.offsetInContainerNode();
     return offsetInText > caretMinOffset(node) && offsetInText < caretMaxOffset(node);
 }
 
-bool ApplyStyleCommand::mergeStartWithPreviousIfIdentical(const Position& start, const Position& end)
+bool ApplyStyleCommand::mergeStartWithPreviousIfIdentical(const Position& start, const Position& end, EditingState* editingState)
 {
     Node* startNode = start.computeContainerNode();
     int startOffset = start.computeOffsetInContainerNode();
     if (startOffset)
         return false;
 
     if (isAtomicNode(startNode)) {
         // note: prior siblings could be unrendered elements. it's silly to miss the
         // merge opportunity just for that.
         if (startNode->previousSibling())
             return false;
 
         startNode = startNode->parentNode();
     }
 
     if (!startNode->isElementNode())
         return false;
 
     Node* previousSibling = startNode->previousSibling();
 
     if (previousSibling && areIdenticalElements(*startNode, *previousSibling)) {
         Element* previousElement = toElement(previousSibling);
         Element* element = toElement(startNode);
         Node* startChild = element->firstChild();
         ASSERT(startChild);
-        mergeIdenticalElements(previousElement, element);
+        mergeIdenticalElements(previousElement, element, editingState);
+        if (editingState->isAborted())
+            return false;
 
         int startOffsetAdjustment = startChild->nodeIndex();
         int endOffsetAdjustment = startNode == end.anchorNode() ? startOffsetAdjustment : 0;
         updateStartEnd(Position(startNode, startOffsetAdjustment),
             Position(end.anchorNode(), end.computeEditingOffset() + endOffsetAdjustment));
         return true;
     }
 
     return false;
 }
 
-bool ApplyStyleCommand::mergeEndWithNextIfIdentical(const Position& start, const Position& end)
+bool ApplyStyleCommand::mergeEndWithNextIfIdentical(const Position& start, const Position& end, EditingState* editingState)
 {
     Node* endNode = end.computeContainerNode();
 
     if (isAtomicNode(endNode)) {
         int endOffset = end.computeOffsetInContainerNode();
         if (offsetIsBeforeLastNodeOffset(endOffset, endNode))
             return false;
 
         if (end.anchorNode()->nextSibling())
             return false;
 
         endNode = end.anchorNode()->parentNode();
     }
 
     if (!endNode->isElementNode() || isHTMLBRElement(*endNode))
         return false;
 
     Node* nextSibling = endNode->nextSibling();
     if (nextSibling && areIdenticalElements(*endNode, *nextSibling)) {
         Element* nextElement = toElement(nextSibling);
         Element* element = toElement(endNode);
         Node* nextChild = nextElement->firstChild();
 
-        mergeIdenticalElements(element, nextElement);
+        mergeIdenticalElements(element, nextElement, editingState);
+        if (editingState->isAborted())
+            return false;
 
         bool shouldUpdateStart = start.computeContainerNode() == endNode;
         int endOffset = nextChild ? nextChild->nodeIndex() : nextElement->childNodes()->length();
         updateStartEnd(shouldUpdateStart ? Position(nextElement, start.offsetInContainerNode()) : start,
             Position(nextElement, endOffset));
         return true;
     }
 
     return false;
 }
@@ skipping 19 matching lines @@
                 return;
         }
         if (node == endNode)
             break;
         node = next;
     }
 
     RefPtrWillBeRawPtr<Node> nextSibling = element->nextSibling();
     RefPtrWillBeRawPtr<Node> previousSibling = element->previousSibling();
     if (nextSibling && nextSibling->isElementNode() && nextSibling->hasEditableStyle()
-        && areIdenticalElements(*element, toElement(*nextSibling)))
-        mergeIdenticalElements(element.get(), toElement(nextSibling));
+        && areIdenticalElements(*element, toElement(*nextSibling))) {
+        mergeIdenticalElements(element.get(), toElement(nextSibling), editingState);
+        if (editingState->isAborted())
+            return;
+    }
 
     if (previousSibling && previousSibling->isElementNode() && previousSibling->hasEditableStyle()) {
         Node* mergedElement = previousSibling->nextSibling();
         if (mergedElement->isElementNode() && mergedElement->hasEditableStyle()
-            && areIdenticalElements(toElement(*previousSibling), toElement(*mergedElement)))
-            mergeIdenticalElements(toElement(previousSibling), toElement(mergedElement));
+            && areIdenticalElements(toElement(*previousSibling), toElement(*mergedElement))) {
+            mergeIdenticalElements(toElement(previousSibling), toElement(mergedElement), editingState);
+            if (editingState->isAborted())
+                return;
+        }
     }
 
     // FIXME: We should probably call updateStartEnd if the start or end was in the node
     // range so that the endingSelection() is canonicalized.  See the comments at the end of
     // VisibleSelection::validate().
 }
 
 void ApplyStyleCommand::addBlockStyle(const StyleChange& styleChange, HTMLElement* block)
 {
     // Do not check for legacy styles here. Those styles, like <B> and <I>, only apply for
     // inline content.
     if (!block)
         return;
 
     String cssStyle = styleChange.cssStyle();
     StringBuilder cssText;
     cssText.append(cssStyle);
     if (const StylePropertySet* decl = block->inlineStyle()) {
         if (!cssStyle.isEmpty())
             cssText.append(' ');
         cssText.append(decl->asText());
     }
     setNodeAttribute(block, styleAttr, cssText.toAtomicString());
 }
 
-void ApplyStyleCommand::addInlineStyleIfNeeded(EditingStyle* style, PassRefPtrWillBeRawPtr<Node> passedStart, PassRefPtrWillBeRawPtr<Node> passedEnd, EAddStyledElement addStyledElement)
+void ApplyStyleCommand::addInlineStyleIfNeeded(EditingStyle* style, PassRefPtrWillBeRawPtr<Node> passedStart, PassRefPtrWillBeRawPtr<Node> passedEnd, EditingState* editingState, EAddStyledElement addStyledElement)
 {
     if (!passedStart || !passedEnd || !passedStart->inDocument() || !passedEnd->inDocument())
         return;
 
     RefPtrWillBeRawPtr<Node> start = passedStart;
     RefPtrWillBeMember<HTMLSpanElement> dummyElement = nullptr;
     StyleChange styleChange(style, positionToComputeInlineStyleChange(start, dummyElement));
 
-    if (dummyElement)
-        removeNode(dummyElement);
+    if (dummyElement) {
+        removeNode(dummyElement, editingState);
+        if (editingState->isAborted())
+            return;
+    }
 
-    applyInlineStyleChange(start, passedEnd, styleChange, addStyledElement, ASSERT_NO_EDITING_ABORT);
+    applyInlineStyleChange(start, passedEnd, styleChange, addStyledElement, editingState);
 }
 
 Position ApplyStyleCommand::positionToComputeInlineStyleChange(PassRefPtrWillBeRawPtr<Node> startNode, RefPtrWillBeMember<HTMLSpanElement>& dummyElement)
 {
     // It's okay to obtain the style at the startNode because we've removed all relevant styles from the current run.
     if (!startNode->isElementNode()) {
         dummyElement = HTMLSpanElement::create(document());
         insertNodeAt(dummyElement, positionBeforeNode(startNode.get()));
         return positionBeforeNode(dummyElement.get());
     }
@@ skipping 148 matching lines @@
         if (!next || !next->isTextNode())
             continue;
 
         Text* nextText = toText(next);
         if (start.isOffsetInAnchor() && next == start.computeContainerNode())
             newStart = Position(childText, childText->length() + start.offsetInContainerNode());
         if (end.isOffsetInAnchor() && next == end.computeContainerNode())
             newEnd = Position(childText, childText->length() + end.offsetInContainerNode());
         String textToMove = nextText->data();
         insertTextIntoNode(childText, childText->length(), textToMove);
-        removeNode(next);
+        // Removing a Text node doesn't dispatch synchronous events.
+        removeNode(next, ASSERT_NO_EDITING_ABORT);
         // don't move child node pointer. it may want to merge with more text nodes.
     }
 
     updateStartEnd(newStart, newEnd);
 }
 
 DEFINE_TRACE(ApplyStyleCommand)
 {
     visitor->trace(m_style);
     visitor->trace(m_start);
     visitor->trace(m_end);
     visitor->trace(m_styledInlineElement);
     CompositeEditCommand::trace(visitor);
 }
 
 } // namespace blink