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

third_party/WebKit/Source/core/events/EventPath.cpp

 /*
  * Copyright (C) 2013 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Neither the name of Google Inc. nor the names of its
@@ skipping 101 matching lines @@
   // Exclude nodes in SVG <use>'s shadow tree from event path.
   // See crbug.com/630870
   while (current->isSVGElement()) {
     SVGUseElement* correspondingUseElement =
         toSVGElement(current)->correspondingUseElement();
     if (!correspondingUseElement)
       break;
     current = correspondingUseElement;
   }
 
-  nodesInPath.append(current);
+  nodesInPath.push_back(current);
   while (current) {
     if (m_event && current->keepEventInNode(m_event))
       break;
     HeapVector<Member<InsertionPoint>, 8> insertionPoints;
     collectDestinationInsertionPoints(*current, insertionPoints);
     if (!insertionPoints.isEmpty()) {
       for (const auto& insertionPoint : insertionPoints) {
         if (insertionPoint->isShadowInsertionPoint()) {
           ShadowRoot* containingShadowRoot =
               insertionPoint->containingShadowRoot();
           DCHECK(containingShadowRoot);
           if (!containingShadowRoot->isOldest())
-            nodesInPath.append(containingShadowRoot->olderShadowRoot());
+            nodesInPath.push_back(containingShadowRoot->olderShadowRoot());
         }
-        nodesInPath.append(insertionPoint);
+        nodesInPath.push_back(insertionPoint);
       }
       current = insertionPoints.back();
       continue;
     }
     if (current->isChildOfV1ShadowHost()) {
       if (HTMLSlotElement* slot = current->assignedSlot()) {
         current = slot;
-        nodesInPath.append(current);
+        nodesInPath.push_back(current);
         continue;
       }
     }
     if (current->isShadowRoot()) {
       if (m_event &&
           shouldStopAtShadowRoot(*m_event, *toShadowRoot(current), *m_node))
         break;
       current = current->ownerShadowHost();
-      nodesInPath.append(current);
+      nodesInPath.push_back(current);
     } else {
       current = current->parentNode();
       if (current)
-        nodesInPath.append(current);
+        nodesInPath.push_back(current);
     }
   }
 
   m_nodeEventContexts.reserveCapacity(nodesInPath.size());
   for (Node* nodeInPath : nodesInPath) {
-    m_nodeEventContexts.append(NodeEventContext(
+    m_nodeEventContexts.push_back(NodeEventContext(
         nodeInPath, eventTargetRespectingTargetRules(*nodeInPath)));
   }
 }
 
 void EventPath::calculateTreeOrderAndSetNearestAncestorClosedTree() {
   // Precondition:
   //   - TreeScopes in m_treeScopeEventContexts must be *connected* in the same
   //     composed tree.
   //   - The root tree must be included.
   HeapHashMap<Member<const TreeScope>, Member<TreeScopeEventContext>>
@@ skipping 92 matching lines @@
   // the memory in subsequent event dispatchings.
   relatedTargetEventPath->clear();
 }
 
 EventTarget* EventPath::findRelatedNode(TreeScope& scope,
                                         RelatedTargetMap& relatedTargetMap) {
   HeapVector<Member<TreeScope>, 32> parentTreeScopes;
   EventTarget* relatedNode = nullptr;
   for (TreeScope* current = &scope; current;
        current = current->olderShadowRootOrParentTreeScope()) {
-    parentTreeScopes.append(current);
+    parentTreeScopes.push_back(current);
     RelatedTargetMap::const_iterator iter = relatedTargetMap.find(current);
     if (iter != relatedTargetMap.end() && iter->value) {
       relatedNode = iter->value;
       break;
     }
   }
   DCHECK(relatedNode);
   for (const auto& entry : parentTreeScopes)
     relatedTargetMap.add(entry, relatedNode);
 
@@ skipping 49 matching lines @@
 
 void EventPath::adjustForTouchEvent(TouchEvent& touchEvent) {
   HeapVector<Member<TouchList>> adjustedTouches;
   HeapVector<Member<TouchList>> adjustedTargetTouches;
   HeapVector<Member<TouchList>> adjustedChangedTouches;
   HeapVector<Member<TreeScope>> treeScopes;
 
   for (const auto& treeScopeEventContext : m_treeScopeEventContexts) {
     TouchEventContext* touchEventContext =
         treeScopeEventContext->ensureTouchEventContext();
-    adjustedTouches.append(&touchEventContext->touches());
-    adjustedTargetTouches.append(&touchEventContext->targetTouches());
-    adjustedChangedTouches.append(&touchEventContext->changedTouches());
-    treeScopes.append(&treeScopeEventContext->treeScope());
+    adjustedTouches.push_back(&touchEventContext->touches());
+    adjustedTargetTouches.push_back(&touchEventContext->targetTouches());
+    adjustedChangedTouches.push_back(&touchEventContext->changedTouches());
+    treeScopes.push_back(&treeScopeEventContext->treeScope());
   }
 
   adjustTouchList(touchEvent.touches(), adjustedTouches, treeScopes);
   adjustTouchList(touchEvent.targetTouches(), adjustedTargetTouches,
                   treeScopes);
   adjustTouchList(touchEvent.changedTouches(), adjustedChangedTouches,
                   treeScopes);
 
 #if DCHECK_IS_ON()
   for (const auto& treeScopeEventContext : m_treeScopeEventContexts) {
@@ skipping 57 matching lines @@
 
 DEFINE_TRACE(EventPath) {
   visitor->trace(m_nodeEventContexts);
   visitor->trace(m_node);
   visitor->trace(m_event);
   visitor->trace(m_treeScopeEventContexts);
   visitor->trace(m_windowEventContext);
 }
 
 }  // namespace blink