src/third_party/WebKit/Source/core/editing/DeleteSelectionCommand.cpp

   1 /*
   2  * Copyright (C) 2005 Apple Computer, Inc.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "core/editing/DeleteSelectionCommand.h"
  28
  29 #include "core/HTMLNames.h"
  30 #include "core/dom/Document.h"
  31 #include "core/dom/Element.h"
  32 #include "core/dom/NodeTraversal.h"
  33 #include "core/dom/Text.h"
  34 #include "core/editing/EditingBoundary.h"
  35 #include "core/editing/Editor.h"
  36 #include "core/editing/VisibleUnits.h"
  37 #include "core/editing/htmlediting.h"
  38 #include "core/frame/LocalFrame.h"
  39 #include "core/html/HTMLBRElement.h"
  40 #include "core/html/HTMLInputElement.h"
  41 #include "core/html/HTMLStyleElement.h"
  42 #include "core/html/HTMLTableRowElement.h"
  43 #include "core/rendering/RenderTableCell.h"
  44 #include "core/rendering/RenderText.h"
  45
  46 namespace blink {
  47
  48 using namespace HTMLNames;
  49
  50 static bool isTableCellEmpty(Node* cell)
  51 {
  52     ASSERT(isTableCell(cell));
  53     return VisiblePosition(firstPositionInNode(cell)) == VisiblePosition(lastPositionInNode(cell));
  54 }
  55
  56 static bool isTableRowEmpty(Node* row)
  57 {
  58     if (!isHTMLTableRowElement(row))
  59         return false;
  60
  61     for (Node* child = row->firstChild(); child; child = child->nextSibling())
  62         if (isTableCell(child) && !isTableCellEmpty(child))
  63             return false;
  64
  65     return true;
  66 }
  67
  68 DeleteSelectionCommand::DeleteSelectionCommand(Document& document, bool smartDelete, bool mergeBlocksAfterDelete, bool expandForSpecialElements, bool sanitizeMarkup)
  69     : CompositeEditCommand(document)
  70     , m_hasSelectionToDelete(false)
  71     , m_smartDelete(smartDelete)
  72     , m_mergeBlocksAfterDelete(mergeBlocksAfterDelete)
  73     , m_needPlaceholder(false)
  74     , m_expandForSpecialElements(expandForSpecialElements)
  75     , m_pruneStartBlockIfNecessary(false)
  76     , m_startsAtEmptyLine(false)
  77     , m_sanitizeMarkup(sanitizeMarkup)
  78     , m_startBlock(nullptr)
  79     , m_endBlock(nullptr)
  80     , m_typingStyle(nullptr)
  81     , m_deleteIntoBlockquoteStyle(nullptr)
  82 {
  83 }
  84
  85 DeleteSelectionCommand::DeleteSelectionCommand(const VisibleSelection& selection, bool smartDelete, bool mergeBlocksAfterDelete, bool expandForSpecialElements, bool sanitizeMarkup)
  86     : CompositeEditCommand(*selection.start().document())
  87     , m_hasSelectionToDelete(true)
  88     , m_smartDelete(smartDelete)
  89     , m_mergeBlocksAfterDelete(mergeBlocksAfterDelete)
  90     , m_needPlaceholder(false)
  91     , m_expandForSpecialElements(expandForSpecialElements)
  92     , m_pruneStartBlockIfNecessary(false)
  93     , m_startsAtEmptyLine(false)
  94     , m_sanitizeMarkup(sanitizeMarkup)
  95     , m_selectionToDelete(selection)
  96     , m_startBlock(nullptr)
  97     , m_endBlock(nullptr)
  98     , m_typingStyle(nullptr)
  99     , m_deleteIntoBlockquoteStyle(nullptr)
 100 {
 101 }
 102
 103 void DeleteSelectionCommand::initializeStartEnd(Position& start, Position& end)
 104 {
 105     HTMLElement* startSpecialContainer = 0;
 106     HTMLElement* endSpecialContainer = 0;
 107
 108     start = m_selectionToDelete.start();
 109     end = m_selectionToDelete.end();
 110
 111     // For HRs, we'll get a position at (HR,1) when hitting delete from the beginning of the previous line, or (HR,0) when forward deleting,
 112     // but in these cases, we want to delete it, so manually expand the selection
 113     if (isHTMLHRElement(*start.deprecatedNode()))
 114         start = positionBeforeNode(start.deprecatedNode());
 115     else if (isHTMLHRElement(*end.deprecatedNode()))
 116         end = positionAfterNode(end.deprecatedNode());
 117
 118     // FIXME: This is only used so that moveParagraphs can avoid the bugs in special element expansion.
 119     if (!m_expandForSpecialElements)
 120         return;
 121
 122     while (1) {
 123         startSpecialContainer = 0;
 124         endSpecialContainer = 0;
 125
 126         Position s = positionBeforeContainingSpecialElement(start, &startSpecialContainer);
 127         Position e = positionAfterContainingSpecialElement(end, &endSpecialContainer);
 128
 129         if (!startSpecialContainer && !endSpecialContainer)
 130             break;
 131
 132         if (VisiblePosition(start) != m_selectionToDelete.visibleStart() || VisiblePosition(end) != m_selectionToDelete.visibleEnd())
 133             break;
 134
 135         // If we're going to expand to include the startSpecialContainer, it must be fully selected.
 136         if (startSpecialContainer && !endSpecialContainer && comparePositions(positionInParentAfterNode(*startSpecialContainer), end) > -1)
 137             break;
 138
 139         // If we're going to expand to include the endSpecialContainer, it must be fully selected.
 140         if (endSpecialContainer && !startSpecialContainer && comparePositions(start, positionInParentBeforeNode(*endSpecialContainer)) > -1)
 141             break;
 142
 143         if (startSpecialContainer && startSpecialContainer->isDescendantOf(endSpecialContainer))
 144             // Don't adjust the end yet, it is the end of a special element that contains the start
 145             // special element (which may or may not be fully selected).
 146             start = s;
 147         else if (endSpecialContainer && endSpecialContainer->isDescendantOf(startSpecialContainer))
 148             // Don't adjust the start yet, it is the start of a special element that contains the end
 149             // special element (which may or may not be fully selected).
 150             end = e;
 151         else {
 152             start = s;
 153             end = e;
 154         }
 155     }
 156 }
 157
 158 void DeleteSelectionCommand::setStartingSelectionOnSmartDelete(const Position& start, const Position& end)
 159 {
 160     bool isBaseFirst = startingSelection().isBaseFirst();
 161     VisiblePosition newBase(isBaseFirst ? start : end);
 162     VisiblePosition newExtent(isBaseFirst ? end : start);
 163     setStartingSelection(VisibleSelection(newBase, newExtent, startingSelection().isDirectional()));
 164 }
 165
 166 void DeleteSelectionCommand::initializePositionData()
 167 {
 168     Position start, end;
 169     initializeStartEnd(start, end);
 170
 171     ASSERT(isEditablePosition(start, ContentIsEditable, DoNotUpdateStyle));
 172     if (!isEditablePosition(end, ContentIsEditable, DoNotUpdateStyle))
 173         end = lastEditablePositionBeforePositionInRoot(end, highestEditableRoot(start));
 174
 175     m_upstreamStart = start.upstream();
 176     m_downstreamStart = start.downstream();
 177     m_upstreamEnd = end.upstream();
 178     m_downstreamEnd = end.downstream();
 179
 180     m_startRoot = editableRootForPosition(start);
 181     m_endRoot = editableRootForPosition(end);
 182
 183     m_startTableRow = toHTMLTableRowElement(enclosingNodeOfType(start, &isHTMLTableRowElement));
 184     m_endTableRow = toHTMLTableRowElement(enclosingNodeOfType(end, &isHTMLTableRowElement));
 185
 186     // Don't move content out of a table cell.
 187     // If the cell is non-editable, enclosingNodeOfType won't return it by default, so
 188     // tell that function that we don't care if it returns non-editable nodes.
 189     Node* startCell = enclosingNodeOfType(m_upstreamStart, &isTableCell, CanCrossEditingBoundary);
 190     Node* endCell = enclosingNodeOfType(m_downstreamEnd, &isTableCell, CanCrossEditingBoundary);
 191     // FIXME: This isn't right.  A borderless table with two rows and a single column would appear as two paragraphs.
 192     if (endCell && endCell != startCell)
 193         m_mergeBlocksAfterDelete = false;
 194
 195     // Usually the start and the end of the selection to delete are pulled together as a result of the deletion.
 196     // Sometimes they aren't (like when no merge is requested), so we must choose one position to hold the caret
 197     // and receive the placeholder after deletion.
 198     VisiblePosition visibleEnd(m_downstreamEnd);
 199     if (m_mergeBlocksAfterDelete && !isEndOfParagraph(visibleEnd))
 200         m_endingPosition = m_downstreamEnd;
 201     else
 202         m_endingPosition = m_downstreamStart;
 203
 204     // We don't want to merge into a block if it will mean changing the quote level of content after deleting
 205     // selections that contain a whole number paragraphs plus a line break, since it is unclear to most users
 206     // that such a selection actually ends at the start of the next paragraph. This matches TextEdit behavior
 207     // for indented paragraphs.
 208     // Only apply this rule if the endingSelection is a range selection.  If it is a caret, then other operations have created
 209     // the selection we're deleting (like the process of creating a selection to delete during a backspace), and the user isn't in the situation described above.
 210     if (numEnclosingMailBlockquotes(start) != numEnclosingMailBlockquotes(end)
 211             && isStartOfParagraph(visibleEnd) && isStartOfParagraph(VisiblePosition(start))
 212             && endingSelection().isRange()) {
 213         m_mergeBlocksAfterDelete = false;
 214         m_pruneStartBlockIfNecessary = true;
 215     }
 216
 217     // Handle leading and trailing whitespace, as well as smart delete adjustments to the selection
 218     m_leadingWhitespace = leadingWhitespacePosition(m_upstreamStart, m_selectionToDelete.affinity());
 219     m_trailingWhitespace = trailingWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY);
 220
 221     if (m_smartDelete) {
 222
 223         // skip smart delete if the selection to delete already starts or ends with whitespace
 224         Position pos = VisiblePosition(m_upstreamStart, m_selectionToDelete.affinity()).deepEquivalent();
 225         bool skipSmartDelete = trailingWhitespacePosition(pos, VP_DEFAULT_AFFINITY, ConsiderNonCollapsibleWhitespace).isNotNull();
 226         if (!skipSmartDelete)
 227             skipSmartDelete = leadingWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY, ConsiderNonCollapsibleWhitespace).isNotNull();
 228
 229         // extend selection upstream if there is whitespace there
 230         bool hasLeadingWhitespaceBeforeAdjustment = leadingWhitespacePosition(m_upstreamStart, m_selectionToDelete.affinity(), ConsiderNonCollapsibleWhitespace).isNotNull();
 231         if (!skipSmartDelete && hasLeadingWhitespaceBeforeAdjustment) {
 232             VisiblePosition visiblePos = VisiblePosition(m_upstreamStart, VP_DEFAULT_AFFINITY).previous();
 233             pos = visiblePos.deepEquivalent();
 234             // Expand out one character upstream for smart delete and recalculate
 235             // positions based on this change.
 236             m_upstreamStart = pos.upstream();
 237             m_downstreamStart = pos.downstream();
 238             m_leadingWhitespace = leadingWhitespacePosition(m_upstreamStart, visiblePos.affinity());
 239
 240             setStartingSelectionOnSmartDelete(m_upstreamStart, m_upstreamEnd);
 241         }
 242
 243         // trailing whitespace is only considered for smart delete if there is no leading
 244         // whitespace, as in the case where you double-click the first word of a paragraph.
 245         if (!skipSmartDelete && !hasLeadingWhitespaceBeforeAdjustment && trailingWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY, ConsiderNonCollapsibleWhitespace).isNotNull()) {
 246             // Expand out one character downstream for smart delete and recalculate
 247             // positions based on this change.
 248             pos = VisiblePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY).next().deepEquivalent();
 249             m_upstreamEnd = pos.upstream();
 250             m_downstreamEnd = pos.downstream();
 251             m_trailingWhitespace = trailingWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY);
 252
 253             setStartingSelectionOnSmartDelete(m_downstreamStart, m_downstreamEnd);
 254         }
 255     }
 256
 257     // We must pass call parentAnchoredEquivalent on the positions since some editing positions
 258     // that appear inside their nodes aren't really inside them.  [hr, 0] is one example.
 259     // FIXME: parentAnchoredEquivalent should eventually be moved into enclosing element getters
 260     // like the one below, since editing functions should obviously accept editing positions.
 261     // FIXME: Passing false to enclosingNodeOfType tells it that it's OK to return a non-editable
 262     // node.  This was done to match existing behavior, but it seems wrong.
 263     m_startBlock = enclosingNodeOfType(m_downstreamStart.parentAnchoredEquivalent(), &isBlock, CanCrossEditingBoundary);
 264     m_endBlock = enclosingNodeOfType(m_upstreamEnd.parentAnchoredEquivalent(), &isBlock, CanCrossEditingBoundary);
 265 }
 266
 267 // We don't want to inherit style from an element which can't have contents.
 268 static bool shouldNotInheritStyleFrom(const Node& node)
 269 {
 270     return !node.canContainRangeEndPoint();
 271 }
 272
 273 void DeleteSelectionCommand::saveTypingStyleState()
 274 {
 275     // A common case is deleting characters that are all from the same text node. In
 276     // that case, the style at the start of the selection before deletion will be the
 277     // same as the style at the start of the selection after deletion (since those
 278     // two positions will be identical). Therefore there is no need to save the
 279     // typing style at the start of the selection, nor is there a reason to
 280     // compute the style at the start of the selection after deletion (see the
 281     // early return in calculateTypingStyleAfterDelete).
 282     if (m_upstreamStart.deprecatedNode() == m_downstreamEnd.deprecatedNode() && m_upstreamStart.deprecatedNode()->isTextNode())
 283         return;
 284
 285     if (shouldNotInheritStyleFrom(*m_selectionToDelete.start().anchorNode()))
 286         return;
 287
 288     // Figure out the typing style in effect before the delete is done.
 289     m_typingStyle = EditingStyle::create(m_selectionToDelete.start(), EditingStyle::EditingPropertiesInEffect);
 290     m_typingStyle->removeStyleAddedByElement(enclosingAnchorElement(m_selectionToDelete.start()));
 291
 292     // If we're deleting into a Mail blockquote, save the style at end() instead of start()
 293     // We'll use this later in computeTypingStyleAfterDelete if we end up outside of a Mail blockquote
 294     if (enclosingNodeOfType(m_selectionToDelete.start(), isMailHTMLBlockquoteElement))
 295         m_deleteIntoBlockquoteStyle = EditingStyle::create(m_selectionToDelete.end());
 296     else
 297         m_deleteIntoBlockquoteStyle = nullptr;
 298 }
 299
 300 bool DeleteSelectionCommand::handleSpecialCaseBRDelete()
 301 {
 302     Node* nodeAfterUpstreamStart = m_upstreamStart.computeNodeAfterPosition();
 303     Node* nodeAfterDownstreamStart = m_downstreamStart.computeNodeAfterPosition();
 304     // Upstream end will appear before BR due to canonicalization
 305     Node* nodeAfterUpstreamEnd = m_upstreamEnd.computeNodeAfterPosition();
 306
 307     if (!nodeAfterUpstreamStart || !nodeAfterDownstreamStart)
 308         return false;
 309
 310     // Check for special-case where the selection contains only a BR on a line by itself after another BR.
 311     bool upstreamStartIsBR = isHTMLBRElement(*nodeAfterUpstreamStart);
 312     bool downstreamStartIsBR = isHTMLBRElement(*nodeAfterDownstreamStart);
 313     bool isBROnLineByItself = upstreamStartIsBR && downstreamStartIsBR && nodeAfterDownstreamStart == nodeAfterUpstreamEnd;
 314     if (isBROnLineByItself) {
 315         removeNode(nodeAfterDownstreamStart);
 316         return true;
 317     }
 318
 319     // FIXME: This code doesn't belong in here.
 320     // We detect the case where the start is an empty line consisting of BR not wrapped in a block element.
 321     if (upstreamStartIsBR && downstreamStartIsBR && !(isStartOfBlock(VisiblePosition(positionBeforeNode(nodeAfterUpstreamStart))) && isEndOfBlock(VisiblePosition(positionAfterNode(nodeAfterUpstreamStart))))) {
 322         m_startsAtEmptyLine = true;
 323         m_endingPosition = m_downstreamEnd;
 324     }
 325
 326     return false;
 327 }
 328
 329 static Position firstEditablePositionInNode(Node* node)
 330 {
 331     ASSERT(node);
 332     Node* next = node;
 333     while (next && !next->hasEditableStyle())
 334         next = NodeTraversal::next(*next, node);
 335     return next ? firstPositionInOrBeforeNode(next) : Position();
 336 }
 337
 338 void DeleteSelectionCommand::removeNode(PassRefPtrWillBeRawPtr<Node> node, ShouldAssumeContentIsAlwaysEditable shouldAssumeContentIsAlwaysEditable)
 339 {
 340     if (!node)
 341         return;
 342
 343     if (m_startRoot != m_endRoot && !(node->isDescendantOf(m_startRoot.get()) && node->isDescendantOf(m_endRoot.get()))) {
 344         // If a node is not in both the start and end editable roots, remove it only if its inside an editable region.
 345         if (!node->parentNode()->hasEditableStyle()) {
 346             // Don't remove non-editable atomic nodes.
 347             if (!node->hasChildren())
 348                 return;
 349             // Search this non-editable region for editable regions to empty.
 350             RefPtrWillBeRawPtr<Node> child = node->firstChild();
 351             while (child) {
 352                 RefPtrWillBeRawPtr<Node> nextChild = child->nextSibling();
 353                 removeNode(child.get(), shouldAssumeContentIsAlwaysEditable);
 354                 // Bail if nextChild is no longer node's child.
 355                 if (nextChild && nextChild->parentNode() != node)
 356                     return;
 357                 child = nextChild;
 358             }
 359
 360             // Don't remove editable regions that are inside non-editable ones, just clear them.
 361             return;
 362         }
 363     }
 364
 365     if (isTableStructureNode(node.get()) || node->isRootEditableElement()) {
 366         // Do not remove an element of table structure; remove its contents.
 367         // Likewise for the root editable element.
 368         Node* child = node->firstChild();
 369         while (child) {
 370             Node* remove = child;
 371             child = child->nextSibling();
 372             removeNode(remove, shouldAssumeContentIsAlwaysEditable);
 373         }
 374
 375         // Make sure empty cell has some height, if a placeholder can be inserted.
 376         document().updateLayoutIgnorePendingStylesheets();
 377         RenderObject *r = node->renderer();
 378         if (r && r->isTableCell() && toRenderTableCell(r)->contentHeight() <= 0) {
 379             Position firstEditablePosition = firstEditablePositionInNode(node.get());
 380             if (firstEditablePosition.isNotNull())
 381                 insertBlockPlaceholder(firstEditablePosition);
 382         }
 383         return;
 384     }
 385
 386     if (node == m_startBlock) {
 387         VisiblePosition previous = VisiblePosition(firstPositionInNode(m_startBlock.get())).previous();
 388         if (previous.isNotNull() && !isEndOfBlock(previous))
 389             m_needPlaceholder = true;
 390     }
 391     if (node == m_endBlock) {
 392         VisiblePosition next = VisiblePosition(lastPositionInNode(m_endBlock.get())).next();
 393         if (next.isNotNull() && !isStartOfBlock(next))
 394             m_needPlaceholder = true;
 395     }
 396
 397     // FIXME: Update the endpoints of the range being deleted.
 398     updatePositionForNodeRemoval(m_endingPosition, *node);
 399     updatePositionForNodeRemoval(m_leadingWhitespace, *node);
 400     updatePositionForNodeRemoval(m_trailingWhitespace, *node);
 401
 402     CompositeEditCommand::removeNode(node, shouldAssumeContentIsAlwaysEditable);
 403 }
 404
 405 static void updatePositionForTextRemoval(Text* node, int offset, int count, Position& position)
 406 {
 407     if (position.anchorType() != Position::PositionIsOffsetInAnchor || position.containerNode() != node)
 408         return;
 409
 410     if (position.offsetInContainerNode() > offset + count)
 411         position.moveToOffset(position.offsetInContainerNode() - count);
 412     else if (position.offsetInContainerNode() > offset)
 413         position.moveToOffset(offset);
 414 }
 415
 416 void DeleteSelectionCommand::deleteTextFromNode(PassRefPtrWillBeRawPtr<Text> node, unsigned offset, unsigned count)
 417 {
 418     // FIXME: Update the endpoints of the range being deleted.
 419     updatePositionForTextRemoval(node.get(), offset, count, m_endingPosition);
 420     updatePositionForTextRemoval(node.get(), offset, count, m_leadingWhitespace);
 421     updatePositionForTextRemoval(node.get(), offset, count, m_trailingWhitespace);
 422     updatePositionForTextRemoval(node.get(), offset, count, m_downstreamEnd);
 423
 424     CompositeEditCommand::deleteTextFromNode(node, offset, count);
 425 }
 426
 427 void DeleteSelectionCommand::makeStylingElementsDirectChildrenOfEditableRootToPreventStyleLoss()
 428 {
 429     RefPtrWillBeRawPtr<Range> range = m_selectionToDelete.toNormalizedRange();
 430     RefPtrWillBeRawPtr<Node> node = range->firstNode();
 431     while (node && node != range->pastLastNode()) {
 432         RefPtrWillBeRawPtr<Node> nextNode = NodeTraversal::next(*node);
 433         if (isHTMLStyleElement(*node) || isHTMLLinkElement(*node)) {
 434             nextNode = NodeTraversal::nextSkippingChildren(*node);
 435             RefPtrWillBeRawPtr<Element> rootEditableElement = node->rootEditableElement();
 436             if (rootEditableElement.get()) {
 437                 removeNode(node);
 438                 appendNode(node, rootEditableElement);
 439             }
 440         }
 441         node = nextNode;
 442     }
 443 }
 444
 445 void DeleteSelectionCommand::handleGeneralDelete()
 446 {
 447     if (m_upstreamStart.isNull())
 448         return;
 449
 450     int startOffset = m_upstreamStart.deprecatedEditingOffset();
 451     Node* startNode = m_upstreamStart.deprecatedNode();
 452     ASSERT(startNode);
 453
 454     makeStylingElementsDirectChildrenOfEditableRootToPreventStyleLoss();
 455
 456     // Never remove the start block unless it's a table, in which case we won't merge content in.
 457     if (startNode->isSameNode(m_startBlock.get()) && !startOffset && canHaveChildrenForEditing(startNode) && !isHTMLTableElement(*startNode)) {
 458         startOffset = 0;
 459         startNode = NodeTraversal::next(*startNode);
 460         if (!startNode)
 461             return;
 462     }
 463
 464     if (startOffset >= caretMaxOffset(startNode) && startNode->isTextNode()) {
 465         Text* text = toText(startNode);
 466         if (text->length() > (unsigned)caretMaxOffset(startNode))
 467             deleteTextFromNode(text, caretMaxOffset(startNode), text->length() - caretMaxOffset(startNode));
 468     }
 469
 470     if (startOffset >= lastOffsetForEditing(startNode)) {
 471         startNode = NodeTraversal::nextSkippingChildren(*startNode);
 472         startOffset = 0;
 473     }
 474
 475     // Done adjusting the start.  See if we're all done.
 476     if (!startNode)
 477         return;
 478
 479     if (startNode == m_downstreamEnd.deprecatedNode()) {
 480         if (m_downstreamEnd.deprecatedEditingOffset() - startOffset > 0) {
 481             if (startNode->isTextNode()) {
 482                 // in a text node that needs to be trimmed
 483                 Text* text = toText(startNode);
 484                 deleteTextFromNode(text, startOffset, m_downstreamEnd.deprecatedEditingOffset() - startOffset);
 485             } else {
 486                 removeChildrenInRange(startNode, startOffset, m_downstreamEnd.deprecatedEditingOffset());
 487                 m_endingPosition = m_upstreamStart;
 488             }
 489         }
 490
 491         // The selection to delete is all in one node.
 492         if (!startNode->renderer() || (!startOffset && m_downstreamEnd.atLastEditingPositionForNode()))
 493             removeNode(startNode);
 494     }
 495     else {
 496         bool startNodeWasDescendantOfEndNode = m_upstreamStart.deprecatedNode()->isDescendantOf(m_downstreamEnd.deprecatedNode());
 497         // The selection to delete spans more than one node.
 498         RefPtrWillBeRawPtr<Node> node(startNode);
 499
 500         if (startOffset > 0) {
 501             if (startNode->isTextNode()) {
 502                 // in a text node that needs to be trimmed
 503                 Text* text = toText(node);
 504                 deleteTextFromNode(text, startOffset, text->length() - startOffset);
 505                 node = NodeTraversal::next(*node);
 506             } else {
 507                 node = NodeTraversal::childAt(*startNode, startOffset);
 508             }
 509         } else if (startNode == m_upstreamEnd.deprecatedNode() && startNode->isTextNode()) {
 510             Text* text = toText(m_upstreamEnd.deprecatedNode());
 511             deleteTextFromNode(text, 0, m_upstreamEnd.deprecatedEditingOffset());
 512         }
 513
 514         // handle deleting all nodes that are completely selected
 515         while (node && node != m_downstreamEnd.deprecatedNode()) {
 516             if (comparePositions(firstPositionInOrBeforeNode(node.get()), m_downstreamEnd) >= 0) {
 517                 // NodeTraversal::nextSkippingChildren just blew past the end position, so stop deleting
 518                 node = nullptr;
 519             } else if (!m_downstreamEnd.deprecatedNode()->isDescendantOf(node.get())) {
 520                 RefPtrWillBeRawPtr<Node> nextNode = NodeTraversal::nextSkippingChildren(*node);
 521                 // if we just removed a node from the end container, update end position so the
 522                 // check above will work
 523                 updatePositionForNodeRemoval(m_downstreamEnd, *node);
 524                 removeNode(node.get());
 525                 node = nextNode.get();
 526             } else {
 527                 Node& n = NodeTraversal::lastWithinOrSelf(*node);
 528                 if (m_downstreamEnd.deprecatedNode() == n && m_downstreamEnd.deprecatedEditingOffset() >= caretMaxOffset(&n)) {
 529                     removeNode(node.get());
 530                     node = nullptr;
 531                 } else {
 532                     node = NodeTraversal::next(*node);
 533                 }
 534             }
 535         }
 536
 537         if (m_downstreamEnd.deprecatedNode() != startNode && !m_upstreamStart.deprecatedNode()->isDescendantOf(m_downstreamEnd.deprecatedNode()) && m_downstreamEnd.inDocument() && m_downstreamEnd.deprecatedEditingOffset() >= caretMinOffset(m_downstreamEnd.deprecatedNode())) {
 538             if (m_downstreamEnd.atLastEditingPositionForNode() && !canHaveChildrenForEditing(m_downstreamEnd.deprecatedNode())) {
 539                 // The node itself is fully selected, not just its contents.  Delete it.
 540                 removeNode(m_downstreamEnd.deprecatedNode());
 541             } else {
 542                 if (m_downstreamEnd.deprecatedNode()->isTextNode()) {
 543                     // in a text node that needs to be trimmed
 544                     Text* text = toText(m_downstreamEnd.deprecatedNode());
 545                     if (m_downstreamEnd.deprecatedEditingOffset() > 0) {
 546                         deleteTextFromNode(text, 0, m_downstreamEnd.deprecatedEditingOffset());
 547                     }
 548                 // Remove children of m_downstreamEnd.deprecatedNode() that come after m_upstreamStart.
 549                 // Don't try to remove children if m_upstreamStart was inside m_downstreamEnd.deprecatedNode()
 550                 // and m_upstreamStart has been removed from the document, because then we don't
 551                 // know how many children to remove.
 552                 // FIXME: Make m_upstreamStart a position we update as we remove content, then we can
 553                 // always know which children to remove.
 554                 } else if (!(startNodeWasDescendantOfEndNode && !m_upstreamStart.inDocument())) {
 555                     int offset = 0;
 556                     if (m_upstreamStart.deprecatedNode()->isDescendantOf(m_downstreamEnd.deprecatedNode())) {
 557                         Node* n = m_upstreamStart.deprecatedNode();
 558                         while (n && n->parentNode() != m_downstreamEnd.deprecatedNode())
 559                             n = n->parentNode();
 560                         if (n)
 561                             offset = n->nodeIndex() + 1;
 562                     }
 563                     removeChildrenInRange(m_downstreamEnd.deprecatedNode(), offset, m_downstreamEnd.deprecatedEditingOffset());
 564                     m_downstreamEnd = createLegacyEditingPosition(m_downstreamEnd.deprecatedNode(), offset);
 565                 }
 566             }
 567         }
 568     }
 569 }
 570
 571 void DeleteSelectionCommand::fixupWhitespace()
 572 {
 573     document().updateLayoutIgnorePendingStylesheets();
 574     // FIXME: isRenderedCharacter should be removed, and we should use VisiblePosition::characterAfter and VisiblePosition::characterBefore
 575     if (m_leadingWhitespace.isNotNull() && !m_leadingWhitespace.isRenderedCharacter() && m_leadingWhitespace.deprecatedNode()->isTextNode()) {
 576         Text* textNode = toText(m_leadingWhitespace.deprecatedNode());
 577         ASSERT(!textNode->renderer() || textNode->renderer()->style()->collapseWhiteSpace());
 578         replaceTextInNodePreservingMarkers(textNode, m_leadingWhitespace.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
 579     }
 580     if (m_trailingWhitespace.isNotNull() && !m_trailingWhitespace.isRenderedCharacter() && m_trailingWhitespace.deprecatedNode()->isTextNode()) {
 581         Text* textNode = toText(m_trailingWhitespace.deprecatedNode());
 582         ASSERT(!textNode->renderer() ||textNode->renderer()->style()->collapseWhiteSpace());
 583         replaceTextInNodePreservingMarkers(textNode, m_trailingWhitespace.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
 584     }
 585 }
 586
 587 // If a selection starts in one block and ends in another, we have to merge to bring content before the
 588 // start together with content after the end.
 589 void DeleteSelectionCommand::mergeParagraphs()
 590 {
 591     if (!m_mergeBlocksAfterDelete) {
 592         if (m_pruneStartBlockIfNecessary) {
 593             // We aren't going to merge into the start block, so remove it if it's empty.
 594             prune(m_startBlock);
 595             // Removing the start block during a deletion is usually an indication that we need
 596             // a placeholder, but not in this case.
 597             m_needPlaceholder = false;
 598         }
 599         return;
 600     }
 601
 602     // It shouldn't have been asked to both try and merge content into the start block and prune it.
 603     ASSERT(!m_pruneStartBlockIfNecessary);
 604
 605     // FIXME: Deletion should adjust selection endpoints as it removes nodes so that we never get into this state (4099839).
 606     if (!m_downstreamEnd.inDocument() || !m_upstreamStart.inDocument())
 607          return;
 608
 609     // FIXME: The deletion algorithm shouldn't let this happen.
 610     if (comparePositions(m_upstreamStart, m_downstreamEnd) > 0)
 611         return;
 612
 613     // There's nothing to merge.
 614     if (m_upstreamStart == m_downstreamEnd)
 615         return;
 616
 617     VisiblePosition startOfParagraphToMove(m_downstreamEnd);
 618     VisiblePosition mergeDestination(m_upstreamStart);
 619
 620     // m_downstreamEnd's block has been emptied out by deletion.  There is no content inside of it to
 621     // move, so just remove it.
 622     Element* endBlock = enclosingBlock(m_downstreamEnd.deprecatedNode());
 623     if (!endBlock || !endBlock->contains(startOfParagraphToMove.deepEquivalent().deprecatedNode()) || !startOfParagraphToMove.deepEquivalent().deprecatedNode()) {
 624         removeNode(enclosingBlock(m_downstreamEnd.deprecatedNode()));
 625         return;
 626     }
 627
 628     // We need to merge into m_upstreamStart's block, but it's been emptied out and collapsed by deletion.
 629     if (!mergeDestination.deepEquivalent().deprecatedNode() || (!mergeDestination.deepEquivalent().deprecatedNode()->isDescendantOf(enclosingBlock(m_upstreamStart.containerNode())) && (!mergeDestination.deepEquivalent().anchorNode()->hasChildren() || !m_upstreamStart.containerNode()->hasChildren())) || (m_startsAtEmptyLine && mergeDestination != startOfParagraphToMove)) {
 630         insertNodeAt(createBreakElement(document()).get(), m_upstreamStart);
 631         mergeDestination = VisiblePosition(m_upstreamStart);
 632     }
 633
 634     if (mergeDestination == startOfParagraphToMove)
 635         return;
 636
 637     VisiblePosition endOfParagraphToMove = endOfParagraph(startOfParagraphToMove, CanSkipOverEditingBoundary);
 638
 639     if (mergeDestination == endOfParagraphToMove)
 640         return;
 641
 642     // If the merge destination and source to be moved are both list items of different lists, merge them into single list.
 643     Node* listItemInFirstParagraph = enclosingNodeOfType(m_upstreamStart, isListItem);
 644     Node* listItemInSecondParagraph = enclosingNodeOfType(m_downstreamEnd, isListItem);
 645     if (listItemInFirstParagraph && listItemInSecondParagraph
 646         && listItemInFirstParagraph->parentElement() != listItemInSecondParagraph->parentElement()
 647         && canMergeLists(listItemInFirstParagraph->parentElement(), listItemInSecondParagraph->parentElement())) {
 648         mergeIdenticalElements(listItemInFirstParagraph->parentElement(), listItemInSecondParagraph->parentElement());
 649         m_endingPosition = mergeDestination.deepEquivalent();
 650         return;
 651     }
 652
 653     // The rule for merging into an empty block is: only do so if its farther to the right.
 654     // FIXME: Consider RTL.
 655     if (!m_startsAtEmptyLine && isStartOfParagraph(mergeDestination) && startOfParagraphToMove.absoluteCaretBounds().x() > mergeDestination.absoluteCaretBounds().x()) {
 656         if (isHTMLBRElement(*mergeDestination.deepEquivalent().downstream().deprecatedNode())) {
 657             removeNodeAndPruneAncestors(mergeDestination.deepEquivalent().downstream().deprecatedNode());
 658             m_endingPosition = startOfParagraphToMove.deepEquivalent();
 659             return;
 660         }
 661     }
 662
 663     // Block images, tables and horizontal rules cannot be made inline with content at mergeDestination.  If there is
 664     // any (!isStartOfParagraph(mergeDestination)), don't merge, just move the caret to just before the selection we deleted.
 665     // See https://bugs.webkit.org/show_bug.cgi?id=25439
 666     if (isRenderedAsNonInlineTableImageOrHR(startOfParagraphToMove.deepEquivalent().deprecatedNode()) && !isStartOfParagraph(mergeDestination)) {
 667         m_endingPosition = m_upstreamStart;
 668         return;
 669     }
 670
 671     // moveParagraphs will insert placeholders if it removes blocks that would require their use, don't let block
 672     // removals that it does cause the insertion of *another* placeholder.
 673     bool needPlaceholder = m_needPlaceholder;
 674     bool paragraphToMergeIsEmpty = (startOfParagraphToMove == endOfParagraphToMove);
 675     moveParagraph(startOfParagraphToMove, endOfParagraphToMove, mergeDestination, false, !paragraphToMergeIsEmpty);
 676     m_needPlaceholder = needPlaceholder;
 677     // The endingPosition was likely clobbered by the move, so recompute it (moveParagraph selects the moved paragraph).
 678     m_endingPosition = endingSelection().start();
 679 }
 680
 681 void DeleteSelectionCommand::removePreviouslySelectedEmptyTableRows()
 682 {
 683     if (m_endTableRow && m_endTableRow->inDocument() && m_endTableRow != m_startTableRow) {
 684         Node* row = m_endTableRow->previousSibling();
 685         while (row && row != m_startTableRow) {
 686             RefPtrWillBeRawPtr<Node> previousRow = row->previousSibling();
 687             if (isTableRowEmpty(row))
 688                 // Use a raw removeNode, instead of DeleteSelectionCommand's, because
 689                 // that won't remove rows, it only empties them in preparation for this function.
 690                 CompositeEditCommand::removeNode(row);
 691             row = previousRow.get();
 692         }
 693     }
 694
 695     // Remove empty rows after the start row.
 696     if (m_startTableRow && m_startTableRow->inDocument() && m_startTableRow != m_endTableRow) {
 697         Node* row = m_startTableRow->nextSibling();
 698         while (row && row != m_endTableRow) {
 699             RefPtrWillBeRawPtr<Node> nextRow = row->nextSibling();
 700             if (isTableRowEmpty(row))
 701                 CompositeEditCommand::removeNode(row);
 702             row = nextRow.get();
 703         }
 704     }
 705
 706     if (m_endTableRow && m_endTableRow->inDocument() && m_endTableRow != m_startTableRow)
 707         if (isTableRowEmpty(m_endTableRow.get())) {
 708             // Don't remove m_endTableRow if it's where we're putting the ending selection.
 709             if (!m_endingPosition.deprecatedNode()->isDescendantOf(m_endTableRow.get())) {
 710                 // FIXME: We probably shouldn't remove m_endTableRow unless it's fully selected, even if it is empty.
 711                 // We'll need to start adjusting the selection endpoints during deletion to know whether or not m_endTableRow
 712                 // was fully selected here.
 713                 CompositeEditCommand::removeNode(m_endTableRow.get());
 714             }
 715         }
 716 }
 717
 718 void DeleteSelectionCommand::calculateTypingStyleAfterDelete()
 719 {
 720     // Clearing any previously set typing style and doing an early return.
 721     if (!m_typingStyle) {
 722         document().frame()->selection().clearTypingStyle();
 723         return;
 724     }
 725
 726     // Compute the difference between the style before the delete and the style now
 727     // after the delete has been done. Set this style on the frame, so other editing
 728     // commands being composed with this one will work, and also cache it on the command,
 729     // so the LocalFrame::appliedEditing can set it after the whole composite command
 730     // has completed.
 731
 732     // If we deleted into a blockquote, but are now no longer in a blockquote, use the alternate typing style
 733     if (m_deleteIntoBlockquoteStyle && !enclosingNodeOfType(m_endingPosition, isMailHTMLBlockquoteElement, CanCrossEditingBoundary))
 734         m_typingStyle = m_deleteIntoBlockquoteStyle;
 735     m_deleteIntoBlockquoteStyle = nullptr;
 736
 737     m_typingStyle->prepareToApplyAt(m_endingPosition);
 738     if (m_typingStyle->isEmpty())
 739         m_typingStyle = nullptr;
 740     // This is where we've deleted all traces of a style but not a whole paragraph (that's handled above).
 741     // In this case if we start typing, the new characters should have the same style as the just deleted ones,
 742     // but, if we change the selection, come back and start typing that style should be lost.  Also see
 743     // preserveTypingStyle() below.
 744     document().frame()->selection().setTypingStyle(m_typingStyle);
 745 }
 746
 747 void DeleteSelectionCommand::clearTransientState()
 748 {
 749     m_selectionToDelete = VisibleSelection();
 750     m_upstreamStart.clear();
 751     m_downstreamStart.clear();
 752     m_upstreamEnd.clear();
 753     m_downstreamEnd.clear();
 754     m_endingPosition.clear();
 755     m_leadingWhitespace.clear();
 756     m_trailingWhitespace.clear();
 757 }
 758
 759 // This method removes div elements with no attributes that have only one child or no children at all.
 760 void DeleteSelectionCommand::removeRedundantBlocks()
 761 {
 762     Node* node = m_endingPosition.containerNode();
 763     Element* rootElement = node->rootEditableElement();
 764
 765     while (node != rootElement) {
 766         if (isRemovableBlock(node)) {
 767             if (node == m_endingPosition.anchorNode())
 768                 updatePositionForNodeRemovalPreservingChildren(m_endingPosition, *node);
 769
 770             CompositeEditCommand::removeNodePreservingChildren(node);
 771             node = m_endingPosition.anchorNode();
 772         } else
 773             node = node->parentNode();
 774     }
 775 }
 776
 777 void DeleteSelectionCommand::doApply()
 778 {
 779     // If selection has not been set to a custom selection when the command was created,
 780     // use the current ending selection.
 781     if (!m_hasSelectionToDelete)
 782         m_selectionToDelete = endingSelection();
 783
 784     if (!m_selectionToDelete.isNonOrphanedRange())
 785         return;
 786
 787     // save this to later make the selection with
 788     EAffinity affinity = m_selectionToDelete.affinity();
 789
 790     Position downstreamEnd = m_selectionToDelete.end().downstream();
 791     bool rootWillStayOpenWithoutPlaceholder = downstreamEnd.containerNode() == downstreamEnd.containerNode()->rootEditableElement()
 792         || (downstreamEnd.containerNode()->isTextNode() && downstreamEnd.containerNode()->parentNode() == downstreamEnd.containerNode()->rootEditableElement());
 793     bool lineBreakAtEndOfSelectionToDelete = lineBreakExistsAtVisiblePosition(m_selectionToDelete.visibleEnd());
 794     m_needPlaceholder = !rootWillStayOpenWithoutPlaceholder
 795         && isStartOfParagraph(m_selectionToDelete.visibleStart(), CanCrossEditingBoundary)
 796         && isEndOfParagraph(m_selectionToDelete.visibleEnd(), CanCrossEditingBoundary)
 797         && !lineBreakAtEndOfSelectionToDelete;
 798     if (m_needPlaceholder) {
 799         // Don't need a placeholder when deleting a selection that starts just before a table
 800         // and ends inside it (we do need placeholders to hold open empty cells, but that's
 801         // handled elsewhere).
 802         if (Element* table = isLastPositionBeforeTable(m_selectionToDelete.visibleStart()))
 803             if (m_selectionToDelete.end().deprecatedNode()->isDescendantOf(table))
 804                 m_needPlaceholder = false;
 805     }
 806
 807
 808     // set up our state
 809     initializePositionData();
 810
 811     bool lineBreakBeforeStart = lineBreakExistsAtVisiblePosition(VisiblePosition(m_upstreamStart).previous());
 812
 813     // Delete any text that may hinder our ability to fixup whitespace after the delete
 814     deleteInsignificantTextDownstream(m_trailingWhitespace);
 815
 816     saveTypingStyleState();
 817
 818     // deleting just a BR is handled specially, at least because we do not
 819     // want to replace it with a placeholder BR!
 820     if (handleSpecialCaseBRDelete()) {
 821         calculateTypingStyleAfterDelete();
 822         setEndingSelection(VisibleSelection(m_endingPosition, affinity, endingSelection().isDirectional()));
 823         clearTransientState();
 824         rebalanceWhitespace();
 825         return;
 826     }
 827
 828     handleGeneralDelete();
 829
 830     fixupWhitespace();
 831
 832     mergeParagraphs();
 833
 834     removePreviouslySelectedEmptyTableRows();
 835
 836     if (!m_needPlaceholder && rootWillStayOpenWithoutPlaceholder) {
 837         VisiblePosition visualEnding(m_endingPosition);
 838         bool hasPlaceholder = lineBreakExistsAtVisiblePosition(visualEnding)
 839             && visualEnding.next(CannotCrossEditingBoundary).isNull();
 840         m_needPlaceholder = hasPlaceholder && lineBreakBeforeStart && !lineBreakAtEndOfSelectionToDelete;
 841     }
 842
 843     RefPtrWillBeRawPtr<HTMLBRElement> placeholder = m_needPlaceholder ? createBreakElement(document()) : nullptr;
 844
 845     if (placeholder) {
 846         if (m_sanitizeMarkup)
 847             removeRedundantBlocks();
 848         insertNodeAt(placeholder.get(), m_endingPosition);
 849     }
 850
 851     rebalanceWhitespaceAt(m_endingPosition);
 852
 853     calculateTypingStyleAfterDelete();
 854
 855     setEndingSelection(VisibleSelection(m_endingPosition, affinity, endingSelection().isDirectional()));
 856     clearTransientState();
 857 }
 858
 859 EditAction DeleteSelectionCommand::editingAction() const
 860 {
 861     // Note that DeleteSelectionCommand is also used when the user presses the Delete key,
 862     // but in that case there's a TypingCommand that supplies the editingAction(), so
 863     // the Undo menu correctly shows "Undo Typing"
 864     return EditActionCut;
 865 }
 866
 867 // Normally deletion doesn't preserve the typing style that was present before it.  For example,
 868 // type a character, Bold, then delete the character and start typing.  The Bold typing style shouldn't
 869 // stick around.  Deletion should preserve a typing style that *it* sets, however.
 870 bool DeleteSelectionCommand::preservesTypingStyle() const
 871 {
 872     return m_typingStyle;
 873 }
 874
 875 void DeleteSelectionCommand::trace(Visitor* visitor)
 876 {
 877     visitor->trace(m_selectionToDelete);
 878     visitor->trace(m_upstreamStart);
 879     visitor->trace(m_downstreamStart);
 880     visitor->trace(m_upstreamEnd);
 881     visitor->trace(m_downstreamEnd);
 882     visitor->trace(m_endingPosition);
 883     visitor->trace(m_leadingWhitespace);
 884     visitor->trace(m_trailingWhitespace);
 885     visitor->trace(m_startBlock);
 886     visitor->trace(m_endBlock);
 887     visitor->trace(m_typingStyle);
 888     visitor->trace(m_deleteIntoBlockquoteStyle);
 889     visitor->trace(m_startRoot);
 890     visitor->trace(m_endRoot);
 891     visitor->trace(m_startTableRow);
 892     visitor->trace(m_endTableRow);
 893     visitor->trace(m_temporaryPlaceholder);
 894     CompositeEditCommand::trace(visitor);
 895 }
 896
 897 } // namespace blink