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