cd888770ad6de1244d1fc0fcb3bcfceeee717502
[WebKit-https.git] / 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 "CSSMutableStyleDeclaration.h"
30 #include "Document.h"
31 #include "DocumentFragment.h"
32 #include "Editor.h"
33 #include "EditorClient.h"
34 #include "Element.h"
35 #include "Frame.h"
36 #include "Logging.h"
37 #include "CSSComputedStyleDeclaration.h"
38 #include "htmlediting.h"
39 #include "HTMLInputElement.h"
40 #include "HTMLNames.h"
41 #include "markup.h"
42 #include "RenderTableCell.h"
43 #include "ReplaceSelectionCommand.h"
44 #include "Text.h"
45 #include "TextIterator.h"
46 #include "visible_units.h"
47 #include "ApplyStyleCommand.h"
48
49 namespace WebCore {
50
51 using namespace HTMLNames;
52
53 static bool isTableRow(const Node* node)
54 {
55     return node && node->hasTagName(trTag);
56 }
57
58 static bool isTableCellEmpty(Node* cell)
59 {
60     ASSERT(isTableCell(cell));
61     return VisiblePosition(firstDeepEditingPositionForNode(cell)) == VisiblePosition(lastDeepEditingPositionForNode(cell));
62 }
63
64 static bool isTableRowEmpty(Node* row)
65 {
66     if (!isTableRow(row))
67         return false;
68         
69     for (Node* child = row->firstChild(); child; child = child->nextSibling())
70         if (isTableCell(child) && !isTableCellEmpty(child))
71             return false;
72     
73     return true;
74 }
75
76 DeleteSelectionCommand::DeleteSelectionCommand(Document *document, bool smartDelete, bool mergeBlocksAfterDelete, bool replace, bool expandForSpecialElements)
77     : CompositeEditCommand(document), 
78       m_hasSelectionToDelete(false), 
79       m_smartDelete(smartDelete), 
80       m_mergeBlocksAfterDelete(mergeBlocksAfterDelete),
81       m_replace(replace),
82       m_expandForSpecialElements(expandForSpecialElements),
83       m_pruneStartBlockIfNecessary(false),
84       m_startsAtEmptyLine(false),
85       m_startBlock(0),
86       m_endBlock(0),
87       m_typingStyle(0),
88       m_deleteIntoBlockquoteStyle(0)
89 {
90 }
91
92 DeleteSelectionCommand::DeleteSelectionCommand(const VisibleSelection& selection, bool smartDelete, bool mergeBlocksAfterDelete, bool replace, bool expandForSpecialElements)
93     : CompositeEditCommand(selection.start().node()->document()), 
94       m_hasSelectionToDelete(true), 
95       m_smartDelete(smartDelete), 
96       m_mergeBlocksAfterDelete(mergeBlocksAfterDelete),
97       m_replace(replace),
98       m_expandForSpecialElements(expandForSpecialElements),
99       m_pruneStartBlockIfNecessary(false),
100       m_startsAtEmptyLine(false),
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.node()->hasTagName(hrTag))
120         start = Position(start.node(), 0);
121     else if (end.node()->hasTagName(hrTag))
122         end = Position(end.node(), 1);
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));            
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, false);
198     Node* endCell = enclosingNodeOfType(m_downstreamEnd, &isTableCell, false);
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 the positions through rangeCompliantEquivalent, since some editing positions
266     // that appear inside their nodes aren't really inside them.  [hr, 0] is one example.
267     // FIXME: rangeComplaintEquivalent 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(rangeCompliantEquivalent(m_downstreamStart), &isBlock, false);
272     m_endBlock = enclosingNodeOfType(rangeCompliantEquivalent(m_upstreamEnd), &isBlock, false);
273 }
274
275 static void removeEnclosingAnchorStyle(CSSMutableStyleDeclaration* style, const Position& position)
276 {
277     Node* enclosingAnchor = enclosingAnchorElement(position);
278     if (!enclosingAnchor || !enclosingAnchor->parentNode())
279         return;
280     
281     removeStylesAddedByNode(style, enclosingAnchor);
282 }
283
284 void DeleteSelectionCommand::saveTypingStyleState()
285 {
286     // A common case is deleting characters that are all from the same text node. In 
287     // that case, the style at the start of the selection before deletion will be the 
288     // same as the style at the start of the selection after deletion (since those
289     // two positions will be identical). Therefore there is no need to save the
290     // typing style at the start of the selection, nor is there a reason to 
291     // compute the style at the start of the selection after deletion (see the 
292     // early return in calculateTypingStyleAfterDelete).
293     if (m_upstreamStart.node() == m_downstreamEnd.node() && m_upstreamStart.node()->isTextNode())
294         return;
295
296     // Figure out the typing style in effect before the delete is done.
297     m_typingStyle = EditingStyle::create(positionBeforeTabSpan(m_selectionToDelete.start()));
298
299     removeEnclosingAnchorStyle(m_typingStyle->style(), m_selectionToDelete.start());
300
301     // If we're deleting into a Mail blockquote, save the style at end() instead of start()
302     // We'll use this later in computeTypingStyleAfterDelete if we end up outside of a Mail blockquote
303     if (nearestMailBlockquote(m_selectionToDelete.start().node()))
304         m_deleteIntoBlockquoteStyle = EditingStyle::create(m_selectionToDelete.end());
305     else
306         m_deleteIntoBlockquoteStyle = 0;
307 }
308
309 bool DeleteSelectionCommand::handleSpecialCaseBRDelete()
310 {
311     // Check for special-case where the selection contains only a BR on a line by itself after another BR.
312     bool upstreamStartIsBR = m_upstreamStart.node()->hasTagName(brTag);
313     bool downstreamStartIsBR = m_downstreamStart.node()->hasTagName(brTag);
314     bool isBROnLineByItself = upstreamStartIsBR && downstreamStartIsBR && m_downstreamStart.node() == m_upstreamEnd.node();
315     if (isBROnLineByItself) {
316         removeNode(m_downstreamStart.node());
317         return true;
318     }
319
320     // Not a special-case delete per se, but we can detect that the merging of content between blocks
321     // should not be done.
322     if (upstreamStartIsBR && downstreamStartIsBR) {
323         m_startsAtEmptyLine = true;
324         m_endingPosition = m_downstreamEnd;
325     }
326     
327     return false;
328 }
329
330 static void updatePositionForNodeRemoval(Node* node, Position& position)
331 {
332     if (position.isNull())
333         return;
334     if (node->parent() == position.node() && node->nodeIndex() < (unsigned)position.deprecatedEditingOffset())
335         position = Position(position.node(), position.deprecatedEditingOffset() - 1);
336     if (position.node() == node || position.node()->isDescendantOf(node))
337         position = positionInParentBeforeNode(node);
338 }
339
340 void DeleteSelectionCommand::removeNode(PassRefPtr<Node> node)
341 {
342     if (!node)
343         return;
344         
345     if (m_startRoot != m_endRoot && !(node->isDescendantOf(m_startRoot.get()) && node->isDescendantOf(m_endRoot.get()))) {
346         // If a node is not in both the start and end editable roots, remove it only if its inside an editable region.
347         if (!node->parentNode()->isContentEditable()) {
348             // Don't remove non-editable atomic nodes.
349             if (!node->firstChild())
350                 return;
351             // Search this non-editable region for editable regions to empty.
352             RefPtr<Node> child = node->firstChild();
353             while (child) {
354                 RefPtr<Node> nextChild = child->nextSibling();
355                 removeNode(child.get());
356                 // Bail if nextChild is no longer node's child.
357                 if (nextChild && nextChild->parentNode() != node)
358                     return;
359                 child = nextChild;
360             }
361             
362             // Don't remove editable regions that are inside non-editable ones, just clear them.
363             return;
364         }
365     }
366     
367     if (isTableStructureNode(node.get()) || node == node->rootEditableElement()) {
368         // Do not remove an element of table structure; remove its contents.
369         // Likewise for the root editable element.
370         Node* child = node->firstChild();
371         while (child) {
372             Node* remove = child;
373             child = child->nextSibling();
374             removeNode(remove);
375         }
376         
377         // make sure empty cell has some height
378         updateLayout();
379         RenderObject *r = node->renderer();
380         if (r && r->isTableCell() && toRenderTableCell(r)->contentHeight() <= 0)
381             insertBlockPlaceholder(Position(node, 0));
382         return;
383     }
384     
385     if (node == m_startBlock && !isEndOfBlock(VisiblePosition(firstDeepEditingPositionForNode(m_startBlock.get())).previous()))
386         m_needPlaceholder = true;
387     else if (node == m_endBlock && !isStartOfBlock(VisiblePosition(lastDeepEditingPositionForNode(m_startBlock.get())).next()))
388         m_needPlaceholder = true;
389     
390     // FIXME: Update the endpoints of the range being deleted.
391     updatePositionForNodeRemoval(node.get(), m_endingPosition);
392     updatePositionForNodeRemoval(node.get(), m_leadingWhitespace);
393     updatePositionForNodeRemoval(node.get(), m_trailingWhitespace);
394     
395     CompositeEditCommand::removeNode(node);
396 }
397
398 static void updatePositionForTextRemoval(Node* node, int offset, int count, Position& position)
399 {
400     if (position.node() == node) {
401         if (position.deprecatedEditingOffset() > offset + count)
402             position = Position(position.node(), position.deprecatedEditingOffset() - count);
403         else if (position.deprecatedEditingOffset() > offset)
404             position = Position(position.node(), offset);
405     }
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     int startOffset = m_upstreamStart.deprecatedEditingOffset();
422     Node* startNode = m_upstreamStart.node();
423     
424     // Never remove the start block unless it's a table, in which case we won't merge content in.
425     if (startNode == m_startBlock && startOffset == 0 && canHaveChildrenForEditing(startNode) && !startNode->hasTagName(tableTag)) {
426         startOffset = 0;
427         startNode = startNode->traverseNextNode();
428     }
429
430     if (startOffset >= caretMaxOffset(startNode) && startNode->isTextNode()) {
431         Text *text = static_cast<Text *>(startNode);
432         if (text->length() > (unsigned)caretMaxOffset(startNode))
433             deleteTextFromNode(text, caretMaxOffset(startNode), text->length() - caretMaxOffset(startNode));
434     }
435
436     if (startOffset >= lastOffsetForEditing(startNode)) {
437         startNode = startNode->traverseNextSibling();
438         startOffset = 0;
439     }
440
441     // Done adjusting the start.  See if we're all done.
442     if (!startNode)
443         return;
444
445     if (startNode == m_downstreamEnd.node()) {
446         if (m_downstreamEnd.deprecatedEditingOffset() - startOffset > 0) {
447             if (startNode->isTextNode()) {
448                 // in a text node that needs to be trimmed
449                 Text* text = static_cast<Text*>(startNode);
450                 deleteTextFromNode(text, startOffset, m_downstreamEnd.deprecatedEditingOffset() - startOffset);
451             } else {
452                 removeChildrenInRange(startNode, startOffset, m_downstreamEnd.deprecatedEditingOffset());
453                 m_endingPosition = m_upstreamStart;
454             }
455         }
456
457         // The selection to delete is all in one node.
458         if (!startNode->renderer() || (!startOffset && m_downstreamEnd.atLastEditingPositionForNode()))
459             removeNode(startNode);
460     }
461     else {
462         bool startNodeWasDescendantOfEndNode = m_upstreamStart.node()->isDescendantOf(m_downstreamEnd.node());
463         // The selection to delete spans more than one node.
464         RefPtr<Node> node(startNode);
465         
466         if (startOffset > 0) {
467             if (startNode->isTextNode()) {
468                 // in a text node that needs to be trimmed
469                 Text *text = static_cast<Text *>(node.get());
470                 deleteTextFromNode(text, startOffset, text->length() - startOffset);
471                 node = node->traverseNextNode();
472             } else {
473                 node = startNode->childNode(startOffset);
474             }
475         } else if (startNode == m_upstreamEnd.node() && startNode->isTextNode()) {
476             Text* text = static_cast<Text*>(m_upstreamEnd.node());
477             deleteTextFromNode(text, 0, m_upstreamEnd.deprecatedEditingOffset());
478         }
479         
480         // handle deleting all nodes that are completely selected
481         while (node && node != m_downstreamEnd.node()) {
482             if (comparePositions(Position(node.get(), 0), m_downstreamEnd) >= 0) {
483                 // traverseNextSibling just blew past the end position, so stop deleting
484                 node = 0;
485             } else if (!m_downstreamEnd.node()->isDescendantOf(node.get())) {
486                 RefPtr<Node> nextNode = node->traverseNextSibling();
487                 // if we just removed a node from the end container, update end position so the
488                 // check above will work
489                 if (node->parentNode() == m_downstreamEnd.node()) {
490                     ASSERT(node->nodeIndex() < (unsigned)m_downstreamEnd.deprecatedEditingOffset());
491                     m_downstreamEnd = Position(m_downstreamEnd.node(), m_downstreamEnd.deprecatedEditingOffset() - 1);
492                 }
493                 removeNode(node.get());
494                 node = nextNode.get();
495             } else {
496                 Node* n = node->lastDescendant();
497                 if (m_downstreamEnd.node() == n && m_downstreamEnd.deprecatedEditingOffset() >= caretMaxOffset(n)) {
498                     removeNode(node.get());
499                     node = 0;
500                 } else
501                     node = node->traverseNextNode();
502             }
503         }
504         
505         if (m_downstreamEnd.node() != startNode && !m_upstreamStart.node()->isDescendantOf(m_downstreamEnd.node()) && m_downstreamEnd.node()->inDocument() && m_downstreamEnd.deprecatedEditingOffset() >= caretMinOffset(m_downstreamEnd.node())) {
506             if (m_downstreamEnd.atLastEditingPositionForNode() && !canHaveChildrenForEditing(m_downstreamEnd.node())) {
507                 // The node itself is fully selected, not just its contents.  Delete it.
508                 removeNode(m_downstreamEnd.node());
509             } else {
510                 if (m_downstreamEnd.node()->isTextNode()) {
511                     // in a text node that needs to be trimmed
512                     Text *text = static_cast<Text *>(m_downstreamEnd.node());
513                     if (m_downstreamEnd.deprecatedEditingOffset() > 0) {
514                         deleteTextFromNode(text, 0, m_downstreamEnd.deprecatedEditingOffset());
515                     }
516                 // Remove children of m_downstreamEnd.node() that come after m_upstreamStart.
517                 // Don't try to remove children if m_upstreamStart was inside m_downstreamEnd.node()
518                 // and m_upstreamStart has been removed from the document, because then we don't 
519                 // know how many children to remove.
520                 // FIXME: Make m_upstreamStart a position we update as we remove content, then we can
521                 // always know which children to remove.
522                 } else if (!(startNodeWasDescendantOfEndNode && !m_upstreamStart.node()->inDocument())) {
523                     int offset = 0;
524                     if (m_upstreamStart.node()->isDescendantOf(m_downstreamEnd.node())) {
525                         Node *n = m_upstreamStart.node();
526                         while (n && n->parentNode() != m_downstreamEnd.node())
527                             n = n->parentNode();
528                         if (n)
529                             offset = n->nodeIndex() + 1;
530                     }
531                     removeChildrenInRange(m_downstreamEnd.node(), offset, m_downstreamEnd.deprecatedEditingOffset());
532                     m_downstreamEnd = Position(m_downstreamEnd.node(), offset);
533                 }
534             }
535         }
536     }
537 }
538
539 void DeleteSelectionCommand::fixupWhitespace()
540 {
541     updateLayout();
542     // FIXME: isRenderedCharacter should be removed, and we should use VisiblePosition::characterAfter and VisiblePosition::characterBefore
543     if (m_leadingWhitespace.isNotNull() && !m_leadingWhitespace.isRenderedCharacter() && m_leadingWhitespace.node()->isTextNode()) {
544         Text* textNode = static_cast<Text*>(m_leadingWhitespace.node());
545         ASSERT(!textNode->renderer() || textNode->renderer()->style()->collapseWhiteSpace());
546         replaceTextInNode(textNode, m_leadingWhitespace.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
547     }
548     if (m_trailingWhitespace.isNotNull() && !m_trailingWhitespace.isRenderedCharacter() && m_trailingWhitespace.node()->isTextNode()) {
549         Text* textNode = static_cast<Text*>(m_trailingWhitespace.node());
550         ASSERT(!textNode->renderer() ||textNode->renderer()->style()->collapseWhiteSpace());
551         replaceTextInNode(textNode, m_trailingWhitespace.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
552     }
553 }
554
555 // If a selection starts in one block and ends in another, we have to merge to bring content before the
556 // start together with content after the end.
557 void DeleteSelectionCommand::mergeParagraphs()
558 {
559     if (!m_mergeBlocksAfterDelete) {
560         if (m_pruneStartBlockIfNecessary) {
561             // We aren't going to merge into the start block, so remove it if it's empty.
562             prune(m_startBlock);
563             // Removing the start block during a deletion is usually an indication that we need
564             // a placeholder, but not in this case.
565             m_needPlaceholder = false;
566         }
567         return;
568     }
569     
570     // It shouldn't have been asked to both try and merge content into the start block and prune it.
571     ASSERT(!m_pruneStartBlockIfNecessary);
572
573     // FIXME: Deletion should adjust selection endpoints as it removes nodes so that we never get into this state (4099839).
574     if (!m_downstreamEnd.node()->inDocument() || !m_upstreamStart.node()->inDocument())
575          return;
576          
577     // FIXME: The deletion algorithm shouldn't let this happen.
578     if (comparePositions(m_upstreamStart, m_downstreamEnd) > 0)
579         return;
580         
581     // There's nothing to merge.
582     if (m_upstreamStart == m_downstreamEnd)
583         return;
584         
585     VisiblePosition startOfParagraphToMove(m_downstreamEnd);
586     VisiblePosition mergeDestination(m_upstreamStart);
587     
588     // m_downstreamEnd's block has been emptied out by deletion.  There is no content inside of it to
589     // move, so just remove it.
590     Element* endBlock = static_cast<Element*>(enclosingBlock(m_downstreamEnd.node()));
591     if (!startOfParagraphToMove.deepEquivalent().node() || !endBlock->contains(startOfParagraphToMove.deepEquivalent().node())) {
592         removeNode(enclosingBlock(m_downstreamEnd.node()));
593         return;
594     }
595     
596     // We need to merge into m_upstreamStart's block, but it's been emptied out and collapsed by deletion.
597     if (!mergeDestination.deepEquivalent().node() || !mergeDestination.deepEquivalent().node()->isDescendantOf(m_upstreamStart.node()->enclosingBlockFlowElement()) || m_startsAtEmptyLine) {
598         insertNodeAt(createBreakElement(document()).get(), m_upstreamStart);
599         mergeDestination = VisiblePosition(m_upstreamStart);
600     }
601     
602     if (mergeDestination == startOfParagraphToMove)
603         return;
604         
605     VisiblePosition endOfParagraphToMove = endOfParagraph(startOfParagraphToMove);
606     
607     if (mergeDestination == endOfParagraphToMove)
608         return;
609     
610     // The rule for merging into an empty block is: only do so if its farther to the right.
611     // FIXME: Consider RTL.
612     if (!m_startsAtEmptyLine && isStartOfParagraph(mergeDestination) && startOfParagraphToMove.absoluteCaretBounds().x() > mergeDestination.absoluteCaretBounds().x()) {
613         if (mergeDestination.deepEquivalent().downstream().node()->hasTagName(brTag)) {
614             removeNodeAndPruneAncestors(mergeDestination.deepEquivalent().downstream().node());
615             m_endingPosition = startOfParagraphToMove.deepEquivalent();
616             return;
617         }
618     }
619     
620     // Block images, tables and horizontal rules cannot be made inline with content at mergeDestination.  If there is 
621     // any (!isStartOfParagraph(mergeDestination)), don't merge, just move the caret to just before the selection we deleted.
622     // See https://bugs.webkit.org/show_bug.cgi?id=25439
623     if (isRenderedAsNonInlineTableImageOrHR(startOfParagraphToMove.deepEquivalent().node()) && !isStartOfParagraph(mergeDestination)) {
624         m_endingPosition = m_upstreamStart;
625         return;
626     }
627     
628     RefPtr<Range> range = Range::create(document(), rangeCompliantEquivalent(startOfParagraphToMove.deepEquivalent()), rangeCompliantEquivalent(endOfParagraphToMove.deepEquivalent()));
629     RefPtr<Range> rangeToBeReplaced = Range::create(document(), rangeCompliantEquivalent(mergeDestination.deepEquivalent()), rangeCompliantEquivalent(mergeDestination.deepEquivalent()));
630     if (!document()->frame()->editor()->client()->shouldMoveRangeAfterDelete(range.get(), rangeToBeReplaced.get()))
631         return;
632     
633     // moveParagraphs will insert placeholders if it removes blocks that would require their use, don't let block
634     // removals that it does cause the insertion of *another* placeholder.
635     bool needPlaceholder = m_needPlaceholder;
636     bool paragraphToMergeIsEmpty = (startOfParagraphToMove == endOfParagraphToMove);
637     moveParagraph(startOfParagraphToMove, endOfParagraphToMove, mergeDestination, false, !paragraphToMergeIsEmpty);
638     m_needPlaceholder = needPlaceholder;
639     // The endingPosition was likely clobbered by the move, so recompute it (moveParagraph selects the moved paragraph).
640     m_endingPosition = endingSelection().start();
641 }
642
643 void DeleteSelectionCommand::removePreviouslySelectedEmptyTableRows()
644 {
645     if (m_endTableRow && m_endTableRow->inDocument() && m_endTableRow != m_startTableRow) {
646         Node* row = m_endTableRow->previousSibling();
647         while (row && row != m_startTableRow) {
648             RefPtr<Node> previousRow = row->previousSibling();
649             if (isTableRowEmpty(row))
650                 // Use a raw removeNode, instead of DeleteSelectionCommand's, because
651                 // that won't remove rows, it only empties them in preparation for this function.
652                 CompositeEditCommand::removeNode(row);
653             row = previousRow.get();
654         }
655     }
656     
657     // Remove empty rows after the start row.
658     if (m_startTableRow && m_startTableRow->inDocument() && m_startTableRow != m_endTableRow) {
659         Node* row = m_startTableRow->nextSibling();
660         while (row && row != m_endTableRow) {
661             RefPtr<Node> nextRow = row->nextSibling();
662             if (isTableRowEmpty(row))
663                 CompositeEditCommand::removeNode(row);
664             row = nextRow.get();
665         }
666     }
667     
668     if (m_endTableRow && m_endTableRow->inDocument() && m_endTableRow != m_startTableRow)
669         if (isTableRowEmpty(m_endTableRow.get())) {
670             // Don't remove m_endTableRow if it's where we're putting the ending selection.
671             if (!m_endingPosition.node()->isDescendantOf(m_endTableRow.get())) {
672                 // FIXME: We probably shouldn't remove m_endTableRow unless it's fully selected, even if it is empty.
673                 // We'll need to start adjusting the selection endpoints during deletion to know whether or not m_endTableRow
674                 // was fully selected here.
675                 CompositeEditCommand::removeNode(m_endTableRow.get());
676             }
677         }
678 }
679
680 void DeleteSelectionCommand::calculateTypingStyleAfterDelete()
681 {
682     if (!m_typingStyle)
683         return;
684         
685     // Compute the difference between the style before the delete and the style now
686     // after the delete has been done. Set this style on the frame, so other editing
687     // commands being composed with this one will work, and also cache it on the command,
688     // so the Frame::appliedEditing can set it after the whole composite command 
689     // has completed.
690     
691     // If we deleted into a blockquote, but are now no longer in a blockquote, use the alternate typing style
692     if (m_deleteIntoBlockquoteStyle && !nearestMailBlockquote(m_endingPosition.node()))
693         m_typingStyle = m_deleteIntoBlockquoteStyle;
694     m_deleteIntoBlockquoteStyle = 0;
695
696     m_typingStyle->prepareToApplyAt(m_endingPosition);
697     if (m_typingStyle->isEmpty())
698         m_typingStyle = 0;
699     VisiblePosition visibleEnd(m_endingPosition);
700     if (m_typingStyle && 
701         isStartOfParagraph(visibleEnd) &&
702         isEndOfParagraph(visibleEnd) &&
703         lineBreakExistsAtVisiblePosition(visibleEnd)) {
704         // Apply style to the placeholder that is now holding open the empty paragraph. 
705         // This makes sure that the paragraph has the right height, and that the paragraph 
706         // takes on the right style and retains it even if you move the selection away and
707         // then move it back (which will clear typing style).
708
709         setEndingSelection(visibleEnd);
710         applyStyle(m_typingStyle->style(), EditActionUnspecified);
711         // applyStyle can destroy the placeholder that was at m_endingPosition if it needs to 
712         // move it, but it will set an endingSelection() at [movedPlaceholder, 0] if it does so.
713         m_endingPosition = endingSelection().start();
714         m_typingStyle = 0;
715     }
716     // This is where we've deleted all traces of a style but not a whole paragraph (that's handled above).
717     // In this case if we start typing, the new characters should have the same style as the just deleted ones,
718     // but, if we change the selection, come back and start typing that style should be lost.  Also see 
719     // preserveTypingStyle() below.
720     document()->frame()->selection()->setTypingStyle(m_typingStyle);
721 }
722
723 void DeleteSelectionCommand::clearTransientState()
724 {
725     m_selectionToDelete = VisibleSelection();
726     m_upstreamStart.clear();
727     m_downstreamStart.clear();
728     m_upstreamEnd.clear();
729     m_downstreamEnd.clear();
730     m_endingPosition.clear();
731     m_leadingWhitespace.clear();
732     m_trailingWhitespace.clear();
733 }
734
735 void DeleteSelectionCommand::doApply()
736 {
737     // If selection has not been set to a custom selection when the command was created,
738     // use the current ending selection.
739     if (!m_hasSelectionToDelete)
740         m_selectionToDelete = endingSelection();
741
742     if (!m_selectionToDelete.isNonOrphanedRange())
743         return;
744
745     // 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. 
746     if (!m_replace) {
747         Node* startNode = m_selectionToDelete.start().node();
748         Node* ancestorNode = startNode ? startNode->shadowAncestorNode() : 0;
749         if (ancestorNode && ancestorNode->hasTagName(inputTag)
750                 && static_cast<HTMLInputElement*>(ancestorNode)->isTextField()
751                 && ancestorNode->focused())
752             document()->frame()->editor()->textWillBeDeletedInTextField(static_cast<Element*>(ancestorNode));
753     }
754
755     // save this to later make the selection with
756     EAffinity affinity = m_selectionToDelete.affinity();
757     
758     Position downstreamEnd = m_selectionToDelete.end().downstream();
759     m_needPlaceholder = isStartOfParagraph(m_selectionToDelete.visibleStart(), Position::CanCrossEditingBoundary)
760             && isEndOfParagraph(m_selectionToDelete.visibleEnd(), Position::CanCrossEditingBoundary)
761             && !lineBreakExistsAtVisiblePosition(m_selectionToDelete.visibleEnd());
762     if (m_needPlaceholder) {
763         // Don't need a placeholder when deleting a selection that starts just before a table
764         // and ends inside it (we do need placeholders to hold open empty cells, but that's
765         // handled elsewhere).
766         if (Node* table = isLastPositionBeforeTable(m_selectionToDelete.visibleStart()))
767             if (m_selectionToDelete.end().node()->isDescendantOf(table))
768                 m_needPlaceholder = false;
769     }
770         
771     
772     // set up our state
773     initializePositionData();
774
775     // Delete any text that may hinder our ability to fixup whitespace after the delete
776     deleteInsignificantTextDownstream(m_trailingWhitespace);    
777
778     saveTypingStyleState();
779     
780     // deleting just a BR is handled specially, at least because we do not
781     // want to replace it with a placeholder BR!
782     if (handleSpecialCaseBRDelete()) {
783         calculateTypingStyleAfterDelete();
784         setEndingSelection(VisibleSelection(m_endingPosition, affinity));
785         clearTransientState();
786         rebalanceWhitespace();
787         return;
788     }
789     
790     handleGeneralDelete();
791     
792     fixupWhitespace();
793     
794     mergeParagraphs();
795     
796     removePreviouslySelectedEmptyTableRows();
797     
798     RefPtr<Node> placeholder = m_needPlaceholder ? createBreakElement(document()).get() : 0;
799     
800     if (placeholder)
801         insertNodeAt(placeholder.get(), m_endingPosition);
802
803     rebalanceWhitespaceAt(m_endingPosition);
804
805     calculateTypingStyleAfterDelete();
806     
807     setEndingSelection(VisibleSelection(m_endingPosition, affinity));
808     clearTransientState();
809 }
810
811 EditAction DeleteSelectionCommand::editingAction() const
812 {
813     // Note that DeleteSelectionCommand is also used when the user presses the Delete key,
814     // but in that case there's a TypingCommand that supplies the editingAction(), so
815     // the Undo menu correctly shows "Undo Typing"
816     return EditActionCut;
817 }
818
819 // Normally deletion doesn't preserve the typing style that was present before it.  For example,
820 // type a character, Bold, then delete the character and start typing.  The Bold typing style shouldn't
821 // stick around.  Deletion should preserve a typing style that *it* sets, however.
822 bool DeleteSelectionCommand::preservesTypingStyle() const
823 {
824     return m_typingStyle;
825 }
826
827 } // namespace WebCore