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

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

 /*
  * Copyright (C) 2011 Google 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:
  *
  *     * 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
@@ skipping 945 matching lines @@
   m_orderIterator.first();
   for (LayoutBox* child = m_orderIterator.currentChild(); child;
        child = m_orderIterator.next()) {
 
     if (child->isOutOfFlowPositioned()) {
       // Out-of-flow children are not flex items, so we skip them here.
       prepareChildForPositionedLayout(*child);
       continue;
     }
 
-    allItems.append(constructFlexItem(*child, layoutType));
+    allItems.push_back(constructFlexItem(*child, layoutType));
   }
 
   const LayoutUnit lineBreakLength = mainAxisContentExtent(LayoutUnit::max());
   FlexLayoutAlgorithm flexAlgorithm(style(), lineBreakLength, allItems);
   LayoutUnit crossAxisOffset =
       flowAwareBorderBefore() + flowAwarePaddingBefore();
   Vector<FlexItem> lineItems;
   size_t nextIndex = 0;
   while (flexAlgorithm.ComputeNextFlexLine(
       nextIndex, lineItems, sumFlexBaseSize, totalFlexGrow, totalFlexShrink,
@@ skipping 436 matching lines @@
     DCHECK(!flexItem.frozen) << i;
     float flexFactor = (flexSign == PositiveFlexibility)
                            ? child->style()->flexGrow()
                            : child->style()->flexShrink();
     if (flexFactor == 0 ||
         (flexSign == PositiveFlexibility &&
          flexItem.flexBaseContentSize > flexItem.hypotheticalMainContentSize) ||
         (flexSign == NegativeFlexibility &&
          flexItem.flexBaseContentSize < flexItem.hypotheticalMainContentSize)) {
       flexItem.flexedContentSize = flexItem.hypotheticalMainContentSize;
-      newInflexibleItems.append(&flexItem);
+      newInflexibleItems.push_back(&flexItem);
     }
   }
   freezeViolations(newInflexibleItems, remainingFreeSpace, totalFlexGrow,
                    totalFlexShrink, totalWeightedFlexShrink);
 }
 
 // Returns true if we successfully ran the algorithm and sized the flex items.
 bool LayoutFlexibleBox::resolveFlexibleLengths(
     FlexSign flexSign,
     Vector<FlexItem>& children,
@@ skipping 40 matching lines @@
       childSize += LayoutUnit::fromFloatRound(extraSpace);
 
     LayoutUnit adjustedChildSize =
         adjustChildSizeForMinAndMax(*child, childSize);
     DCHECK_GE(adjustedChildSize, 0);
     flexItem.flexedContentSize = adjustedChildSize;
     usedFreeSpace += adjustedChildSize - flexItem.flexBaseContentSize;
 
     LayoutUnit violation = adjustedChildSize - childSize;
     if (violation > 0)
-      minViolations.append(&flexItem);
+      minViolations.push_back(&flexItem);
     else if (violation < 0)
-      maxViolations.append(&flexItem);
+      maxViolations.push_back(&flexItem);
     totalViolation += violation;
   }
 
   if (totalViolation)
     freezeViolations(totalViolation < 0 ? maxViolations : minViolations,
                      remainingFreeSpace, totalFlexGrow, totalFlexShrink,
                      totalWeightedFlexShrink);
   else
     remainingFreeSpace -= usedFreeSpace;
 
@@ skipping 388 matching lines @@
   if (style()->flexDirection() == FlowColumnReverse) {
     // We have to do an extra pass for column-reverse to reposition the flex
     // items since the start depends on the height of the flexbox, which we
     // only know after we've positioned all the flex items.
     updateLogicalHeight();
     layoutColumnReverse(children, crossAxisOffset, availableFreeSpace);
   }
 
   if (m_numberOfInFlowChildrenOnFirstLine == -1)
     m_numberOfInFlowChildrenOnFirstLine = children.size();
-  lineContexts.append(LineContext(crossAxisOffset, maxChildCrossAxisExtent,
-                                  maxAscent, std::move(children)));
+  lineContexts.push_back(LineContext(crossAxisOffset, maxChildCrossAxisExtent,
+                                     maxAscent, std::move(children)));
   crossAxisOffset += maxChildCrossAxisExtent;
 }
 
 void LayoutFlexibleBox::layoutColumnReverse(const Vector<FlexItem>& children,
                                             LayoutUnit crossAxisOffset,
                                             LayoutUnit availableFreeSpace) {
   ContentPosition position = styleRef().resolvedJustifyContentPosition(
       contentAlignmentNormalBehavior());
   ContentDistributionType distribution =
       styleRef().resolvedJustifyContentDistribution(
@@ skipping 149 matching lines @@
           maxAscent, styleRef().flexWrap() == FlexWrapReverse);
       adjustAlignmentForChild(*flexItem.box, offset);
       if (position == ItemPositionBaseline &&
           styleRef().flexWrap() == FlexWrapReverse) {
         minMarginAfterBaseline = std::min(
             minMarginAfterBaseline, availableAlignmentSpaceForChild(
                                         lineCrossAxisExtent, *flexItem.box) -
                                         offset);
       }
     }
-    minMarginAfterBaselines.append(minMarginAfterBaseline);
+    minMarginAfterBaselines.push_back(minMarginAfterBaseline);
   }
 
   if (style()->flexWrap() != FlexWrapReverse)
     return;
 
   // wrap-reverse flips the cross axis start and end. For baseline alignment,
   // this means we need to align the after edge of baseline elements with the
   // after edge of the flex line.
   for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
     const LineContext& lineContext = lineContexts[lineNumber];
@@ skipping 106 matching lines @@
       LayoutUnit originalOffset =
           lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
       LayoutUnit newOffset =
           contentExtent - originalOffset - lineCrossAxisExtent;
       adjustAlignmentForChild(*flexItem.box, newOffset - originalOffset);
     }
   }
 }
 
 }  // namespace blink