[Editing] Store |CommandSource| in |CompositeEditCommand|

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 196 matching lines @@
   if (event->isDrop())
     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);
+          CommandSource::MenuOrKeyBinding, event->pastingFragment(), false,
+          event->shouldSmartReplace(), event->shouldMatchStyle(),
+          InputEvent::InputType::InsertFromPaste);
     } else {
-      replaceSelectionWithText(event->data(), false,
-                               event->shouldSmartReplace(),
+      replaceSelectionWithText(CommandSource::MenuOrKeyBinding, 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(CommandSource::MenuOrKeyBinding,
+                                           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(CommandSource 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(),
+          *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;
 }
 
 void Editor::deleteSelectionWithSmartDelete(
+    CommandSource 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,
+      *frame().document(), source, deleteMode == DeleteMode::Smart,
       kMergeBlocksAfterDelete, kExpandForSpecialElements, kSanitizeMarkup,
       inputType, referenceMovePosition)
       ->apply();
 }
 
 void Editor::pasteAsPlainText(const String& pastingText, bool smartReplace) {
   Element* target = findEventTargetFromSelection();
   if (!target)
     return;
   target->dispatchEvent(TextEvent::createForPlainTextPaste(
@@ skipping 159 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,
+void Editor::replaceSelectionWithFragment(CommandSource 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)
+  ReplaceSelectionCommand::create(*frame().document(), source, fragment,
+                                  options, inputType)
       ->apply();
   revealSelectionAfterEditingOperation();
 }
 
-void Editor::replaceSelectionWithText(const String& text,
+void Editor::replaceSelectionWithText(CommandSource 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)
     options |= ReplaceSelectionCommand::SmartReplace;
   if (dragSourceType == DragSourceType::PlainTextSource)
     options |= ReplaceSelectionCommand::MatchStyle;
   DCHECK(frame().document());
-  ReplaceSelectionCommand::create(*frame().document(), fragment, options,
-                                  InputEvent::InputType::InsertFromDrop)
+  ReplaceSelectionCommand::create(
+      *frame().document(), CommandSource::MenuOrKeyBinding, fragment, options,
+      InputEvent::InputType::InsertFromDrop)
       ->apply();
 }
 
 bool Editor::deleteSelectionAfterDraggingWithEvents(
     Element* dragSource,
     DeleteMode deleteMode,
     const Position& referenceMovePosition) {
   if (!dragSource || !dragSource->isConnected())
     return true;
 
   // Dispatch 'beforeinput'.
   const bool shouldDelete = dispatchBeforeInputEditorCommand(
                                 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);
+    deleteSelectionWithSmartDelete(CommandSource::MenuOrKeyBinding, 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() {
+void Editor::removeFormattingAndStyle(CommandSource source) {
   DCHECK(frame().document());
-  RemoveFormatCommand::create(*frame().document())->apply();
+  RemoveFormatCommand::create(*frame().document(), source)->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(CommandSource 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(),
+        ApplyStyleCommand::create(*frame().document(), source,
                                   EditingStyle::create(style), inputType)
             ->apply();
       }
       break;
   }
 }
 
-void Editor::applyParagraphStyle(StylePropertySet* style,
+void Editor::applyParagraphStyle(CommandSource 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)
+  ApplyStyleCommand::create(*frame().document(), source,
+                            EditingStyle::create(style), inputType,
+                            ApplyStyleCommand::ForceBlockProperties)
       ->apply();
 }
 
-void Editor::applyStyleToSelection(StylePropertySet* style,
+void Editor::applyStyleToSelection(CommandSource 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(CommandSource 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(CommandSource 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(
       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());
+      if (!focusedOrMainFrame->selection().isAvailable())

[Xiaocheng, 2016/12/14 04:19:50]

Seems irrelevant to this patch.

[chongz, 2016/12/15 00:53:32]

Will remove.

+        return true;
       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()))
+  if (!TypingCommand::insertLineBreak(*frame().document(),
+                                      CommandSource::MenuOrKeyBinding))
     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()))
+  if (!TypingCommand::insertParagraphSeparator(*frame().document(),
+                                               CommandSource::MenuOrKeyBinding))
     return false;
   revealSelectionAfterEditingOperation(
       alignToEdge ? ScrollAlignment::alignToEdgeIfNeeded
                   : ScrollAlignment::alignCenterIfNeeded);
 
   return true;
 }
 
-void Editor::cut(EditorCommandSource source) {
+void Editor::cut(CommandSource source) {
   if (tryDHTMLCut())
     return;  // DHTML did the whole operation
   if (!canCut())
     return;
 
   // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
   // needs to be audited.  See http://crbug.com/590369 for more details.
   // |tryDHTMLCut| dispatches cut event, which may make layout dirty, but we
   // need clean layout to obtain the selected content.
   frame().document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   // TODO(yosin) We should use early return style here.
   if (canDeleteRange(selectedRange())) {
     spellChecker().updateMarkersForWordsAffectedByEditing(true);
     if (enclosingTextControl(frame().selection().start())) {
       String plainText = frame().selectedTextForClipboard();
       Pasteboard::generalPasteboard()->writePlainText(
           plainText, canSmartCopyOrDelete() ? Pasteboard::CanSmartReplace
                                             : Pasteboard::CannotSmartReplace);
     } else {
       writeSelectionToPasteboard();
     }
 
-    if (source == CommandFromMenuOrKeyBinding) {
+    if (source == CommandSource::MenuOrKeyBinding) {
       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 12 matching lines @@
     Document* document = frame().document();
     if (HTMLImageElement* imageElement =
             imageElementFromImageDocument(document))
       writeImageNodeToPasteboard(Pasteboard::generalPasteboard(), imageElement,
                                  document->title());
     else
       writeSelectionToPasteboard();
   }
 }
 
-void Editor::paste(EditorCommandSource source) {
+void Editor::paste(CommandSource source) {
   DCHECK(frame().document());
   if (tryDHTMLPaste(AllMimeTypes))
     return;  // DHTML did the whole operation
   if (!canPaste())
     return;
   spellChecker().updateMarkersForWordsAffectedByEditing(false);
   ResourceFetcher* loader = frame().document()->fetcher();
   ResourceCacheValidationSuppressor validationSuppressor(loader);
 
   PasteMode pasteMode = frame().selection().isContentRichlyEditable()
                             ? AllMimeTypes
                             : PlainTextOnly;
 
-  if (source == CommandFromMenuOrKeyBinding) {
+  if (source == CommandSource::MenuOrKeyBinding) {
     DataTransfer* dataTransfer =
         DataTransfer::create(DataTransfer::CopyAndPaste, DataTransferReadable,
                              DataObject::createFromPasteboard(pasteMode));
 
     if (dispatchBeforeInputDataTransfer(findEventTargetFromSelection(),
                                         InputEvent::InputType::InsertFromPaste,
                                         dataTransfer, nullptr) !=
         DispatchEventResult::NotCanceled)
       return;
     // 'beforeinput' event handler may destroy target frame.
     if (m_frame->document()->frame() != m_frame)
       return;
   }
 
   if (pasteMode == AllMimeTypes)
     pasteWithPasteboard(Pasteboard::generalPasteboard());
   else
     pasteAsPlainTextWithPasteboard(Pasteboard::generalPasteboard());
 }
 
-void Editor::pasteAsPlainText(EditorCommandSource source) {
+void Editor::pasteAsPlainText(CommandSource source) {
   if (tryDHTMLPaste(PlainTextOnly))
     return;
   if (!canPaste())
     return;
   spellChecker().updateMarkersForWordsAffectedByEditing(false);
   pasteAsPlainTextWithPasteboard(Pasteboard::generalPasteboard());
 }
 
-void Editor::performDelete() {
+void Editor::performDelete(CommandSource 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() {
+void Editor::undo(CommandSource) {
   m_undoStack->undo();
 }
 
 bool Editor::canRedo() {
   return m_undoStack->canRedo();
 }
 
-void Editor::redo() {
+void Editor::redo(CommandSource) {
   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);
+      CommandSource::MenuOrKeyBinding, style,
+      InputEvent::InputType::FormatSetBlockTextDirection);
 }
 
 void Editor::revealSelectionAfterEditingOperation(
     const ScrollAlignment& alignment,
     RevealExtentOption revealExtentOption) {
-  if (m_preventRevealSelection)
+  if (m_preventRevealSelection || !m_frame->selection().isAvailable())

[Xiaocheng, 2016/12/14 04:19:50]

Seems irrelevant to this patch.

[chongz, 2016/12/15 00:53:32]

Will remove.

     return;
   frame().selection().revealSelection(alignment, revealExtentOption);
 }
 
-void Editor::transpose() {
+void Editor::transpose(CommandSource 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,
+void Editor::computeAndSetTypingStyle(CommandSource 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)
+    ApplyStyleCommand::create(*frame().document(), source, blockStyle,
+                              inputType)
         ->apply();
   }
 
   // Set the remaining style as the typing style.
-  frame().selection().setTypingStyle(typingStyle);
+  if (frame().selection().isAvailable())

[Xiaocheng, 2016/12/14 04:19:50]

Seems irrelevant to this patch.

[chongz, 2016/12/15 00:53:32]

Will remove.

+    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
   // |EphemeralRange| rather than|Range| object.
   Range* resultRange = findRangeOfString(
       target, EphemeralRange(selection.start(), selection.end()),
       static_cast<FindOptions>(options | FindAPICall));
@@ skipping 226 matching lines @@
 }
 
 DEFINE_TRACE(Editor) {
   visitor->trace(m_frame);
   visitor->trace(m_lastEditCommand);
   visitor->trace(m_undoStack);
   visitor->trace(m_mark);
 }
 
 }  // namespace blink