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