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

third_party/WebKit/Source/core/dom/Node.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
  *
@@ skipping 1348 matching lines @@
   if (!start1 || !start2) {
     unsigned short direction = (this > otherNode) ? kDocumentPositionPreceding
                                                   : kDocumentPositionFollowing;
     return kDocumentPositionDisconnected |
            kDocumentPositionImplementationSpecific | direction;
   }
 
   HeapVector<Member<const Node>, 16> chain1;
   HeapVector<Member<const Node>, 16> chain2;
   if (attr1)
-    chain1.append(attr1);
+    chain1.push_back(attr1);
   if (attr2)
-    chain2.append(attr2);
+    chain2.push_back(attr2);
 
   if (attr1 && attr2 && start1 == start2 && start1) {
     // We are comparing two attributes on the same node. Crawl our attribute map
     // and see which one we hit first.
     const Element* owner1 = attr1->ownerElement();
     AttributeCollection attributes = owner1->attributes();
     for (const Attribute& attr : attributes) {
       // If neither of the two determining nodes is a child node and nodeType is
       // the same for both determining nodes, then an implementation-dependent
       // order between the determining nodes is returned. This order is stable
@@ skipping 24 matching lines @@
     unsigned short direction = (this > otherNode) ? kDocumentPositionPreceding
                                                   : kDocumentPositionFollowing;
     return kDocumentPositionDisconnected |
            kDocumentPositionImplementationSpecific | direction;
   }
 
   // We need to find a common ancestor container, and then compare the indices
   // of the two immediate children.
   const Node* current;
   for (current = start1; current; current = current->parentOrShadowHostNode())
-    chain1.append(current);
+    chain1.push_back(current);
   for (current = start2; current; current = current->parentOrShadowHostNode())
-    chain2.append(current);
+    chain2.push_back(current);
 
   unsigned index1 = chain1.size();
   unsigned index2 = chain2.size();
 
   // If the two elements don't have a common root, they're not in the same tree.
   if (chain1[index1 - 1] != chain2[index2 - 1]) {
     unsigned short direction = (this > otherNode) ? kDocumentPositionPreceding
                                                   : kDocumentPositionFollowing;
     return kDocumentPositionDisconnected |
            kDocumentPositionImplementationSpecific | direction;
@@ skipping 142 matching lines @@
 }
 
 String Node::toFlatTreeStringForThis() const {
   return toMarkedFlatTreeString(this, "*");
 }
 
 void Node::printNodePathTo(std::ostream& stream) const {
   HeapVector<Member<const Node>, 16> chain;
   const Node* node = this;
   while (node->parentOrShadowHostNode()) {
-    chain.append(node);
+    chain.push_back(node);
     node = node->parentOrShadowHostNode();
   }
   for (unsigned index = chain.size(); index > 0; --index) {
     const Node* node = chain[index - 1];
     if (node->isShadowRoot()) {
       int count = 0;
       for (const ShadowRoot* shadowRoot = toShadowRoot(node)->olderShadowRoot();
            shadowRoot; shadowRoot = shadowRoot->olderShadowRoot())
         ++count;
       stream << "/#shadow-root[" << count << "]";
@@ skipping 695 matching lines @@
 
 StaticNodeList* Node::getDestinationInsertionPoints() {
   updateDistribution();
   HeapVector<Member<InsertionPoint>, 8> insertionPoints;
   collectDestinationInsertionPoints(*this, insertionPoints);
   HeapVector<Member<Node>> filteredInsertionPoints;
   for (const auto& insertionPoint : insertionPoints) {
     DCHECK(insertionPoint->containingShadowRoot());
     if (!insertionPoint->containingShadowRoot()->isOpenOrV0())
       break;
-    filteredInsertionPoints.append(insertionPoint);
+    filteredInsertionPoints.push_back(insertionPoint);
   }
   return StaticNodeList::adopt(filteredInsertionPoints);
 }
 
 HTMLSlotElement* Node::assignedSlot() const {
   // assignedSlot doesn't need to call updateDistribution().
   DCHECK(!isPseudoElement());
   if (ShadowRoot* root = v1ShadowRootOfParent())
     return root->ensureSlotAssignment().findSlot(*this);
   return nullptr;
@@ skipping 234 matching lines @@
   if (node) {
     std::stringstream stream;
     node->printNodePathTo(stream);
     LOG(INFO) << stream.str();
   } else {
     LOG(INFO) << "Cannot showNodePath for <null>";
   }
 }
 
 #endif