[InputEvent] Support |deleteByDrag|, |insertFromDrop| and fire in sequential order

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 15 matching lines @@
 #include "core/editing/commands/DeleteSelectionCommand.h"
 
 #include "core/HTMLNames.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/Text.h"
 #include "core/editing/EditingBoundary.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/Editor.h"
+#include "core/editing/RelocatablePosition.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLBRElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLStyleElement.h"
 #include "core/html/HTMLTableRowElement.h"
 #include "core/layout/LayoutTableCell.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 static bool isTableCellEmpty(Node* cell) {
   DCHECK(isTableCell(cell)) << cell;
   return VisiblePosition::firstPositionInNode(cell).deepEquivalent() ==
          VisiblePosition::lastPositionInNode(cell).deepEquivalent();
 }
 
 static bool isTableRowEmpty(Node* row) {
   if (!isHTMLTableRowElement(row))
     return false;
 
   for (Node* child = row->firstChild(); child; child = child->nextSibling()) {
     if (isTableCell(child) && !isTableCellEmpty(child))
       return false;
   }
   return true;
 }
 
-DeleteSelectionCommand::DeleteSelectionCommand(Document& document,
-                                               bool smartDelete,
-                                               bool mergeBlocksAfterDelete,
-                                               bool expandForSpecialElements,
-                                               bool sanitizeMarkup,
-                                               InputEvent::InputType inputType)
+DeleteSelectionCommand::DeleteSelectionCommand(
+    Document& document,
+    bool smartDelete,
+    bool mergeBlocksAfterDelete,
+    bool expandForSpecialElements,
+    bool sanitizeMarkup,
+    InputEvent::InputType inputType,
+    const Position& referenceMovePosition)
     : CompositeEditCommand(document),
       m_hasSelectionToDelete(false),
       m_smartDelete(smartDelete),
       m_mergeBlocksAfterDelete(mergeBlocksAfterDelete),
       m_needPlaceholder(false),
       m_expandForSpecialElements(expandForSpecialElements),
       m_pruneStartBlockIfNecessary(false),
       m_startsAtEmptyLine(false),
       m_sanitizeMarkup(sanitizeMarkup),
       m_inputType(inputType),
+      m_referenceMovePosition(referenceMovePosition),
       m_startBlock(nullptr),
       m_endBlock(nullptr),
       m_typingStyle(nullptr),
       m_deleteIntoBlockquoteStyle(nullptr) {}
 
 DeleteSelectionCommand::DeleteSelectionCommand(
     const VisibleSelection& selection,
     bool smartDelete,
     bool mergeBlocksAfterDelete,
     bool expandForSpecialElements,
@@ skipping 850 matching lines @@
 
 void DeleteSelectionCommand::clearTransientState() {
   m_selectionToDelete = VisibleSelection();
   m_upstreamStart = Position();
   m_downstreamStart = Position();
   m_upstreamEnd = Position();
   m_downstreamEnd = Position();
   m_endingPosition = Position();
   m_leadingWhitespace = Position();
   m_trailingWhitespace = Position();
+  m_referenceMovePosition = Position();
 }
 
 // This method removes div elements with no attributes that have only one child or no children at all.
 void DeleteSelectionCommand::removeRedundantBlocks(EditingState* editingState) {
   Node* node = m_endingPosition.computeContainerNode();
   Element* rootElement = rootEditableElement(*node);
 
   while (node != rootElement) {
     if (isRemovableBlock(node)) {
       if (node == m_endingPosition.anchorNode())
@@ skipping 12 matching lines @@
 void DeleteSelectionCommand::doApply(EditingState* editingState) {
   // If selection has not been set to a custom selection when the command was created,
   // use the current ending selection.
   if (!m_hasSelectionToDelete)
     m_selectionToDelete = endingSelection();
 
   if (!m_selectionToDelete.isNonOrphanedRange() ||
       !m_selectionToDelete.isContentEditable())
     return;
 
+  RelocatablePosition relocatableReferencePosition(m_referenceMovePosition);
+
   // save this to later make the selection with
   TextAffinity affinity = m_selectionToDelete.affinity();
 
   Position downstreamEnd = mostForwardCaretPosition(m_selectionToDelete.end());
   bool rootWillStayOpenWithoutPlaceholder =
       downstreamEnd.computeContainerNode() ==
           rootEditableElement(*downstreamEnd.computeContainerNode()) ||
       (downstreamEnd.computeContainerNode()->isTextNode() &&
        downstreamEnd.computeContainerNode()->parentNode() ==
            rootEditableElement(*downstreamEnd.computeContainerNode()));
@@ skipping 86 matching lines @@
         return;
     }
   }
 
   rebalanceWhitespaceAt(m_endingPosition);
 
   calculateTypingStyleAfterDelete();
 
   setEndingSelection(createVisibleSelectionDeprecated(
       m_endingPosition, affinity, endingSelection().isDirectional()));
+
+  if (relocatableReferencePosition.position().isNull()) {
+    clearTransientState();
+    return;
+  }
+
+  // This deletion command is part of a move operation, we need to cleanup after deletion.
+  m_referenceMovePosition = relocatableReferencePosition.position();
+  // If the node for the destination has been removed as a result of the deletion,
+  // set the destination to the ending point after the deletion.
+  // Fixes: <rdar://problem/3910425> REGRESSION (Mail): Crash in ReplaceSelectionCommand;
+  //        selection is empty, leading to null deref
+  if (!m_referenceMovePosition.isConnected())
+    m_referenceMovePosition = endingSelection().start();
+
+  // Move selection shouldn't left empty <li> block.
+  cleanupAfterDeletion(
+      editingState, createVisiblePositionDeprecated(m_referenceMovePosition));
+  if (editingState->isAborted())
+    return;
+
   clearTransientState();
 }
 
 InputEvent::InputType DeleteSelectionCommand::inputType() const {
   // |DeleteSelectionCommand| could be used with Cut, Menu Bar deletion and |TypingCommand|.
   // 1. Cut and Menu Bar deletion should rely on correct |m_inputType|.
   // 2. |TypingCommand| will supply the |inputType()|, so |m_inputType| could default to |InputType::None|.
   return m_inputType;
 }
 
 // Normally deletion doesn't preserve the typing style that was present before it.  For example,
 // type a character, Bold, then delete the character and start typing.  The Bold typing style shouldn't
 // stick around.  Deletion should preserve a typing style that *it* sets, however.
 bool DeleteSelectionCommand::preservesTypingStyle() const {
   return m_typingStyle;
 }
 
 DEFINE_TRACE(DeleteSelectionCommand) {
   visitor->trace(m_selectionToDelete);
   visitor->trace(m_upstreamStart);
   visitor->trace(m_downstreamStart);
   visitor->trace(m_upstreamEnd);
   visitor->trace(m_downstreamEnd);
   visitor->trace(m_endingPosition);
   visitor->trace(m_leadingWhitespace);
   visitor->trace(m_trailingWhitespace);
+  visitor->trace(m_referenceMovePosition);
   visitor->trace(m_startBlock);
   visitor->trace(m_endBlock);
   visitor->trace(m_typingStyle);
   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