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

third_party/WebKit/Source/core/css/RuleSet.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 158 matching lines @@
 }
 
 bool RuleSet::findBestRuleSetAndAdd(const CSSSelector& component,
                                     RuleData& ruleData) {
   AtomicString id;
   AtomicString className;
   AtomicString customPseudoElementName;
   AtomicString tagName;
 
 #ifndef NDEBUG
-  m_allRules.append(ruleData);
+  m_allRules.push_back(ruleData);
 #endif
 
   const CSSSelector* it = &component;
   for (; it && it->relation() == CSSSelector::SubSelector;
        it = it->tagHistory())
     extractValuesforSelector(it, id, className, customPseudoElementName,
                              tagName);
   if (it)
     extractValuesforSelector(it, id, className, customPseudoElementName,
                              tagName);
@@ skipping 13 matching lines @@
     // never be a situation where extractValuesforSelector finsd id and
     // className in addition to custom pseudo.
     ASSERT(id.isEmpty() && className.isEmpty());
     addToRuleSet(customPseudoElementName,
                  ensurePendingRules()->shadowPseudoElementRules, ruleData);
     return true;
   }
 
   switch (component.getPseudoType()) {
     case CSSSelector::PseudoCue:
-      m_cuePseudoRules.append(ruleData);
+      m_cuePseudoRules.push_back(ruleData);
       return true;
     case CSSSelector::PseudoLink:
     case CSSSelector::PseudoVisited:
     case CSSSelector::PseudoAnyLink:
-      m_linkPseudoClassRules.append(ruleData);
+      m_linkPseudoClassRules.push_back(ruleData);
       return true;
     case CSSSelector::PseudoFocus:
-      m_focusPseudoClassRules.append(ruleData);
+      m_focusPseudoClassRules.push_back(ruleData);
       return true;
     case CSSSelector::PseudoPlaceholder:
-      m_placeholderPseudoRules.append(ruleData);
+      m_placeholderPseudoRules.push_back(ruleData);
       return true;
     default:
       break;
   }
 
   if (!tagName.isEmpty()) {
     addToRuleSet(tagName, ensurePendingRules()->tagRules, ruleData);
     return true;
   }
 
   if (component.isHostPseudoClass()) {
-    m_shadowHostRules.append(ruleData);
+    m_shadowHostRules.push_back(ruleData);
     return true;
   }
 
   return false;
 }
 
 void RuleSet::addRule(StyleRule* rule,
                       unsigned selectorIndex,
                       AddRuleFlags addRuleFlags) {
   RuleData ruleData(rule, selectorIndex, m_ruleCount++, addRuleFlags);
   if (m_features.collectFeaturesFromRuleData(ruleData) ==
       RuleFeatureSet::SelectorNeverMatches)
     return;
 
   if (!findBestRuleSetAndAdd(ruleData.selector(), ruleData)) {
     // If we didn't find a specialized map to stick it in, file under universal
     // rules.
-    m_universalRules.append(ruleData);
+    m_universalRules.push_back(ruleData);
   }
 }
 
 void RuleSet::addPageRule(StyleRulePage* rule) {
   ensurePendingRules();  // So that m_pageRules.shrinkToFit() gets called.
-  m_pageRules.append(rule);
+  m_pageRules.push_back(rule);
 }
 
 void RuleSet::addFontFaceRule(StyleRuleFontFace* rule) {
   ensurePendingRules();  // So that m_fontFaceRules.shrinkToFit() gets called.
-  m_fontFaceRules.append(rule);
+  m_fontFaceRules.push_back(rule);
 }
 
 void RuleSet::addKeyframesRule(StyleRuleKeyframes* rule) {
   ensurePendingRules();  // So that m_keyframesRules.shrinkToFit() gets called.
-  m_keyframesRules.append(rule);
+  m_keyframesRules.push_back(rule);
 }
 
 void RuleSet::addChildRules(const HeapVector<Member<StyleRuleBase>>& rules,
                             const MediaQueryEvaluator& medium,
                             AddRuleFlags addRuleFlags) {
   for (unsigned i = 0; i < rules.size(); ++i) {
     StyleRuleBase* rule = rules[i].get();
 
     if (rule->isStyleRule()) {
       StyleRule* styleRule = toStyleRule(rule);
 
       const CSSSelectorList& selectorList = styleRule->selectorList();
       for (const CSSSelector* selector = selectorList.first(); selector;
            selector = selectorList.next(*selector)) {
         size_t selectorIndex = selectorList.selectorIndex(*selector);
         if (selector->hasDeepCombinatorOrShadowPseudo()) {
-          m_deepCombinatorOrShadowPseudoRules.append(
+          m_deepCombinatorOrShadowPseudoRules.push_back(
               MinimalRuleData(styleRule, selectorIndex, addRuleFlags));
         } else if (selector->hasContentPseudo()) {
-          m_contentPseudoElementRules.append(
+          m_contentPseudoElementRules.push_back(
               MinimalRuleData(styleRule, selectorIndex, addRuleFlags));
         } else if (selector->hasSlottedPseudo()) {
-          m_slottedPseudoElementRules.append(
+          m_slottedPseudoElementRules.push_back(
               MinimalRuleData(styleRule, selectorIndex, addRuleFlags));
         } else {
           addRule(styleRule, selectorIndex, addRuleFlags);
         }
       }
     } else if (rule->isPageRule()) {
       addPageRule(toStyleRulePage(rule));
     } else if (rule->isMediaRule()) {
       StyleRuleMedia* mediaRule = toStyleRuleMedia(rule);
       if (!mediaRule->mediaQueries() ||
@@ skipping 121 matching lines @@
 }
 
 #ifndef NDEBUG
 void RuleSet::show() const {
   for (const auto& rule : m_allRules)
     rule.selector().show();
 }
 #endif
 
 }  // namespace blink