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

third_party/WebKit/Source/core/css/parser/CSSParserImpl.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/css/parser/CSSParserImpl.h"
 
 #include "core/css/CSSCustomIdentValue.h"
 #include "core/css/CSSCustomPropertyDeclaration.h"
 #include "core/css/CSSKeyframesRule.h"
 #include "core/css/CSSStyleSheet.h"
@@ skipping 260 matching lines @@
         return CSSSelectorList();
     }
     if (!typeSelector.isNull()) {
       selector->prependTagSelector(QualifiedName(
           nullAtom, typeSelector, styleSheet->defaultNamespace()));
     }
   }
 
   selector->setForPage();
   Vector<std::unique_ptr<CSSParserSelector>> selectorVector;
-  selectorVector.append(std::move(selector));
+  selectorVector.push_back(std::move(selector));
   CSSSelectorList selectorList =
       CSSSelectorList::adoptSelectorVector(selectorVector);
   return selectorList;
 }
 
 ImmutableStylePropertySet* CSSParserImpl::parseCustomPropertySet(
     CSSParserTokenRange range) {
   range.consumeWhitespace();
   if (range.peek().type() != LeftBraceToken)
     return nullptr;
@@ skipping 283 matching lines @@
     m_observerWrapper->observer().endRuleHeader(
         m_observerWrapper->endOffset(prelude));
     m_observerWrapper->observer().startRuleBody(
         m_observerWrapper->previousTokenStartOffset(block));
   }
 
   if (m_styleSheet)
     m_styleSheet->setHasMediaQueries();
 
   consumeRuleList(block, RegularRuleList,
-                  [&rules](StyleRuleBase* rule) { rules.append(rule); });
+                  [&rules](StyleRuleBase* rule) { rules.push_back(rule); });
 
   if (m_observerWrapper)
     m_observerWrapper->observer().endRuleBody(
         m_observerWrapper->endOffset(block));
 
   return StyleRuleMedia::create(MediaQueryParser::parseMediaQuerySet(prelude),
                                 rules);
 }
 
 StyleRuleSupports* CSSParserImpl::consumeSupportsRule(
     CSSParserTokenRange prelude,
     CSSParserTokenRange block) {
   CSSSupportsParser::SupportsResult supported =
       CSSSupportsParser::supportsCondition(prelude, *this);
   if (supported == CSSSupportsParser::Invalid)
     return nullptr;  // Parse error, invalid @supports condition
 
   if (m_observerWrapper) {
     m_observerWrapper->observer().startRuleHeader(
         StyleRule::Supports, m_observerWrapper->startOffset(prelude));
     m_observerWrapper->observer().endRuleHeader(
         m_observerWrapper->endOffset(prelude));
     m_observerWrapper->observer().startRuleBody(
         m_observerWrapper->previousTokenStartOffset(block));
   }
 
   HeapVector<Member<StyleRuleBase>> rules;
   consumeRuleList(block, RegularRuleList,
-                  [&rules](StyleRuleBase* rule) { rules.append(rule); });
+                  [&rules](StyleRuleBase* rule) { rules.push_back(rule); });
 
   if (m_observerWrapper)
     m_observerWrapper->observer().endRuleBody(
         m_observerWrapper->endOffset(block));
 
   return StyleRuleSupports::create(prelude.serialize().stripWhiteSpace(),
                                    supported, rules);
 }
 
 StyleRuleViewport* CSSParserImpl::consumeViewportRule(
@@ skipping 108 matching lines @@
       std::move(selectorList),
       createStylePropertySet(m_parsedProperties, m_context.mode()));
 }
 
 void CSSParserImpl::consumeApplyRule(CSSParserTokenRange prelude) {
   ASSERT(RuntimeEnabledFeatures::cssApplyAtRulesEnabled());
 
   const CSSParserToken& ident = prelude.consumeIncludingWhitespace();
   if (!prelude.atEnd() || !CSSVariableParser::isValidVariableName(ident))
     return;  // Parse error, expected a single custom property name
-  m_parsedProperties.append(CSSProperty(
+  m_parsedProperties.push_back(CSSProperty(
       CSSPropertyApplyAtRule,
       *CSSCustomIdentValue::create(ident.value().toAtomicString())));
 }
 
 StyleRuleKeyframe* CSSParserImpl::consumeKeyframeStyleRule(
     CSSParserTokenRange prelude,
     CSSParserTokenRange block) {
   std::unique_ptr<Vector<double>> keyList = consumeKeyframeKeyList(prelude);
   if (!keyList)
     return nullptr;
@@ skipping 173 matching lines @@
   }
 }
 
 void CSSParserImpl::consumeVariableValue(CSSParserTokenRange range,
                                          const AtomicString& variableName,
                                          bool important,
                                          bool isAnimationTainted) {
   if (CSSCustomPropertyDeclaration* value =
           CSSVariableParser::parseDeclarationValue(variableName, range,
                                                    isAnimationTainted))
-    m_parsedProperties.append(
+    m_parsedProperties.push_back(
         CSSProperty(CSSPropertyVariable, *value, important));
 }
 
 void CSSParserImpl::consumeDeclarationValue(CSSParserTokenRange range,
                                             CSSPropertyID unresolvedProperty,
                                             bool important,
                                             StyleRule::RuleType ruleType) {
   CSSPropertyParser::parseValue(unresolvedProperty, important, range, m_context,
                                 m_parsedProperties, ruleType);
 }
 
 std::unique_ptr<Vector<double>> CSSParserImpl::consumeKeyframeKeyList(
     CSSParserTokenRange range) {
   std::unique_ptr<Vector<double>> result = WTF::wrapUnique(new Vector<double>);
   while (true) {
     range.consumeWhitespace();
     const CSSParserToken& token = range.consumeIncludingWhitespace();
     if (token.type() == PercentageToken && token.numericValue() >= 0 &&
         token.numericValue() <= 100)
-      result->append(token.numericValue() / 100);
+      result->push_back(token.numericValue() / 100);
     else if (token.type() == IdentToken &&
              equalIgnoringASCIICase(token.value(), "from"))
-      result->append(0);
+      result->push_back(0);
     else if (token.type() == IdentToken &&
              equalIgnoringASCIICase(token.value(), "to"))
-      result->append(1);
+      result->push_back(1);
     else
       return nullptr;  // Parser error, invalid value in keyframe selector
     if (range.atEnd())
       return result;
     if (range.consume().type() != CommaToken)
       return nullptr;  // Parser error
   }
 }
 
 }  // namespace blink