Changeset 107310 in webkit


Ignore:
Timestamp:
Feb 9, 2012 4:42:46 PM (12 years ago)
Author:
tony@chromium.org
Message:

more refactoring of RenderFlexibleBox in preparation for multiline
​https://bugs.webkit.org/show_bug.cgi?id=78281

Reviewed by Ojan Vafai.

Previously, we were creating Vector of each flex item's preferred size in document order,
but for multiline, we need to break the lines in the flex order. I just removed this code
since it was the wrong order.

Instead, have 2 funtions, computeMainAxisPreferredSizes which only does the necessary
layouts and margin computations to compute preferred sizes and computeFlexOrder which
does the work of computing the flex order, preferred sizes, positive/negative flex.

For multiline, we will have computeFlexOrder drive a while loop and it will return the
flex items, preferred size, and positive/negative flex values for each line.

No new tests, just refactoring.

  • rendering/RenderFlexibleBox.cpp:

(WebCore::RenderFlexibleBox::layoutFlexItems):
(WebCore::RenderFlexibleBox::computeMainAxisPreferredSizes): Only layout auto sized children and set margins.
(WebCore::RenderFlexibleBox::computeFlexOrder): Compute flex order, preferred size, positive/negative flex.
(WebCore::RenderFlexibleBox::runFreeSpaceAllocationAlgorithm): Use the precomputed flex order.
(WebCore::RenderFlexibleBox::layoutAndPlaceChildren): Use the precomputed flex order.
(WebCore::RenderFlexibleBox::layoutColumnReverse): Use the precomputed flex order.
(WebCore::RenderFlexibleBox::alignChildren): Use the precomputed flex order.

  • rendering/RenderFlexibleBox.h:

(RenderFlexibleBox):

Location:
trunk/Source/WebCore
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r107304 r107310  
     12012-02-09  Tony Chang  <tony@chromium.org>
     2
     3        more refactoring of RenderFlexibleBox in preparation for multiline
     4        https://bugs.webkit.org/show_bug.cgi?id=78281
     5
     6        Reviewed by Ojan Vafai.
     7
     8        Previously, we were creating Vector of each flex item's preferred size in document order,
     9        but for multiline, we need to break the lines in the flex order.  I just removed this code
     10        since it was the wrong order.
     11
     12        Instead, have 2 funtions, computeMainAxisPreferredSizes which only does the necessary
     13        layouts and margin computations to compute preferred sizes and computeFlexOrder which
     14        does the work of computing the flex order, preferred sizes, positive/negative flex.
     15
     16        For multiline, we will have computeFlexOrder drive a while loop and it will return the
     17        flex items, preferred size, and positive/negative flex values for each line.
     18
     19        No new tests, just refactoring.
     20
     21        * rendering/RenderFlexibleBox.cpp:
     22        (WebCore::RenderFlexibleBox::layoutFlexItems):
     23        (WebCore::RenderFlexibleBox::computeMainAxisPreferredSizes): Only layout auto sized children and set margins.
     24        (WebCore::RenderFlexibleBox::computeFlexOrder): Compute flex order, preferred size, positive/negative flex.
     25        (WebCore::RenderFlexibleBox::runFreeSpaceAllocationAlgorithm): Use the precomputed flex order.
     26        (WebCore::RenderFlexibleBox::layoutAndPlaceChildren): Use the precomputed flex order.
     27        (WebCore::RenderFlexibleBox::layoutColumnReverse): Use the precomputed flex order.
     28        (WebCore::RenderFlexibleBox::alignChildren): Use the precomputed flex order.
     29        * rendering/RenderFlexibleBox.h:
     30        (RenderFlexibleBox):
     31
    1322012-02-09  Kentaro Hara  <haraken@chromium.org>
    233

  • trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp

    r107179 r107310  
    466466void RenderFlexibleBox::layoutFlexItems(bool relayoutChildren)
    467467{
     468    TreeOrderIterator treeIterator(this);
     469    computeMainAxisPreferredSizes(relayoutChildren, treeIterator);
     470
     471    OrderedFlexItemList orderedChildren;
     472    LayoutUnit preferredMainAxisExtent;
    468473    float totalPositiveFlexibility;
    469474    float totalNegativeFlexibility;
    470     TreeOrderIterator treeIterator(this);
    471 
    472     WTF::Vector<LayoutUnit> preferredSizes;
    473     computeMainAxisPreferredSizes(relayoutChildren, treeIterator, preferredSizes, totalPositiveFlexibility, totalNegativeFlexibility);
    474     LayoutUnit preferredMainAxisExtent = 0;
    475     for (size_t i = 0; i < preferredSizes.size(); ++i)
    476         preferredMainAxisExtent += preferredSizes[i];
     475    FlexOrderIterator flexIterator(this, treeIterator.flexOrderValues());
     476    computeFlexOrder(flexIterator, orderedChildren, preferredMainAxisExtent, totalPositiveFlexibility, totalNegativeFlexibility);
     477
    477478    LayoutUnit availableFreeSpace = mainAxisContentExtent() - preferredMainAxisExtent;
    478 
    479     FlexOrderIterator flexIterator(this, treeIterator.flexOrderValues());
    480479    InflexibleFlexItemSize inflexibleItems;
    481480    WTF::Vector<LayoutUnit> childSizes;
    482     while (!runFreeSpaceAllocationAlgorithm(flexIterator, availableFreeSpace, totalPositiveFlexibility, totalNegativeFlexibility, inflexibleItems, childSizes)) {
     481    while (!runFreeSpaceAllocationAlgorithm(orderedChildren, availableFreeSpace, totalPositiveFlexibility, totalNegativeFlexibility, inflexibleItems, childSizes)) {
    483482        ASSERT(totalPositiveFlexibility >= 0 && totalNegativeFlexibility >= 0);
    484483        ASSERT(inflexibleItems.size() > 0);
    485484    }
    486485
    487     layoutAndPlaceChildren(flexIterator, childSizes, availableFreeSpace, totalPositiveFlexibility);
     486    layoutAndPlaceChildren(orderedChildren, childSizes, availableFreeSpace, totalPositiveFlexibility);
    488487}
    489488
    … …  
    513512}
    514513
    515 void RenderFlexibleBox::computeMainAxisPreferredSizes(bool relayoutChildren, TreeOrderIterator& iterator, WTF::Vector<LayoutUnit>& preferredSizes, float& totalPositiveFlexibility, float& totalNegativeFlexibility)
    516 {
    517     totalPositiveFlexibility = totalNegativeFlexibility = 0;
    518 
     514void RenderFlexibleBox::computeMainAxisPreferredSizes(bool relayoutChildren, TreeOrderIterator& iterator)
     515{
    519516    LayoutUnit flexboxAvailableContentExtent = mainAxisContentExtent();
    520517    for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
    521         if (child->isPositioned()) {
    522             preferredSizes.append(0);
     518        if (child->isPositioned())
    523519            continue;
    524         }
    525520
    526521        child->clearOverrideSize();
    … …  
    530525            child->layoutIfNeeded();
    531526        }
    532 
    533         LayoutUnit preferredSize = mainAxisBorderAndPaddingExtentForChild(child) + preferredMainAxisContentExtentForChild(child);
    534527
    535528        // We set the margins because we want to make sure 'auto' has a margin
    … …  
    539532            child->setMarginLeft(child->style()->marginLeft().calcMinValue(flexboxAvailableContentExtent));
    540533            child->setMarginRight(child->style()->marginRight().calcMinValue(flexboxAvailableContentExtent));
    541             preferredSize += child->marginLeft() + child->marginRight();
    542534        } else {
    543535            child->setMarginTop(child->style()->marginTop().calcMinValue(flexboxAvailableContentExtent));
    544536            child->setMarginBottom(child->style()->marginBottom().calcMinValue(flexboxAvailableContentExtent));
    545             preferredSize += child->marginTop() + child->marginBottom();
    546         }
    547 
    548         preferredSizes.append(preferredSize);
    549 
     537        }
     538    }
     539}
     540
     541void RenderFlexibleBox::computeFlexOrder(FlexOrderIterator& iterator, OrderedFlexItemList& orderedChildren, LayoutUnit& preferredMainAxisExtent, float& totalPositiveFlexibility, float& totalNegativeFlexibility)
     542{
     543    orderedChildren.clear();
     544    preferredMainAxisExtent = 0;
     545    totalPositiveFlexibility = totalNegativeFlexibility = 0;
     546    for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
     547        orderedChildren.append(child);
     548        if (child->isPositioned())
     549            continue;
     550
     551        LayoutUnit childMainAxisExtent = mainAxisBorderAndPaddingExtentForChild(child) + preferredMainAxisContentExtentForChild(child);
     552        if (isHorizontalFlow())
     553            childMainAxisExtent += child->marginLeft() + child->marginRight();
     554        else
     555            childMainAxisExtent += child->marginTop() + child->marginBottom();
     556
     557        // FIXME: When implementing multiline, we would return here if adding
     558        // the child's main axis extent would cause us to overflow.
     559        preferredMainAxisExtent += childMainAxisExtent;
    550560        totalPositiveFlexibility += positiveFlexForChild(child);
    551561        totalNegativeFlexibility += negativeFlexForChild(child);
    … …  
    554564
    555565// Returns true if we successfully ran the algorithm and sized the flex items.
    556 bool RenderFlexibleBox::runFreeSpaceAllocationAlgorithm(FlexOrderIterator& iterator, LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalNegativeFlexibility, InflexibleFlexItemSize& inflexibleItems, WTF::Vector<LayoutUnit>& childSizes)
     566bool RenderFlexibleBox::runFreeSpaceAllocationAlgorithm(const OrderedFlexItemList& children, LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalNegativeFlexibility, InflexibleFlexItemSize& inflexibleItems, WTF::Vector<LayoutUnit>& childSizes)
    557567{
    558568    childSizes.clear();
    559569
    560570    LayoutUnit flexboxAvailableContentExtent = mainAxisContentExtent();
    561     for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
     571    for (size_t i = 0; i < children.size(); ++i) {
     572        RenderBox* child = children[i];
    562573        if (child->isPositioned()) {
    563574            childSizes.append(0);
    … …  
    665676}
    666677
    667 void RenderFlexibleBox::layoutAndPlaceChildren(FlexOrderIterator& iterator, const WTF::Vector<LayoutUnit>& childSizes, LayoutUnit availableFreeSpace, float totalPositiveFlexibility)
     678void RenderFlexibleBox::layoutAndPlaceChildren(const OrderedFlexItemList& children, const WTF::Vector<LayoutUnit>& childSizes, LayoutUnit availableFreeSpace, float totalPositiveFlexibility)
    668679{
    669680    LayoutUnit mainAxisOffset = flowAwareBorderStart() + flowAwarePaddingStart();
    … …  
    676687    LayoutUnit maxAscent = 0, maxDescent = 0; // Used when flex-align: baseline.
    677688    bool shouldFlipMainAxis = !isColumnFlow() && !isLeftToRightFlow();
    678     size_t i = 0;
    679     for (RenderBox* child = iterator.first(); child; child = iterator.next(), ++i) {
     689    for (size_t i = 0; i < children.size(); ++i) {
     690        RenderBox* child = children[i];
    680691        if (child->isPositioned()) {
    681692            prepareChildForPositionedLayout(child, mainAxisOffset, crossAxisOffset);
    … …  
    720731        // on the height of the flexbox, which we only know after we've positioned all the flex items.
    721732        computeLogicalHeight();
    722         layoutColumnReverse(iterator, childSizes, availableFreeSpace, totalPositiveFlexibility);
    723     }
    724 
    725     alignChildren(iterator, maxAscent);
    726 }
    727 
    728 void RenderFlexibleBox::layoutColumnReverse(FlexOrderIterator& iterator, const WTF::Vector<LayoutUnit>& childSizes, LayoutUnit availableFreeSpace, float totalPositiveFlexibility)
     733        layoutColumnReverse(children, childSizes, availableFreeSpace, totalPositiveFlexibility);
     734    }
     735
     736    alignChildren(children, maxAscent);
     737}
     738
     739void RenderFlexibleBox::layoutColumnReverse(const OrderedFlexItemList& children, const WTF::Vector<LayoutUnit>& childSizes, LayoutUnit availableFreeSpace, float totalPositiveFlexibility)
    729740{
    730741    // This is similar to the logic in layoutAndPlaceChildren, except we place the children
    … …  
    736747
    737748    LayoutUnit crossAxisOffset = flowAwareBorderBefore() + flowAwarePaddingBefore();
    738     size_t i = 0;
    739     for (RenderBox* child = iterator.first(); child; child = iterator.next(), ++i) {
     749    for (size_t i = 0; i < children.size(); ++i) {
     750        RenderBox* child = children[i];
    740751        if (child->isPositioned()) {
    741752            child->layer()->setStaticBlockPosition(mainAxisOffset);
    … …  
    768779}
    769780
    770 void RenderFlexibleBox::alignChildren(FlexOrderIterator& iterator, LayoutUnit maxAscent)
     781void RenderFlexibleBox::alignChildren(const OrderedFlexItemList& children, LayoutUnit maxAscent)
    771782{
    772783    LayoutUnit crossExtent = crossAxisExtent();
    773784
    774     for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
     785    for (size_t i = 0; i < children.size(); ++i) {
     786        RenderBox* child = children[i];
    775787        // direction:rtl + flex-direction:column means the cross-axis direction is flipped.
    776788        if (!style()->isLeftToRightDirection() && isColumnFlow()) {

  • trunk/Source/WebCore/rendering/RenderFlexibleBox.h

    r107179 r107310  
    5353    class FlexOrderIterator;
    5454    typedef WTF::HashMap<const RenderBox*, LayoutUnit> InflexibleFlexItemSize;
     55    typedef WTF::Vector<RenderBox*> OrderedFlexItemList;
    5556
    5657    bool hasOrthogonalFlow(RenderBox* child) const;
    … …  
    9697    LayoutUnit marginBoxAscent(RenderBox*);
    9798
    98     void computeMainAxisPreferredSizes(bool relayoutChildren, TreeOrderIterator&, WTF::Vector<LayoutUnit>&, float& totalPositiveFlexibility, float& totalNegativeFlexibility);
    99     bool runFreeSpaceAllocationAlgorithm(FlexOrderIterator&, LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalNegativeFlexibility, InflexibleFlexItemSize&, WTF::Vector<LayoutUnit>& childSizes);
     99    void computeMainAxisPreferredSizes(bool relayoutChildren, TreeOrderIterator&);
     100    void computeFlexOrder(FlexOrderIterator&, OrderedFlexItemList& orderedChildren, LayoutUnit& preferredMainAxisExtent, float& totalPositiveFlexibility, float& totalNegativeFlexibility);
     101    bool runFreeSpaceAllocationAlgorithm(const OrderedFlexItemList&, LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalNegativeFlexibility, InflexibleFlexItemSize&, WTF::Vector<LayoutUnit>& childSizes);
    100102    void setLogicalOverrideSize(RenderBox* child, LayoutUnit childPreferredSize);
    101103    void prepareChildForPositionedLayout(RenderBox* child, LayoutUnit mainAxisOffset, LayoutUnit crossAxisOffset);
    102     void layoutAndPlaceChildren(FlexOrderIterator&, const WTF::Vector<LayoutUnit>& childSizes, LayoutUnit availableFreeSpace, float totalPositiveFlexibility);
    103     void layoutColumnReverse(FlexOrderIterator&, const WTF::Vector<LayoutUnit>& childSizes, LayoutUnit availableFreeSpace, float totalPositiveFlexibility);
    104     void alignChildren(FlexOrderIterator&, LayoutUnit maxAscent);
     104    void layoutAndPlaceChildren(const OrderedFlexItemList&, const WTF::Vector<LayoutUnit>& childSizes, LayoutUnit availableFreeSpace, float totalPositiveFlexibility);
     105    void layoutColumnReverse(const OrderedFlexItemList&, const WTF::Vector<LayoutUnit>& childSizes, LayoutUnit availableFreeSpace, float totalPositiveFlexibility);
     106    void alignChildren(const OrderedFlexItemList&, LayoutUnit maxAscent);
    105107};
    106108
Note: See TracChangeset for help on using the changeset viewer.