src/third_party/WebKit/Source/core/editing/TypingCommand.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 "core/editing/TypingCommand.h"
  28
  29 #include "core/HTMLNames.h"
  30 #include "core/dom/Document.h"
  31 #include "core/dom/Element.h"
  32 #include "core/dom/ElementTraversal.h"
  33 #include "core/editing/BreakBlockquoteCommand.h"
  34 #include "core/editing/Editor.h"
  35 #include "core/editing/FrameSelection.h"
  36 #include "core/editing/InsertLineBreakCommand.h"
  37 #include "core/editing/InsertParagraphSeparatorCommand.h"
  38 #include "core/editing/InsertTextCommand.h"
  39 #include "core/editing/SpellChecker.h"
  40 #include "core/editing/VisiblePosition.h"
  41 #include "core/editing/VisibleUnits.h"
  42 #include "core/editing/htmlediting.h"
  43 #include "core/frame/LocalFrame.h"
  44 #include "core/html/HTMLBRElement.h"
  45 #include "core/rendering/RenderObject.h"
  46
  47 namespace blink {
  48
  49 using namespace HTMLNames;
  50
  51 class TypingCommandLineOperation
  52 {
  53 public:
  54     TypingCommandLineOperation(TypingCommand* typingCommand, bool selectInsertedText, const String& text)
  55     : m_typingCommand(typingCommand)
  56     , m_selectInsertedText(selectInsertedText)
  57     , m_text(text)
  58     { }
  59
  60     void operator()(size_t lineOffset, size_t lineLength, bool isLastLine) const
  61     {
  62         if (isLastLine) {
  63             if (!lineOffset || lineLength > 0)
  64                 m_typingCommand->insertTextRunWithoutNewlines(m_text.substring(lineOffset, lineLength), m_selectInsertedText);
  65         } else {
  66             if (lineLength > 0)
  67                 m_typingCommand->insertTextRunWithoutNewlines(m_text.substring(lineOffset, lineLength), false);
  68             m_typingCommand->insertParagraphSeparator();
  69         }
  70     }
  71
  72 private:
  73     TypingCommand* m_typingCommand;
  74     bool m_selectInsertedText;
  75     const String& m_text;
  76 };
  77
  78 TypingCommand::TypingCommand(Document& document, ETypingCommand commandType, const String &textToInsert, Options options, TextGranularity granularity, TextCompositionType compositionType)
  79     : TextInsertionBaseCommand(document)
  80     , m_commandType(commandType)
  81     , m_textToInsert(textToInsert)
  82     , m_openForMoreTyping(true)
  83     , m_selectInsertedText(options & SelectInsertedText)
  84     , m_smartDelete(options & SmartDelete)
  85     , m_granularity(granularity)
  86     , m_compositionType(compositionType)
  87     , m_killRing(options & KillRing)
  88     , m_openedByBackwardDelete(false)
  89     , m_shouldRetainAutocorrectionIndicator(options & RetainAutocorrectionIndicator)
  90     , m_shouldPreventSpellChecking(options & PreventSpellChecking)
  91 {
  92     updatePreservesTypingStyle(m_commandType);
  93 }
  94
  95 void TypingCommand::deleteSelection(Document& document, Options options)
  96 {
  97     LocalFrame* frame = document.frame();
  98     ASSERT(frame);
  99
 100     if (!frame->selection().isRange())
 101         return;
 102
 103     if (RefPtrWillBeRawPtr<TypingCommand> lastTypingCommand = lastTypingCommandIfStillOpenForTyping(frame)) {
 104         lastTypingCommand->setShouldPreventSpellChecking(options & PreventSpellChecking);
 105         lastTypingCommand->deleteSelection(options & SmartDelete);
 106         return;
 107     }
 108
 109     TypingCommand::create(document, DeleteSelection, "", options)->apply();
 110 }
 111
 112 void TypingCommand::deleteKeyPressed(Document& document, Options options, TextGranularity granularity)
 113 {
 114     if (granularity == CharacterGranularity) {
 115         LocalFrame* frame = document.frame();
 116         if (RefPtrWillBeRawPtr<TypingCommand> lastTypingCommand = lastTypingCommandIfStillOpenForTyping(frame)) {
 117             // If the last typing command is not Delete, open a new typing command.
 118             // We need to group continuous delete commands alone in a single typing command.
 119             if (lastTypingCommand->commandTypeOfOpenCommand() == DeleteKey) {
 120                 updateSelectionIfDifferentFromCurrentSelection(lastTypingCommand.get(), frame);
 121                 lastTypingCommand->setShouldPreventSpellChecking(options & PreventSpellChecking);
 122                 lastTypingCommand->deleteKeyPressed(granularity, options & KillRing);
 123                 return;
 124             }
 125         }
 126     }
 127
 128     TypingCommand::create(document, DeleteKey, "", options, granularity)->apply();
 129 }
 130
 131 void TypingCommand::forwardDeleteKeyPressed(Document& document, Options options, TextGranularity granularity)
 132 {
 133     // FIXME: Forward delete in TextEdit appears to open and close a new typing command.
 134     if (granularity == CharacterGranularity) {
 135         LocalFrame* frame = document.frame();
 136         if (RefPtrWillBeRawPtr<TypingCommand> lastTypingCommand = lastTypingCommandIfStillOpenForTyping(frame)) {
 137             updateSelectionIfDifferentFromCurrentSelection(lastTypingCommand.get(), frame);
 138             lastTypingCommand->setShouldPreventSpellChecking(options & PreventSpellChecking);
 139             lastTypingCommand->forwardDeleteKeyPressed(granularity, options & KillRing);
 140             return;
 141         }
 142     }
 143
 144     TypingCommand::create(document, ForwardDeleteKey, "", options, granularity)->apply();
 145 }
 146
 147 void TypingCommand::updateSelectionIfDifferentFromCurrentSelection(TypingCommand* typingCommand, LocalFrame* frame)
 148 {
 149     ASSERT(frame);
 150     VisibleSelection currentSelection = frame->selection().selection();
 151     if (currentSelection == typingCommand->endingSelection())
 152         return;
 153
 154     typingCommand->setStartingSelection(currentSelection);
 155     typingCommand->setEndingSelection(currentSelection);
 156 }
 157
 158 void TypingCommand::insertText(Document& document, const String& text, Options options, TextCompositionType composition)
 159 {
 160     LocalFrame* frame = document.frame();
 161     ASSERT(frame);
 162
 163     if (!text.isEmpty())
 164         document.frame()->spellChecker().updateMarkersForWordsAffectedByEditing(isSpaceOrNewline(text[0]));
 165
 166     insertText(document, text, frame->selection().selection(), options, composition);
 167 }
 168
 169 // FIXME: We shouldn't need to take selectionForInsertion. It should be identical to FrameSelection's current selection.
 170 void TypingCommand::insertText(Document& document, const String& text, const VisibleSelection& selectionForInsertion, Options options, TextCompositionType compositionType)
 171 {
 172     RefPtrWillBeRawPtr<LocalFrame> frame = document.frame();
 173     ASSERT(frame);
 174
 175     VisibleSelection currentSelection = frame->selection().selection();
 176
 177     String newText = dispatchBeforeTextInsertedEvent(text, selectionForInsertion, compositionType == TextCompositionUpdate);
 178
 179     // Set the starting and ending selection appropriately if we are using a selection
 180     // that is different from the current selection.  In the future, we should change EditCommand
 181     // to deal with custom selections in a general way that can be used by all of the commands.
 182     if (RefPtrWillBeRawPtr<TypingCommand> lastTypingCommand = lastTypingCommandIfStillOpenForTyping(frame.get())) {
 183         if (lastTypingCommand->endingSelection() != selectionForInsertion) {
 184             lastTypingCommand->setStartingSelection(selectionForInsertion);
 185             lastTypingCommand->setEndingSelection(selectionForInsertion);
 186         }
 187
 188         lastTypingCommand->setCompositionType(compositionType);
 189         lastTypingCommand->setShouldRetainAutocorrectionIndicator(options & RetainAutocorrectionIndicator);
 190         lastTypingCommand->setShouldPreventSpellChecking(options & PreventSpellChecking);
 191         lastTypingCommand->insertText(newText, options & SelectInsertedText);
 192         return;
 193     }
 194
 195     RefPtrWillBeRawPtr<TypingCommand> cmd = TypingCommand::create(document, InsertText, newText, options, compositionType);
 196     applyTextInsertionCommand(frame.get(), cmd, selectionForInsertion, currentSelection);
 197 }
 198
 199 void TypingCommand::insertLineBreak(Document& document, Options options)
 200 {
 201     if (RefPtrWillBeRawPtr<TypingCommand> lastTypingCommand = lastTypingCommandIfStillOpenForTyping(document.frame())) {
 202         lastTypingCommand->setShouldRetainAutocorrectionIndicator(options & RetainAutocorrectionIndicator);
 203         lastTypingCommand->insertLineBreak();
 204         return;
 205     }
 206
 207     TypingCommand::create(document, InsertLineBreak, "", options)->apply();
 208 }
 209
 210 void TypingCommand::insertParagraphSeparatorInQuotedContent(Document& document)
 211 {
 212     if (RefPtrWillBeRawPtr<TypingCommand> lastTypingCommand = lastTypingCommandIfStillOpenForTyping(document.frame())) {
 213         lastTypingCommand->insertParagraphSeparatorInQuotedContent();
 214         return;
 215     }
 216
 217     TypingCommand::create(document, InsertParagraphSeparatorInQuotedContent)->apply();
 218 }
 219
 220 void TypingCommand::insertParagraphSeparator(Document& document, Options options)
 221 {
 222     if (RefPtrWillBeRawPtr<TypingCommand> lastTypingCommand = lastTypingCommandIfStillOpenForTyping(document.frame())) {
 223         lastTypingCommand->setShouldRetainAutocorrectionIndicator(options & RetainAutocorrectionIndicator);
 224         lastTypingCommand->insertParagraphSeparator();
 225         return;
 226     }
 227
 228     TypingCommand::create(document, InsertParagraphSeparator, "", options)->apply();
 229 }
 230
 231 PassRefPtrWillBeRawPtr<TypingCommand> TypingCommand::lastTypingCommandIfStillOpenForTyping(LocalFrame* frame)
 232 {
 233     ASSERT(frame);
 234
 235     RefPtrWillBeRawPtr<CompositeEditCommand> lastEditCommand = frame->editor().lastEditCommand();
 236     if (!lastEditCommand || !lastEditCommand->isTypingCommand() || !static_cast<TypingCommand*>(lastEditCommand.get())->isOpenForMoreTyping())
 237         return nullptr;
 238
 239     return static_cast<TypingCommand*>(lastEditCommand.get());
 240 }
 241
 242 void TypingCommand::closeTyping(LocalFrame* frame)
 243 {
 244     if (RefPtrWillBeRawPtr<TypingCommand> lastTypingCommand = lastTypingCommandIfStillOpenForTyping(frame))
 245         lastTypingCommand->closeTyping();
 246 }
 247
 248 void TypingCommand::doApply()
 249 {
 250     if (!endingSelection().isNonOrphanedCaretOrRange())
 251         return;
 252
 253     if (m_commandType == DeleteKey)
 254         if (m_commands.isEmpty())
 255             m_openedByBackwardDelete = true;
 256
 257     switch (m_commandType) {
 258     case DeleteSelection:
 259         deleteSelection(m_smartDelete);
 260         return;
 261     case DeleteKey:
 262         deleteKeyPressed(m_granularity, m_killRing);
 263         return;
 264     case ForwardDeleteKey:
 265         forwardDeleteKeyPressed(m_granularity, m_killRing);
 266         return;
 267     case InsertLineBreak:
 268         insertLineBreak();
 269         return;
 270     case InsertParagraphSeparator:
 271         insertParagraphSeparator();
 272         return;
 273     case InsertParagraphSeparatorInQuotedContent:
 274         insertParagraphSeparatorInQuotedContent();
 275         return;
 276     case InsertText:
 277         insertText(m_textToInsert, m_selectInsertedText);
 278         return;
 279     }
 280
 281     ASSERT_NOT_REACHED();
 282 }
 283
 284 EditAction TypingCommand::editingAction() const
 285 {
 286     return EditActionTyping;
 287 }
 288
 289 void TypingCommand::markMisspellingsAfterTyping(ETypingCommand commandType)
 290 {
 291     LocalFrame* frame = document().frame();
 292     if (!frame)
 293         return;
 294
 295     if (!frame->spellChecker().isContinuousSpellCheckingEnabled())
 296         return;
 297
 298     frame->spellChecker().cancelCheck();
 299
 300     // Take a look at the selection that results after typing and determine whether we need to spellcheck.
 301     // Since the word containing the current selection is never marked, this does a check to
 302     // see if typing made a new word that is not in the current selection. Basically, you
 303     // get this by being at the end of a word and typing a space.
 304     VisiblePosition start(endingSelection().start(), endingSelection().affinity());
 305     VisiblePosition previous = start.previous();
 306
 307     VisiblePosition p1 = startOfWord(previous, LeftWordIfOnBoundary);
 308
 309     if (commandType == InsertParagraphSeparator) {
 310         VisiblePosition p2 = nextWordPosition(start);
 311         VisibleSelection words(p1, endOfWord(p2));
 312         frame->spellChecker().markMisspellingsAfterLineBreak(words);
 313     } else if (previous.isNotNull()) {
 314         VisiblePosition p2 = startOfWord(start, LeftWordIfOnBoundary);
 315         if (p1 != p2)
 316             frame->spellChecker().markMisspellingsAfterTypingToWord(p1, endingSelection());
 317     }
 318 }
 319
 320 void TypingCommand::typingAddedToOpenCommand(ETypingCommand commandTypeForAddedTyping)
 321 {
 322     LocalFrame* frame = document().frame();
 323     if (!frame)
 324         return;
 325
 326     updatePreservesTypingStyle(commandTypeForAddedTyping);
 327     updateCommandTypeOfOpenCommand(commandTypeForAddedTyping);
 328
 329     // The old spellchecking code requires that checking be done first, to prevent issues like that in 6864072, where <doesn't> is marked as misspelled.
 330     markMisspellingsAfterTyping(commandTypeForAddedTyping);
 331     frame->editor().appliedEditing(this);
 332 }
 333
 334 void TypingCommand::insertText(const String &text, bool selectInsertedText)
 335 {
 336     // FIXME: Need to implement selectInsertedText for cases where more than one insert is involved.
 337     // This requires support from insertTextRunWithoutNewlines and insertParagraphSeparator for extending
 338     // an existing selection; at the moment they can either put the caret after what's inserted or
 339     // select what's inserted, but there's no way to "extend selection" to include both an old selection
 340     // that ends just before where we want to insert text and the newly inserted text.
 341     TypingCommandLineOperation operation(this, selectInsertedText, text);
 342     forEachLineInString(text, operation);
 343 }
 344
 345 void TypingCommand::insertTextRunWithoutNewlines(const String &text, bool selectInsertedText)
 346 {
 347     RefPtrWillBeRawPtr<InsertTextCommand> command = InsertTextCommand::create(document(), text, selectInsertedText,
 348         m_compositionType == TextCompositionNone ? InsertTextCommand::RebalanceLeadingAndTrailingWhitespaces : InsertTextCommand::RebalanceAllWhitespaces);
 349
 350     applyCommandToComposite(command, endingSelection());
 351
 352     typingAddedToOpenCommand(InsertText);
 353 }
 354
 355 void TypingCommand::insertLineBreak()
 356 {
 357     if (!canAppendNewLineFeedToSelection(endingSelection()))
 358         return;
 359
 360     applyCommandToComposite(InsertLineBreakCommand::create(document()));
 361     typingAddedToOpenCommand(InsertLineBreak);
 362 }
 363
 364 void TypingCommand::insertParagraphSeparator()
 365 {
 366     if (!canAppendNewLineFeedToSelection(endingSelection()))
 367         return;
 368
 369     applyCommandToComposite(InsertParagraphSeparatorCommand::create(document()));
 370     typingAddedToOpenCommand(InsertParagraphSeparator);
 371 }
 372
 373 void TypingCommand::insertParagraphSeparatorInQuotedContent()
 374 {
 375     // If the selection starts inside a table, just insert the paragraph separator normally
 376     // Breaking the blockquote would also break apart the table, which is unecessary when inserting a newline
 377     if (enclosingNodeOfType(endingSelection().start(), &isTableStructureNode)) {
 378         insertParagraphSeparator();
 379         return;
 380     }
 381
 382     applyCommandToComposite(BreakBlockquoteCommand::create(document()));
 383     typingAddedToOpenCommand(InsertParagraphSeparatorInQuotedContent);
 384 }
 385
 386 bool TypingCommand::makeEditableRootEmpty()
 387 {
 388     Element* root = endingSelection().rootEditableElement();
 389     if (!root || !root->hasChildren())
 390         return false;
 391
 392     if (root->firstChild() == root->lastChild()) {
 393         if (isHTMLBRElement(root->firstChild())) {
 394             // If there is a single child and it could be a placeholder, leave it alone.
 395             if (root->renderer() && root->renderer()->isRenderBlockFlow())
 396                 return false;
 397         }
 398     }
 399
 400     while (Node* child = root->firstChild())
 401         removeNode(child);
 402
 403     addBlockPlaceholderIfNeeded(root);
 404     setEndingSelection(VisibleSelection(firstPositionInNode(root), DOWNSTREAM, endingSelection().isDirectional()));
 405
 406     return true;
 407 }
 408
 409 void TypingCommand::deleteKeyPressed(TextGranularity granularity, bool killRing)
 410 {
 411     LocalFrame* frame = document().frame();
 412     if (!frame)
 413         return;
 414
 415     frame->spellChecker().updateMarkersForWordsAffectedByEditing(false);
 416
 417     VisibleSelection selectionToDelete;
 418     VisibleSelection selectionAfterUndo;
 419
 420     switch (endingSelection().selectionType()) {
 421     case RangeSelection:
 422         selectionToDelete = endingSelection();
 423         selectionAfterUndo = selectionToDelete;
 424         break;
 425     case CaretSelection: {
 426         // After breaking out of an empty mail blockquote, we still want continue with the deletion
 427         // so actual content will get deleted, and not just the quote style.
 428         if (breakOutOfEmptyMailBlockquotedParagraph())
 429             typingAddedToOpenCommand(DeleteKey);
 430
 431         m_smartDelete = false;
 432
 433         OwnPtrWillBeRawPtr<FrameSelection> selection = FrameSelection::create();
 434         selection->setSelection(endingSelection());
 435         selection->modify(FrameSelection::AlterationExtend, DirectionBackward, granularity);
 436         if (killRing && selection->isCaret() && granularity != CharacterGranularity)
 437             selection->modify(FrameSelection::AlterationExtend, DirectionBackward, CharacterGranularity);
 438
 439         VisiblePosition visibleStart(endingSelection().visibleStart());
 440         if (visibleStart.previous(CannotCrossEditingBoundary).isNull()) {
 441             // When the caret is at the start of the editable area in an empty list item, break out of the list item.
 442             if (breakOutOfEmptyListItem()) {
 443                 typingAddedToOpenCommand(DeleteKey);
 444                 return;
 445             }
 446             // When there are no visible positions in the editing root, delete its entire contents.
 447             if (visibleStart.next(CannotCrossEditingBoundary).isNull() && makeEditableRootEmpty()) {
 448                 typingAddedToOpenCommand(DeleteKey);
 449                 return;
 450             }
 451         }
 452
 453         // If we have a caret selection at the beginning of a cell, we have nothing to do.
 454         Node* enclosingTableCell = enclosingNodeOfType(visibleStart.deepEquivalent(), &isTableCell);
 455         if (enclosingTableCell && visibleStart == VisiblePosition(firstPositionInNode(enclosingTableCell)))
 456             return;
 457
 458         // If the caret is at the start of a paragraph after a table, move content into the last table cell.
 459         if (isStartOfParagraph(visibleStart) && isFirstPositionAfterTable(visibleStart.previous(CannotCrossEditingBoundary))) {
 460             // Unless the caret is just before a table.  We don't want to move a table into the last table cell.
 461             if (isLastPositionBeforeTable(visibleStart))
 462                 return;
 463             // Extend the selection backward into the last cell, then deletion will handle the move.
 464             selection->modify(FrameSelection::AlterationExtend, DirectionBackward, granularity);
 465         // If the caret is just after a table, select the table and don't delete anything.
 466         } else if (Element* table = isFirstPositionAfterTable(visibleStart)) {
 467             setEndingSelection(VisibleSelection(positionBeforeNode(table), endingSelection().start(), DOWNSTREAM, endingSelection().isDirectional()));
 468             typingAddedToOpenCommand(DeleteKey);
 469             return;
 470         }
 471
 472         selectionToDelete = selection->selection();
 473
 474         if (granularity == CharacterGranularity && selectionToDelete.end().containerNode() == selectionToDelete.start().containerNode()
 475             && selectionToDelete.end().computeOffsetInContainerNode() - selectionToDelete.start().computeOffsetInContainerNode() > 1) {
 476             // If there are multiple Unicode code points to be deleted, adjust the range to match platform conventions.
 477             selectionToDelete.setWithoutValidation(selectionToDelete.end(), selectionToDelete.end().previous(BackwardDeletion));
 478         }
 479
 480         if (!startingSelection().isRange() || selectionToDelete.base() != startingSelection().start())
 481             selectionAfterUndo = selectionToDelete;
 482         else
 483             // It's a little tricky to compute what the starting selection would have been in the original document.
 484             // We can't let the VisibleSelection class's validation kick in or it'll adjust for us based on
 485             // the current state of the document and we'll get the wrong result.
 486             selectionAfterUndo.setWithoutValidation(startingSelection().end(), selectionToDelete.extent());
 487         break;
 488     }
 489     case NoSelection:
 490         ASSERT_NOT_REACHED();
 491         break;
 492     }
 493
 494     ASSERT(!selectionToDelete.isNone());
 495     if (selectionToDelete.isNone())
 496         return;
 497
 498     if (selectionToDelete.isCaret())
 499         return;
 500
 501     if (killRing)
 502         frame->editor().addToKillRing(selectionToDelete.toNormalizedRange().get(), false);
 503     // On Mac, make undo select everything that has been deleted, unless an undo will undo more than just this deletion.
 504     // FIXME: This behaves like TextEdit except for the case where you open with text insertion and then delete
 505     // more text than you insert.  In that case all of the text that was around originally should be selected.
 506     if (frame->editor().behavior().shouldUndoOfDeleteSelectText() && m_openedByBackwardDelete)
 507         setStartingSelection(selectionAfterUndo);
 508     CompositeEditCommand::deleteSelection(selectionToDelete, m_smartDelete);
 509     setSmartDelete(false);
 510     typingAddedToOpenCommand(DeleteKey);
 511 }
 512
 513 void TypingCommand::forwardDeleteKeyPressed(TextGranularity granularity, bool killRing)
 514 {
 515     LocalFrame* frame = document().frame();
 516     if (!frame)
 517         return;
 518
 519     frame->spellChecker().updateMarkersForWordsAffectedByEditing(false);
 520
 521     VisibleSelection selectionToDelete;
 522     VisibleSelection selectionAfterUndo;
 523
 524     switch (endingSelection().selectionType()) {
 525     case RangeSelection:
 526         selectionToDelete = endingSelection();
 527         selectionAfterUndo = selectionToDelete;
 528         break;
 529     case CaretSelection: {
 530         m_smartDelete = false;
 531
 532         // Handle delete at beginning-of-block case.
 533         // Do nothing in the case that the caret is at the start of a
 534         // root editable element or at the start of a document.
 535         OwnPtrWillBeRawPtr<FrameSelection> selection = FrameSelection::create();
 536         selection->setSelection(endingSelection());
 537         selection->modify(FrameSelection::AlterationExtend, DirectionForward, granularity);
 538         if (killRing && selection->isCaret() && granularity != CharacterGranularity)
 539             selection->modify(FrameSelection::AlterationExtend, DirectionForward, CharacterGranularity);
 540
 541         Position downstreamEnd = endingSelection().end().downstream();
 542         VisiblePosition visibleEnd = endingSelection().visibleEnd();
 543         Node* enclosingTableCell = enclosingNodeOfType(visibleEnd.deepEquivalent(), &isTableCell);
 544         if (enclosingTableCell && visibleEnd == VisiblePosition(lastPositionInNode(enclosingTableCell)))
 545             return;
 546         if (visibleEnd == endOfParagraph(visibleEnd))
 547             downstreamEnd = visibleEnd.next(CannotCrossEditingBoundary).deepEquivalent().downstream();
 548         // When deleting tables: Select the table first, then perform the deletion
 549         if (isRenderedTableElement(downstreamEnd.containerNode()) && downstreamEnd.computeOffsetInContainerNode() <= caretMinOffset(downstreamEnd.containerNode())) {
 550             setEndingSelection(VisibleSelection(endingSelection().end(), positionAfterNode(downstreamEnd.containerNode()), DOWNSTREAM, endingSelection().isDirectional()));
 551             typingAddedToOpenCommand(ForwardDeleteKey);
 552             return;
 553         }
 554
 555         // deleting to end of paragraph when at end of paragraph needs to merge the next paragraph (if any)
 556         if (granularity == ParagraphBoundary && selection->selection().isCaret() && isEndOfParagraph(selection->selection().visibleEnd()))
 557             selection->modify(FrameSelection::AlterationExtend, DirectionForward, CharacterGranularity);
 558
 559         selectionToDelete = selection->selection();
 560         if (!startingSelection().isRange() || selectionToDelete.base() != startingSelection().start())
 561             selectionAfterUndo = selectionToDelete;
 562         else {
 563             // It's a little tricky to compute what the starting selection would have been in the original document.
 564             // We can't let the VisibleSelection class's validation kick in or it'll adjust for us based on
 565             // the current state of the document and we'll get the wrong result.
 566             Position extent = startingSelection().end();
 567             if (extent.containerNode() != selectionToDelete.end().containerNode())
 568                 extent = selectionToDelete.extent();
 569             else {
 570                 int extraCharacters;
 571                 if (selectionToDelete.start().containerNode() == selectionToDelete.end().containerNode())
 572                     extraCharacters = selectionToDelete.end().computeOffsetInContainerNode() - selectionToDelete.start().computeOffsetInContainerNode();
 573                 else
 574                     extraCharacters = selectionToDelete.end().computeOffsetInContainerNode();
 575                 extent = Position(extent.containerNode(), extent.computeOffsetInContainerNode() + extraCharacters, Position::PositionIsOffsetInAnchor);
 576             }
 577             selectionAfterUndo.setWithoutValidation(startingSelection().start(), extent);
 578         }
 579         break;
 580     }
 581     case NoSelection:
 582         ASSERT_NOT_REACHED();
 583         break;
 584     }
 585
 586     ASSERT(!selectionToDelete.isNone());
 587     if (selectionToDelete.isNone())
 588         return;
 589
 590     if (selectionToDelete.isCaret())
 591         return;
 592
 593     if (killRing)
 594         frame->editor().addToKillRing(selectionToDelete.toNormalizedRange().get(), false);
 595     // Make undo select what was deleted on Mac alone
 596     if (frame->editor().behavior().shouldUndoOfDeleteSelectText())
 597         setStartingSelection(selectionAfterUndo);
 598     CompositeEditCommand::deleteSelection(selectionToDelete, m_smartDelete);
 599     setSmartDelete(false);
 600     typingAddedToOpenCommand(ForwardDeleteKey);
 601 }
 602
 603 void TypingCommand::deleteSelection(bool smartDelete)
 604 {
 605     CompositeEditCommand::deleteSelection(smartDelete);
 606     typingAddedToOpenCommand(DeleteSelection);
 607 }
 608
 609 void TypingCommand::updatePreservesTypingStyle(ETypingCommand commandType)
 610 {
 611     switch (commandType) {
 612     case DeleteSelection:
 613     case DeleteKey:
 614     case ForwardDeleteKey:
 615     case InsertParagraphSeparator:
 616     case InsertLineBreak:
 617         m_preservesTypingStyle = true;
 618         return;
 619     case InsertParagraphSeparatorInQuotedContent:
 620     case InsertText:
 621         m_preservesTypingStyle = false;
 622         return;
 623     }
 624     ASSERT_NOT_REACHED();
 625     m_preservesTypingStyle = false;
 626 }
 627
 628 bool TypingCommand::isTypingCommand() const
 629 {
 630     return true;
 631 }
 632
 633 } // namespace blink