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

third_party/WebKit/Source/core/css/resolver/StyleBuilderConverter.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
  * copyright notice, this list of conditions and the following disclaimer
  * in the documentation and/or other materials provided with the
  * distribution.
  *     * Neither the name of Google Inc. nor the names of its
@@ skipping 621 matching lines @@
     const CSSValue& value,
     size_t currentNamedGridLine,
     NamedGridLinesMap& namedGridLines,
     OrderedNamedGridLines& orderedNamedGridLines) {
   ASSERT(value.isGridLineNamesValue());
 
   for (auto& namedGridLineValue : toCSSValueList(value)) {
     String namedGridLine = toCSSCustomIdentValue(*namedGridLineValue).value();
     NamedGridLinesMap::AddResult result =
         namedGridLines.add(namedGridLine, Vector<size_t>());
-    result.storedValue->value.append(currentNamedGridLine);
+    result.storedValue->value.push_back(currentNamedGridLine);
     OrderedNamedGridLines::AddResult orderedInsertionResult =
         orderedNamedGridLines.add(currentNamedGridLine, Vector<String>());
-    orderedInsertionResult.storedValue->value.append(namedGridLine);
+    orderedInsertionResult.storedValue->value.push_back(namedGridLine);
   }
 }
 
 Vector<GridTrackSize> StyleBuilderConverter::convertGridTrackSizeList(
     StyleResolverState& state,
     const CSSValue& value) {
   DCHECK(value.isValueList());
   Vector<GridTrackSize> trackSizes;
   for (auto& currValue : toCSSValueList(value)) {
     DCHECK(!currValue->isGridLineNamesValue());
     DCHECK(!currValue->isGridAutoRepeatValue());
-    trackSizes.append(convertGridTrackSize(state, *currValue));
+    trackSizes.push_back(convertGridTrackSize(state, *currValue));
   }
   return trackSizes;
 }
 
 void StyleBuilderConverter::convertGridTrackList(
     const CSSValue& value,
     Vector<GridTrackSize>& trackSizes,
     NamedGridLinesMap& namedGridLines,
     OrderedNamedGridLines& orderedNamedGridLines,
     Vector<GridTrackSize>& autoRepeatTrackSizes,
@@ skipping 24 matching lines @@
              autoRepeatID == CSSValueAutoFit);
       autoRepeatType = autoRepeatID == CSSValueAutoFill ? AutoFill : AutoFit;
       for (auto autoRepeatValue : toCSSValueList(*currValue)) {
         if (autoRepeatValue->isGridLineNamesValue()) {
           convertGridLineNamesList(*autoRepeatValue, autoRepeatIndex,
                                    autoRepeatNamedGridLines,
                                    autoRepeatOrderedNamedGridLines);
           continue;
         }
         ++autoRepeatIndex;
-        autoRepeatTrackSizes.append(
+        autoRepeatTrackSizes.push_back(
             convertGridTrackSize(state, *autoRepeatValue));
       }
       autoRepeatInsertionPoint = currentNamedGridLine++;
       continue;
     }
 
     ++currentNamedGridLine;
-    trackSizes.append(convertGridTrackSize(state, *currValue));
+    trackSizes.push_back(convertGridTrackSize(state, *currValue));
   }
 
   // The parser should have rejected any <track-list> without any <track-size>
   // as this is not conformant to the syntax.
   ASSERT(!trackSizes.isEmpty() || !autoRepeatTrackSizes.isEmpty());
 }
 
 void StyleBuilderConverter::convertOrderedNamedGridLinesMapToNamedGridLinesMap(
     const OrderedNamedGridLines& orderedNamedGridLines,
     NamedGridLinesMap& namedGridLines) {
   ASSERT(namedGridLines.size() == 0);
 
   if (orderedNamedGridLines.size() == 0)
     return;
 
   for (auto& orderedNamedGridLine : orderedNamedGridLines) {
     for (auto& lineName : orderedNamedGridLine.value) {
       NamedGridLinesMap::AddResult startResult =
           namedGridLines.add(lineName, Vector<size_t>());
-      startResult.storedValue->value.append(orderedNamedGridLine.key);
+      startResult.storedValue->value.push_back(orderedNamedGridLine.key);
     }
   }
 
   for (auto& namedGridLine : namedGridLines) {
     Vector<size_t> gridLineIndexes = namedGridLine.value;
     std::sort(gridLineIndexes.begin(), gridLineIndexes.end());
   }
 }
 
 void StyleBuilderConverter::createImplicitNamedGridLinesFromGridArea(
     const NamedGridAreaMap& namedGridAreas,
     NamedGridLinesMap& namedGridLines,
     GridTrackSizingDirection direction) {
   for (const auto& namedGridAreaEntry : namedGridAreas) {
     GridSpan areaSpan = direction == ForRows ? namedGridAreaEntry.value.rows
                                              : namedGridAreaEntry.value.columns;
     {
       NamedGridLinesMap::AddResult startResult = namedGridLines.add(
           namedGridAreaEntry.key + "-start", Vector<size_t>());
-      startResult.storedValue->value.append(areaSpan.startLine());
+      startResult.storedValue->value.push_back(areaSpan.startLine());
       std::sort(startResult.storedValue->value.begin(),
                 startResult.storedValue->value.end());
     }
     {
       NamedGridLinesMap::AddResult endResult =
           namedGridLines.add(namedGridAreaEntry.key + "-end", Vector<size_t>());
-      endResult.storedValue->value.append(areaSpan.endLine());
+      endResult.storedValue->value.push_back(areaSpan.endLine());
       std::sort(endResult.storedValue->value.begin(),
                 endResult.storedValue->value.end());
     }
   }
 }
 
 Length StyleBuilderConverter::convertLength(const StyleResolverState& state,
                                             const CSSValue& value) {
   return toCSSPrimitiveValue(value).convertToLength(
       state.cssToLengthConversionData());
@@ skipping 527 matching lines @@
       // Instead of the actual zoom, use 1 to avoid potential rounding errors
       Length length = primitiveValue.convertToLength(
           state.cssToLengthConversionData().copyWithAdjustedZoom(1));
       return *CSSPrimitiveValue::create(length, 1);
     }
   }
   return value;
 }
 
 }  // namespace blink