[Editing] Store |CommandSource| in |CompositeEditCommand|

third_party/WebKit/Source/core/editing/commands/CompositeEditCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  * 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 25 matching lines @@
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/Editor.h"
 #include "core/editing/PlainTextRange.h"
 #include "core/editing/RelocatablePosition.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/editing/commands/AppendNodeCommand.h"
 #include "core/editing/commands/ApplyStyleCommand.h"
 #include "core/editing/commands/DeleteFromTextNodeCommand.h"
 #include "core/editing/commands/DeleteSelectionCommand.h"
 #include "core/editing/commands/InsertIntoTextNodeCommand.h"
-#include "core/editing/commands/InsertLineBreakCommand.h"
 #include "core/editing/commands/InsertNodeBeforeCommand.h"
 #include "core/editing/commands/InsertParagraphSeparatorCommand.h"
 #include "core/editing/commands/MergeIdenticalElementsCommand.h"
 #include "core/editing/commands/RemoveCSSPropertyCommand.h"
 #include "core/editing/commands/RemoveNodeCommand.h"
 #include "core/editing/commands/RemoveNodePreservingChildrenCommand.h"
 #include "core/editing/commands/ReplaceNodeWithSpanCommand.h"
 #include "core/editing/commands/ReplaceSelectionCommand.h"
 #include "core/editing/commands/SetNodeAttributeCommand.h"
 #include "core/editing/commands/SplitElementCommand.h"
@@ skipping 116 matching lines @@
 DEFINE_TRACE(EditCommandComposition) {
   visitor->trace(m_document);
   visitor->trace(m_startingSelection);
   visitor->trace(m_endingSelection);
   visitor->trace(m_commands);
   visitor->trace(m_startingRootEditableElement);
   visitor->trace(m_endingRootEditableElement);
   UndoStep::trace(visitor);
 }
 
-CompositeEditCommand::CompositeEditCommand(Document& document)
-    : EditCommand(document) {}
+CompositeEditCommand::CompositeEditCommand(Document& document,
+                                           CommandSource source)
+    : EditCommand(document), m_source(source) {}
 
 CompositeEditCommand::~CompositeEditCommand() {
   DCHECK(isTopLevelCommand() || !m_composition);
 }
 
 bool CompositeEditCommand::apply() {
   DCHECK(!isCommandGroupWrapper());
   if (!endingSelection().isContentRichlyEditable()) {
     switch (inputType()) {
       case InputEvent::InputType::InsertText:
@@ skipping 113 matching lines @@
     CompositeEditCommand* command) {
   ensureComposition()->append(command->ensureComposition());
   command->m_composition = nullptr;
   command->setParent(this);
   m_commands.append(command);
 }
 
 void CompositeEditCommand::applyStyle(const EditingStyle* style,
                                       EditingState* editingState) {
   applyCommandToComposite(
-      ApplyStyleCommand::create(document(), style, InputEvent::InputType::None),
+      ApplyStyleCommand::create(document(), commandSource(), style,
+                                InputEvent::InputType::None),
       editingState);
 }
 
 void CompositeEditCommand::applyStyle(const EditingStyle* style,
                                       const Position& start,
                                       const Position& end,
                                       EditingState* editingState) {
   applyCommandToComposite(
-      ApplyStyleCommand::create(document(), style, start, end), editingState);
+      ApplyStyleCommand::create(document(), commandSource(), style, start, end),
+      editingState);
 }
 
 void CompositeEditCommand::applyStyledElement(Element* element,
                                               EditingState* editingState) {
-  applyCommandToComposite(ApplyStyleCommand::create(element, false),
-                          editingState);
+  applyCommandToComposite(
+      ApplyStyleCommand::create(commandSource(), element, false), editingState);
 }
 
 void CompositeEditCommand::removeStyledElement(Element* element,
                                                EditingState* editingState) {
-  applyCommandToComposite(ApplyStyleCommand::create(element, true),
-                          editingState);
+  applyCommandToComposite(
+      ApplyStyleCommand::create(commandSource(), element, true), editingState);
 }
 
 void CompositeEditCommand::insertParagraphSeparator(
     EditingState* editingState,
     bool useDefaultParagraphElement,
     bool pasteBlockqutoeIntoUnquotedArea) {
-  applyCommandToComposite(InsertParagraphSeparatorCommand::create(
-                              document(), useDefaultParagraphElement,
-                              pasteBlockqutoeIntoUnquotedArea),
-                          editingState);
+  applyCommandToComposite(
+      InsertParagraphSeparatorCommand::create(document(), commandSource(),
+                                              useDefaultParagraphElement,
+                                              pasteBlockqutoeIntoUnquotedArea),
+      editingState);
 }
 
 bool CompositeEditCommand::isRemovableBlock(const Node* node) {
   DCHECK(node);
   if (!isHTMLDivElement(*node))
     return false;
 
   const HTMLDivElement& element = toHTMLDivElement(*node);
   ContainerNode* parentNode = element.parentNode();
   if (parentNode && parentNode->firstChild() != parentNode->lastChild())
@@ skipping 118 matching lines @@
   applyCommandToComposite(
       RemoveNodeCommand::create(node, shouldAssumeContentIsAlwaysEditable),
       editingState);
 }
 
 void CompositeEditCommand::removeNodePreservingChildren(
     Node* node,
     EditingState* editingState,
     ShouldAssumeContentIsAlwaysEditable shouldAssumeContentIsAlwaysEditable) {
   ABORT_EDITING_COMMAND_IF(!node->document().frame());
-  applyCommandToComposite(RemoveNodePreservingChildrenCommand::create(
-                              node, shouldAssumeContentIsAlwaysEditable),
-                          editingState);
+  applyCommandToComposite(
+      RemoveNodePreservingChildrenCommand::create(
+          commandSource(), node, shouldAssumeContentIsAlwaysEditable),
+      editingState);
 }
 
 void CompositeEditCommand::removeNodeAndPruneAncestors(
     Node* node,
     EditingState* editingState,
     Node* excludeNode) {
   DCHECK_NE(node, excludeNode);
   ContainerNode* parent = node->parentNode();
   removeNode(node, editingState);
   if (editingState->isAborted())
@@ skipping 88 matching lines @@
 
 void CompositeEditCommand::wrapContentsInDummySpan(Element* element) {
   // WrapContentsInDummySpanCommand is never aborted.
   applyCommandToComposite(WrapContentsInDummySpanCommand::create(element),
                           ASSERT_NO_EDITING_ABORT);
 }
 
 void CompositeEditCommand::splitTextNodeContainingElement(Text* text,
                                                           unsigned offset) {
   // SplitTextNodeContainingElementCommand is never aborted.
-  applyCommandToComposite(
-      SplitTextNodeContainingElementCommand::create(text, offset),
-      ASSERT_NO_EDITING_ABORT);
+  applyCommandToComposite(SplitTextNodeContainingElementCommand::create(
+                              commandSource(), text, offset),
+                          ASSERT_NO_EDITING_ABORT);
 }
 
 void CompositeEditCommand::insertTextIntoNode(Text* node,
                                               unsigned offset,
                                               const String& text) {
   // InsertIntoTextNodeCommand is never aborted.
   if (!text.isEmpty())
     applyCommandToComposite(
         InsertIntoTextNodeCommand::create(node, offset, text),
         ASSERT_NO_EDITING_ABORT);
@@ skipping 120 matching lines @@
     EditingState* editingState) {
   // insert node before, after, or at split of tab span
   insertNodeAt(node, positionOutsideTabSpan(pos), editingState);
 }
 
 void CompositeEditCommand::deleteSelection(EditingState* editingState,
                                            bool smartDelete,
                                            bool mergeBlocksAfterDelete,
                                            bool expandForSpecialElements,
                                            bool sanitizeMarkup) {
-  if (endingSelection().isRange())
-    applyCommandToComposite(DeleteSelectionCommand::create(
-                                document(), smartDelete, mergeBlocksAfterDelete,
-                                expandForSpecialElements, sanitizeMarkup),
-                            editingState);
+  if (endingSelection().isRange()) {
+    applyCommandToComposite(
+        DeleteSelectionCommand::create(
+            document(), commandSource(), smartDelete, mergeBlocksAfterDelete,
+            expandForSpecialElements, sanitizeMarkup),
+        editingState);
+  }
 }
 
 void CompositeEditCommand::deleteSelection(const VisibleSelection& selection,
                                            EditingState* editingState,
                                            bool smartDelete,
                                            bool mergeBlocksAfterDelete,
                                            bool expandForSpecialElements,
                                            bool sanitizeMarkup) {
-  if (selection.isRange())
-    applyCommandToComposite(DeleteSelectionCommand::create(
-                                selection, smartDelete, mergeBlocksAfterDelete,
-                                expandForSpecialElements, sanitizeMarkup),
-                            editingState);
+  if (selection.isRange()) {
+    applyCommandToComposite(
+        DeleteSelectionCommand::create(
+            commandSource(), selection, smartDelete, mergeBlocksAfterDelete,
+            expandForSpecialElements, sanitizeMarkup),
+        editingState);
+  }
 }
 
 void CompositeEditCommand::removeCSSProperty(Element* element,
                                              CSSPropertyID property) {
   // RemoveCSSPropertyCommand is never aborted.
   applyCommandToComposite(
       RemoveCSSPropertyCommand::create(document(), element, property),
       ASSERT_NO_EDITING_ABORT);
 }
 
@@ skipping 890 matching lines @@
     // We abort executing command since |destination| becomes invisible.
     editingState->abort();
     return;
   }
   setEndingSelection(destinationSelection);
   ReplaceSelectionCommand::CommandOptions options =
       ReplaceSelectionCommand::SelectReplacement |
       ReplaceSelectionCommand::MovingParagraph;
   if (shouldPreserveStyle == DoNotPreserveStyle)
     options |= ReplaceSelectionCommand::MatchStyle;
-  applyCommandToComposite(
-      ReplaceSelectionCommand::create(document(), fragment, options),
-      editingState);
+  applyCommandToComposite(ReplaceSelectionCommand::create(
+                              document(), commandSource(), fragment, options),
+                          editingState);
   if (editingState->isAborted())
     return;
 
   document().updateStyleAndLayoutIgnorePendingStylesheets();
 
   document().frame()->spellChecker().markMisspellingsForMovingParagraphs(
       endingSelection());
 
   // If the selection is in an empty paragraph, restore styles from the old
   // empty paragraph to the new empty paragraph.
@@ skipping 339 matching lines @@
         VisiblePosition::firstPositionInNode(parentElement);
     VisiblePosition positionInNode =
         createVisiblePosition(firstPositionInOrBeforeNode(node));
     if (positionInParent.deepEquivalent() != positionInNode.deepEquivalent())
       splitElement(parentElement, node);
   }
 
   return node;
 }
 
+CommandSource CompositeEditCommand::commandSource() const {
+  if (!parent())
+    return m_source;
+  return parent()->commandSource();
+}
+
 DEFINE_TRACE(CompositeEditCommand) {
   visitor->trace(m_commands);
   visitor->trace(m_composition);
   EditCommand::trace(visitor);
 }
 
 }  // namespace blink