[EditCommandSource] Pass source from |Editor::Command| to |Editor::apply*()/insert*()/...| (2/3)

third_party/WebKit/Source/core/editing/Editor.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  *
  * 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
@@ skipping 201 matching lines @@
   if (event->isIncrementalInsertion())
     return false;
 
   // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
   // needs to be audited.  See http://crbug.com/590369 for more details.
   m_frame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   if (event->isPaste()) {
     if (event->pastingFragment()) {
       replaceSelectionWithFragment(
-          event->pastingFragment(), false, event->shouldSmartReplace(),
-          event->shouldMatchStyle(), InputEvent::InputType::InsertFromPaste);
+          EditCommandSource::kMenuOrKeyBinding, event->pastingFragment(), false,
+          event->shouldSmartReplace(), event->shouldMatchStyle(),
+          InputEvent::InputType::InsertFromPaste);
     } else {
-      replaceSelectionWithText(event->data(), false,
-                               event->shouldSmartReplace(),
-                               InputEvent::InputType::InsertFromPaste);
+      replaceSelectionWithText(
+          EditCommandSource::kMenuOrKeyBinding, event->data(), false,
+          event->shouldSmartReplace(), InputEvent::InputType::InsertFromPaste);
     }
     return true;
   }
 
   String data = event->data();
   if (data == "\n") {
     if (event->isLineBreak())
       return insertLineBreak();
     return insertParagraphSeparator();
   }
 
-  return insertTextWithoutSendingTextEvent(data, false, event);
+  return insertTextWithoutSendingTextEvent(EditCommandSource::kMenuOrKeyBinding,
+                                           data, false, event);
 }
 
 bool Editor::canEdit() const {
   return frame().selection().rootEditableElement();
 }
 
 bool Editor::canEditRichly() const {
   return frame().selection().isContentRichlyEditable();
 }
 
@@ skipping 59 matching lines @@
   return smartInsertDeleteEnabled() &&
          frame().selection().granularity() == WordGranularity;
 }
 
 bool Editor::isSelectTrailingWhitespaceEnabled() const {
   if (Settings* settings = frame().settings())
     return settings->selectTrailingWhitespaceEnabled();
   return false;
 }
 
-bool Editor::deleteWithDirection(DeleteDirection direction,
+bool Editor::deleteWithDirection(EditCommandSource source,
+                                 DeleteDirection direction,
                                  TextGranularity granularity,
                                  bool killRing,
                                  bool isTypingAction) {
   if (!canEdit())
     return false;
 
   EditingState editingState;
   if (frame().selection().isRange()) {
     if (isTypingAction) {
       DCHECK(frame().document());
       TypingCommand::deleteKeyPressed(
           *frame().document(),
           canSmartCopyOrDelete() ? TypingCommand::SmartDelete : 0, granularity);
       revealSelectionAfterEditingOperation();
     } else {
       if (killRing)
         addToKillRing(selectedRange());
       deleteSelectionWithSmartDelete(
+          source,
           canSmartCopyOrDelete() ? DeleteMode::Smart : DeleteMode::Simple,
           deletionInputTypeFromTextGranularity(direction, granularity));
       // Implicitly calls revealSelectionAfterEditingOperation().
     }
   } else {
     TypingCommand::Options options = 0;
     if (canSmartCopyOrDelete())
       options |= TypingCommand::SmartDelete;
     if (killRing)
       options |= TypingCommand::KillRing;
@@ skipping 16 matching lines @@
 
   // FIXME: We should to move this down into deleteKeyPressed.
   // clear the "start new kill ring sequence" setting, because it was set to
   // true when the selection was updated by deleting the range
   if (killRing)
     setStartNewKillRingSequence(false);
 
   return true;
 }
 
+// TODO(chongz): Pass |EditCommandSource| to |CompositeEditCommand|.
 void Editor::deleteSelectionWithSmartDelete(
+    EditCommandSource,
     DeleteMode deleteMode,
     InputEvent::InputType inputType,
     const Position& referenceMovePosition) {
   if (frame().selection().isNone())
     return;
 
   const bool kMergeBlocksAfterDelete = true;
   const bool kExpandForSpecialElements = false;
   const bool kSanitizeMarkup = true;
   DCHECK(frame().document());
@@ skipping 172 matching lines @@
   // invalidate clipboard here for security
   dataTransfer->setAccessPolicy(DataTransferNumb);
 
   return !noDefaultProcessing;
 }
 
 bool Editor::canSmartReplaceWithPasteboard(Pasteboard* pasteboard) {
   return smartInsertDeleteEnabled() && pasteboard->canSmartReplace();
 }
 
-void Editor::replaceSelectionWithFragment(DocumentFragment* fragment,
+// TODO(chongz): Pass |EditCommandSource| to |CompositeEditCommand|.
+void Editor::replaceSelectionWithFragment(EditCommandSource,
+                                          DocumentFragment* fragment,
                                           bool selectReplacement,
                                           bool smartReplace,
                                           bool matchStyle,
                                           InputEvent::InputType inputType) {
   DCHECK(!frame().document()->needsLayoutTreeUpdate());
   if (frame().selection().isNone() ||
       !frame().selection().isContentEditable() || !fragment)
     return;
 
   ReplaceSelectionCommand::CommandOptions options =
       ReplaceSelectionCommand::PreventNesting |
       ReplaceSelectionCommand::SanitizeFragment;
   if (selectReplacement)
     options |= ReplaceSelectionCommand::SelectReplacement;
   if (smartReplace)
     options |= ReplaceSelectionCommand::SmartReplace;
   if (matchStyle)
     options |= ReplaceSelectionCommand::MatchStyle;
   DCHECK(frame().document());
   ReplaceSelectionCommand::create(*frame().document(), fragment, options,
                                   inputType)
       ->apply();
   revealSelectionAfterEditingOperation();
 }
 
-void Editor::replaceSelectionWithText(const String& text,
+void Editor::replaceSelectionWithText(EditCommandSource source,
+                                      const String& text,
                                       bool selectReplacement,
                                       bool smartReplace,
                                       InputEvent::InputType inputType) {
-  replaceSelectionWithFragment(createFragmentFromText(selectedRange(), text),
-                               selectReplacement, smartReplace, true,
-                               inputType);
+  replaceSelectionWithFragment(
+      source, createFragmentFromText(selectedRange(), text), selectReplacement,
+      smartReplace, true, inputType);
 }
 
 // TODO(xiaochengh): Merge it with |replaceSelectionWithFragment()|.
 void Editor::replaceSelectionAfterDragging(DocumentFragment* fragment,
                                            InsertMode insertMode,
                                            DragSourceType dragSourceType) {
   ReplaceSelectionCommand::CommandOptions options =
       ReplaceSelectionCommand::SelectReplacement |
       ReplaceSelectionCommand::PreventNesting;
   if (insertMode == InsertMode::Smart)
@@ skipping 18 matching lines @@
                                 dragSource, InputEvent::InputType::DeleteByDrag,
                                 nullptr) == DispatchEventResult::NotCanceled;
 
   // 'beforeinput' event handler may destroy frame, return false to cancel
   // remaining actions;
   if (m_frame->document()->frame() != m_frame)
     return false;
 
   if (shouldDelete && dragSource->isConnected()) {
     deleteSelectionWithSmartDelete(
-        deleteMode, InputEvent::InputType::DeleteByDrag, referenceMovePosition);
+        EditCommandSource::kMenuOrKeyBinding, deleteMode,
+        InputEvent::InputType::DeleteByDrag, referenceMovePosition);
   }
 
   return true;
 }
 
 bool Editor::replaceSelectionAfterDraggingWithEvents(
     Element* dropTarget,
     DragData* dragData,
     DocumentFragment* fragment,
     Range* dropCaretRange,
@@ skipping 43 matching lines @@
   if (frame().settings() && frame().settings()->accessibilityEnabled()) {
     Node* node = endingSelection.start().anchorNode();
     if (AXObjectCache* cache = frame().document()->existingAXObjectCache())
       cache->handleEditableTextContentChanged(node);
   }
 
   spellChecker().updateMarkersForWordsAffectedByEditing(true);
   client().respondToChangedContents();
 }
 
-void Editor::removeFormattingAndStyle() {
+// TODO(chongz): Pass |EditCommandSource| to |CompositeEditCommand|.
+void Editor::removeFormattingAndStyle(EditCommandSource) {
   DCHECK(frame().document());
   RemoveFormatCommand::create(*frame().document())->apply();
 }
 
 void Editor::registerCommandGroup(CompositeEditCommand* commandGroupWrapper) {
   DCHECK(commandGroupWrapper->isCommandGroupWrapper());
   m_lastEditCommand = commandGroupWrapper;
 }
 
 void Editor::clearLastEditCommand() {
   m_lastEditCommand.clear();
 }
 
 Element* Editor::findEventTargetFrom(const VisibleSelection& selection) const {
   Element* target = associatedElementOf(selection.start());
   if (!target)
     target = frame().document()->body();
 
   return target;
 }
 
 Element* Editor::findEventTargetFromSelection() const {
   return findEventTargetFrom(frame().selection().selection());
 }
 
-void Editor::applyStyle(StylePropertySet* style,
+void Editor::applyStyle(EditCommandSource source,
+                        StylePropertySet* style,
                         InputEvent::InputType inputType) {
   switch (frame().selection().getSelectionType()) {
     case NoSelection:
       // do nothing
       break;
     case CaretSelection:
-      computeAndSetTypingStyle(style, inputType);
+      computeAndSetTypingStyle(source, style, inputType);
       break;
     case RangeSelection:
       if (style) {
         DCHECK(frame().document());
         ApplyStyleCommand::create(*frame().document(),
                                   EditingStyle::create(style), inputType)
             ->apply();
       }
       break;
   }
 }
 
-void Editor::applyParagraphStyle(StylePropertySet* style,
+// TODO(chongz): Pass |EditCommandSource| to |CompositeEditCommand|.
+void Editor::applyParagraphStyle(EditCommandSource,
+                                 StylePropertySet* style,
                                  InputEvent::InputType inputType) {
   if (frame().selection().isNone() || !style)
     return;
   DCHECK(frame().document());
   ApplyStyleCommand::create(*frame().document(), EditingStyle::create(style),
                             inputType, ApplyStyleCommand::ForceBlockProperties)
       ->apply();
 }
 
-void Editor::applyStyleToSelection(StylePropertySet* style,
+void Editor::applyStyleToSelection(EditCommandSource source,
+                                   StylePropertySet* style,
                                    InputEvent::InputType inputType) {
   if (!style || style->isEmpty() || !canEditRichly())
     return;
 
-  applyStyle(style, inputType);
+  applyStyle(source, style, inputType);
 }
 
-void Editor::applyParagraphStyleToSelection(StylePropertySet* style,
+void Editor::applyParagraphStyleToSelection(EditCommandSource source,
+                                            StylePropertySet* style,
                                             InputEvent::InputType inputType) {
   if (!style || style->isEmpty() || !canEditRichly())
     return;
 
-  applyParagraphStyle(style, inputType);
+  applyParagraphStyle(source, style, inputType);
 }
 
 bool Editor::selectionStartHasStyle(CSSPropertyID propertyID,
                                     const String& value) const {
   EditingStyle* styleToCheck = EditingStyle::create(propertyID, value);
   EditingStyle* styleAtStart = EditingStyle::styleAtSelectionStart(
       frame().selection().selection(), propertyID == CSSPropertyBackgroundColor,
       styleToCheck->style());
   return styleToCheck->triStateOfStyle(styleAtStart);
 }
@@ skipping 165 matching lines @@
   frame().inputMethodController().clear();
   m_shouldStyleWithCSS = false;
   m_defaultParagraphSeparator = EditorParagraphSeparatorIsDiv;
   m_undoStack->clear();
 }
 
 bool Editor::insertText(const String& text, KeyboardEvent* triggeringEvent) {
   return frame().eventHandler().handleTextInputEvent(text, triggeringEvent);
 }
 
-bool Editor::insertTextWithoutSendingTextEvent(const String& text,
+bool Editor::insertTextWithoutSendingTextEvent(EditCommandSource source,
+                                               const String& text,
                                                bool selectInsertedText,
                                                TextEvent* triggeringEvent) {
   if (text.isEmpty())
     return false;
 
   const VisibleSelection& selection = selectionForCommand(triggeringEvent);
   if (!selection.isContentEditable())
     return false;
 
   spellChecker().updateMarkersForWordsAffectedByEditing(
@@ skipping 84 matching lines @@
       if (dispatchBeforeInputDataTransfer(findEventTargetFromSelection(),
                                           InputEvent::InputType::DeleteByCut,
                                           nullptr, nullptr) !=
           DispatchEventResult::NotCanceled)
         return;
       // 'beforeinput' event handler may destroy target frame.
       if (m_frame->document()->frame() != m_frame)
         return;
     }
     deleteSelectionWithSmartDelete(
-        canSmartCopyOrDelete() ? DeleteMode::Smart : DeleteMode::Simple,
+        source, canSmartCopyOrDelete() ? DeleteMode::Smart : DeleteMode::Simple,
         InputEvent::InputType::DeleteByCut);
   }
 }
 
 void Editor::copy() {
   if (tryDHTMLCopy())
     return;  // DHTML did the whole operation
   if (!canCopy())
     return;
 
@@ skipping 56 matching lines @@
 
 void Editor::pasteAsPlainText(EditCommandSource source) {
   if (tryDHTMLPaste(PlainTextOnly))
     return;
   if (!canPaste())
     return;
   spellChecker().updateMarkersForWordsAffectedByEditing(false);
   pasteAsPlainTextWithPasteboard(Pasteboard::generalPasteboard());
 }
 
-void Editor::performDelete() {
+void Editor::performDelete(EditCommandSource source) {
   if (!canDelete())
     return;
 
   // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
   // needs to be audited.  See http://crbug.com/590369 for more details.
   // |selectedRange| requires clean layout for visible selection normalization.
   frame().document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   addToKillRing(selectedRange());
   // TODO(chongz): |Editor::performDelete()| has no direction.
   // https://github.com/w3c/editing/issues/130
   deleteSelectionWithSmartDelete(
-      canSmartCopyOrDelete() ? DeleteMode::Smart : DeleteMode::Simple,
+      source, canSmartCopyOrDelete() ? DeleteMode::Smart : DeleteMode::Simple,
       InputEvent::InputType::DeleteContentBackward);
 
   // clear the "start new kill ring sequence" setting, because it was set to
   // true when the selection was updated by deleting the range
   setStartNewKillRingSequence(false);
 }
 
 static void countEditingEvent(ExecutionContext* executionContext,
                               const Event* event,
                               UseCounter::Feature featureOnInput,
@@ skipping 66 matching lines @@
 void Editor::copyImage(const HitTestResult& result) {
   writeImageNodeToPasteboard(Pasteboard::generalPasteboard(),
                              result.innerNodeOrImageMapImage(),
                              result.altDisplayString());
 }
 
 bool Editor::canUndo() {
   return m_undoStack->canUndo();
 }
 
-void Editor::undo() {
+// TODO(chongz): Fire 'beforeinput' for user triggered undo.
+void Editor::undo(EditCommandSource) {
   m_undoStack->undo();
 }
 
 bool Editor::canRedo() {
   return m_undoStack->canRedo();
 }
 
-void Editor::redo() {
+// TODO(chongz): Fire 'beforeinput' for user triggered redo.
+void Editor::redo(EditCommandSource) {
   m_undoStack->redo();
 }
 
 void Editor::setBaseWritingDirection(WritingDirection direction) {
   Element* focusedElement = frame().document()->focusedElement();
   if (isTextControlElement(focusedElement)) {
     if (direction == NaturalWritingDirection)
       return;
     focusedElement->setAttribute(
         dirAttr, direction == LeftToRightWritingDirection ? "ltr" : "rtl");
     focusedElement->dispatchInputEvent();
     return;
   }
 
   MutableStylePropertySet* style =
       MutableStylePropertySet::create(HTMLQuirksMode);
   style->setProperty(
       CSSPropertyDirection,
       direction == LeftToRightWritingDirection
           ? "ltr"
           : direction == RightToLeftWritingDirection ? "rtl" : "inherit",
       false);
   applyParagraphStyleToSelection(
-      style, InputEvent::InputType::FormatSetBlockTextDirection);
+      EditCommandSource::kMenuOrKeyBinding, style,
+      InputEvent::InputType::FormatSetBlockTextDirection);
 }
 
 void Editor::revealSelectionAfterEditingOperation(
     const ScrollAlignment& alignment,
     RevealExtentOption revealExtentOption) {
   if (m_preventRevealSelection)
     return;
   frame().selection().revealSelection(alignment, revealExtentOption);
 }
 
-void Editor::transpose() {
+void Editor::transpose(EditCommandSource source) {
   if (!canEdit())
     return;
 
   VisibleSelection selection = frame().selection().selection();
   if (!selection.isCaret())
     return;
 
   // Make a selection that goes back one character and forward two characters.
   VisiblePosition caret = selection.visibleStart();
   VisiblePosition next =
@@ skipping 16 matching lines @@
     return;
   String transposed = text.right(1) + text.left(1);
 
   // Select the two characters.
   if (newSelection != frame().selection().selection())
     frame().selection().setSelection(newSelection);
 
   // Insert the transposed characters.
   // TODO(chongz): Once we add |InsertTranspose| in |InputEvent::InputType|, we
   // should use it instead of |InsertFromPaste|.
-  replaceSelectionWithText(transposed, false, false,
+  replaceSelectionWithText(source, transposed, false, false,
                            InputEvent::InputType::InsertFromPaste);
 }
 
 void Editor::addToKillRing(const EphemeralRange& range) {
   if (m_shouldStartNewKillRingSequence)
     killRing().startNewSequence();
 
   DCHECK(!frame().document()->needsLayoutTreeUpdate());
   String text = plainText(range);
   killRing().append(text);
@@ skipping 60 matching lines @@
                    std::max(startCaretRect.height(), endCaretRect.height()));
   }
 
   // start and end aren't on the same line, so go from start to the end of its
   // line
   return IntRect(startCaretRect.x(), startCaretRect.y(),
                  (startCaretRect.width() + extraWidthToEndOfLine).toInt(),
                  startCaretRect.height());
 }
 
-void Editor::computeAndSetTypingStyle(StylePropertySet* style,
+// TODO(chongz): Pass |EditCommandSource| to |CompositeEditCommand|.
+void Editor::computeAndSetTypingStyle(EditCommandSource,
+                                      StylePropertySet* style,
                                       InputEvent::InputType inputType) {
   if (!style || style->isEmpty()) {
     frame().selection().clearTypingStyle();
     return;
   }
 
   // Calculate the current typing style.
   EditingStyle* typingStyle = nullptr;
   if (frame().selection().typingStyle()) {
     typingStyle = frame().selection().typingStyle()->copy();
@@ skipping 251 matching lines @@
   DCHECK(!document.documentElement());
   document.appendChild(root);
 
   // TODO(tkent): Should we check and move Text node children of <html>?
 }
 
 void Editor::replaceSelection(const String& text) {
   DCHECK(!frame().document()->needsLayoutTreeUpdate());
   bool selectReplacement = behavior().shouldSelectReplacement();
   bool smartReplace = true;
-  replaceSelectionWithText(text, selectReplacement, smartReplace,
+  replaceSelectionWithText(EditCommandSource::kMenuOrKeyBinding, text,
+                           selectReplacement, smartReplace,
                            InputEvent::InputType::InsertReplacementText);
 }
 
+void Editor::replaceSelectionForSpellChecker(const String& text) {
+  DCHECK(!frame().document()->needsLayoutTreeUpdate());
+  const bool kSelectReplacement = false;
+  const bool kSmartReplace = false;
+  replaceSelectionWithText(EditCommandSource::kMenuOrKeyBinding, text,
+                           kSelectReplacement, kSmartReplace,
+                           InputEvent::InputType::InsertReplacementText);
+}
+
 DEFINE_TRACE(Editor) {
   visitor->trace(m_frame);
   visitor->trace(m_lastEditCommand);
   visitor->trace(m_undoStack);
   visitor->trace(m_mark);
 }
 
 }  // namespace blink