[EditCommandSource] Pass source through |CompositeEditCommand| ctor instead of |apply(source)|

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 370 matching lines @@
     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,
+      *frame().document(), source, deleteMode == DeleteMode::Smart,
       kMergeBlocksAfterDelete, kExpandForSpecialElements, kSanitizeMarkup,
       inputType, referenceMovePosition)
-      ->apply(source);
+      ->apply();
 }
 
 void Editor::pasteAsPlainText(const String& pastingText, bool smartReplace) {
   Element* target = findEventTargetFromSelection();
   if (!target)
     return;
   target->dispatchEvent(TextEvent::createForPlainTextPaste(
       frame().domWindow(), pastingText, smartReplace));
 }
 
@@ skipping 178 matching lines @@
   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(source);
+  ReplaceSelectionCommand::create(*frame().document(), source, fragment,
+                                  options, inputType)
+      ->apply();
   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(EditCommandSource::kMenuOrKeyBinding);
+  ReplaceSelectionCommand::create(
+      *frame().document(), EditCommandSource::kMenuOrKeyBinding, fragment,
+      options, InputEvent::InputType::InsertFromDrop)
+      ->apply();
 }
 
 bool Editor::deleteSelectionAfterDraggingWithEvents(
     Element* dragSource,
     DeleteMode deleteMode,
     const Position& referenceMovePosition) {
   if (!dragSource || !dragSource->isConnected())
     return true;
 
   // Dispatch 'beforeinput'.
@@ skipping 68 matching lines @@
     if (AXObjectCache* cache = frame().document()->existingAXObjectCache())
       cache->handleEditableTextContentChanged(node);
   }
 
   spellChecker().updateMarkersForWordsAffectedByEditing(true);
   client().respondToChangedContents();
 }
 
 void Editor::removeFormattingAndStyle(EditCommandSource source) {
   DCHECK(frame().document());
-  RemoveFormatCommand::create(*frame().document())->apply(source);
+  RemoveFormatCommand::create(*frame().document(), source)->apply();
 }
 
 void Editor::registerCommandGroup(CompositeEditCommand* commandGroupWrapper) {
   DCHECK(commandGroupWrapper->isCommandGroupWrapper());
   m_lastEditCommand = commandGroupWrapper;
 }
 
 void Editor::clearLastEditCommand() {
   m_lastEditCommand.clear();
 }
@@ skipping 16 matching lines @@
   switch (frame().selection().getSelectionType()) {
     case NoSelection:
       // do nothing
       break;
     case CaretSelection:
       computeAndSetTypingStyle(source, style, inputType);
       break;
     case RangeSelection:
       if (style) {
         DCHECK(frame().document());
-        ApplyStyleCommand::create(*frame().document(),
+        ApplyStyleCommand::create(*frame().document(), source,
                                   EditingStyle::create(style), inputType)
-            ->apply(source);
+            ->apply();
       }
       break;
   }
 }
 
 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(source);
+  ApplyStyleCommand::create(*frame().document(), source,
+                            EditingStyle::create(style), inputType,
+                            ApplyStyleCommand::ForceBlockProperties)
+      ->apply();
 }
 
 void Editor::applyStyleToSelection(EditCommandSource source,
                                    StylePropertySet* style,
                                    InputEvent::InputType inputType) {
   if (!style || style->isEmpty() || !canEditRichly())
     return;
 
   applyStyle(source, style, inputType);
 }
@@ skipping 661 matching lines @@
   }
 
   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(source);
+    ApplyStyleCommand::create(*frame().document(), source, blockStyle,
+                              inputType)
+        ->apply();
   }
 
   // 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