Clean up names related to EditCommandComposition

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 65 matching lines @@
 #include <algorithm>
 
 namespace blink {
 
 using namespace HTMLNames;
 
 CompositeEditCommand::CompositeEditCommand(Document& document)
     : EditCommand(document) {}
 
 CompositeEditCommand::~CompositeEditCommand() {
-  DCHECK(isTopLevelCommand() || !m_composition);
+  DCHECK(isTopLevelCommand() || !m_undoStep);
 }
 
 bool CompositeEditCommand::apply() {
   DCHECK(!isCommandGroupWrapper());
   if (!endingSelection().isContentRichlyEditable()) {
     switch (inputType()) {
       case InputEvent::InputType::InsertText:
       case InputEvent::InputType::InsertLineBreak:
       case InputEvent::InputType::InsertParagraph:
       case InputEvent::InputType::InsertFromPaste:
       case InputEvent::InputType::InsertFromDrop:
       case InputEvent::InputType::InsertReplacementText:
       case InputEvent::InputType::DeleteComposedCharacterForward:
       case InputEvent::InputType::DeleteComposedCharacterBackward:
       case InputEvent::InputType::DeleteWordBackward:
       case InputEvent::InputType::DeleteWordForward:
       case InputEvent::InputType::DeleteLineBackward:
       case InputEvent::InputType::DeleteLineForward:
       case InputEvent::InputType::DeleteContentBackward:
       case InputEvent::InputType::DeleteContentForward:
       case InputEvent::InputType::DeleteByCut:
       case InputEvent::InputType::DeleteByDrag:
       case InputEvent::InputType::None:
         break;
       default:
         NOTREACHED();
         return false;
     }
   }
-  ensureComposition();
+  ensureUndoStep();
 
   // Changes to the document may have been made since the last editing operation
   // that require a layout, as in <rdar://problem/5658603>. Low level
   // operations, like RemoveNodeCommand, don't require a layout because the high
   // level operations that use them perform one if one is necessary (like for
   // the creation of VisiblePositions).
   document().updateStyleAndLayoutIgnorePendingStylesheets();
 
   LocalFrame* frame = document().frame();
   DCHECK(frame);
   EditingState editingState;
   {
     EventQueueScope eventQueueScope;
     doApply(&editingState);
   }
 
   // Only need to call appliedEditing for top-level commands, and TypingCommands
   // do it on their own (see TypingCommand::typingAddedToOpenCommand).
   if (!isTypingCommand())
     frame->editor().appliedEditing(this);
   setShouldRetainAutocorrectionIndicator(false);
   return !editingState.isAborted();
 }
 
-UndoStep* CompositeEditCommand::ensureComposition() {
+UndoStep* CompositeEditCommand::ensureUndoStep() {
   CompositeEditCommand* command = this;
   while (command && command->parent())
     command = command->parent();
-  if (!command->m_composition) {
-    command->m_composition = UndoStep::create(&document(), startingSelection(),
-                                              endingSelection(), inputType());
+  if (!command->m_undoStep) {
+    command->m_undoStep = UndoStep::create(&document(), startingSelection(),
+                                           endingSelection(), inputType());
   }
-  return command->m_composition.get();
+  return command->m_undoStep.get();
 }
 
 bool CompositeEditCommand::preservesTypingStyle() const {
   return false;
 }
 
 bool CompositeEditCommand::isTypingCommand() const {
   return false;
 }
 
@@ skipping 18 matching lines @@
 void CompositeEditCommand::applyCommandToComposite(EditCommand* command,
                                                    EditingState* editingState) {
   command->setParent(this);
   command->doApply(editingState);
   if (editingState->isAborted()) {
     command->setParent(nullptr);
     return;
   }
   if (command->isSimpleEditCommand()) {
     command->setParent(0);
-    ensureComposition()->append(toSimpleEditCommand(command));
+    ensureUndoStep()->append(toSimpleEditCommand(command));
   }
   m_commands.push_back(command);
 }
 
 void CompositeEditCommand::applyCommandToComposite(
     CompositeEditCommand* command,
     const VisibleSelection& selection,
     EditingState* editingState) {
   command->setParent(this);
   if (selection != command->endingSelection()) {
     command->setStartingSelection(selection);
     command->setEndingVisibleSelection(selection);
   }
   command->doApply(editingState);
   if (!editingState->isAborted())
     m_commands.push_back(command);
 }
 
-void CompositeEditCommand::appendCommandToComposite(
+void CompositeEditCommand::appendCommandToUndoStep(
     CompositeEditCommand* command) {
-  ensureComposition()->append(command->ensureComposition());
-  command->m_composition = nullptr;
+  ensureUndoStep()->append(command->ensureUndoStep());
+  command->m_undoStep = nullptr;
   command->setParent(this);
   m_commands.push_back(command);
 }
 
 void CompositeEditCommand::applyStyle(const EditingStyle* style,
                                       EditingState* editingState) {
   applyCommandToComposite(
       ApplyStyleCommand::create(document(), style, InputEvent::InputType::None),
       editingState);
 }
@@ skipping 1704 matching lines @@
         createVisiblePosition(firstPositionInOrBeforeNode(node));
     if (positionInParent.deepEquivalent() != positionInNode.deepEquivalent())
       splitElement(parentElement, node);
   }
 
   return node;
 }
 
 DEFINE_TRACE(CompositeEditCommand) {
   visitor->trace(m_commands);
-  visitor->trace(m_composition);
+  visitor->trace(m_undoStep);
   EditCommand::trace(visitor);
 }
 
 }  // namespace blink