2011-06-23 Darin Adler <darin@apple.com>
[WebKit-https.git] / Source / WebCore / editing / CompositeEditCommand.cpp
1 /*
2  * Copyright (C) 2005, 2006, 2007, 2008 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 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 "CompositeEditCommand.h"
28
29 #include "AppendNodeCommand.h"
30 #include "ApplyStyleCommand.h"
31 #include "DeleteFromTextNodeCommand.h"
32 #include "DeleteSelectionCommand.h"
33 #include "Document.h"
34 #include "DocumentFragment.h"
35 #include "DocumentMarkerController.h"
36 #include "EditorInsertAction.h"
37 #include "Frame.h"
38 #include "HTMLElement.h"
39 #include "HTMLNames.h"
40 #include "InlineTextBox.h"
41 #include "InsertIntoTextNodeCommand.h"
42 #include "InsertLineBreakCommand.h"
43 #include "InsertNodeBeforeCommand.h"
44 #include "InsertParagraphSeparatorCommand.h"
45 #include "InsertTextCommand.h"
46 #include "MergeIdenticalElementsCommand.h"
47 #include "Range.h"
48 #include "RemoveCSSPropertyCommand.h"
49 #include "RemoveNodeCommand.h"
50 #include "RemoveNodePreservingChildrenCommand.h"
51 #include "ReplaceNodeWithSpanCommand.h"
52 #include "ReplaceSelectionCommand.h"
53 #include "RenderBlock.h"
54 #include "RenderText.h"
55 #include "SetNodeAttributeCommand.h"
56 #include "SplitElementCommand.h"
57 #include "SplitTextNodeCommand.h"
58 #include "SplitTextNodeContainingElementCommand.h"
59 #include "Text.h"
60 #include "TextIterator.h"
61 #include "WrapContentsInDummySpanCommand.h"
62 #include "htmlediting.h"
63 #include "markup.h"
64 #include "visible_units.h"
65 #include <wtf/unicode/CharacterNames.h>
66
67 using namespace std;
68
69 namespace WebCore {
70
71 using namespace HTMLNames;
72
73 CompositeEditCommand::CompositeEditCommand(Document *document)
74     : EditCommand(document)
75 {
76 }
77
78 CompositeEditCommand::~CompositeEditCommand()
79 {
80 }
81
82 void CompositeEditCommand::doUnapply()
83 {
84     size_t size = m_commands.size();
85     for (size_t i = size; i != 0; --i)
86         m_commands[i - 1]->unapply();
87 }
88
89 void CompositeEditCommand::doReapply()
90 {
91     size_t size = m_commands.size();
92     for (size_t i = 0; i != size; ++i)
93         m_commands[i]->reapply();
94 }
95
96 //
97 // sugary-sweet convenience functions to help create and apply edit commands in composite commands
98 //
99 void CompositeEditCommand::applyCommandToComposite(PassRefPtr<EditCommand> cmd)
100 {
101     cmd->setParent(this);
102     cmd->apply();
103     m_commands.append(cmd);
104 }
105
106 void CompositeEditCommand::applyStyle(const EditingStyle* style, EditAction editingAction)
107 {
108     applyCommandToComposite(ApplyStyleCommand::create(document(), style, editingAction));
109 }
110
111 void CompositeEditCommand::applyStyle(const EditingStyle* style, const Position& start, const Position& end, EditAction editingAction)
112 {
113     applyCommandToComposite(ApplyStyleCommand::create(document(), style, start, end, editingAction));
114 }
115
116 void CompositeEditCommand::applyStyledElement(PassRefPtr<Element> element)
117 {
118     applyCommandToComposite(ApplyStyleCommand::create(element, false));
119 }
120
121 void CompositeEditCommand::removeStyledElement(PassRefPtr<Element> element)
122 {
123     applyCommandToComposite(ApplyStyleCommand::create(element, true));
124 }
125
126 void CompositeEditCommand::insertParagraphSeparator(bool useDefaultParagraphElement)
127 {
128     applyCommandToComposite(InsertParagraphSeparatorCommand::create(document(), useDefaultParagraphElement));
129 }
130
131 void CompositeEditCommand::insertLineBreak()
132 {
133     applyCommandToComposite(InsertLineBreakCommand::create(document()));
134 }
135
136 void CompositeEditCommand::insertNodeBefore(PassRefPtr<Node> insertChild, PassRefPtr<Node> refChild)
137 {
138     ASSERT(!refChild->hasTagName(bodyTag));
139     applyCommandToComposite(InsertNodeBeforeCommand::create(insertChild, refChild));
140 }
141
142 void CompositeEditCommand::insertNodeAfter(PassRefPtr<Node> insertChild, PassRefPtr<Node> refChild)
143 {
144     ASSERT(insertChild);
145     ASSERT(refChild);
146     ASSERT(!refChild->hasTagName(bodyTag));
147     ContainerNode* parent = refChild->parentNode();
148     ASSERT(parent);
149     ASSERT(!parent->isShadowRoot());
150     if (parent->lastChild() == refChild)
151         appendNode(insertChild, parent);
152     else {
153         ASSERT(refChild->nextSibling());
154         insertNodeBefore(insertChild, refChild->nextSibling());
155     }
156 }
157
158 void CompositeEditCommand::insertNodeAt(PassRefPtr<Node> insertChild, const Position& editingPosition)
159 {
160     ASSERT(isEditablePosition(editingPosition));
161     // For editing positions like [table, 0], insert before the table,
162     // likewise for replaced elements, brs, etc.
163     Position p = editingPosition.parentAnchoredEquivalent();
164     Node* refChild = p.deprecatedNode();
165     int offset = p.deprecatedEditingOffset();
166     
167     if (canHaveChildrenForEditing(refChild)) {
168         Node* child = refChild->firstChild();
169         for (int i = 0; child && i < offset; i++)
170             child = child->nextSibling();
171         if (child)
172             insertNodeBefore(insertChild, child);
173         else
174             appendNode(insertChild, static_cast<Element*>(refChild));
175     } else if (caretMinOffset(refChild) >= offset)
176         insertNodeBefore(insertChild, refChild);
177     else if (refChild->isTextNode() && caretMaxOffset(refChild) > offset) {
178         splitTextNode(static_cast<Text *>(refChild), offset);
179
180         // Mutation events (bug 22634) from the text node insertion may have removed the refChild
181         if (!refChild->inDocument())
182             return;
183         insertNodeBefore(insertChild, refChild);
184     } else
185         insertNodeAfter(insertChild, refChild);
186 }
187
188 void CompositeEditCommand::appendNode(PassRefPtr<Node> node, PassRefPtr<ContainerNode> parent)
189 {
190     ASSERT(canHaveChildrenForEditing(parent.get()));
191     applyCommandToComposite(AppendNodeCommand::create(parent, node));
192 }
193
194 void CompositeEditCommand::removeChildrenInRange(PassRefPtr<Node> node, unsigned from, unsigned to)
195 {
196     Vector<RefPtr<Node> > children;
197     Node* child = node->childNode(from);
198     for (unsigned i = from; child && i < to; i++, child = child->nextSibling())
199         children.append(child);
200
201     size_t size = children.size();
202     for (size_t i = 0; i < size; ++i)
203         removeNode(children[i].release());
204 }
205
206 void CompositeEditCommand::removeNode(PassRefPtr<Node> node)
207 {
208     if (!node || !node->nonShadowBoundaryParentNode())
209         return;
210     applyCommandToComposite(RemoveNodeCommand::create(node));
211 }
212
213 void CompositeEditCommand::removeNodePreservingChildren(PassRefPtr<Node> node)
214 {
215     applyCommandToComposite(RemoveNodePreservingChildrenCommand::create(node));
216 }
217
218 void CompositeEditCommand::removeNodeAndPruneAncestors(PassRefPtr<Node> node)
219 {
220     RefPtr<ContainerNode> parent = node->parentNode();
221     removeNode(node);
222     prune(parent.release());
223 }
224
225 HTMLElement* CompositeEditCommand::replaceElementWithSpanPreservingChildrenAndAttributes(PassRefPtr<HTMLElement> node)
226 {
227     // It would also be possible to implement all of ReplaceNodeWithSpanCommand
228     // as a series of existing smaller edit commands.  Someone who wanted to
229     // reduce the number of edit commands could do so here.
230     RefPtr<ReplaceNodeWithSpanCommand> command = ReplaceNodeWithSpanCommand::create(node);
231     applyCommandToComposite(command);
232     // Returning a raw pointer here is OK because the command is retained by
233     // applyCommandToComposite (thus retaining the span), and the span is also
234     // in the DOM tree, and thus alive whie it has a parent.
235     ASSERT(command->spanElement()->inDocument());
236     return command->spanElement();
237 }
238
239 static bool hasARenderedDescendant(Node* node)
240 {
241     Node* n = node->firstChild();
242     while (n) {
243         if (n->renderer())
244             return true;
245         n = n->traverseNextNode(node);
246     }
247     return false;
248 }
249
250 void CompositeEditCommand::prune(PassRefPtr<Node> prpNode)
251 {
252     RefPtr<Node> node = prpNode;
253
254     while (node) {
255         // If you change this rule you may have to add an updateLayout() here.
256         RenderObject* renderer = node->renderer();
257         if (renderer && (!renderer->canHaveChildren() || hasARenderedDescendant(node.get()) || node->rootEditableElement() == node))
258             return;
259             
260         RefPtr<ContainerNode> next = node->parentNode();
261         removeNode(node);
262         node = next;
263     }
264 }
265
266 void CompositeEditCommand::splitTextNode(PassRefPtr<Text> node, unsigned offset)
267 {
268     applyCommandToComposite(SplitTextNodeCommand::create(node, offset));
269 }
270
271 void CompositeEditCommand::splitElement(PassRefPtr<Element> element, PassRefPtr<Node> atChild)
272 {
273     applyCommandToComposite(SplitElementCommand::create(element, atChild));
274 }
275
276 void CompositeEditCommand::mergeIdenticalElements(PassRefPtr<Element> prpFirst, PassRefPtr<Element> prpSecond)
277 {
278     RefPtr<Element> first = prpFirst;
279     RefPtr<Element> second = prpSecond;
280     ASSERT(!first->isDescendantOf(second.get()) && second != first);
281     if (first->nextSibling() != second) {
282         removeNode(second);
283         insertNodeAfter(second, first);
284     }
285     applyCommandToComposite(MergeIdenticalElementsCommand::create(first, second));
286 }
287
288 void CompositeEditCommand::wrapContentsInDummySpan(PassRefPtr<Element> element)
289 {
290     applyCommandToComposite(WrapContentsInDummySpanCommand::create(element));
291 }
292
293 void CompositeEditCommand::splitTextNodeContainingElement(PassRefPtr<Text> text, unsigned offset)
294 {
295     applyCommandToComposite(SplitTextNodeContainingElementCommand::create(text, offset));
296 }
297
298 void CompositeEditCommand::inputText(const String& text, bool selectInsertedText)
299 {
300     unsigned offset = 0;
301     unsigned length = text.length();
302     RefPtr<Range> startRange = Range::create(document(), firstPositionInNode(document()->documentElement()), endingSelection().start());
303     unsigned startIndex = TextIterator::rangeLength(startRange.get());
304     size_t newline;
305     do {
306         newline = text.find('\n', offset);
307         if (newline != offset) {
308             RefPtr<InsertTextCommand> command = InsertTextCommand::create(document());
309             applyCommandToComposite(command);
310             int substringLength = newline == notFound ? length - offset : newline - offset;
311             command->input(text.substring(offset, substringLength), false);
312         }
313         if (newline != notFound)
314             insertLineBreak();
315             
316         offset = newline + 1;
317     } while (newline != notFound && offset != length);
318     
319     if (selectInsertedText) {
320         RefPtr<Range> selectedRange = TextIterator::rangeFromLocationAndLength(document()->documentElement(), startIndex, length);
321         setEndingSelection(VisibleSelection(selectedRange.get()));
322     }
323 }
324
325 void CompositeEditCommand::insertTextIntoNode(PassRefPtr<Text> node, unsigned offset, const String& text)
326 {
327     if (!text.isEmpty())
328         applyCommandToComposite(InsertIntoTextNodeCommand::create(node, offset, text));
329 }
330
331 void CompositeEditCommand::deleteTextFromNode(PassRefPtr<Text> node, unsigned offset, unsigned count)
332 {
333     applyCommandToComposite(DeleteFromTextNodeCommand::create(node, offset, count));
334 }
335
336 void CompositeEditCommand::replaceTextInNode(PassRefPtr<Text> node, unsigned offset, unsigned count, const String& replacementText)
337 {
338     applyCommandToComposite(DeleteFromTextNodeCommand::create(node.get(), offset, count));
339     if (!replacementText.isEmpty())
340         applyCommandToComposite(InsertIntoTextNodeCommand::create(node, offset, replacementText));
341 }
342
343 Position CompositeEditCommand::replaceSelectedTextInNode(const String& text)
344 {
345     Position start = endingSelection().start();
346     Position end = endingSelection().end();
347     if (start.containerNode() != end.containerNode() || !start.containerNode()->isTextNode() || isTabSpanTextNode(start.containerNode()))
348         return Position();
349
350     RefPtr<Text> textNode = static_cast<Text*>(start.containerNode());
351     replaceTextInNode(textNode, start.offsetInContainerNode(), end.offsetInContainerNode() - start.offsetInContainerNode(), text);
352
353     return Position(textNode.release(), start.offsetInContainerNode() + text.length());
354 }
355
356 void CompositeEditCommand::replaceTextInNodePreservingMarkers(PassRefPtr<Text> prpNode, unsigned offset, unsigned count, const String& replacementText)
357 {
358     RefPtr<Text> node(prpNode);
359     DocumentMarkerController* markerController = document()->markers();
360     Vector<DocumentMarker*> markers = markerController->markersInRange(Range::create(document(), node, offset, node, offset + count).get(), DocumentMarker::AllMarkers());
361     replaceTextInNode(node, offset, count, replacementText);
362     RefPtr<Range> newRange = Range::create(document(), node, offset, node, offset + replacementText.length());
363     for (size_t i = 0; i < markers.size(); ++i) {
364         if (markers[i]->hasDescription())
365             markerController->addMarker(newRange.get(), markers[i]->type(), markers[i]->description());
366         else
367             markerController->addMarker(newRange.get(), markers[i]->type());
368     }
369 }
370
371 Position CompositeEditCommand::positionOutsideTabSpan(const Position& pos)
372 {
373     if (!isTabSpanTextNode(pos.anchorNode()))
374         return pos;
375
376     if (pos.anchorType() == Position::PositionIsAfterAnchor)
377         return positionInParentAfterNode(pos.anchorNode());
378     if (pos.anchorType() == Position::PositionIsBeforeAnchor)
379         return positionInParentBeforeNode(pos.anchorNode());
380
381     Node* tabSpan = tabSpanNode(pos.containerNode());
382
383     if (pos.offsetInContainerNode() <= caretMinOffset(pos.containerNode()))
384         return positionInParentBeforeNode(tabSpan);
385
386     if (pos.offsetInContainerNode() >= caretMaxOffset(pos.containerNode()))
387         return positionInParentAfterNode(tabSpan);
388
389     splitTextNodeContainingElement(static_cast<Text *>(pos.containerNode()), pos.offsetInContainerNode());
390     return positionInParentBeforeNode(tabSpan);
391 }
392
393 void CompositeEditCommand::insertNodeAtTabSpanPosition(PassRefPtr<Node> node, const Position& pos)
394 {
395     // insert node before, after, or at split of tab span
396     insertNodeAt(node, positionOutsideTabSpan(pos));
397 }
398
399 void CompositeEditCommand::deleteSelection(bool smartDelete, bool mergeBlocksAfterDelete, bool replace, bool expandForSpecialElements)
400 {
401     if (endingSelection().isRange())
402         applyCommandToComposite(DeleteSelectionCommand::create(document(), smartDelete, mergeBlocksAfterDelete, replace, expandForSpecialElements));
403 }
404
405 void CompositeEditCommand::deleteSelection(const VisibleSelection &selection, bool smartDelete, bool mergeBlocksAfterDelete, bool replace, bool expandForSpecialElements)
406 {
407     if (selection.isRange())
408         applyCommandToComposite(DeleteSelectionCommand::create(selection, smartDelete, mergeBlocksAfterDelete, replace, expandForSpecialElements));
409 }
410
411 void CompositeEditCommand::removeCSSProperty(PassRefPtr<StyledElement> element, CSSPropertyID property)
412 {
413     applyCommandToComposite(RemoveCSSPropertyCommand::create(document(), element, property));
414 }
415
416 void CompositeEditCommand::removeNodeAttribute(PassRefPtr<Element> element, const QualifiedName& attribute)
417 {
418     setNodeAttribute(element, attribute, AtomicString());
419 }
420
421 void CompositeEditCommand::setNodeAttribute(PassRefPtr<Element> element, const QualifiedName& attribute, const AtomicString& value)
422 {
423     applyCommandToComposite(SetNodeAttributeCommand::create(element, attribute, value));
424 }
425
426 static inline bool containsOnlyWhitespace(const String& text)
427 {
428     for (unsigned i = 0; i < text.length(); ++i) {
429         if (!isWhitespace(text.characters()[i]))
430             return false;
431     }
432     
433     return true;
434 }
435
436 bool CompositeEditCommand::shouldRebalanceLeadingWhitespaceFor(const String& text) const
437 {
438     return containsOnlyWhitespace(text);
439 }
440
441 bool CompositeEditCommand::canRebalance(const Position& position) const
442 {
443     Node* node = position.containerNode();
444     if (position.anchorType() != Position::PositionIsOffsetInAnchor || !node || !node->isTextNode())
445         return false;
446
447     Text* textNode = static_cast<Text*>(node);
448     if (textNode->length() == 0)
449         return false;
450
451     RenderObject* renderer = textNode->renderer();
452     if (renderer && !renderer->style()->collapseWhiteSpace())
453         return false;
454
455     return true;
456 }
457
458 // FIXME: Doesn't go into text nodes that contribute adjacent text (siblings, cousins, etc).
459 void CompositeEditCommand::rebalanceWhitespaceAt(const Position& position)
460 {
461     Node* node = position.containerNode();
462     if (!canRebalance(position))
463         return;
464
465     // If the rebalance is for the single offset, and neither text[offset] nor text[offset - 1] are some form of whitespace, do nothing.
466     int offset = position.deprecatedEditingOffset();
467     String text = static_cast<Text*>(node)->data();
468     if (!isWhitespace(text[offset])) {
469         offset--;
470         if (offset < 0 || !isWhitespace(text[offset]))
471             return;
472     }
473
474     rebalanceWhitespaceOnTextSubstring(static_cast<Text*>(node), position.offsetInContainerNode(), position.offsetInContainerNode());
475 }
476
477 void CompositeEditCommand::rebalanceWhitespaceOnTextSubstring(PassRefPtr<Text> prpTextNode, int startOffset, int endOffset)
478 {
479     RefPtr<Text> textNode = prpTextNode;
480
481     String text = textNode->data();
482     ASSERT(!text.isEmpty());
483
484     // Set upstream and downstream to define the extent of the whitespace surrounding text[offset].
485     int upstream = startOffset;
486     while (upstream > 0 && isWhitespace(text[upstream - 1]))
487         upstream--;
488     
489     int downstream = endOffset;
490     while ((unsigned)downstream < text.length() && isWhitespace(text[downstream]))
491         downstream++;
492     
493     int length = downstream - upstream;
494     if (!length)
495         return;
496
497     VisiblePosition visibleUpstreamPos(Position(textNode, upstream));
498     VisiblePosition visibleDownstreamPos(Position(textNode, downstream));
499     
500     String string = text.substring(upstream, length);
501     String rebalancedString = stringWithRebalancedWhitespace(string,
502     // FIXME: Because of the problem mentioned at the top of this function, we must also use nbsps at the start/end of the string because
503     // this function doesn't get all surrounding whitespace, just the whitespace in the current text node.
504                                                              isStartOfParagraph(visibleUpstreamPos) || upstream == 0, 
505                                                              isEndOfParagraph(visibleDownstreamPos) || (unsigned)downstream == text.length());
506     
507     if (string != rebalancedString)
508         replaceTextInNodePreservingMarkers(textNode.release(), upstream, length, rebalancedString);
509 }
510
511 void CompositeEditCommand::prepareWhitespaceAtPositionForSplit(Position& position)
512 {
513     Node* node = position.deprecatedNode();
514     if (!node || !node->isTextNode())
515         return;
516     Text* textNode = static_cast<Text*>(node);    
517     
518     if (textNode->length() == 0)
519         return;
520     RenderObject* renderer = textNode->renderer();
521     if (renderer && !renderer->style()->collapseWhiteSpace())
522         return;
523
524     // Delete collapsed whitespace so that inserting nbsps doesn't uncollapse it.
525     Position upstreamPos = position.upstream();
526     deleteInsignificantText(position.upstream(), position.downstream());
527     position = upstreamPos.downstream();
528
529     VisiblePosition visiblePos(position);
530     VisiblePosition previousVisiblePos(visiblePos.previous());
531     Position previous(previousVisiblePos.deepEquivalent());
532     
533     if (isCollapsibleWhitespace(previousVisiblePos.characterAfter()) && previous.deprecatedNode()->isTextNode() && !previous.deprecatedNode()->hasTagName(brTag))
534         replaceTextInNodePreservingMarkers(static_cast<Text*>(previous.deprecatedNode()), previous.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
535     if (isCollapsibleWhitespace(visiblePos.characterAfter()) && position.deprecatedNode()->isTextNode() && !position.deprecatedNode()->hasTagName(brTag))
536         replaceTextInNodePreservingMarkers(static_cast<Text*>(position.deprecatedNode()), position.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
537 }
538
539 void CompositeEditCommand::rebalanceWhitespace()
540 {
541     VisibleSelection selection = endingSelection();
542     if (selection.isNone())
543         return;
544         
545     rebalanceWhitespaceAt(selection.start());
546     if (selection.isRange())
547         rebalanceWhitespaceAt(selection.end());
548 }
549
550 void CompositeEditCommand::deleteInsignificantText(PassRefPtr<Text> textNode, unsigned start, unsigned end)
551 {
552     if (!textNode || start >= end)
553         return;
554
555     RenderText* textRenderer = toRenderText(textNode->renderer());
556     if (!textRenderer)
557         return;
558
559     Vector<InlineTextBox*> sortedTextBoxes;
560     size_t sortedTextBoxesPosition = 0;
561    
562     for (InlineTextBox* textBox = textRenderer->firstTextBox(); textBox; textBox = textBox->nextTextBox())
563         sortedTextBoxes.append(textBox);
564     
565     // If there is mixed directionality text, the boxes can be out of order,
566     // (like Arabic with embedded LTR), so sort them first. 
567     if (textRenderer->containsReversedText())    
568         std::sort(sortedTextBoxes.begin(), sortedTextBoxes.end(), InlineTextBox::compareByStart);
569     InlineTextBox* box = sortedTextBoxes.isEmpty() ? 0 : sortedTextBoxes[sortedTextBoxesPosition];
570
571     if (!box) {
572         // whole text node is empty
573         removeNode(textNode);
574         return;    
575     }
576     
577     unsigned length = textNode->length();
578     if (start >= length || end > length)
579         return;
580
581     unsigned removed = 0;
582     InlineTextBox* prevBox = 0;
583     String str;
584
585     // This loop structure works to process all gaps preceding a box,
586     // and also will look at the gap after the last box.
587     while (prevBox || box) {
588         unsigned gapStart = prevBox ? prevBox->start() + prevBox->len() : 0;
589         if (end < gapStart)
590             // No more chance for any intersections
591             break;
592
593         unsigned gapEnd = box ? box->start() : length;
594         bool indicesIntersect = start <= gapEnd && end >= gapStart;
595         int gapLen = gapEnd - gapStart;
596         if (indicesIntersect && gapLen > 0) {
597             gapStart = max(gapStart, start);
598             gapEnd = min(gapEnd, end);
599             if (str.isNull())
600                 str = textNode->data().substring(start, end - start);
601             // remove text in the gap
602             str.remove(gapStart - start - removed, gapLen);
603             removed += gapLen;
604         }
605         
606         prevBox = box;
607         if (box) {
608             if (++sortedTextBoxesPosition < sortedTextBoxes.size())
609                 box = sortedTextBoxes[sortedTextBoxesPosition];
610             else
611                 box = 0;
612         }
613     }
614
615     if (!str.isNull()) {
616         // Replace the text between start and end with our pruned version.
617         if (!str.isEmpty())
618             replaceTextInNode(textNode, start, end - start, str);
619         else {
620             // Assert that we are not going to delete all of the text in the node.
621             // If we were, that should have been done above with the call to 
622             // removeNode and return.
623             ASSERT(start > 0 || end - start < textNode->length());
624             deleteTextFromNode(textNode, start, end - start);
625         }
626     }
627 }
628
629 void CompositeEditCommand::deleteInsignificantText(const Position& start, const Position& end)
630 {
631     if (start.isNull() || end.isNull())
632         return;
633
634     if (comparePositions(start, end) >= 0)
635         return;
636
637     Node* next;
638     for (Node* node = start.deprecatedNode(); node; node = next) {
639         next = node->traverseNextNode();
640         if (node->isTextNode()) {
641             Text* textNode = static_cast<Text*>(node);
642             int startOffset = node == start.deprecatedNode() ? start.deprecatedEditingOffset() : 0;
643             int endOffset = node == end.deprecatedNode() ? end.deprecatedEditingOffset() : static_cast<int>(textNode->length());
644             deleteInsignificantText(textNode, startOffset, endOffset);
645         }
646         if (node == end.deprecatedNode())
647             break;
648     }
649 }
650
651 void CompositeEditCommand::deleteInsignificantTextDownstream(const Position& pos)
652 {
653     Position end = VisiblePosition(pos, VP_DEFAULT_AFFINITY).next().deepEquivalent().downstream();
654     deleteInsignificantText(pos, end);
655 }
656
657 PassRefPtr<Node> CompositeEditCommand::appendBlockPlaceholder(PassRefPtr<Element> container)
658 {
659     if (!container)
660         return 0;
661     
662     // Should assert isBlockFlow || isInlineFlow when deletion improves. See 4244964.
663     ASSERT(container->renderer());
664
665     RefPtr<Node> placeholder = createBlockPlaceholderElement(document());
666     appendNode(placeholder, container);
667     return placeholder.release();
668 }
669
670 PassRefPtr<Node> CompositeEditCommand::insertBlockPlaceholder(const Position& pos)
671 {
672     if (pos.isNull())
673         return 0;
674
675     // Should assert isBlockFlow || isInlineFlow when deletion improves.  See 4244964.
676     ASSERT(pos.deprecatedNode()->renderer());
677
678     RefPtr<Node> placeholder = createBlockPlaceholderElement(document());
679     insertNodeAt(placeholder, pos);
680     return placeholder.release();
681 }
682
683 PassRefPtr<Node> CompositeEditCommand::addBlockPlaceholderIfNeeded(Element* container)
684 {
685     if (!container)
686         return 0;
687
688     updateLayout();
689
690     RenderObject* renderer = container->renderer();
691     if (!renderer || !renderer->isBlockFlow())
692         return 0;
693     
694     // append the placeholder to make sure it follows
695     // any unrendered blocks
696     RenderBlock* block = toRenderBlock(renderer);
697     if (block->height() == 0 || (block->isListItem() && block->isEmpty()))
698         return appendBlockPlaceholder(container);
699
700     return 0;
701 }
702
703 // Assumes that the position is at a placeholder and does the removal without much checking.
704 void CompositeEditCommand::removePlaceholderAt(const Position& p)
705 {
706     ASSERT(lineBreakExistsAtPosition(p));
707     
708     // We are certain that the position is at a line break, but it may be a br or a preserved newline.
709     if (p.anchorNode()->hasTagName(brTag)) {
710         removeNode(p.anchorNode());
711         return;
712     }
713     
714     deleteTextFromNode(static_cast<Text*>(p.anchorNode()), p.offsetInContainerNode(), 1);
715 }
716
717 PassRefPtr<Node> CompositeEditCommand::insertNewDefaultParagraphElementAt(const Position& position)
718 {
719     RefPtr<Element> paragraphElement = createDefaultParagraphElement(document());
720     ExceptionCode ec;
721     paragraphElement->appendChild(createBreakElement(document()), ec);
722     insertNodeAt(paragraphElement, position);
723     return paragraphElement.release();
724 }
725
726 // If the paragraph is not entirely within it's own block, create one and move the paragraph into 
727 // it, and return that block.  Otherwise return 0.
728 PassRefPtr<Node> CompositeEditCommand::moveParagraphContentsToNewBlockIfNecessary(const Position& pos)
729 {
730     if (pos.isNull())
731         return 0;
732     
733     updateLayout();
734     
735     // It's strange that this function is responsible for verifying that pos has not been invalidated
736     // by an earlier call to this function.  The caller, applyBlockStyle, should do this.
737     VisiblePosition visiblePos(pos, VP_DEFAULT_AFFINITY);
738     VisiblePosition visibleParagraphStart(startOfParagraph(visiblePos));
739     VisiblePosition visibleParagraphEnd = endOfParagraph(visiblePos);
740     VisiblePosition next = visibleParagraphEnd.next();
741     VisiblePosition visibleEnd = next.isNotNull() ? next : visibleParagraphEnd;
742     
743     Position upstreamStart = visibleParagraphStart.deepEquivalent().upstream();
744     Position upstreamEnd = visibleEnd.deepEquivalent().upstream();
745
746     // If there are no VisiblePositions in the same block as pos then 
747     // upstreamStart will be outside the paragraph
748     if (comparePositions(pos, upstreamStart) < 0)
749         return 0;
750
751     // Perform some checks to see if we need to perform work in this function.
752     if (isBlock(upstreamStart.deprecatedNode())) {
753         // If the block is the root editable element, always move content to a new block,
754         // since it is illegal to modify attributes on the root editable element for editing.
755         if (upstreamStart.deprecatedNode() == editableRootForPosition(upstreamStart)) {
756             // If the block is the root editable element and it contains no visible content, create a new
757             // block but don't try and move content into it, since there's nothing for moveParagraphs to move.
758             if (!Position::hasRenderedNonAnonymousDescendantsWithHeight(upstreamStart.deprecatedNode()->renderer()))
759                 return insertNewDefaultParagraphElementAt(upstreamStart);
760         } else if (isBlock(upstreamEnd.deprecatedNode())) {
761             if (!upstreamEnd.deprecatedNode()->isDescendantOf(upstreamStart.deprecatedNode())) {
762                 // If the paragraph end is a descendant of paragraph start, then we need to run
763                 // the rest of this function. If not, we can bail here.
764                 return 0;
765             }
766         } else if (enclosingBlock(upstreamEnd.deprecatedNode()) != upstreamStart.deprecatedNode()) {
767             // The visibleEnd.  It must be an ancestor of the paragraph start.
768             // We can bail as we have a full block to work with.
769             ASSERT(upstreamStart.deprecatedNode()->isDescendantOf(enclosingBlock(upstreamEnd.deprecatedNode())));
770             return 0;
771         } else if (isEndOfDocument(visibleEnd)) {
772             // At the end of the document. We can bail here as well.
773             return 0;
774         }
775     }
776
777     RefPtr<Node> newBlock = insertNewDefaultParagraphElementAt(upstreamStart);
778
779     bool endWasBr = visibleParagraphEnd.deepEquivalent().deprecatedNode()->hasTagName(brTag);
780
781     moveParagraphs(visibleParagraphStart, visibleParagraphEnd, VisiblePosition(firstPositionInNode(newBlock.get())));
782
783     if (newBlock->lastChild() && newBlock->lastChild()->hasTagName(brTag) && !endWasBr)
784         removeNode(newBlock->lastChild());
785
786     return newBlock.release();
787 }
788
789 void CompositeEditCommand::pushAnchorElementDown(Node* anchorNode)
790 {
791     if (!anchorNode)
792         return;
793     
794     ASSERT(anchorNode->isLink());
795     
796     setEndingSelection(VisibleSelection::selectionFromContentsOfNode(anchorNode));
797     applyStyledElement(static_cast<Element*>(anchorNode));
798     // Clones of anchorNode have been pushed down, now remove it.
799     if (anchorNode->inDocument())
800         removeNodePreservingChildren(anchorNode);
801 }
802
803 // Clone the paragraph between start and end under blockElement,
804 // preserving the hierarchy up to outerNode. 
805
806 void CompositeEditCommand::cloneParagraphUnderNewElement(Position& start, Position& end, Node* outerNode, Element* blockElement)
807 {
808     // First we clone the outerNode
809     
810     RefPtr<Node> topNode = outerNode->cloneNode(isTableElement(outerNode));
811     appendNode(topNode, blockElement);
812     RefPtr<Node> lastNode = topNode;
813
814     if (start.deprecatedNode() != outerNode) {
815         Vector<RefPtr<Node> > ancestors;
816         
817         // Insert each node from innerNode to outerNode (excluded) in a list.
818         for (Node* n = start.deprecatedNode(); n && n != outerNode; n = n->parentNode())
819             ancestors.append(n);
820
821         // Clone every node between start.deprecatedNode() and outerBlock.
822
823         for (size_t i = ancestors.size(); i != 0; --i) {
824             Node* item = ancestors[i - 1].get();
825             RefPtr<Node> child = item->cloneNode(isTableElement(item));
826             appendNode(child, static_cast<Element *>(lastNode.get()));
827             lastNode = child.release();
828         }
829     }
830
831     // Handle the case of paragraphs with more than one node,
832     // cloning all the siblings until end.deprecatedNode() is reached.
833     
834     if (start.deprecatedNode() != end.deprecatedNode() && !start.deprecatedNode()->isDescendantOf(end.deprecatedNode())) {
835         // If end is not a descendant of outerNode we need to
836         // find the first common ancestor and adjust the insertion
837         // point accordingly.
838         while (!end.deprecatedNode()->isDescendantOf(outerNode)) {
839             outerNode = outerNode->parentNode();
840             topNode = topNode->parentNode();
841         }
842
843         for (Node* n = start.deprecatedNode()->traverseNextSibling(outerNode); n; n = n->traverseNextSibling(outerNode)) {
844             if (n->parentNode() != start.deprecatedNode()->parentNode())
845                 lastNode = topNode->lastChild();
846
847             RefPtr<Node> clonedNode = n->cloneNode(true);
848             insertNodeAfter(clonedNode, lastNode);
849             lastNode = clonedNode.release();
850             if (n == end.deprecatedNode() || end.deprecatedNode()->isDescendantOf(n))
851                 break;
852         }
853     }
854 }
855
856     
857 // There are bugs in deletion when it removes a fully selected table/list.
858 // It expands and removes the entire table/list, but will let content
859 // before and after the table/list collapse onto one line.   
860 // Deleting a paragraph will leave a placeholder. Remove it (and prune
861 // empty or unrendered parents).
862
863 void CompositeEditCommand::cleanupAfterDeletion(VisiblePosition destination)
864 {
865     VisiblePosition caretAfterDelete = endingSelection().visibleStart();
866     if (caretAfterDelete != destination && isStartOfParagraph(caretAfterDelete) && isEndOfParagraph(caretAfterDelete)) {
867         // Note: We want the rightmost candidate.
868         Position position = caretAfterDelete.deepEquivalent().downstream();
869         Node* node = position.deprecatedNode();
870         // Normally deletion will leave a br as a placeholder.
871         if (node->hasTagName(brTag))
872             removeNodeAndPruneAncestors(node);
873         // If the selection to move was empty and in an empty block that 
874         // doesn't require a placeholder to prop itself open (like a bordered
875         // div or an li), remove it during the move (the list removal code
876         // expects this behavior).
877         else if (isBlock(node))
878             removeNodeAndPruneAncestors(node);
879         else if (lineBreakExistsAtPosition(position)) {
880             // There is a preserved '\n' at caretAfterDelete.
881             // We can safely assume this is a text node.
882             Text* textNode = static_cast<Text*>(node);
883             if (textNode->length() == 1)
884                 removeNodeAndPruneAncestors(node);
885             else
886                 deleteTextFromNode(textNode, position.deprecatedEditingOffset(), 1);
887         }
888     }
889 }
890     
891 // This is a version of moveParagraph that preserves style by keeping the original markup
892 // It is currently used only by IndentOutdentCommand but it is meant to be used in the
893 // future by several other commands such as InsertList and the align commands.
894 // The blockElement parameter is the element to move the paragraph to,
895 // outerNode is the top element of the paragraph hierarchy. 
896
897 void CompositeEditCommand::moveParagraphWithClones(const VisiblePosition& startOfParagraphToMove, const VisiblePosition& endOfParagraphToMove, Element* blockElement, Node* outerNode)
898 {
899     ASSERT(outerNode);
900     ASSERT(blockElement);
901
902     VisiblePosition beforeParagraph = startOfParagraphToMove.previous();
903     VisiblePosition afterParagraph(endOfParagraphToMove.next());
904     
905     // We upstream() the end and downstream() the start so that we don't include collapsed whitespace in the move.
906     // When we paste a fragment, spaces after the end and before the start are treated as though they were rendered.
907     Position start = startOfParagraphToMove.deepEquivalent().downstream();
908     Position end = endOfParagraphToMove.deepEquivalent().upstream();
909
910     cloneParagraphUnderNewElement(start, end, outerNode, blockElement);
911       
912     setEndingSelection(VisibleSelection(start, end, DOWNSTREAM));
913     deleteSelection(false, false, false, false);
914     
915     // There are bugs in deletion when it removes a fully selected table/list.
916     // It expands and removes the entire table/list, but will let content
917     // before and after the table/list collapse onto one line.
918        
919     cleanupAfterDeletion();
920     
921     // Add a br if pruning an empty block level element caused a collapse.  For example:
922     // foo^
923     // <div>bar</div>
924     // baz
925     // Imagine moving 'bar' to ^.  'bar' will be deleted and its div pruned.  That would
926     // cause 'baz' to collapse onto the line with 'foobar' unless we insert a br.
927     // Must recononicalize these two VisiblePositions after the pruning above.
928     beforeParagraph = VisiblePosition(beforeParagraph.deepEquivalent());
929     afterParagraph = VisiblePosition(afterParagraph.deepEquivalent());
930
931     if (beforeParagraph.isNotNull() && !isTableElement(beforeParagraph.deepEquivalent().deprecatedNode())
932         && ((!isEndOfParagraph(beforeParagraph) && !isStartOfParagraph(beforeParagraph)) || beforeParagraph == afterParagraph)) {
933         // FIXME: Trim text between beforeParagraph and afterParagraph if they aren't equal.
934         insertNodeAt(createBreakElement(document()), beforeParagraph.deepEquivalent());
935     }
936 }
937     
938     
939 // This moves a paragraph preserving its style.
940 void CompositeEditCommand::moveParagraph(const VisiblePosition& startOfParagraphToMove, const VisiblePosition& endOfParagraphToMove, const VisiblePosition& destination, bool preserveSelection, bool preserveStyle)
941 {
942     ASSERT(isStartOfParagraph(startOfParagraphToMove));
943     ASSERT(isEndOfParagraph(endOfParagraphToMove));
944     moveParagraphs(startOfParagraphToMove, endOfParagraphToMove, destination, preserveSelection, preserveStyle);
945 }
946
947 void CompositeEditCommand::moveParagraphs(const VisiblePosition& startOfParagraphToMove, const VisiblePosition& endOfParagraphToMove, const VisiblePosition& destination, bool preserveSelection, bool preserveStyle)
948 {
949     if (startOfParagraphToMove == destination)
950         return;
951     
952     int startIndex = -1;
953     int endIndex = -1;
954     int destinationIndex = -1;
955     if (preserveSelection && !endingSelection().isNone()) {
956         VisiblePosition visibleStart = endingSelection().visibleStart();
957         VisiblePosition visibleEnd = endingSelection().visibleEnd();
958         
959         bool startAfterParagraph = comparePositions(visibleStart, endOfParagraphToMove) > 0;
960         bool endBeforeParagraph = comparePositions(visibleEnd, startOfParagraphToMove) < 0;
961         
962         if (!startAfterParagraph && !endBeforeParagraph) {
963             bool startInParagraph = comparePositions(visibleStart, startOfParagraphToMove) >= 0;
964             bool endInParagraph = comparePositions(visibleEnd, endOfParagraphToMove) <= 0;
965             
966             startIndex = 0;
967             if (startInParagraph) {
968                 RefPtr<Range> startRange = Range::create(document(), startOfParagraphToMove.deepEquivalent().parentAnchoredEquivalent(), visibleStart.deepEquivalent().parentAnchoredEquivalent());
969                 startIndex = TextIterator::rangeLength(startRange.get(), true);
970             }
971
972             endIndex = 0;
973             if (endInParagraph) {
974                 RefPtr<Range> endRange = Range::create(document(), startOfParagraphToMove.deepEquivalent().parentAnchoredEquivalent(), visibleEnd.deepEquivalent().parentAnchoredEquivalent());
975                 endIndex = TextIterator::rangeLength(endRange.get(), true);
976             }
977         }
978     }
979     
980     VisiblePosition beforeParagraph = startOfParagraphToMove.previous(CannotCrossEditingBoundary);
981     VisiblePosition afterParagraph(endOfParagraphToMove.next(CannotCrossEditingBoundary));
982
983     // We upstream() the end and downstream() the start so that we don't include collapsed whitespace in the move.
984     // When we paste a fragment, spaces after the end and before the start are treated as though they were rendered.
985     Position start = startOfParagraphToMove.deepEquivalent().downstream();
986     Position end = endOfParagraphToMove.deepEquivalent().upstream();
987     
988     // start and end can't be used directly to create a Range; they are "editing positions"
989     Position startRangeCompliant = start.parentAnchoredEquivalent();
990     Position endRangeCompliant = end.parentAnchoredEquivalent();
991     RefPtr<Range> range = Range::create(document(), startRangeCompliant.deprecatedNode(), startRangeCompliant.deprecatedEditingOffset(), endRangeCompliant.deprecatedNode(), endRangeCompliant.deprecatedEditingOffset());
992
993     // FIXME: This is an inefficient way to preserve style on nodes in the paragraph to move. It
994     // shouldn't matter though, since moved paragraphs will usually be quite small.
995     RefPtr<DocumentFragment> fragment;
996     // This used to use a ternary for initialization, but that confused some versions of GCC, see bug 37912
997     if (startOfParagraphToMove != endOfParagraphToMove)
998         fragment = createFragmentFromMarkup(document(), createMarkup(range.get(), 0, DoNotAnnotateForInterchange, true), "");
999
1000     // A non-empty paragraph's style is moved when we copy and move it.  We don't move 
1001     // anything if we're given an empty paragraph, but an empty paragraph can have style
1002     // too, <div><b><br></b></div> for example.  Save it so that we can preserve it later.
1003     RefPtr<EditingStyle> styleInEmptyParagraph;
1004     if (startOfParagraphToMove == endOfParagraphToMove && preserveStyle) {
1005         styleInEmptyParagraph = EditingStyle::create(startOfParagraphToMove.deepEquivalent());
1006         styleInEmptyParagraph->mergeTypingStyle(document());
1007         // The moved paragraph should assume the block style of the destination.
1008         styleInEmptyParagraph->removeBlockProperties();
1009     }
1010     
1011     // FIXME (5098931): We should add a new insert action "WebViewInsertActionMoved" and call shouldInsertFragment here.
1012     
1013     setEndingSelection(VisibleSelection(start, end, DOWNSTREAM));
1014     document()->frame()->editor()->clearMisspellingsAndBadGrammar(endingSelection());
1015     deleteSelection(false, false, false, false);
1016
1017     ASSERT(destination.deepEquivalent().anchorNode()->inDocument());
1018     cleanupAfterDeletion(destination);
1019     ASSERT(destination.deepEquivalent().anchorNode()->inDocument());
1020
1021     // Add a br if pruning an empty block level element caused a collapse. For example:
1022     // foo^
1023     // <div>bar</div>
1024     // baz
1025     // Imagine moving 'bar' to ^. 'bar' will be deleted and its div pruned. That would
1026     // cause 'baz' to collapse onto the line with 'foobar' unless we insert a br.
1027     // Must recononicalize these two VisiblePositions after the pruning above.
1028     beforeParagraph = VisiblePosition(beforeParagraph.deepEquivalent());
1029     afterParagraph = VisiblePosition(afterParagraph.deepEquivalent());
1030     if (beforeParagraph.isNotNull() && (!isEndOfParagraph(beforeParagraph) || beforeParagraph == afterParagraph)) {
1031         // FIXME: Trim text between beforeParagraph and afterParagraph if they aren't equal.
1032         insertNodeAt(createBreakElement(document()), beforeParagraph.deepEquivalent());
1033         // Need an updateLayout here in case inserting the br has split a text node.
1034         updateLayout();
1035     }
1036
1037     RefPtr<Range> startToDestinationRange(Range::create(document(), firstPositionInNode(document()->documentElement()), destination.deepEquivalent().parentAnchoredEquivalent()));
1038     destinationIndex = TextIterator::rangeLength(startToDestinationRange.get(), true);
1039
1040     setEndingSelection(destination);
1041     ASSERT(endingSelection().isCaretOrRange());
1042     ReplaceSelectionCommand::CommandOptions options = ReplaceSelectionCommand::SelectReplacement | ReplaceSelectionCommand::MovingParagraph;
1043     if (!preserveStyle)
1044         options |= ReplaceSelectionCommand::MatchStyle;
1045     applyCommandToComposite(ReplaceSelectionCommand::create(document(), fragment, options));
1046
1047     document()->frame()->editor()->markMisspellingsAndBadGrammar(endingSelection());
1048
1049     // If the selection is in an empty paragraph, restore styles from the old empty paragraph to the new empty paragraph.
1050     bool selectionIsEmptyParagraph = endingSelection().isCaret() && isStartOfParagraph(endingSelection().visibleStart()) && isEndOfParagraph(endingSelection().visibleStart());
1051     if (styleInEmptyParagraph && selectionIsEmptyParagraph)
1052         applyStyle(styleInEmptyParagraph.get());
1053
1054     if (preserveSelection && startIndex != -1) {
1055         // Fragment creation (using createMarkup) incorrectly uses regular
1056         // spaces instead of nbsps for some spaces that were rendered (11475), which
1057         // causes spaces to be collapsed during the move operation.  This results
1058         // in a call to rangeFromLocationAndLength with a location past the end
1059         // of the document (which will return null).
1060         RefPtr<Range> start = TextIterator::rangeFromLocationAndLength(document()->documentElement(), destinationIndex + startIndex, 0, true);
1061         RefPtr<Range> end = TextIterator::rangeFromLocationAndLength(document()->documentElement(), destinationIndex + endIndex, 0, true);
1062         if (start && end)
1063             setEndingSelection(VisibleSelection(start->startPosition(), end->startPosition(), DOWNSTREAM));
1064     }
1065 }
1066
1067 // FIXME: Send an appropriate shouldDeleteRange call.
1068 bool CompositeEditCommand::breakOutOfEmptyListItem()
1069 {
1070     Node* emptyListItem = enclosingEmptyListItem(endingSelection().visibleStart());
1071     if (!emptyListItem)
1072         return false;
1073
1074     RefPtr<EditingStyle> style = EditingStyle::create(endingSelection().start());
1075     style->mergeTypingStyle(document());
1076
1077     ContainerNode* listNode = emptyListItem->parentNode();
1078     // FIXME: Can't we do something better when the immediate parent wasn't a list node?
1079     if (!listNode
1080         || (!listNode->hasTagName(ulTag) && !listNode->hasTagName(olTag))
1081         || !listNode->rendererIsEditable()
1082         || listNode == emptyListItem->rootEditableElement())
1083         return false;
1084
1085     RefPtr<Element> newBlock = 0;
1086     if (ContainerNode* blockEnclosingList = listNode->parentNode()) {
1087         if (blockEnclosingList->hasTagName(liTag)) { // listNode is inside another list item
1088             if (visiblePositionAfterNode(blockEnclosingList) == visiblePositionAfterNode(listNode)) {
1089                 // If listNode appears at the end of the outer list item, then move listNode outside of this list item
1090                 // e.g. <ul><li>hello <ul><li><br></li></ul> </li></ul> should become <ul><li>hello</li> <ul><li><br></li></ul> </ul> after this section
1091                 // If listNode does NOT appear at the end, then we should consider it as a regular paragraph.
1092                 // e.g. <ul><li> <ul><li><br></li></ul> hello</li></ul> should become <ul><li> <div><br></div> hello</li></ul> at the end
1093                 splitElement(static_cast<Element*>(blockEnclosingList), listNode);
1094                 removeNodePreservingChildren(listNode->parentNode());
1095                 newBlock = createListItemElement(document());
1096             }
1097             // If listNode does NOT appear at the end of the outer list item, then behave as if in a regular paragraph.
1098         } else if (blockEnclosingList->hasTagName(olTag) || blockEnclosingList->hasTagName(ulTag))
1099             newBlock = createListItemElement(document());
1100     }
1101     if (!newBlock)
1102         newBlock = createDefaultParagraphElement(document());
1103
1104     if (emptyListItem->renderer()->nextSibling()) {
1105         // If emptyListItem follows another list item, split the list node.
1106         if (emptyListItem->renderer()->previousSibling())
1107             splitElement(static_cast<Element*>(listNode), emptyListItem);
1108
1109         // If emptyListItem is followed by other list item, then insert newBlock before the list node.
1110         // Because we have splitted the element, emptyListItem is the first element in the list node.
1111         // i.e. insert newBlock before ul or ol whose first element is emptyListItem
1112         insertNodeBefore(newBlock, listNode);
1113         removeNode(emptyListItem);
1114     } else {
1115         // When emptyListItem does not follow any list item, insert newBlock after the enclosing list node.
1116         // Remove the enclosing node if emptyListItem is the only child; otherwise just remove emptyListItem.
1117         insertNodeAfter(newBlock, listNode);
1118         removeNode(emptyListItem->renderer()->previousSibling() ? emptyListItem : listNode);
1119     }
1120
1121     appendBlockPlaceholder(newBlock);
1122     setEndingSelection(VisibleSelection(firstPositionInNode(newBlock.get()), DOWNSTREAM));
1123
1124     style->prepareToApplyAt(endingSelection().start());
1125     if (!style->isEmpty())
1126         applyStyle(style.get());
1127
1128     return true;
1129 }
1130
1131 // If the caret is in an empty quoted paragraph, and either there is nothing before that
1132 // paragraph, or what is before is unquoted, and the user presses delete, unquote that paragraph.
1133 bool CompositeEditCommand::breakOutOfEmptyMailBlockquotedParagraph()
1134 {
1135     if (!endingSelection().isCaret())
1136         return false;
1137         
1138     VisiblePosition caret(endingSelection().visibleStart());
1139     Node* highestBlockquote = highestEnclosingNodeOfType(caret.deepEquivalent(), &isMailBlockquote);
1140     if (!highestBlockquote)
1141         return false;
1142         
1143     if (!isStartOfParagraph(caret) || !isEndOfParagraph(caret))
1144         return false;
1145     
1146     VisiblePosition previous(caret.previous(CannotCrossEditingBoundary));
1147     // Only move forward if there's nothing before the caret, or if there's unquoted content before it.
1148     if (enclosingNodeOfType(previous.deepEquivalent(), &isMailBlockquote))
1149         return false;
1150     
1151     RefPtr<Node> br = createBreakElement(document());
1152     // We want to replace this quoted paragraph with an unquoted one, so insert a br
1153     // to hold the caret before the highest blockquote.
1154     insertNodeBefore(br, highestBlockquote);
1155     VisiblePosition atBR(positionBeforeNode(br.get()));
1156     // If the br we inserted collapsed, for example foo<br><blockquote>...</blockquote>, insert
1157     // a second one.
1158     if (!isStartOfParagraph(atBR))
1159         insertNodeBefore(createBreakElement(document()), br);
1160     setEndingSelection(VisibleSelection(atBR));
1161     
1162     // If this is an empty paragraph there must be a line break here.
1163     if (!lineBreakExistsAtVisiblePosition(caret))
1164         return false;
1165
1166     Position caretPos(caret.deepEquivalent().downstream());
1167     // A line break is either a br or a preserved newline.
1168     ASSERT(caretPos.deprecatedNode()->hasTagName(brTag) || (caretPos.deprecatedNode()->isTextNode() && caretPos.deprecatedNode()->renderer()->style()->preserveNewline()));
1169     
1170     if (caretPos.deprecatedNode()->hasTagName(brTag)) {
1171         Position beforeBR(positionInParentBeforeNode(caretPos.deprecatedNode()));
1172         removeNode(caretPos.deprecatedNode());
1173         prune(beforeBR.deprecatedNode());
1174     } else if (caretPos.deprecatedNode()->isTextNode()) {
1175         ASSERT(caretPos.deprecatedEditingOffset() == 0);
1176         Text* textNode = static_cast<Text*>(caretPos.deprecatedNode());
1177         ContainerNode* parentNode = textNode->parentNode();
1178         // The preserved newline must be the first thing in the node, since otherwise the previous
1179         // paragraph would be quoted, and we verified that it wasn't above.
1180         deleteTextFromNode(textNode, 0, 1);
1181         prune(parentNode);
1182     }
1183
1184     return true;
1185 }
1186
1187 // Operations use this function to avoid inserting content into an anchor when at the start or the end of
1188 // that anchor, as in NSTextView.
1189 // FIXME: This is only an approximation of NSTextViews insertion behavior, which varies depending on how
1190 // the caret was made. 
1191 Position CompositeEditCommand::positionAvoidingSpecialElementBoundary(const Position& original)
1192 {
1193     if (original.isNull())
1194         return original;
1195         
1196     VisiblePosition visiblePos(original);
1197     Node* enclosingAnchor = enclosingAnchorElement(original);
1198     Position result = original;
1199
1200     if (!enclosingAnchor)
1201         return result;
1202
1203     // Don't avoid block level anchors, because that would insert content into the wrong paragraph.
1204     if (enclosingAnchor && !isBlock(enclosingAnchor)) {
1205         VisiblePosition firstInAnchor(firstPositionInNode(enclosingAnchor));
1206         VisiblePosition lastInAnchor(lastPositionInNode(enclosingAnchor));
1207         // If visually just after the anchor, insert *inside* the anchor unless it's the last
1208         // VisiblePosition in the document, to match NSTextView.
1209         if (visiblePos == lastInAnchor) {
1210             // Make sure anchors are pushed down before avoiding them so that we don't
1211             // also avoid structural elements like lists and blocks (5142012).
1212             if (original.deprecatedNode() != enclosingAnchor && original.deprecatedNode()->parentNode() != enclosingAnchor) {
1213                 pushAnchorElementDown(enclosingAnchor);
1214                 enclosingAnchor = enclosingAnchorElement(original);
1215                 if (!enclosingAnchor)
1216                     return original;
1217             }
1218             // Don't insert outside an anchor if doing so would skip over a line break.  It would
1219             // probably be safe to move the line break so that we could still avoid the anchor here.
1220             Position downstream(visiblePos.deepEquivalent().downstream());
1221             if (lineBreakExistsAtVisiblePosition(visiblePos) && downstream.deprecatedNode()->isDescendantOf(enclosingAnchor))
1222                 return original;
1223             
1224             result = positionInParentAfterNode(enclosingAnchor);
1225         }
1226         // If visually just before an anchor, insert *outside* the anchor unless it's the first
1227         // VisiblePosition in a paragraph, to match NSTextView.
1228         if (visiblePos == firstInAnchor) {
1229             // Make sure anchors are pushed down before avoiding them so that we don't
1230             // also avoid structural elements like lists and blocks (5142012).
1231             if (original.deprecatedNode() != enclosingAnchor && original.deprecatedNode()->parentNode() != enclosingAnchor) {
1232                 pushAnchorElementDown(enclosingAnchor);
1233                 enclosingAnchor = enclosingAnchorElement(original);
1234             }
1235             if (!enclosingAnchor)
1236                 return original;
1237
1238             result = positionInParentBeforeNode(enclosingAnchor);
1239         }
1240     }
1241         
1242     if (result.isNull() || !editableRootForPosition(result))
1243         result = original;
1244     
1245     return result;
1246 }
1247
1248 // Splits the tree parent by parent until we reach the specified ancestor. We use VisiblePositions
1249 // to determine if the split is necessary. Returns the last split node.
1250 PassRefPtr<Node> CompositeEditCommand::splitTreeToNode(Node* start, Node* end, bool shouldSplitAncestor)
1251 {
1252     ASSERT(start);
1253     ASSERT(end);
1254     ASSERT(start != end);
1255
1256     RefPtr<Node> node;
1257     if (shouldSplitAncestor && end->parentNode())
1258         end = end->parentNode();
1259
1260     RefPtr<Node> endNode = end;
1261     for (node = start; node && node->parentNode() != endNode; node = node->parentNode()) {
1262         if (!node->parentNode()->isElementNode())
1263             break;
1264         // Do not split a node when doing so introduces an empty node.
1265         VisiblePosition positionInParent = firstPositionInNode(node->parentNode());
1266         VisiblePosition positionInNode = firstPositionInOrBeforeNode(node.get());
1267         if (positionInParent != positionInNode)
1268             splitElement(static_cast<Element*>(node->parentNode()), node);
1269     }
1270
1271     return node.release();
1272 }
1273
1274 PassRefPtr<Element> createBlockPlaceholderElement(Document* document)
1275 {
1276     RefPtr<Element> breakNode = document->createElement(brTag, false);
1277     return breakNode.release();
1278 }
1279
1280 } // namespace WebCore