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

third_party/WebKit/Source/core/dom/shadow/ElementShadowV0.cpp

 /*
  * Copyright (C) 2012 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 53 matching lines @@
 inline void DistributionPool::populateChildren(const ContainerNode& parent) {
   clear();
   for (Node* child = parent.firstChild(); child; child = child->nextSibling()) {
     if (isHTMLSlotElement(child)) {
       // TODO(hayato): Support re-distribution across v0 and v1 shadow trees
       continue;
     }
     if (isActiveInsertionPoint(*child)) {
       InsertionPoint* insertionPoint = toInsertionPoint(child);
       for (size_t i = 0; i < insertionPoint->distributedNodesSize(); ++i)
-        m_nodes.append(insertionPoint->distributedNodeAt(i));
+        m_nodes.push_back(insertionPoint->distributedNodeAt(i));
     } else {
-      m_nodes.append(child);
+      m_nodes.push_back(child);
     }
   }
   m_distributed.resize(m_nodes.size());
   m_distributed.fill(false);
 }
 
 void DistributionPool::distributeTo(InsertionPoint* insertionPoint,
                                     ElementShadowV0* elementShadow) {
   DistributedNodes distributedNodes;
 
@@ skipping 76 matching lines @@
 
   for (ShadowRoot* root = &youngestShadowRoot(); root;
        root = root->olderShadowRoot()) {
     HTMLShadowElement* shadowInsertionPoint = 0;
     for (const auto& point : root->descendantInsertionPoints()) {
       if (!point->isActive())
         continue;
       if (isHTMLShadowElement(*point)) {
         DCHECK(!shadowInsertionPoint);
         shadowInsertionPoint = toHTMLShadowElement(point);
-        shadowInsertionPoints.append(shadowInsertionPoint);
+        shadowInsertionPoints.push_back(shadowInsertionPoint);
       } else {
         pool.distributeTo(point, this);
         if (ElementShadow* shadow =
                 shadowWhereNodeCanBeDistributedForV0(*point))
           shadow->setNeedsDistributionRecalc();
       }
     }
   }
 
   for (size_t i = shadowInsertionPoints.size(); i > 0; --i) {
@@ skipping 17 matching lines @@
   InspectorInstrumentation::didPerformElementShadowDistribution(
       &m_elementShadow->host());
 }
 
 void ElementShadowV0::didDistributeNode(const Node* node,
                                         InsertionPoint* insertionPoint) {
   NodeToDestinationInsertionPoints::AddResult result =
       m_nodeToInsertionPoints.add(node, nullptr);
   if (result.isNewEntry)
     result.storedValue->value = new DestinationInsertionPoints;
-  result.storedValue->value->append(insertionPoint);
+  result.storedValue->value->push_back(insertionPoint);
 }
 
 const SelectRuleFeatureSet& ElementShadowV0::ensureSelectFeatureSet() {
   if (!m_needsSelectFeatureSet)
     return m_selectFeatures;
 
   m_selectFeatures.clear();
   for (const ShadowRoot* root = &oldestShadowRoot(); root;
        root = root->youngerShadowRoot())
     collectSelectFeatureSetFrom(*root);
@@ skipping 37 matching lines @@
 
 DEFINE_TRACE(ElementShadowV0) {
   visitor->trace(m_elementShadow);
   visitor->trace(m_nodeToInsertionPoints);
   visitor->trace(m_selectFeatures);
 }
 
 DEFINE_TRACE_WRAPPERS(ElementShadowV0) {}
 
 }  // namespace blink