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

third_party/WebKit/Source/core/layout/LayoutGrid.cpp

 /*
  * Copyright (C) 2011 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 53 matching lines @@
   }
 }
 
 void LayoutGrid::Grid::insert(LayoutBox& child, const GridArea& area) {
   DCHECK(area.rows.isTranslatedDefinite() &&
          area.columns.isTranslatedDefinite());
   ensureGridSize(area.rows.endLine(), area.columns.endLine());
 
   for (const auto& row : area.rows) {
     for (const auto& column : area.columns)
-      m_grid[row][column].append(&child);
+      m_grid[row][column].push_back(&child);
   }
 
   setGridItemArea(child, area);
 }
 
 void LayoutGrid::Grid::setSmallestTracksStart(int rowStart, int columnStart) {
   m_smallestRowStart = rowStart;
   m_smallestColumnStart = columnStart;
 }
 
@@ skipping 816 matching lines @@
         computeUsedBreadthOfMaxLength(trackSize, track.baseSize(), maxSize));
     track.setInfinitelyGrowable(false);
 
     if (trackSize.isFitContent()) {
       GridLength gridLength = trackSize.fitContentTrackBreadth();
       if (!gridLength.hasPercentage() || hasDefiniteFreeSpace)
         track.setGrowthLimitCap(valueForLength(gridLength.length(), maxSize));
     }
 
     if (trackSize.isContentSized())
-      sizingData.contentSizedTracksIndex.append(i);
+      sizingData.contentSizedTracksIndex.push_back(i);
     if (trackSize.maxTrackBreadth().isFlex())
-      flexibleSizedTracksIndex.append(i);
+      flexibleSizedTracksIndex.push_back(i);
   }
 
   // 2. Resolve content-based TrackSizingFunctions.
   if (!sizingData.contentSizedTracksIndex.isEmpty())
     resolveContentBasedTrackSizingFunctions(direction, sizingData);
 
   baseSizesWithoutMaximization = growthLimitsWithoutMaximization = LayoutUnit();
 
   for (auto& track : tracks) {
     ASSERT(!track.infiniteGrowthPotential());
@@ skipping 230 matching lines @@
   if (leftOverSpace <= 0)
     return 0;
 
   double flexFactorSum = 0;
   Vector<size_t, 8> flexibleTracksIndexes;
   for (const auto& trackIndex : tracksSpan) {
     GridTrackSize trackSize = gridTrackSize(direction, trackIndex, sizingData);
     if (!trackSize.maxTrackBreadth().isFlex()) {
       leftOverSpace -= tracks[trackIndex].baseSize();
     } else {
-      flexibleTracksIndexes.append(trackIndex);
+      flexibleTracksIndexes.push_back(trackIndex);
       flexFactorSum += trackSize.maxTrackBreadth().flex();
     }
   }
 
   // The function is not called if we don't have <flex> grid tracks
   ASSERT(!flexibleTracksIndexes.isEmpty());
 
   return computeFlexFactorUnitSize(tracks, direction, flexFactorSum,
                                    leftOverSpace, flexibleTracksIndexes,
                                    sizingData);
@@ skipping 355 matching lines @@
                              ? sizingData.columnTracks[trackIndex]
                              : sizingData.rowTracks[trackIndex];
       while (LayoutBox* gridItem = iterator.nextGridItem()) {
         if (itemsSet.add(gridItem).isNewEntry) {
           const GridSpan& span = grid.gridItemSpan(*gridItem, direction);
           if (span.integerSpan() == 1) {
             resolveContentBasedTrackSizingFunctionsForNonSpanningItems(
                 direction, span, *gridItem, track, sizingData);
           } else if (!spanningItemCrossesFlexibleSizedTracks(span, direction,
                                                              sizingData)) {
-            sizingData.itemsSortedByIncreasingSpan.append(
+            sizingData.itemsSortedByIncreasingSpan.push_back(
                 GridItemWithSpan(*gridItem, span));
           }
         }
       }
     }
     std::sort(sizingData.itemsSortedByIncreasingSpan.begin(),
               sizingData.itemsSortedByIncreasingSpan.end());
   }
 
   auto it = sizingData.itemsSortedByIncreasingSpan.begin();
@@ skipping 223 matching lines @@
       GridTrackSize trackSize =
           gridTrackSize(direction, trackPosition, sizingData);
       GridTrack& track = (direction == ForColumns)
                              ? sizingData.columnTracks[trackPosition]
                              : sizingData.rowTracks[trackPosition];
       spanningTracksSize +=
           trackSizeForTrackSizeComputationPhase(phase, track, ForbidInfinity);
       if (!shouldProcessTrackForTrackSizeComputationPhase(phase, trackSize))
         continue;
 
-      sizingData.filteredTracks.append(&track);
+      sizingData.filteredTracks.push_back(&track);
 
       if (trackShouldGrowBeyondGrowthLimitsForTrackSizeComputationPhase(
               phase, trackSize))
-        sizingData.growBeyondGrowthLimitsTracks.append(&track);
+        sizingData.growBeyondGrowthLimitsTracks.push_back(&track);
     }
 
     if (sizingData.filteredTracks.isEmpty())
       continue;
 
     spanningTracksSize +=
         guttersSize(sizingData.grid(), direction, itemSpan.startLine(),
                     itemSpan.integerSpan(), sizingData.sizingOperation);
 
     LayoutUnit extraSpace =
@@ skipping 321 matching lines @@
       area.rows.translate(abs(grid.smallestTrackStart(ForRows)));
     if (!area.columns.isIndefinite())
       area.columns.translate(abs(grid.smallestTrackStart(ForColumns)));
 
     if (area.rows.isIndefinite() || area.columns.isIndefinite()) {
       grid.setGridItemArea(*child, area);
       GridSpan majorAxisPositions =
           (autoPlacementMajorAxisDirection() == ForColumns) ? area.columns
                                                             : area.rows;
       if (majorAxisPositions.isIndefinite())
-        autoMajorAxisAutoGridItems.append(child);
+        autoMajorAxisAutoGridItems.push_back(child);
       else
-        specifiedMajorAxisAutoGridItems.append(child);
+        specifiedMajorAxisAutoGridItems.push_back(child);
       continue;
     }
     grid.insert(*child, area);
   }
   grid.setHasAnyOrthogonalGridItem(hasAnyOrthogonalGridItem);
 
 #if ENABLE(ASSERT)
   if (grid.hasGridItems()) {
     DCHECK_GE(grid.numTracks(ForRows),
               GridPositionsResolver::explicitGridRowCount(
@@ skipping 286 matching lines @@
   if (numPositions < 2)
     return tracks;
 
   DCHECK(!m_grid.needsItemsPlacement());
   bool hasCollapsedTracks = m_grid.hasAutoRepeatEmptyTracks(direction);
   LayoutUnit gap = !hasCollapsedTracks
                        ? gridGapForDirection(direction, TrackSizing)
                        : LayoutUnit();
   tracks.reserveCapacity(numPositions - 1);
   for (size_t i = 0; i < numPositions - 2; ++i)
-    tracks.append(positions[i + 1] - positions[i] - offsetBetweenTracks - gap);
-  tracks.append(positions[numPositions - 1] - positions[numPositions - 2]);
+    tracks.push_back(positions[i + 1] - positions[i] - offsetBetweenTracks -
+                     gap);
+  tracks.push_back(positions[numPositions - 1] - positions[numPositions - 2]);
 
   if (!hasCollapsedTracks)
     return tracks;
 
   size_t remainingEmptyTracks = m_grid.autoRepeatEmptyTracks(direction)->size();
   size_t lastLine = tracks.size();
   gap = gridGapForDirection(direction, TrackSizing);
   for (size_t i = 1; i < lastLine; ++i) {
     if (m_grid.isEmptyAutoRepeatTrack(direction, i - 1)) {
       --remainingEmptyTracks;
@@ skipping 32 matching lines @@
 
   // Spec defines auto-sized tracks as the ones with an 'auto' max-sizing
   // function.
   Vector<GridTrack>& tracks = (direction == ForColumns)
                                   ? sizingData.columnTracks
                                   : sizingData.rowTracks;
   Vector<unsigned> autoSizedTracksIndex;
   for (unsigned i = 0; i < tracks.size(); ++i) {
     const GridTrackSize& trackSize = gridTrackSize(direction, i, sizingData);
     if (trackSize.hasAutoMaxTrackBreadth())
-      autoSizedTracksIndex.append(i);
+      autoSizedTracksIndex.push_back(i);
   }
 
   unsigned numberOfAutoSizedTracks = autoSizedTracksIndex.size();
   if (numberOfAutoSizedTracks < 1)
     return;
 
   LayoutUnit sizeToIncrease = availableSpace / numberOfAutoSizedTracks;
   for (const auto& trackIndex : autoSizedTracksIndex) {
     GridTrack* track = tracks.data() + trackIndex;
     LayoutUnit baseSize = track->baseSize() + sizeToIncrease;
@@ skipping 71 matching lines @@
     LayoutUnit childGridAreaHeight =
         isHorizontalWritingMode() ? overrideContainingBlockContentLogicalHeight
                                   : overrideContainingBlockContentLogicalWidth;
     LayoutUnit childGridAreaWidth =
         isHorizontalWritingMode() ? overrideContainingBlockContentLogicalWidth
                                   : overrideContainingBlockContentLogicalHeight;
     LayoutRect gridAreaRect(
         gridAreaLogicalPosition(area),
         LayoutSize(childGridAreaWidth, childGridAreaHeight));
     if (!gridAreaRect.contains(child->frameRect()))
-      m_gridItemsOverflowingGridArea.append(child);
+      m_gridItemsOverflowingGridArea.push_back(child);
   }
 }
 
 void LayoutGrid::prepareChildForPositionedLayout(LayoutBox& child) {
   ASSERT(child.isOutOfFlowPositioned());
   child.containingBlock()->insertPositionedObject(&child);
 
   PaintLayer* childLayer = child.layer();
   childLayer->setStaticInlinePosition(borderAndPaddingStart());
   childLayer->setStaticBlockPosition(borderAndPaddingBefore());
@@ skipping 1021 matching lines @@
   if (direction == ForRows)
     return grid.numTracks(ForRows);
 
   return grid.numTracks(ForRows)
              ? grid.numTracks(ForColumns)
              : GridPositionsResolver::explicitGridColumnCount(
                    styleRef(), grid.autoRepeatTracks(ForColumns));
 }
 
 }  // namespace blink