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