Merge 107761

Source/WebCore/editing/CompositeEditCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 10 matching lines @@
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "CompositeEditCommand.h"
 
 #include "AppendNodeCommand.h"
 #include "ApplyStyleCommand.h"
+#include "DeleteButtonController.h"
 #include "DeleteFromTextNodeCommand.h"
 #include "DeleteSelectionCommand.h"
 #include "Document.h"
 #include "DocumentFragment.h"
 #include "DocumentMarkerController.h"
 #include "EditorInsertAction.h"
 #include "Frame.h"
 #include "HTMLElement.h"
 #include "HTMLNames.h"
 #include "InlineTextBox.h"
 #include "InsertIntoTextNodeCommand.h"
 #include "InsertLineBreakCommand.h"
 #include "InsertNodeBeforeCommand.h"
 #include "InsertParagraphSeparatorCommand.h"
 #include "InsertTextCommand.h"
 #include "MergeIdenticalElementsCommand.h"
 #include "Range.h"
 #include "RemoveCSSPropertyCommand.h"
 #include "RemoveNodeCommand.h"
 #include "RemoveNodePreservingChildrenCommand.h"
 #include "ReplaceNodeWithSpanCommand.h"
 #include "ReplaceSelectionCommand.h"
 #include "RenderBlock.h"
 #include "RenderText.h"
+#include "ScopedEventQueue.h"
 #include "SetNodeAttributeCommand.h"
 #include "SplitElementCommand.h"
 #include "SplitTextNodeCommand.h"
 #include "SplitTextNodeContainingElementCommand.h"
 #include "Text.h"
 #include "TextIterator.h"
 #include "WrapContentsInDummySpanCommand.h"
 #include "htmlediting.h"
 #include "markup.h"
 #include "visible_units.h"
 #include <wtf/unicode/CharacterNames.h>
 
 using namespace std;
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
+PassRefPtr<EditCommandComposition> EditCommandComposition::create(Document* document,
+    const VisibleSelection& startingSelection, const VisibleSelection& endingSelection, EditAction editAction)
+{
+    return adoptRef(new EditCommandComposition(document, startingSelection, endingSelection, editAction));
+}
+
+EditCommandComposition::EditCommandComposition(Document* document, const VisibleSelection& startingSelection, const VisibleSelection& endingSelection, EditAction editAction)
+    : m_document(document)
+    , m_startingSelection(startingSelection)
+    , m_endingSelection(endingSelection)
+    , m_startingRootEditableElement(startingSelection.rootEditableElement())
+    , m_endingRootEditableElement(endingSelection.rootEditableElement())
+    , m_editAction(editAction)
+{
+}
+
+void EditCommandComposition::unapply()
+{
+    ASSERT(m_document);
+    Frame* frame = m_document->frame();
+    ASSERT(frame);
+
+    // Changes to the document may have been made since the last editing operation that require a layout, as in <rdar://problem/5658603>.
+    // Low level operations, like RemoveNodeCommand, don't require a layout because the high level operations that use them perform one
+    // if one is necessary (like for the creation of VisiblePositions).
+    m_document->updateLayoutIgnorePendingStylesheets();
+    
+    DeleteButtonController* deleteButtonController = frame->editor()->deleteButtonController();
+    deleteButtonController->disable();
+    size_t size = m_commands.size();
+    for (size_t i = size; i != 0; --i)
+        m_commands[i - 1]->doUnapply();
+    deleteButtonController->enable();
+    
+    frame->editor()->unappliedEditing(this);
+}
+
+void EditCommandComposition::reapply()
+{
+    ASSERT(m_document);
+    Frame* frame = m_document->frame();
+    ASSERT(frame);
+
+    // Changes to the document may have been made since the last editing operation that require a layout, as in <rdar://problem/5658603>.
+    // Low level operations, like RemoveNodeCommand, don't require a layout because the high level operations that use them perform one
+    // if one is necessary (like for the creation of VisiblePositions).
+    m_document->updateLayoutIgnorePendingStylesheets();
+    
+    DeleteButtonController* deleteButtonController = frame->editor()->deleteButtonController();
+    deleteButtonController->disable();
+    size_t size = m_commands.size();
+    for (size_t i = 0; i != size; ++i)
+        m_commands[i]->doReapply();
+    deleteButtonController->enable();
+    
+    frame->editor()->reappliedEditing(this);
+}
+
+void EditCommandComposition::append(SimpleEditCommand* command)
+{
+    m_commands.append(command);
+}
+
+void EditCommandComposition::setStartingSelection(const VisibleSelection& selection)
+{
+    m_startingSelection = selection;
+    m_startingRootEditableElement = selection.rootEditableElement();
+}
+
+void EditCommandComposition::setEndingSelection(const VisibleSelection& selection)
+{
+    m_endingSelection = selection;
+    m_endingRootEditableElement = selection.rootEditableElement();
+}
+
+#ifndef NDEBUG
+void EditCommandComposition::getNodesInCommand(HashSet<Node*>& nodes)
+{
+    size_t size = m_commands.size();
+    for (size_t i = 0; i < size; ++i)
+        m_commands[i]->getNodesInCommand(nodes);
+}
+#endif
+
+void applyCommand(PassRefPtr<CompositeEditCommand> command)
+{
+    command->apply();
+}
+
 CompositeEditCommand::CompositeEditCommand(Document *document)
     : EditCommand(document)
 {
 }
 
 CompositeEditCommand::~CompositeEditCommand()
 {
+    ASSERT(isTopLevelCommand() || !m_composition);
 }
 
-void CompositeEditCommand::doUnapply()
+void CompositeEditCommand::apply()
 {
-    size_t size = m_commands.size();
-    for (size_t i = size; i != 0; --i)
-        m_commands[i - 1]->unapply();
+    if (!endingSelection().isContentRichlyEditable()) {
+        switch (editingAction()) {
+        case EditActionTyping:
+        case EditActionPaste:
+        case EditActionDrag:
+        case EditActionSetWritingDirection:
+        case EditActionCut:
+        case EditActionUnspecified:
+            break;
+        default:
+            ASSERT_NOT_REACHED();
+            return;
+        }
+    }
+    ensureComposition();
+
+    // Changes to the document may have been made since the last editing operation that require a layout, as in <rdar://problem/5658603>.
+    // Low level operations, like RemoveNodeCommand, don't require a layout because the high level operations that use them perform one
+    // if one is necessary (like for the creation of VisiblePositions).
+    ASSERT(document());
+    document()->updateLayoutIgnorePendingStylesheets();
+
+    Frame* frame = document()->frame();
+    ASSERT(frame);
+    {
+        EventQueueScope scope;
+        DeleteButtonController* deleteButtonController = frame->editor()->deleteButtonController();
+        deleteButtonController->disable();
+        doApply();
+        deleteButtonController->enable();
+    }
+
+    // Only need to call appliedEditing for top-level commands,
+    // and TypingCommands do it on their own (see TypingCommand::typingAddedToOpenCommand).
+    if (!isTypingCommand())
+        frame->editor()->appliedEditing(this);
+    setShouldRetainAutocorrectionIndicator(false);
 }
 
-void CompositeEditCommand::doReapply()
+EditCommandComposition* CompositeEditCommand::ensureComposition()
 {
-    size_t size = m_commands.size();
-    for (size_t i = 0; i != size; ++i)
-        m_commands[i]->reapply();
+    CompositeEditCommand* command = this;
+    while (command && command->parent())
+        command = command->parent();
+    if (!command->m_composition)
+        command->m_composition = EditCommandComposition::create(document(), startingSelection(), endingSelection(), editingAction());
+    return command->m_composition.get();
+}
+
+bool CompositeEditCommand::isCreateLinkCommand() const
+{
+    return false;
+}
+
+bool CompositeEditCommand::preservesTypingStyle() const
+{
+    return false;
+}
+
+bool CompositeEditCommand::isTypingCommand() const
+{
+    return false;
+}
+
+bool CompositeEditCommand::shouldRetainAutocorrectionIndicator() const
+{
+    return false;
+}
+
+void CompositeEditCommand::setShouldRetainAutocorrectionIndicator(bool)
+{
 }
 
 //
 // sugary-sweet convenience functions to help create and apply edit commands in composite commands
 //
-void CompositeEditCommand::applyCommandToComposite(PassRefPtr<EditCommand> cmd)
+void CompositeEditCommand::applyCommandToComposite(PassRefPtr<EditCommand> prpCommand)
 {
-    cmd->setParent(this);
-    cmd->apply();
-    m_commands.append(cmd);
+    RefPtr<EditCommand> command = prpCommand;
+    command->setParent(this);
+    command->doApply();
+    if (command->isSimpleEditCommand()) {
+        command->setParent(0);
+        ensureComposition()->append(toSimpleEditCommand(command.get()));
+    }
+    m_commands.append(command.release());
 }
 
 void CompositeEditCommand::applyCommandToComposite(PassRefPtr<CompositeEditCommand> command, const VisibleSelection& selection)
 {
     command->setParent(this);
     if (selection != command->endingSelection()) {
         command->setStartingSelection(selection);
         command->setEndingSelection(selection);
     }
-    command->apply();
+    command->doApply();
     m_commands.append(command);
 }
 
 void CompositeEditCommand::applyStyle(const EditingStyle* style, EditAction editingAction)
 {
     applyCommandToComposite(ApplyStyleCommand::create(document(), style, editingAction));
 }
 
 void CompositeEditCommand::applyStyle(const EditingStyle* style, const Position& start, const Position& end, EditAction editingAction)
 {
@@ skipping 13 matching lines @@
 void CompositeEditCommand::insertParagraphSeparator(bool useDefaultParagraphElement)
 {
     applyCommandToComposite(InsertParagraphSeparatorCommand::create(document(), useDefaultParagraphElement));
 }
 
 void CompositeEditCommand::insertLineBreak()
 {
     applyCommandToComposite(InsertLineBreakCommand::create(document()));
 }
 
+bool CompositeEditCommand::isRemovableBlock(const Node* node)
+{
+    Node* parentNode = node->parentNode();
+    if ((parentNode && parentNode->firstChild() != parentNode->lastChild()) || !node->hasTagName(divTag))
+        return false;
+
+    if (!node->isElementNode() || !toElement(node)->hasAttributes())
+        return true;
+
+    return false;
+}
+
 void CompositeEditCommand::insertNodeBefore(PassRefPtr<Node> insertChild, PassRefPtr<Node> refChild)
 {
     ASSERT(!refChild->hasTagName(bodyTag));
     applyCommandToComposite(InsertNodeBeforeCommand::create(insertChild, refChild));
 }
 
 void CompositeEditCommand::insertNodeAfter(PassRefPtr<Node> insertChild, PassRefPtr<Node> refChild)
 {
     ASSERT(insertChild);
     ASSERT(refChild);
@@ skipping 22 matching lines @@
         Node* child = refChild->firstChild();
         for (int i = 0; child && i < offset; i++)
             child = child->nextSibling();
         if (child)
             insertNodeBefore(insertChild, child);
         else
             appendNode(insertChild, static_cast<Element*>(refChild));
     } else if (caretMinOffset(refChild) >= offset)
         insertNodeBefore(insertChild, refChild);
     else if (refChild->isTextNode() && caretMaxOffset(refChild) > offset) {
-        splitTextNode(static_cast<Text *>(refChild), offset);
+        splitTextNode(toText(refChild), offset);
 
         // Mutation events (bug 22634) from the text node insertion may have removed the refChild
         if (!refChild->inDocument())
             return;
         insertNodeBefore(insertChild, refChild);
     } else
         insertNodeAfter(insertChild, refChild);
 }
 
 void CompositeEditCommand::appendNode(PassRefPtr<Node> node, PassRefPtr<ContainerNode> parent)
@@ skipping 155 matching lines @@
     }
 
     Node* tabSpan = tabSpanNode(pos.containerNode());
 
     if (pos.offsetInContainerNode() <= caretMinOffset(pos.containerNode()))
         return positionInParentBeforeNode(tabSpan);
 
     if (pos.offsetInContainerNode() >= caretMaxOffset(pos.containerNode()))
         return positionInParentAfterNode(tabSpan);
 
-    splitTextNodeContainingElement(static_cast<Text *>(pos.containerNode()), pos.offsetInContainerNode());
+    splitTextNodeContainingElement(toText(pos.containerNode()), pos.offsetInContainerNode());
     return positionInParentBeforeNode(tabSpan);
 }
 
 void CompositeEditCommand::insertNodeAtTabSpanPosition(PassRefPtr<Node> node, const Position& pos)
 {
     // insert node before, after, or at split of tab span
     insertNodeAt(node, positionOutsideTabSpan(pos));
 }
 
 void CompositeEditCommand::deleteSelection(bool smartDelete, bool mergeBlocksAfterDelete, bool replace, bool expandForSpecialElements)
@@ skipping 37 matching lines @@
 {
     return containsOnlyWhitespace(text);
 }
 
 bool CompositeEditCommand::canRebalance(const Position& position) const
 {
     Node* node = position.containerNode();
     if (position.anchorType() != Position::PositionIsOffsetInAnchor || !node || !node->isTextNode())
         return false;
 
-    Text* textNode = static_cast<Text*>(node);
+    Text* textNode = toText(node);
     if (textNode->length() == 0)
         return false;
 
     RenderObject* renderer = textNode->renderer();
     if (renderer && !renderer->style()->collapseWhiteSpace())
         return false;
 
     return true;
 }
 
 // FIXME: Doesn't go into text nodes that contribute adjacent text (siblings, cousins, etc).
 void CompositeEditCommand::rebalanceWhitespaceAt(const Position& position)
 {
     Node* node = position.containerNode();
     if (!canRebalance(position))
         return;
 
     // If the rebalance is for the single offset, and neither text[offset] nor text[offset - 1] are some form of whitespace, do nothing.
     int offset = position.deprecatedEditingOffset();
-    String text = static_cast<Text*>(node)->data();
+    String text = toText(node)->data();
     if (!isWhitespace(text[offset])) {
         offset--;
         if (offset < 0 || !isWhitespace(text[offset]))
             return;
     }
 
-    rebalanceWhitespaceOnTextSubstring(static_cast<Text*>(node), position.offsetInContainerNode(), position.offsetInContainerNode());
+    rebalanceWhitespaceOnTextSubstring(toText(node), position.offsetInContainerNode(), position.offsetInContainerNode());
 }
 
 void CompositeEditCommand::rebalanceWhitespaceOnTextSubstring(PassRefPtr<Text> prpTextNode, int startOffset, int endOffset)
 {
     RefPtr<Text> textNode = prpTextNode;
 
     String text = textNode->data();
     ASSERT(!text.isEmpty());
 
     // Set upstream and downstream to define the extent of the whitespace surrounding text[offset].
@@ skipping 21 matching lines @@
     
     if (string != rebalancedString)
         replaceTextInNodePreservingMarkers(textNode.release(), upstream, length, rebalancedString);
 }
 
 void CompositeEditCommand::prepareWhitespaceAtPositionForSplit(Position& position)
 {
     Node* node = position.deprecatedNode();
     if (!node || !node->isTextNode())
         return;
-    Text* textNode = static_cast<Text*>(node);    
+    Text* textNode = toText(node);    
     
     if (textNode->length() == 0)
         return;
     RenderObject* renderer = textNode->renderer();
     if (renderer && !renderer->style()->collapseWhiteSpace())
         return;
 
     // Delete collapsed whitespace so that inserting nbsps doesn't uncollapse it.
     Position upstreamPos = position.upstream();
     deleteInsignificantText(position.upstream(), position.downstream());
     position = upstreamPos.downstream();
 
     VisiblePosition visiblePos(position);
     VisiblePosition previousVisiblePos(visiblePos.previous());
     Position previous(previousVisiblePos.deepEquivalent());
     
     if (isCollapsibleWhitespace(previousVisiblePos.characterAfter()) && previous.deprecatedNode()->isTextNode() && !previous.deprecatedNode()->hasTagName(brTag))
-        replaceTextInNodePreservingMarkers(static_cast<Text*>(previous.deprecatedNode()), previous.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
+        replaceTextInNodePreservingMarkers(toText(previous.deprecatedNode()), previous.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
     if (isCollapsibleWhitespace(visiblePos.characterAfter()) && position.deprecatedNode()->isTextNode() && !position.deprecatedNode()->hasTagName(brTag))
-        replaceTextInNodePreservingMarkers(static_cast<Text*>(position.deprecatedNode()), position.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
+        replaceTextInNodePreservingMarkers(toText(position.deprecatedNode()), position.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
 }
 
 void CompositeEditCommand::rebalanceWhitespace()
 {
     VisibleSelection selection = endingSelection();
     if (selection.isNone())
         return;
         
     rebalanceWhitespaceAt(selection.start());
     if (selection.isRange())
         rebalanceWhitespaceAt(selection.end());
 }
 
 void CompositeEditCommand::deleteInsignificantText(PassRefPtr<Text> textNode, unsigned start, unsigned end)
 {
     if (!textNode || start >= end)
         return;
 
+    document()->updateLayout();
+
     RenderText* textRenderer = toRenderText(textNode->renderer());
     if (!textRenderer)
         return;
 
     Vector<InlineTextBox*> sortedTextBoxes;
     size_t sortedTextBoxesPosition = 0;
    
     for (InlineTextBox* textBox = textRenderer->firstTextBox(); textBox; textBox = textBox->nextTextBox())
         sortedTextBoxes.append(textBox);
     
@@ skipping 62 matching lines @@
 }
 
 void CompositeEditCommand::deleteInsignificantText(const Position& start, const Position& end)
 {
     if (start.isNull() || end.isNull())
         return;
 
     if (comparePositions(start, end) >= 0)
         return;
 
-    Node* next;
-    for (Node* node = start.deprecatedNode(); node; node = next) {
-        next = node->traverseNextNode();
-        if (node->isTextNode()) {
-            Text* textNode = static_cast<Text*>(node);
-            int startOffset = node == start.deprecatedNode() ? start.deprecatedEditingOffset() : 0;
-            int endOffset = node == end.deprecatedNode() ? end.deprecatedEditingOffset() : static_cast<int>(textNode->length());
-            deleteInsignificantText(textNode, startOffset, endOffset);
-        }
+    Vector<RefPtr<Text> > nodes;
+    for (Node* node = start.deprecatedNode(); node; node = node->traverseNextNode()) {
+        if (node->isTextNode())
+            nodes.append(toText(node));
         if (node == end.deprecatedNode())
             break;
     }
+
+    for (size_t i = 0; i < nodes.size(); ++i) {
+        Text* textNode = nodes[i].get();
+        int startOffset = textNode == start.deprecatedNode() ? start.deprecatedEditingOffset() : 0;
+        int endOffset = textNode == end.deprecatedNode() ? end.deprecatedEditingOffset() : static_cast<int>(textNode->length());
+        deleteInsignificantText(textNode, startOffset, endOffset);
+    }
 }
 
 void CompositeEditCommand::deleteInsignificantTextDownstream(const Position& pos)
 {
     Position end = VisiblePosition(pos, VP_DEFAULT_AFFINITY).next().deepEquivalent().downstream();
     deleteInsignificantText(pos, end);
 }
 
 PassRefPtr<Node> CompositeEditCommand::appendBlockPlaceholder(PassRefPtr<Element> container)
 {
@@ skipping 19 matching lines @@
     RefPtr<Node> placeholder = createBlockPlaceholderElement(document());
     insertNodeAt(placeholder, pos);
     return placeholder.release();
 }
 
 PassRefPtr<Node> CompositeEditCommand::addBlockPlaceholderIfNeeded(Element* container)
 {
     if (!container)
         return 0;
 
-    updateLayout();
+    document()->updateLayoutIgnorePendingStylesheets();
 
     RenderObject* renderer = container->renderer();
     if (!renderer || !renderer->isBlockFlow())
         return 0;
     
     // append the placeholder to make sure it follows
     // any unrendered blocks
     RenderBlock* block = toRenderBlock(renderer);
     if (block->height() == 0 || (block->isListItem() && block->isEmpty()))
         return appendBlockPlaceholder(container);
 
     return 0;
 }
 
 // Assumes that the position is at a placeholder and does the removal without much checking.
 void CompositeEditCommand::removePlaceholderAt(const Position& p)
 {
     ASSERT(lineBreakExistsAtPosition(p));
     
     // We are certain that the position is at a line break, but it may be a br or a preserved newline.
     if (p.anchorNode()->hasTagName(brTag)) {
         removeNode(p.anchorNode());
         return;
     }
     
-    deleteTextFromNode(static_cast<Text*>(p.anchorNode()), p.offsetInContainerNode(), 1);
+    deleteTextFromNode(toText(p.anchorNode()), p.offsetInContainerNode(), 1);
 }
 
 PassRefPtr<Node> CompositeEditCommand::insertNewDefaultParagraphElementAt(const Position& position)
 {
     RefPtr<Element> paragraphElement = createDefaultParagraphElement(document());
     ExceptionCode ec;
     paragraphElement->appendChild(createBreakElement(document()), ec);
     insertNodeAt(paragraphElement, position);
     return paragraphElement.release();
 }
 
 // If the paragraph is not entirely within it's own block, create one and move the paragraph into 
 // it, and return that block.  Otherwise return 0.
 PassRefPtr<Node> CompositeEditCommand::moveParagraphContentsToNewBlockIfNecessary(const Position& pos)
 {
     if (pos.isNull())
         return 0;
     
-    updateLayout();
+    document()->updateLayoutIgnorePendingStylesheets();
     
     // It's strange that this function is responsible for verifying that pos has not been invalidated
     // by an earlier call to this function.  The caller, applyBlockStyle, should do this.
     VisiblePosition visiblePos(pos, VP_DEFAULT_AFFINITY);
     VisiblePosition visibleParagraphStart(startOfParagraph(visiblePos));
     VisiblePosition visibleParagraphEnd = endOfParagraph(visiblePos);
     VisiblePosition next = visibleParagraphEnd.next();
     VisiblePosition visibleEnd = next.isNotNull() ? next : visibleParagraphEnd;
     
     Position upstreamStart = visibleParagraphStart.deepEquivalent().upstream();
@@ skipping 136 matching lines @@
             removeNodeAndPruneAncestors(node);
         // If the selection to move was empty and in an empty block that 
         // doesn't require a placeholder to prop itself open (like a bordered
         // div or an li), remove it during the move (the list removal code
         // expects this behavior).
         else if (isBlock(node))
             removeNodeAndPruneAncestors(node);
         else if (lineBreakExistsAtPosition(position)) {
             // There is a preserved '\n' at caretAfterDelete.
             // We can safely assume this is a text node.
-            Text* textNode = static_cast<Text*>(node);
+            Text* textNode = toText(node);
             if (textNode->length() == 1)
                 removeNodeAndPruneAncestors(node);
             else
                 deleteTextFromNode(textNode, position.deprecatedEditingOffset(), 1);
         }
     }
 }
     
 // This is a version of moveParagraph that preserves style by keeping the original markup
 // It is currently used only by IndentOutdentCommand but it is meant to be used in the
@@ skipping 132 matching lines @@
     // baz
     // Imagine moving 'bar' to ^. 'bar' will be deleted and its div pruned. That would
     // cause 'baz' to collapse onto the line with 'foobar' unless we insert a br.
     // Must recononicalize these two VisiblePositions after the pruning above.
     beforeParagraph = VisiblePosition(beforeParagraph.deepEquivalent());
     afterParagraph = VisiblePosition(afterParagraph.deepEquivalent());
     if (beforeParagraph.isNotNull() && (!isEndOfParagraph(beforeParagraph) || beforeParagraph == afterParagraph)) {
         // FIXME: Trim text between beforeParagraph and afterParagraph if they aren't equal.
         insertNodeAt(createBreakElement(document()), beforeParagraph.deepEquivalent());
         // Need an updateLayout here in case inserting the br has split a text node.
-        updateLayout();
+        document()->updateLayoutIgnorePendingStylesheets();
     }
 
     RefPtr<Range> startToDestinationRange(Range::create(document(), firstPositionInNode(document()->documentElement()), destination.deepEquivalent().parentAnchoredEquivalent()));
     destinationIndex = TextIterator::rangeLength(startToDestinationRange.get(), true);
 
     setEndingSelection(VisibleSelection(destination, originalIsDirectional));
     ASSERT(endingSelection().isCaretOrRange());
     ReplaceSelectionCommand::CommandOptions options = ReplaceSelectionCommand::SelectReplacement | ReplaceSelectionCommand::MovingParagraph;
     if (!preserveStyle)
         options |= ReplaceSelectionCommand::MatchStyle;
@@ skipping 119 matching lines @@
         return false;
 
     Position caretPos(caret.deepEquivalent().downstream());
     // A line break is either a br or a preserved newline.
     ASSERT(caretPos.deprecatedNode()->hasTagName(brTag) || (caretPos.deprecatedNode()->isTextNode() && caretPos.deprecatedNode()->renderer()->style()->preserveNewline()));
     
     if (caretPos.deprecatedNode()->hasTagName(brTag))
         removeNodeAndPruneAncestors(caretPos.deprecatedNode());
     else if (caretPos.deprecatedNode()->isTextNode()) {
         ASSERT(caretPos.deprecatedEditingOffset() == 0);
-        Text* textNode = static_cast<Text*>(caretPos.deprecatedNode());
+        Text* textNode = toText(caretPos.deprecatedNode());
         ContainerNode* parentNode = textNode->parentNode();
         // The preserved newline must be the first thing in the node, since otherwise the previous
         // paragraph would be quoted, and we verified that it wasn't above.
         deleteTextFromNode(textNode, 0, 1);
         prune(parentNode);
     }
 
     return true;
 }
 
@@ skipping 84 matching lines @@
     return node.release();
 }
 
 PassRefPtr<Element> createBlockPlaceholderElement(Document* document)
 {
     RefPtr<Element> breakNode = document->createElement(brTag, false);
     return breakNode.release();
 }
 
 } // namespace WebCore