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