Migrate WTF::Vector::append() to ::push_back() [part 12 of N]

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 309 matching lines @@
   command->doApply(editingState);
   if (!editingState->isAborted())
     m_commands.push_back(command);
 }
 
 void CompositeEditCommand::appendCommandToComposite(
     CompositeEditCommand* command) {
   ensureComposition()->append(command->ensureComposition());
   command->m_composition = nullptr;
   command->setParent(this);
-  m_commands.append(command);
+  m_commands.push_back(command);
 }
 
 void CompositeEditCommand::applyStyle(const EditingStyle* style,
                                       EditingState* editingState) {
   applyCommandToComposite(
       ApplyStyleCommand::create(document(), style, InputEvent::InputType::None),
       editingState);
 }
 
 void CompositeEditCommand::applyStyle(const EditingStyle* style,
@@ skipping 128 matching lines @@
                           editingState);
 }
 
 void CompositeEditCommand::removeChildrenInRange(Node* node,
                                                  unsigned from,
                                                  unsigned to,
                                                  EditingState* editingState) {
   HeapVector<Member<Node>> children;
   Node* child = NodeTraversal::childAt(*node, from);
   for (unsigned i = from; child && i < to; i++, child = child->nextSibling())
-    children.append(child);
+    children.push_back(child);
 
   size_t size = children.size();
   for (size_t i = 0; i < size; ++i) {
     removeNode(children[i].release(), editingState);
     if (editingState->isAborted())
       return;
   }
 }
 
 void CompositeEditCommand::removeNode(
@@ skipping 31 matching lines @@
 }
 
 void CompositeEditCommand::moveRemainingSiblingsToNewParent(
     Node* node,
     Node* pastLastNodeToMove,
     Element* newParent,
     EditingState* editingState) {
   NodeVector nodesToRemove;
 
   for (; node && node != pastLastNodeToMove; node = node->nextSibling())
-    nodesToRemove.append(node);
+    nodesToRemove.push_back(node);
 
   for (unsigned i = 0; i < nodesToRemove.size(); i++) {
     removeNode(nodesToRemove[i], editingState);
     if (editingState->isAborted())
       return;
     appendNode(nodesToRemove[i], newParent, editingState);
     if (editingState->isAborted())
       return;
   }
 }
@@ skipping 128 matching lines @@
 }
 
 static void copyMarkerTypesAndDescriptions(
     const DocumentMarkerVector& markerPointers,
     Vector<DocumentMarker::MarkerType>& types,
     Vector<String>& descriptions) {
   size_t arraySize = markerPointers.size();
   types.reserveCapacity(arraySize);
   descriptions.reserveCapacity(arraySize);
   for (const auto& markerPointer : markerPointers) {
-    types.append(markerPointer->type());
-    descriptions.append(markerPointer->description());
+    types.push_back(markerPointer->type());
+    descriptions.push_back(markerPointer->description());
   }
 }
 
 void CompositeEditCommand::replaceTextInNodePreservingMarkers(
     Text* node,
     unsigned offset,
     unsigned count,
     const String& replacementText) {
   DocumentMarkerController& markerController = document().markers();
   Vector<DocumentMarker::MarkerType> types;
@@ skipping 274 matching lines @@
 
   LayoutText* textLayoutObject = textNode->layoutObject();
   if (!textLayoutObject)
     return;
 
   Vector<InlineTextBox*> sortedTextBoxes;
   size_t sortedTextBoxesPosition = 0;
 
   for (InlineTextBox* textBox = textLayoutObject->firstTextBox(); textBox;
        textBox = textBox->nextTextBox())
-    sortedTextBoxes.append(textBox);
+    sortedTextBoxes.push_back(textBox);
 
   // If there is mixed directionality text, the boxes can be out of order,
   // (like Arabic with embedded LTR), so sort them first.
   if (textLayoutObject->containsReversedText())
     std::sort(sortedTextBoxes.begin(), sortedTextBoxes.end(),
               InlineTextBox::compareByStart);
   InlineTextBox* box =
       sortedTextBoxes.isEmpty() ? 0 : sortedTextBoxes[sortedTextBoxesPosition];
 
   if (!box) {
@@ skipping 59 matching lines @@
                                                    const Position& end) {
   if (start.isNull() || end.isNull())
     return;
 
   if (comparePositions(start, end) >= 0)
     return;
 
   HeapVector<Member<Text>> nodes;
   for (Node& node : NodeTraversal::startsAt(*start.anchorNode())) {
     if (node.isTextNode())
-      nodes.append(toText(&node));
+      nodes.push_back(toText(&node));
     if (&node == end.anchorNode())
       break;
   }
 
   for (const auto& node : nodes) {
     Text* textNode = node;
     int startOffset = textNode == start.anchorNode()
                           ? start.computeOffsetInContainerNode()
                           : 0;
     int endOffset = textNode == end.anchorNode()
@@ skipping 230 matching lines @@
 
   if (start.anchorNode() != outerNode && lastNode->isElementNode() &&
       start.anchorNode()->isDescendantOf(outerNode)) {
     HeapVector<Member<Node>> ancestors;
 
     // Insert each node from innerNode to outerNode (excluded) in a list.
     for (Node& runner :
          NodeTraversal::inclusiveAncestorsOf(*start.anchorNode())) {
       if (runner == outerNode)
         break;
-      ancestors.append(runner);
+      ancestors.push_back(runner);
     }
 
     // Clone every node between start.anchorNode() and outerBlock.
 
     for (size_t i = ancestors.size(); i != 0; --i) {
       Node* item = ancestors[i - 1].get();
       Node* child = item->cloneNode(isDisplayInsideTable(item));
       appendNode(child, toElement(lastNode), editingState);
       if (editingState->isAborted())
         return;
@@ skipping 729 matching lines @@
   return node;
 }
 
 DEFINE_TRACE(CompositeEditCommand) {
   visitor->trace(m_commands);
   visitor->trace(m_composition);
   EditCommand::trace(visitor);
 }
 
 }  // namespace blink