Setting up OrderIterator shouldn't require an extra Vector

Source/core/rendering/RenderFlexibleBox.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 275 matching lines @@
     RenderFlowThread* flowThread = flowThreadContainingBlock();
     if (logicalWidthChangedInRegions(flowThread))
         relayoutChildren = true;
     if (updateRegionsAndShapesLogicalSize(flowThread))
         relayoutChildren = true;
 
     m_numberOfInFlowChildrenOnFirstLine = -1;
 
     RenderBlock::startDelayUpdateScrollInfo();
 
-    Vector<LineContext> lineContexts;
-    Vector<int> orderValues;
-    computeMainAxisPreferredSizes(orderValues);
-    m_orderIterator.setOrderValues(orderValues);
+    prepareOrderIteratorAndMargins();
 
     ChildFrameRects oldChildRects;
     appendChildFrameRects(oldChildRects);
+
+    Vector<LineContext> lineContexts;
     layoutFlexItems(relayoutChildren, lineContexts);
 
     updateLogicalHeight();
     repositionLogicalHeightDependentFlexItems(lineContexts);
 
     RenderBlock::finishDelayUpdateScrollInfo();
 
     if (logicalHeight() != previousHeight)
         relayoutChildren = true;
 
@@ skipping 551 matching lines @@
 }
 
 LayoutUnit RenderFlexibleBox::computeChildMarginValue(Length margin, RenderView* view)
 {
     // When resolving the margins, we use the content size for resolving percent and calc (for percents in calc expressions) margins.
     // Fortunately, percent margins are always computed with respect to the block's width, even for margin-top and margin-bottom.
     LayoutUnit availableSize = contentLogicalWidth();
     return minimumValueForLength(margin, availableSize, view);
 }
 
-void RenderFlexibleBox::computeMainAxisPreferredSizes(Vector<int>& orderValues)
+void RenderFlexibleBox::prepareOrderIteratorAndMargins()
 {
     RenderView* renderView = view();
-    bool anyChildHasDefaultOrderValue = false;
+    OrderIteratorPopulator populator(m_orderIterator);
 
     for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
-        // Avoid growing the vector for the common-case default value of 0.
-        if (int order = child->style()->order())
-            orderValues.append(child->style()->order());
-        else
-            anyChildHasDefaultOrderValue = true;
+        populator.collectChild(child);
 
         if (child->isOutOfFlowPositioned())
             continue;
 
         // Before running the flex algorithm, 'auto' has a margin of 0.
         // Also, if we're not auto sizing, we don't do a layout that computes the start/end margins.
         if (isHorizontalFlow()) {
             child->setMarginLeft(computeChildMarginValue(child->style()->marginLeft(), renderView));
             child->setMarginRight(computeChildMarginValue(child->style()->marginRight(), renderView));
         } else {
             child->setMarginTop(computeChildMarginValue(child->style()->marginTop(), renderView));
             child->setMarginBottom(computeChildMarginValue(child->style()->marginBottom(), renderView));
         }
     }
-
-    if (anyChildHasDefaultOrderValue) {
-        // Avoid growing the vector to the default capacity of 16 if we're only going to put one item in it.
-        if (orderValues.isEmpty())
-            orderValues.reserveInitialCapacity(1);
-        orderValues.append(0);
-    }
 }
 
 LayoutUnit RenderFlexibleBox::adjustChildSizeForMinAndMax(RenderBox* child, LayoutUnit childSize)
 {
     Length max = isHorizontalFlow() ? child->style()->maxWidth() : child->style()->maxHeight();
     if (max.isSpecifiedOrIntrinsic()) {
         LayoutUnit maxExtent = computeMainAxisExtentForChild(child, MaxSize, max);
         if (maxExtent != -1 && childSize > maxExtent)
             childSize = maxExtent;
     }
@@ skipping 511 matching lines @@
             ASSERT(child);
             LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
             LayoutUnit originalOffset = lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
             LayoutUnit newOffset = contentExtent - originalOffset - lineCrossAxisExtent;
             adjustAlignmentForChild(child, newOffset - originalOffset);
         }
     }
 }
 
 }