[EditCommandSource] Pass source to |CompositEditCommand| and |TypingCommand| (3/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 313 matching lines @@
                                  bool killRing,
                                  bool isTypingAction) {
   if (!canEdit())
     return false;
 
   EditingState editingState;
   if (frame().selection().isRange()) {
     if (isTypingAction) {
       DCHECK(frame().document());
       TypingCommand::deleteKeyPressed(
-          *frame().document(),
+          *frame().document(), source,
           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;
     switch (direction) {
       case DeleteDirection::Forward:
         DCHECK(frame().document());
         TypingCommand::forwardDeleteKeyPressed(
-            *frame().document(), &editingState, options, granularity);
+            *frame().document(), source, &editingState, options, granularity);
         if (editingState.isAborted())
           return false;
         break;
       case DeleteDirection::Backward:
         DCHECK(frame().document());
-        TypingCommand::deleteKeyPressed(*frame().document(), options,
+        TypingCommand::deleteKeyPressed(*frame().document(), source, options,
                                         granularity);
         break;
     }
     revealSelectionAfterEditingOperation();
   }
 
   // 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,
+    EditCommandSource source,
     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());
   DeleteSelectionCommand::create(
       *frame().document(), deleteMode == DeleteMode::Smart,
       kMergeBlocksAfterDelete, kExpandForSpecialElements, kSanitizeMarkup,
       inputType, referenceMovePosition)
-      ->apply();
+      ->apply(source);
 }
 
 void Editor::pasteAsPlainText(const String& pastingText, bool smartReplace) {
   Element* target = findEventTargetFromSelection();
   if (!target)
     return;
   target->dispatchEvent(TextEvent::createForPlainTextPaste(
       frame().domWindow(), pastingText, smartReplace));
 }
 
@@ skipping 157 matching lines @@
   // invalidate clipboard here for security
   dataTransfer->setAccessPolicy(DataTransferNumb);
 
   return !noDefaultProcessing;
 }
 
 bool Editor::canSmartReplaceWithPasteboard(Pasteboard* pasteboard) {
   return smartInsertDeleteEnabled() && pasteboard->canSmartReplace();
 }
 
-// TODO(chongz): Pass |EditCommandSource| to |CompositeEditCommand|.
-void Editor::replaceSelectionWithFragment(EditCommandSource,
+void Editor::replaceSelectionWithFragment(EditCommandSource source,
                                           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();
+      ->apply(source);
   revealSelectionAfterEditingOperation();
 }
 
 void Editor::replaceSelectionWithText(EditCommandSource source,
                                       const String& text,
                                       bool selectReplacement,
                                       bool smartReplace,
                                       InputEvent::InputType 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)
     options |= ReplaceSelectionCommand::SmartReplace;
   if (dragSourceType == DragSourceType::PlainTextSource)
     options |= ReplaceSelectionCommand::MatchStyle;
   DCHECK(frame().document());
   ReplaceSelectionCommand::create(*frame().document(), fragment, options,
                                   InputEvent::InputType::InsertFromDrop)
-      ->apply();
+      ->apply(EditCommandSource::kMenuOrKeyBinding);
 }
 
 bool Editor::deleteSelectionAfterDraggingWithEvents(
     Element* dragSource,
     DeleteMode deleteMode,
     const Position& referenceMovePosition) {
   if (!dragSource || !dragSource->isConnected())
     return true;
 
   // Dispatch 'beforeinput'.
@@ skipping 66 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();
 }
 
-// TODO(chongz): Pass |EditCommandSource| to |CompositeEditCommand|.
-void Editor::removeFormattingAndStyle(EditCommandSource) {
+void Editor::removeFormattingAndStyle(EditCommandSource source) {
   DCHECK(frame().document());
-  RemoveFormatCommand::create(*frame().document())->apply();
+  RemoveFormatCommand::create(*frame().document())->apply(source);
 }
 
 void Editor::registerCommandGroup(CompositeEditCommand* commandGroupWrapper) {
   DCHECK(commandGroupWrapper->isCommandGroupWrapper());
   m_lastEditCommand = commandGroupWrapper;
 }
 
 void Editor::clearLastEditCommand() {
   m_lastEditCommand.clear();
 }
@@ skipping 18 matching lines @@
       // do nothing
       break;
     case CaretSelection:
       computeAndSetTypingStyle(source, style, inputType);
       break;
     case RangeSelection:
       if (style) {
         DCHECK(frame().document());
         ApplyStyleCommand::create(*frame().document(),
                                   EditingStyle::create(style), inputType)
-            ->apply();
+            ->apply(source);
       }
       break;
   }
 }
 
-// TODO(chongz): Pass |EditCommandSource| to |CompositeEditCommand|.
-void Editor::applyParagraphStyle(EditCommandSource,
+void Editor::applyParagraphStyle(EditCommandSource source,
                                  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();
+      ->apply(source);
 }
 
 void Editor::applyStyleToSelection(EditCommandSource source,
                                    StylePropertySet* style,
                                    InputEvent::InputType inputType) {
   if (!style || style->isEmpty() || !canEditRichly())
     return;
 
   applyStyle(source, style, inputType);
 }
@@ skipping 199 matching lines @@
 
   const VisibleSelection& selection = selectionForCommand(triggeringEvent);
   if (!selection.isContentEditable())
     return false;
 
   spellChecker().updateMarkersForWordsAffectedByEditing(
       isSpaceOrNewline(text[0]));
 
   // Insert the text
   TypingCommand::insertText(
-      *selection.start().document(), text, selection,
+      *selection.start().document(), source, text, selection,
       selectInsertedText ? TypingCommand::SelectInsertedText : 0,
       triggeringEvent && triggeringEvent->isComposition()
           ? TypingCommand::TextCompositionConfirm
           : TypingCommand::TextCompositionNone);
 
   // Reveal the current selection
   if (LocalFrame* editedFrame = selection.start().document()->frame()) {
     if (Page* page = editedFrame->page()) {
       LocalFrame* focusedOrMainFrame =
           toLocalFrame(page->focusController().focusedOrMainFrame());
       focusedOrMainFrame->selection().revealSelection(
           ScrollAlignment::alignCenterIfNeeded);
     }
   }
 
   return true;
 }
 
 bool Editor::insertLineBreak() {
   if (!canEdit())
     return false;
 
   VisiblePosition caret = frame().selection().selection().visibleStart();
   bool alignToEdge = isEndOfEditableOrNonEditableContent(caret);
   DCHECK(frame().document());
-  if (!TypingCommand::insertLineBreak(*frame().document()))
+  // we can pass |EditCommandSource::kMenuOrKeyBinding| because
+  // |insertLineBreak()| is only used by |Editor::handleTextEvent()| and
+  // |Editor::insertParagraphSeparator()|.
+  if (!TypingCommand::insertLineBreak(*frame().document(),
+                                      EditCommandSource::kMenuOrKeyBinding))
     return false;
   revealSelectionAfterEditingOperation(
       alignToEdge ? ScrollAlignment::alignToEdgeIfNeeded
                   : ScrollAlignment::alignCenterIfNeeded);
 
   return true;
 }
 
 bool Editor::insertParagraphSeparator() {
   if (!canEdit())
     return false;
 
   if (!canEditRichly())
     return insertLineBreak();
 
   VisiblePosition caret = frame().selection().selection().visibleStart();
   bool alignToEdge = isEndOfEditableOrNonEditableContent(caret);
   DCHECK(frame().document());
   EditingState editingState;
-  if (!TypingCommand::insertParagraphSeparator(*frame().document()))
+  // We can |EditCommandSource::kMenuOrKeyBinding| because
+  // |Editor::insertParagraphSeparator()| is only used by
+  // |Editor::handleTextEvent()|.
+  if (!TypingCommand::insertParagraphSeparator(
+          *frame().document(), EditCommandSource::kMenuOrKeyBinding))
     return false;
   revealSelectionAfterEditingOperation(
       alignToEdge ? ScrollAlignment::alignToEdgeIfNeeded
                   : ScrollAlignment::alignCenterIfNeeded);
 
   return true;
 }
 
 void Editor::cut(EditCommandSource source) {
   if (tryDHTMLCut())
@@ skipping 364 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());
 }
 
-// TODO(chongz): Pass |EditCommandSource| to |CompositeEditCommand|.
-void Editor::computeAndSetTypingStyle(EditCommandSource,
+void Editor::computeAndSetTypingStyle(EditCommandSource source,
                                       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();
     typingStyle->overrideWithStyle(style);
   } else {
     typingStyle = EditingStyle::create(style);
   }
 
   typingStyle->prepareToApplyAt(
       frame().selection().selection().visibleStart().deepEquivalent(),
       EditingStyle::PreserveWritingDirection);
 
   // Handle block styles, substracting these from the typing style.
   EditingStyle* blockStyle = typingStyle->extractAndRemoveBlockProperties();
   if (!blockStyle->isEmpty()) {
     DCHECK(frame().document());
     ApplyStyleCommand::create(*frame().document(), blockStyle, inputType)
-        ->apply();
+        ->apply(source);
   }
 
   // Set the remaining style as the typing style.
   frame().selection().setTypingStyle(typingStyle);
 }
 
 bool Editor::findString(const String& target, FindOptions options) {
   VisibleSelection selection = frame().selection().selection();
 
   // TODO(yosin) We should make |findRangeOfString()| to return
@@ skipping 248 matching lines @@
 }
 
 DEFINE_TRACE(Editor) {
   visitor->trace(m_frame);
   visitor->trace(m_lastEditCommand);
   visitor->trace(m_undoStack);
   visitor->trace(m_mark);
 }
 
 }  // namespace blink