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

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

 /*
  * Copyright (C) 2006, 2010 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 32 matching lines @@
 using namespace HTMLNames;
 
 static Node* enclosingListChild(Node* node, Node* listNode)
 {
     Node* listChild = enclosingListChild(node);
     while (listChild && enclosingList(listChild) != listNode)
         listChild = enclosingListChild(listChild->parentNode());
     return listChild;
 }
 
-HTMLUListElement* InsertListCommand::fixOrphanedListChild(Node* node)
+HTMLUListElement* InsertListCommand::fixOrphanedListChild(Node* node, EditingState* editingState)
 {
     RefPtrWillBeRawPtr<HTMLUListElement> listElement = HTMLUListElement::create(document());
-    insertNodeBefore(listElement, node);
-    removeNode(node);
-    appendNode(node, listElement);
+    insertNodeBefore(listElement, node, editingState);
+    if (editingState->isAborted())
+        return nullptr;
+    removeNode(node, editingState);
+    if (editingState->isAborted())
+        return nullptr;
+    appendNode(node, listElement, editingState);
+    if (editingState->isAborted())
+        return nullptr;
     return listElement.get();
 }
 
-PassRefPtrWillBeRawPtr<HTMLElement> InsertListCommand::mergeWithNeighboringLists(PassRefPtrWillBeRawPtr<HTMLElement> passedList)
+PassRefPtrWillBeRawPtr<HTMLElement> InsertListCommand::mergeWithNeighboringLists(PassRefPtrWillBeRawPtr<HTMLElement> passedList, EditingState* editingState)
 {
     RefPtrWillBeRawPtr<HTMLElement> list = passedList;
     Element* previousList = ElementTraversal::previousSibling(*list);
-    if (canMergeLists(previousList, list.get()))
-        mergeIdenticalElements(previousList, list);
+    if (canMergeLists(previousList, list.get())) {
+        mergeIdenticalElements(previousList, list, editingState);
+        if (editingState->isAborted())
+            return nullptr;
+    }
 
     if (!list)
         return nullptr;
 
     Element* nextSibling = ElementTraversal::nextSibling(*list);
     if (!nextSibling || !nextSibling->isHTMLElement())
         return list.release();
 
     RefPtrWillBeRawPtr<HTMLElement> nextList = toHTMLElement(nextSibling);
     if (canMergeLists(list.get(), nextList.get())) {
-        mergeIdenticalElements(list, nextList);
+        mergeIdenticalElements(list, nextList, editingState);
+        if (editingState->isAborted())
+            return nullptr;
         return nextList.release();
     }
     return list.release();
 }
 
 bool InsertListCommand::selectionHasListOfType(const VisibleSelection& selection, const HTMLQualifiedName& listTag)
 {
     VisiblePosition start = selection.visibleStart();
 
     if (!enclosingList(start.deepEquivalent().anchorNode()))
@@ skipping 141 matching lines @@
                 // out from |listElement|.
                 return false;
             }
             if (!listElement->parentNode()->hasEditableStyle()) {
                 // Since parent of |listElement| is uneditable, we can not remove
                 // |listElement| for switching list type neither unlistify.
                 return false;
             }
         }
         if (!listElement) {
-            listElement = fixOrphanedListChild(listChildNode);
-            listElement = mergeWithNeighboringLists(listElement);
+            listElement = fixOrphanedListChild(listChildNode, editingState);
+            if (editingState->isAborted())
+                return false;
+            listElement = mergeWithNeighboringLists(listElement, editingState);
+            if (editingState->isAborted())
+                return false;
         }
         ASSERT(listElement->hasEditableStyle());
         ASSERT(listElement->parentNode()->hasEditableStyle());
         if (!listElement->hasTagName(listTag)) {
             // |listChildNode| will be removed from the list and a list of type
             // |m_type| will be created.
             switchListType = true;
         }
 
         // If the list is of the desired type, and we are not removing the list,
         // then exit early.
         if (!switchListType && forceCreateList)
             return true;
 
         // If the entire list is selected, then convert the whole list.
         if (switchListType && isNodeVisiblyContainedWithin(*listElement, currentSelection)) {
             bool rangeStartIsInList = visiblePositionBeforeNode(*listElement).deepEquivalent() == createVisiblePosition(currentSelection.startPosition()).deepEquivalent();
             bool rangeEndIsInList = visiblePositionAfterNode(*listElement).deepEquivalent() == createVisiblePosition(currentSelection.endPosition()).deepEquivalent();
 
             RefPtrWillBeRawPtr<HTMLElement> newList = createHTMLElement(document(), listTag);
-            insertNodeBefore(newList, listElement);
+            insertNodeBefore(newList, listElement, editingState);
+            if (editingState->isAborted())
+                return false;
 
             Node* firstChildInList = enclosingListChild(createVisiblePosition(firstPositionInNode(listElement.get())).deepEquivalent().anchorNode(), listElement.get());
             Element* outerBlock = firstChildInList && isBlockFlowElement(*firstChildInList) ? toElement(firstChildInList) : listElement.get();
 
-            moveParagraphWithClones(createVisiblePosition(firstPositionInNode(listElement.get())), createVisiblePosition(lastPositionInNode(listElement.get())), newList.get(), outerBlock);
+            moveParagraphWithClones(createVisiblePosition(firstPositionInNode(listElement.get())), createVisiblePosition(lastPositionInNode(listElement.get())), newList.get(), outerBlock, editingState);
+            if (editingState->isAborted())
+                return false;
 
             // Manually remove listNode because moveParagraphWithClones sometimes leaves it behind in the document.
             // See the bug 33668 and editing/execCommand/insert-list-orphaned-item-with-nested-lists.html.
             // FIXME: This might be a bug in moveParagraphWithClones or deleteSelection.
-            if (listElement && listElement->inDocument())
-                removeNode(listElement);
+            if (listElement && listElement->inDocument()) {
+                removeNode(listElement, editingState);
+                if (editingState->isAborted())
+                    return false;
+            }
 
-            newList = mergeWithNeighboringLists(newList);
+            newList = mergeWithNeighboringLists(newList, editingState);
+            if (editingState->isAborted())
+                return false;
 
             // Restore the start and the end of current selection if they started inside listNode
             // because moveParagraphWithClones could have removed them.
             if (rangeStartIsInList && newList)
                 currentSelection.setStart(newList, 0, IGNORE_EXCEPTION);
             if (rangeEndIsInList && newList)
                 currentSelection.setEnd(newList, lastOffsetInNode(newList.get()), IGNORE_EXCEPTION);
 
             setEndingSelection(createVisiblePosition(firstPositionInNode(newList.get())));
 
@@ skipping 108 matching lines @@
         else
             insertNodeAt(listItemElement, Position::beforeNode(nextList), editingState);
         if (editingState->isAborted())
             return;
 
         moveParagraphOverPositionIntoEmptyListItem(start, listItemElement, editingState);
         if (editingState->isAborted())
             return;
 
         if (canMergeLists(previousList, nextList))
-            mergeIdenticalElements(previousList, nextList);
+            mergeIdenticalElements(previousList, nextList, editingState);
 
         return;
     }
 
     // Create new list element.
 
     // Inserting the list into an empty paragraph that isn't held open
     // by a br or a '\n', will invalidate start and end.  Insert
     // a placeholder and then recompute start and end.
     Position startPos = start.deepEquivalent();
@@ skipping 26 matching lines @@
     // Update the start of content, so we don't try to move the list into itself.  bug 19066
     // Layout is necessary since start's node's inline layoutObjects may have been destroyed by the insertion
     // The end of the content may have changed after the insertion and layout so update it as well.
     if (insertionPos == startPos)
         moveParagraphOverPositionIntoEmptyListItem(originalStart, listItemElement, editingState);
     else
         moveParagraphOverPositionIntoEmptyListItem(createVisiblePosition(startPos), listItemElement, editingState);
     if (editingState->isAborted())
         return;
 
-    mergeWithNeighboringLists(listElement);
+    mergeWithNeighboringLists(listElement, editingState);
 }
 
 void InsertListCommand::moveParagraphOverPositionIntoEmptyListItem(const VisiblePosition& pos, PassRefPtrWillBeRawPtr<HTMLLIElement> listItemElement, EditingState* editingState)
 {
     ASSERT(!listItemElement->hasChildren());
     const RefPtrWillBeRawPtr<HTMLBRElement> placeholder = HTMLBRElement::create(document());
     appendNode(placeholder, listItemElement, editingState);
     if (editingState->isAborted())
         return;
     // Inserting list element and list item list may change start of pargraph
     // to move. We calculate start of paragraph again.
     document().updateLayoutIgnorePendingStylesheets();
     const VisiblePosition& start = startOfParagraph(pos, CanSkipOverEditingBoundary);
     const VisiblePosition& end = endOfParagraph(pos, CanSkipOverEditingBoundary);
     moveParagraph(start, end, createVisiblePosition(positionBeforeNode(placeholder.get())), editingState, true);
 }
 
 DEFINE_TRACE(InsertListCommand)
 {
     CompositeEditCommand::trace(visitor);
 }
 
 } // namespace blink