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

third_party/WebKit/Source/core/css/RuleFeature.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
@@ skipping 328 matching lines @@
     descendantFeatures.insertionPointCrossing = true;
   if (lastInCompound.relationIsAffectedByPseudoContent())
     descendantFeatures.contentPseudoCrossing = true;
 }
 
 void RuleFeatureSet::extractInvalidationSetFeaturesFromSimpleSelector(
     const CSSSelector& selector,
     InvalidationSetFeatures& features) {
   if (selector.match() == CSSSelector::Tag &&
       selector.tagQName().localName() != starAtom) {
-    features.tagNames.append(selector.tagQName().localName());
+    features.tagNames.push_back(selector.tagQName().localName());
     return;
   }
   if (selector.match() == CSSSelector::Id) {
-    features.ids.append(selector.value());
+    features.ids.push_back(selector.value());
     return;
   }
   if (selector.match() == CSSSelector::Class) {
-    features.classes.append(selector.value());
+    features.classes.push_back(selector.value());
     return;
   }
   if (selector.isAttributeSelector()) {
-    features.attributes.append(selector.attribute().localName());
+    features.attributes.push_back(selector.attribute().localName());
     return;
   }
   switch (selector.getPseudoType()) {
     case CSSSelector::PseudoWebKitCustomElement:
     case CSSSelector::PseudoBlinkInternalElement:
       features.customPseudoElement = true;
       return;
     case CSSSelector::PseudoBefore:
     case CSSSelector::PseudoAfter:
       features.hasBeforeOrAfter = true;
@@ skipping 396 matching lines @@
 RuleFeatureSet::SelectorPreMatch RuleFeatureSet::collectFeaturesFromRuleData(
     const RuleData& ruleData) {
   FeatureMetadata metadata;
   if (collectFeaturesFromSelector(ruleData.selector(), metadata) ==
       SelectorNeverMatches)
     return SelectorNeverMatches;
 
   m_metadata.add(metadata);
 
   if (metadata.foundSiblingSelector) {
-    m_siblingRules.append(RuleFeature(ruleData.rule(), ruleData.selectorIndex(),
-                                      ruleData.hasDocumentSecurityOrigin()));
+    m_siblingRules.push_back(RuleFeature(ruleData.rule(),
+                                         ruleData.selectorIndex(),
+                                         ruleData.hasDocumentSecurityOrigin()));
   }
   if (ruleData.containsUncommonAttributeSelector()) {
-    m_uncommonAttributeRules.append(
+    m_uncommonAttributeRules.push_back(
         RuleFeature(ruleData.rule(), ruleData.selectorIndex(),
                     ruleData.hasDocumentSecurityOrigin()));
   }
 
   updateInvalidationSets(ruleData);
   return SelectorMayMatch;
 }
 
 RuleFeatureSet::SelectorPreMatch RuleFeatureSet::collectFeaturesFromSelector(
     const CSSSelector& selector,
@@ skipping 145 matching lines @@
   if (it == m_classInvalidationSets.end())
     return;
 
   DescendantInvalidationSet* descendants;
   SiblingInvalidationSet* siblings;
   extractInvalidationSets(it->value.get(), descendants, siblings);
 
   if (descendants) {
     TRACE_SCHEDULE_STYLE_INVALIDATION(element, *descendants, classChange,
                                       className);
-    invalidationLists.descendants.append(descendants);
+    invalidationLists.descendants.push_back(descendants);
   }
 
   if (siblings) {
     TRACE_SCHEDULE_STYLE_INVALIDATION(element, *siblings, classChange,
                                       className);
-    invalidationLists.siblings.append(siblings);
+    invalidationLists.siblings.push_back(siblings);
   }
 }
 
 void RuleFeatureSet::collectSiblingInvalidationSetForClass(
     InvalidationLists& invalidationLists,
     Element& element,
     const AtomicString& className,
     unsigned minDirectAdjacent) const {
   InvalidationSetMap::const_iterator it =
       m_classInvalidationSets.find(className);
   if (it == m_classInvalidationSets.end())
     return;
 
   InvalidationSet* invalidationSet = it->value.get();
   if (invalidationSet->type() == InvalidateDescendants)
     return;
 
   SiblingInvalidationSet* siblingSet =
       toSiblingInvalidationSet(invalidationSet);
   if (siblingSet->maxDirectAdjacentSelectors() < minDirectAdjacent)
     return;
 
   TRACE_SCHEDULE_STYLE_INVALIDATION(element, *siblingSet, classChange,
                                     className);
-  invalidationLists.siblings.append(siblingSet);
+  invalidationLists.siblings.push_back(siblingSet);
 }
 
 void RuleFeatureSet::collectInvalidationSetsForId(
     InvalidationLists& invalidationLists,
     Element& element,
     const AtomicString& id) const {
   InvalidationSetMap::const_iterator it = m_idInvalidationSets.find(id);
   if (it == m_idInvalidationSets.end())
     return;
 
   DescendantInvalidationSet* descendants;
   SiblingInvalidationSet* siblings;
   extractInvalidationSets(it->value.get(), descendants, siblings);
 
   if (descendants) {
     TRACE_SCHEDULE_STYLE_INVALIDATION(element, *descendants, idChange, id);
-    invalidationLists.descendants.append(descendants);
+    invalidationLists.descendants.push_back(descendants);
   }
 
   if (siblings) {
     TRACE_SCHEDULE_STYLE_INVALIDATION(element, *siblings, idChange, id);
-    invalidationLists.siblings.append(siblings);
+    invalidationLists.siblings.push_back(siblings);
   }
 }
 
 void RuleFeatureSet::collectSiblingInvalidationSetForId(
     InvalidationLists& invalidationLists,
     Element& element,
     const AtomicString& id,
     unsigned minDirectAdjacent) const {
   InvalidationSetMap::const_iterator it = m_idInvalidationSets.find(id);
   if (it == m_idInvalidationSets.end())
     return;
 
   InvalidationSet* invalidationSet = it->value.get();
   if (invalidationSet->type() == InvalidateDescendants)
     return;
 
   SiblingInvalidationSet* siblingSet =
       toSiblingInvalidationSet(invalidationSet);
   if (siblingSet->maxDirectAdjacentSelectors() < minDirectAdjacent)
     return;
 
   TRACE_SCHEDULE_STYLE_INVALIDATION(element, *siblingSet, idChange, id);
-  invalidationLists.siblings.append(siblingSet);
+  invalidationLists.siblings.push_back(siblingSet);
 }
 
 void RuleFeatureSet::collectInvalidationSetsForAttribute(
     InvalidationLists& invalidationLists,
     Element& element,
     const QualifiedName& attributeName) const {
   InvalidationSetMap::const_iterator it =
       m_attributeInvalidationSets.find(attributeName.localName());
   if (it == m_attributeInvalidationSets.end())
     return;
 
   DescendantInvalidationSet* descendants;
   SiblingInvalidationSet* siblings;
   extractInvalidationSets(it->value.get(), descendants, siblings);
 
   if (descendants) {
     TRACE_SCHEDULE_STYLE_INVALIDATION(element, *descendants, attributeChange,
                                       attributeName);
-    invalidationLists.descendants.append(descendants);
+    invalidationLists.descendants.push_back(descendants);
   }
 
   if (siblings) {
     TRACE_SCHEDULE_STYLE_INVALIDATION(element, *siblings, attributeChange,
                                       attributeName);
-    invalidationLists.siblings.append(siblings);
+    invalidationLists.siblings.push_back(siblings);
   }
 }
 
 void RuleFeatureSet::collectSiblingInvalidationSetForAttribute(
     InvalidationLists& invalidationLists,
     Element& element,
     const QualifiedName& attributeName,
     unsigned minDirectAdjacent) const {
   InvalidationSetMap::const_iterator it =
       m_attributeInvalidationSets.find(attributeName.localName());
   if (it == m_attributeInvalidationSets.end())
     return;
 
   InvalidationSet* invalidationSet = it->value.get();
   if (invalidationSet->type() == InvalidateDescendants)
     return;
 
   SiblingInvalidationSet* siblingSet =
       toSiblingInvalidationSet(invalidationSet);
   if (siblingSet->maxDirectAdjacentSelectors() < minDirectAdjacent)
     return;
 
   TRACE_SCHEDULE_STYLE_INVALIDATION(element, *siblingSet, attributeChange,
                                     attributeName);
-  invalidationLists.siblings.append(siblingSet);
+  invalidationLists.siblings.push_back(siblingSet);
 }
 
 void RuleFeatureSet::collectInvalidationSetsForPseudoClass(
     InvalidationLists& invalidationLists,
     Element& element,
     CSSSelector::PseudoType pseudo) const {
   PseudoTypeInvalidationSetMap::const_iterator it =
       m_pseudoInvalidationSets.find(pseudo);
   if (it == m_pseudoInvalidationSets.end())
     return;
 
   DescendantInvalidationSet* descendants;
   SiblingInvalidationSet* siblings;
   extractInvalidationSets(it->value.get(), descendants, siblings);
 
   if (descendants) {
     TRACE_SCHEDULE_STYLE_INVALIDATION(element, *descendants, pseudoChange,
                                       pseudo);
-    invalidationLists.descendants.append(descendants);
+    invalidationLists.descendants.push_back(descendants);
   }
 
   if (siblings) {
     TRACE_SCHEDULE_STYLE_INVALIDATION(element, *siblings, pseudoChange, pseudo);
-    invalidationLists.siblings.append(siblings);
+    invalidationLists.siblings.push_back(siblings);
   }
 }
 
 void RuleFeatureSet::collectUniversalSiblingInvalidationSet(
     InvalidationLists& invalidationLists,
     unsigned minDirectAdjacent) const {
   if (m_universalSiblingInvalidationSet &&
       m_universalSiblingInvalidationSet->maxDirectAdjacentSelectors() >=
           minDirectAdjacent)
-    invalidationLists.siblings.append(m_universalSiblingInvalidationSet);
+    invalidationLists.siblings.push_back(m_universalSiblingInvalidationSet);
 }
 
 SiblingInvalidationSet&
 RuleFeatureSet::ensureUniversalSiblingInvalidationSet() {
   if (!m_universalSiblingInvalidationSet)
     m_universalSiblingInvalidationSet = SiblingInvalidationSet::create(nullptr);
   return *m_universalSiblingInvalidationSet;
 }
 
 void RuleFeatureSet::collectNthInvalidationSet(
     InvalidationLists& invalidationLists) const {
   if (m_nthInvalidationSet)
-    invalidationLists.descendants.append(m_nthInvalidationSet);
+    invalidationLists.descendants.push_back(m_nthInvalidationSet);
 }
 
 DescendantInvalidationSet& RuleFeatureSet::ensureNthInvalidationSet() {
   if (!m_nthInvalidationSet)
     m_nthInvalidationSet = DescendantInvalidationSet::create();
   return *m_nthInvalidationSet;
 }
 
 void RuleFeatureSet::addFeaturesToUniversalSiblingInvalidationSet(
     const InvalidationSetFeatures& siblingFeatures,
@@ skipping 40 matching lines @@
   return !classes.isEmpty() || !attributes.isEmpty() || !ids.isEmpty() ||
          !tagNames.isEmpty() || customPseudoElement;
 }
 
 bool RuleFeatureSet::InvalidationSetFeatures::hasTagIdClassOrAttribute() const {
   return !classes.isEmpty() || !attributes.isEmpty() || !ids.isEmpty() ||
          !tagNames.isEmpty();
 }
 
 }  // namespace blink