| /* |
| * 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 |
| * 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 |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "core/layout/LayoutFlexibleBox.h" |
| |
| #include "core/frame/UseCounter.h" |
| #include "core/layout/FlexibleBoxAlgorithm.h" |
| #include "core/layout/LayoutState.h" |
| #include "core/layout/LayoutView.h" |
| #include "core/layout/TextAutosizer.h" |
| #include "core/paint/BlockPainter.h" |
| #include "core/paint/PaintLayer.h" |
| #include "core/style/ComputedStyle.h" |
| #include "platform/LengthFunctions.h" |
| #include "wtf/MathExtras.h" |
| #include <limits> |
| |
| namespace blink { |
| |
| static bool hasAspectRatio(const LayoutBox& child) { |
| return child.isImage() || child.isCanvas() || child.isVideo(); |
| } |
| |
| struct LayoutFlexibleBox::LineContext { |
| LineContext(LayoutUnit crossAxisOffset, |
| LayoutUnit crossAxisExtent, |
| LayoutUnit maxAscent, |
| Vector<FlexItem>&& flexItems) |
| : crossAxisOffset(crossAxisOffset), |
| crossAxisExtent(crossAxisExtent), |
| maxAscent(maxAscent), |
| flexItems(flexItems) {} |
| |
| LayoutUnit crossAxisOffset; |
| LayoutUnit crossAxisExtent; |
| LayoutUnit maxAscent; |
| Vector<FlexItem> flexItems; |
| }; |
| |
| LayoutFlexibleBox::LayoutFlexibleBox(Element* element) |
| : LayoutBlock(element), |
| m_orderIterator(this), |
| m_numberOfInFlowChildrenOnFirstLine(-1), |
| m_hasDefiniteHeight(SizeDefiniteness::Unknown) { |
| DCHECK(!childrenInline()); |
| if (!isAnonymous()) |
| UseCounter::count(document(), UseCounter::CSSFlexibleBox); |
| } |
| |
| LayoutFlexibleBox::~LayoutFlexibleBox() {} |
| |
| LayoutFlexibleBox* LayoutFlexibleBox::createAnonymous(Document* document) { |
| LayoutFlexibleBox* layoutObject = new LayoutFlexibleBox(nullptr); |
| layoutObject->setDocumentForAnonymous(document); |
| return layoutObject; |
| } |
| |
| void LayoutFlexibleBox::computeIntrinsicLogicalWidths( |
| LayoutUnit& minLogicalWidth, |
| LayoutUnit& maxLogicalWidth) const { |
| // FIXME: We're ignoring flex-basis here and we shouldn't. We can't start |
| // honoring it though until the flex shorthand stops setting it to 0. See |
| // https://bugs.webkit.org/show_bug.cgi?id=116117 and |
| // https://crbug.com/240765. |
| float previousMaxContentFlexFraction = -1; |
| for (LayoutBox* child = firstChildBox(); child; |
| child = child->nextSiblingBox()) { |
| if (child->isOutOfFlowPositioned()) |
| continue; |
| |
| LayoutUnit margin = marginIntrinsicLogicalWidthForChild(*child); |
| |
| LayoutUnit minPreferredLogicalWidth; |
| LayoutUnit maxPreferredLogicalWidth; |
| computeChildPreferredLogicalWidths(*child, minPreferredLogicalWidth, |
| maxPreferredLogicalWidth); |
| DCHECK_GE(minPreferredLogicalWidth, LayoutUnit()); |
| DCHECK_GE(maxPreferredLogicalWidth, LayoutUnit()); |
| minPreferredLogicalWidth += margin; |
| maxPreferredLogicalWidth += margin; |
| if (!isColumnFlow()) { |
| maxLogicalWidth += maxPreferredLogicalWidth; |
| if (isMultiline()) { |
| // For multiline, the min preferred width is if you put a break between |
| // each item. |
| minLogicalWidth = std::max(minLogicalWidth, minPreferredLogicalWidth); |
| } else { |
| minLogicalWidth += minPreferredLogicalWidth; |
| } |
| } else { |
| minLogicalWidth = std::max(minPreferredLogicalWidth, minLogicalWidth); |
| maxLogicalWidth = std::max(maxPreferredLogicalWidth, maxLogicalWidth); |
| } |
| |
| previousMaxContentFlexFraction = countIntrinsicSizeForAlgorithmChange( |
| maxPreferredLogicalWidth, child, previousMaxContentFlexFraction); |
| } |
| |
| maxLogicalWidth = std::max(minLogicalWidth, maxLogicalWidth); |
| |
| // Due to negative margins, it is possible that we calculated a negative |
| // intrinsic width. Make sure that we never return a negative width. |
| minLogicalWidth = std::max(LayoutUnit(), minLogicalWidth); |
| maxLogicalWidth = std::max(LayoutUnit(), maxLogicalWidth); |
| |
| LayoutUnit scrollbarWidth(scrollbarLogicalWidth()); |
| maxLogicalWidth += scrollbarWidth; |
| minLogicalWidth += scrollbarWidth; |
| } |
| |
| float LayoutFlexibleBox::countIntrinsicSizeForAlgorithmChange( |
| LayoutUnit maxPreferredLogicalWidth, |
| LayoutBox* child, |
| float previousMaxContentFlexFraction) const { |
| // Determine whether the new version of the intrinsic size algorithm of the |
| // flexbox spec would produce a different result than our above algorithm. |
| // The algorithm produces a different result iff the max-content flex |
| // fraction (as defined in the new algorithm) is not identical for each flex |
| // item. |
| if (isColumnFlow()) |
| return previousMaxContentFlexFraction; |
| Length flexBasis = child->styleRef().flexBasis(); |
| float flexGrow = child->styleRef().flexGrow(); |
| // A flex-basis of auto will lead to a max-content flex fraction of zero, so |
| // just like an inflexible item it would compute to a size of max-content, so |
| // we ignore it here. |
| if (flexBasis.isAuto() || flexGrow == 0) |
| return previousMaxContentFlexFraction; |
| flexGrow = std::max(1.0f, flexGrow); |
| float maxContentFlexFraction = maxPreferredLogicalWidth.toFloat() / flexGrow; |
| if (previousMaxContentFlexFraction != -1 && |
| maxContentFlexFraction != previousMaxContentFlexFraction) |
| UseCounter::count(document(), |
| UseCounter::FlexboxIntrinsicSizeAlgorithmIsDifferent); |
| return maxContentFlexFraction; |
| } |
| |
| static int synthesizedBaselineFromContentBox(const LayoutBox& box, |
| LineDirectionMode direction) { |
| if (direction == HorizontalLine) { |
| return (box.size().height() - box.borderBottom() - box.paddingBottom() - |
| box.verticalScrollbarWidth()) |
| .toInt(); |
| } |
| return (box.size().width() - box.borderLeft() - box.paddingLeft() - |
| box.horizontalScrollbarHeight()) |
| .toInt(); |
| } |
| |
| int LayoutFlexibleBox::baselinePosition(FontBaseline, |
| bool, |
| LineDirectionMode direction, |
| LinePositionMode mode) const { |
| DCHECK_EQ(mode, PositionOnContainingLine); |
| int baseline = firstLineBoxBaseline(); |
| if (baseline == -1) |
| baseline = synthesizedBaselineFromContentBox(*this, direction); |
| |
| return beforeMarginInLineDirection(direction) + baseline; |
| } |
| |
| static const StyleContentAlignmentData& contentAlignmentNormalBehavior() { |
| // The justify-content property applies along the main axis, but since |
| // flexing in the main axis is controlled by flex, stretch behaves as |
| // flex-start (ignoring the specified fallback alignment, if any). |
| // https://drafts.csswg.org/css-align/#distribution-flex |
| static const StyleContentAlignmentData normalBehavior = { |
| ContentPositionNormal, ContentDistributionStretch}; |
| return normalBehavior; |
| } |
| |
| int LayoutFlexibleBox::firstLineBoxBaseline() const { |
| if (isWritingModeRoot() || m_numberOfInFlowChildrenOnFirstLine <= 0) |
| return -1; |
| LayoutBox* baselineChild = nullptr; |
| int childNumber = 0; |
| for (LayoutBox* child = m_orderIterator.first(); child; |
| child = m_orderIterator.next()) { |
| if (child->isOutOfFlowPositioned()) |
| continue; |
| if (alignmentForChild(*child) == ItemPositionBaseline && |
| !hasAutoMarginsInCrossAxis(*child)) { |
| baselineChild = child; |
| break; |
| } |
| if (!baselineChild) |
| baselineChild = child; |
| |
| ++childNumber; |
| if (childNumber == m_numberOfInFlowChildrenOnFirstLine) |
| break; |
| } |
| |
| if (!baselineChild) |
| return -1; |
| |
| if (!isColumnFlow() && hasOrthogonalFlow(*baselineChild)) |
| return (crossAxisExtentForChild(*baselineChild) + |
| baselineChild->logicalTop()) |
| .toInt(); |
| if (isColumnFlow() && !hasOrthogonalFlow(*baselineChild)) |
| return (mainAxisExtentForChild(*baselineChild) + |
| baselineChild->logicalTop()) |
| .toInt(); |
| |
| int baseline = baselineChild->firstLineBoxBaseline(); |
| if (baseline == -1) { |
| // FIXME: We should pass |direction| into firstLineBoxBaseline and stop |
| // bailing out if we're a writing mode root. This would also fix some |
| // cases where the flexbox is orthogonal to its container. |
| LineDirectionMode direction = |
| isHorizontalWritingMode() ? HorizontalLine : VerticalLine; |
| return (synthesizedBaselineFromContentBox(*baselineChild, direction) + |
| baselineChild->logicalTop()) |
| .toInt(); |
| } |
| |
| return (baseline + baselineChild->logicalTop()).toInt(); |
| } |
| |
| int LayoutFlexibleBox::inlineBlockBaseline(LineDirectionMode direction) const { |
| int baseline = firstLineBoxBaseline(); |
| if (baseline != -1) |
| return baseline; |
| |
| int marginAscent = |
| (direction == HorizontalLine ? marginTop() : marginRight()).toInt(); |
| return synthesizedBaselineFromContentBox(*this, direction) + marginAscent; |
| } |
| |
| IntSize LayoutFlexibleBox::originAdjustmentForScrollbars() const { |
| IntSize size; |
| int adjustmentWidth = verticalScrollbarWidth(); |
| int adjustmentHeight = horizontalScrollbarHeight(); |
| if (!adjustmentWidth && !adjustmentHeight) |
| return size; |
| |
| EFlexDirection flexDirection = style()->flexDirection(); |
| TextDirection textDirection = style()->direction(); |
| WritingMode writingMode = style()->getWritingMode(); |
| |
| if (flexDirection == FlowRow) { |
| if (textDirection == RTL) { |
| if (writingMode == TopToBottomWritingMode) |
| size.expand(adjustmentWidth, 0); |
| else |
| size.expand(0, adjustmentHeight); |
| } |
| if (writingMode == RightToLeftWritingMode) |
| size.expand(adjustmentWidth, 0); |
| } else if (flexDirection == FlowRowReverse) { |
| if (textDirection == LTR) { |
| if (writingMode == TopToBottomWritingMode) |
| size.expand(adjustmentWidth, 0); |
| else |
| size.expand(0, adjustmentHeight); |
| } |
| if (writingMode == RightToLeftWritingMode) |
| size.expand(adjustmentWidth, 0); |
| } else if (flexDirection == FlowColumn) { |
| if (writingMode == RightToLeftWritingMode) |
| size.expand(adjustmentWidth, 0); |
| } else { |
| if (writingMode == TopToBottomWritingMode) |
| size.expand(0, adjustmentHeight); |
| else if (writingMode == LeftToRightWritingMode) |
| size.expand(adjustmentWidth, 0); |
| } |
| return size; |
| } |
| |
| bool LayoutFlexibleBox::hasTopOverflow() const { |
| EFlexDirection flexDirection = style()->flexDirection(); |
| if (isHorizontalWritingMode()) |
| return flexDirection == FlowColumnReverse; |
| return flexDirection == |
| (style()->isLeftToRightDirection() ? FlowRowReverse : FlowRow); |
| } |
| |
| bool LayoutFlexibleBox::hasLeftOverflow() const { |
| EFlexDirection flexDirection = style()->flexDirection(); |
| if (isHorizontalWritingMode()) |
| return flexDirection == |
| (style()->isLeftToRightDirection() ? FlowRowReverse : FlowRow); |
| return flexDirection == FlowColumnReverse; |
| } |
| |
| void LayoutFlexibleBox::removeChild(LayoutObject* child) { |
| LayoutBlock::removeChild(child); |
| m_intrinsicSizeAlongMainAxis.remove(child); |
| } |
| |
| // TODO (lajava): Is this function still needed ? Every time the flex |
| // container's align-items value changes we propagate the diff to its children |
| // (see ComputedStyle::stylePropagationDiff). |
| void LayoutFlexibleBox::styleDidChange(StyleDifference diff, |
| const ComputedStyle* oldStyle) { |
| LayoutBlock::styleDidChange(diff, oldStyle); |
| |
| if (oldStyle && oldStyle->alignItemsPosition() == ItemPositionStretch && |
| diff.needsFullLayout()) { |
| // Flex items that were previously stretching need to be relayed out so we |
| // can compute new available cross axis space. This is only necessary for |
| // stretching since other alignment values don't change the size of the |
| // box. |
| for (LayoutBox* child = firstChildBox(); child; |
| child = child->nextSiblingBox()) { |
| ItemPosition previousAlignment = |
| child->styleRef() |
| .resolvedAlignSelf(selfAlignmentNormalBehavior(), oldStyle) |
| .position(); |
| if (previousAlignment == ItemPositionStretch && |
| previousAlignment != |
| child->styleRef() |
| .resolvedAlignSelf(selfAlignmentNormalBehavior(), style()) |
| .position()) |
| child->setChildNeedsLayout(MarkOnlyThis); |
| } |
| } |
| } |
| |
| void LayoutFlexibleBox::layoutBlock(bool relayoutChildren) { |
| DCHECK(needsLayout()); |
| |
| if (!relayoutChildren && simplifiedLayout()) |
| return; |
| |
| m_relaidOutChildren.clear(); |
| |
| if (updateLogicalWidthAndColumnWidth()) |
| relayoutChildren = true; |
| |
| SubtreeLayoutScope layoutScope(*this); |
| LayoutUnit previousHeight = logicalHeight(); |
| setLogicalHeight(borderAndPaddingLogicalHeight() + scrollbarLogicalHeight()); |
| |
| PaintLayerScrollableArea::DelayScrollOffsetClampScope delayClampScope; |
| |
| { |
| TextAutosizer::LayoutScope textAutosizerLayoutScope(this, &layoutScope); |
| LayoutState state(*this); |
| |
| m_numberOfInFlowChildrenOnFirstLine = -1; |
| |
| prepareOrderIteratorAndMargins(); |
| |
| layoutFlexItems(relayoutChildren, layoutScope); |
| if (PaintLayerScrollableArea::PreventRelayoutScope::relayoutNeeded()) { |
| PaintLayerScrollableArea::FreezeScrollbarsScope freezeScrollbarsScope; |
| prepareOrderIteratorAndMargins(); |
| layoutFlexItems(true, layoutScope); |
| PaintLayerScrollableArea::PreventRelayoutScope::resetRelayoutNeeded(); |
| } |
| |
| if (logicalHeight() != previousHeight) |
| relayoutChildren = true; |
| |
| layoutPositionedObjects(relayoutChildren || isDocumentElement()); |
| |
| // FIXME: css3/flexbox/repaint-rtl-column.html seems to issue paint |
| // invalidations for more overflow than it needs to. |
| computeOverflow(clientLogicalBottomAfterRepositioning()); |
| } |
| |
| updateLayerTransformAfterLayout(); |
| |
| // Update our scroll information if we're overflow:auto/scroll/hidden now |
| // that we know if we overflow or not. |
| updateAfterLayout(); |
| |
| clearNeedsLayout(); |
| |
| // We have to reset this, because changes to our ancestors' style can affect |
| // this value. |
| m_hasDefiniteHeight = SizeDefiniteness::Unknown; |
| } |
| |
| void LayoutFlexibleBox::paintChildren(const PaintInfo& paintInfo, |
| const LayoutPoint& paintOffset) const { |
| BlockPainter::paintChildrenOfFlexibleBox(*this, paintInfo, paintOffset); |
| } |
| |
| void LayoutFlexibleBox::repositionLogicalHeightDependentFlexItems( |
| Vector<LineContext>& lineContexts) { |
| LayoutUnit crossAxisStartEdge = |
| lineContexts.isEmpty() ? LayoutUnit() : lineContexts[0].crossAxisOffset; |
| alignFlexLines(lineContexts); |
| |
| alignChildren(lineContexts); |
| |
| if (style()->flexWrap() == FlexWrapReverse) |
| flipForWrapReverse(lineContexts, crossAxisStartEdge); |
| |
| // direction:rtl + flex-direction:column means the cross-axis direction is |
| // flipped. |
| flipForRightToLeftColumn(lineContexts); |
| } |
| |
| DISABLE_CFI_PERF |
| LayoutUnit LayoutFlexibleBox::clientLogicalBottomAfterRepositioning() { |
| LayoutUnit maxChildLogicalBottom; |
| for (LayoutBox* child = firstChildBox(); child; |
| child = child->nextSiblingBox()) { |
| if (child->isOutOfFlowPositioned()) |
| continue; |
| LayoutUnit childLogicalBottom = logicalTopForChild(*child) + |
| logicalHeightForChild(*child) + |
| marginAfterForChild(*child); |
| maxChildLogicalBottom = std::max(maxChildLogicalBottom, childLogicalBottom); |
| } |
| return std::max(clientLogicalBottom(), |
| maxChildLogicalBottom + paddingAfter()); |
| } |
| |
| bool LayoutFlexibleBox::hasOrthogonalFlow(const LayoutBox& child) const { |
| return isHorizontalFlow() != child.isHorizontalWritingMode(); |
| } |
| |
| bool LayoutFlexibleBox::isColumnFlow() const { |
| return style()->isColumnFlexDirection(); |
| } |
| |
| bool LayoutFlexibleBox::isHorizontalFlow() const { |
| if (isHorizontalWritingMode()) |
| return !isColumnFlow(); |
| return isColumnFlow(); |
| } |
| |
| bool LayoutFlexibleBox::isLeftToRightFlow() const { |
| if (isColumnFlow()) |
| return style()->getWritingMode() == TopToBottomWritingMode || |
| style()->getWritingMode() == LeftToRightWritingMode; |
| return style()->isLeftToRightDirection() ^ |
| (style()->flexDirection() == FlowRowReverse); |
| } |
| |
| bool LayoutFlexibleBox::isMultiline() const { |
| return style()->flexWrap() != FlexNoWrap; |
| } |
| |
| Length LayoutFlexibleBox::flexBasisForChild(const LayoutBox& child) const { |
| Length flexLength = child.style()->flexBasis(); |
| if (flexLength.isAuto()) |
| flexLength = |
| isHorizontalFlow() ? child.style()->width() : child.style()->height(); |
| return flexLength; |
| } |
| |
| LayoutUnit LayoutFlexibleBox::crossAxisExtentForChild( |
| const LayoutBox& child) const { |
| return isHorizontalFlow() ? child.size().height() : child.size().width(); |
| } |
| |
| static inline LayoutUnit constrainedChildIntrinsicContentLogicalHeight( |
| const LayoutBox& child, |
| LayoutUnit childIntrinsicContentLogicalHeight) { |
| // TODO(cbiesinger): scrollbar height? |
| return child.constrainLogicalHeightByMinMax( |
| childIntrinsicContentLogicalHeight + |
| child.borderAndPaddingLogicalHeight(), |
| childIntrinsicContentLogicalHeight); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::childIntrinsicLogicalHeight( |
| const LayoutBox& child) const { |
| // This should only be called if the logical height is the cross size |
| DCHECK(!hasOrthogonalFlow(child)); |
| if (needToStretchChildLogicalHeight(child)) { |
| LayoutUnit childIntrinsicContentLogicalHeight; |
| if (!child.styleRef().containsSize()) |
| childIntrinsicContentLogicalHeight = |
| child.intrinsicContentLogicalHeight(); |
| return constrainedChildIntrinsicContentLogicalHeight( |
| child, childIntrinsicContentLogicalHeight); |
| } |
| return child.logicalHeight(); |
| } |
| |
| DISABLE_CFI_PERF |
| LayoutUnit LayoutFlexibleBox::childIntrinsicLogicalWidth( |
| const LayoutBox& child) const { |
| // This should only be called if the logical width is the cross size |
| DCHECK(hasOrthogonalFlow(child)); |
| // If our height is auto, make sure that our returned height is unaffected by |
| // earlier layouts by returning the max preferred logical width |
| if (!crossAxisLengthIsDefinite(child, child.styleRef().logicalWidth())) |
| return child.maxPreferredLogicalWidth(); |
| |
| return child.logicalWidth(); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::crossAxisIntrinsicExtentForChild( |
| const LayoutBox& child) const { |
| return hasOrthogonalFlow(child) ? childIntrinsicLogicalWidth(child) |
| : childIntrinsicLogicalHeight(child); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::mainAxisExtentForChild( |
| const LayoutBox& child) const { |
| return isHorizontalFlow() ? child.size().width() : child.size().height(); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::mainAxisContentExtentForChildIncludingScrollbar( |
| const LayoutBox& child) const { |
| return isHorizontalFlow() |
| ? child.contentWidth() + child.verticalScrollbarWidth() |
| : child.contentHeight() + child.horizontalScrollbarHeight(); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::crossAxisExtent() const { |
| return isHorizontalFlow() ? size().height() : size().width(); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::mainAxisExtent() const { |
| return isHorizontalFlow() ? size().width() : size().height(); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::crossAxisContentExtent() const { |
| return isHorizontalFlow() ? contentHeight() : contentWidth(); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::mainAxisContentExtent( |
| LayoutUnit contentLogicalHeight) { |
| if (isColumnFlow()) { |
| LogicalExtentComputedValues computedValues; |
| LayoutUnit borderPaddingAndScrollbar = |
| borderAndPaddingLogicalHeight() + scrollbarLogicalHeight(); |
| LayoutUnit borderBoxLogicalHeight = |
| contentLogicalHeight + borderPaddingAndScrollbar; |
| computeLogicalHeight(borderBoxLogicalHeight, logicalTop(), computedValues); |
| if (computedValues.m_extent == LayoutUnit::max()) |
| return computedValues.m_extent; |
| return std::max(LayoutUnit(), |
| computedValues.m_extent - borderPaddingAndScrollbar); |
| } |
| return contentLogicalWidth(); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::computeMainAxisExtentForChild( |
| const LayoutBox& child, |
| SizeType sizeType, |
| const Length& size) { |
| // If we have a horizontal flow, that means the main size is the width. |
| // That's the logical width for horizontal writing modes, and the logical |
| // height in vertical writing modes. For a vertical flow, main size is the |
| // height, so it's the inverse. So we need the logical width if we have a |
| // horizontal flow and horizontal writing mode, or vertical flow and vertical |
| // writing mode. Otherwise we need the logical height. |
| if (isHorizontalFlow() != child.styleRef().isHorizontalWritingMode()) { |
| // We don't have to check for "auto" here - computeContentLogicalHeight |
| // will just return -1 for that case anyway. It's safe to access |
| // scrollbarLogicalHeight here because ComputeNextFlexLine will have |
| // already forced layout on the child. We previously layed out the child |
| // if necessary (see ComputeNextFlexLine and the call to |
| // childHasIntrinsicMainAxisSize) so we can be sure that the two height |
| // calls here will return up-to-date data. |
| return child.computeContentLogicalHeight( |
| sizeType, size, child.intrinsicContentLogicalHeight()) + |
| child.scrollbarLogicalHeight(); |
| } |
| // computeLogicalWidth always re-computes the intrinsic widths. However, when |
| // our logical width is auto, we can just use our cached value. So let's do |
| // that here. (Compare code in LayoutBlock::computePreferredLogicalWidths) |
| LayoutUnit borderAndPadding = child.borderAndPaddingLogicalWidth(); |
| if (child.styleRef().logicalWidth().isAuto() && !hasAspectRatio(child)) { |
| if (size.type() == MinContent) |
| return child.minPreferredLogicalWidth() - borderAndPadding; |
| if (size.type() == MaxContent) |
| return child.maxPreferredLogicalWidth() - borderAndPadding; |
| } |
| return child.computeLogicalWidthUsing(sizeType, size, contentLogicalWidth(), |
| this) - |
| borderAndPadding; |
| } |
| |
| LayoutFlexibleBox::TransformedWritingMode |
| LayoutFlexibleBox::getTransformedWritingMode() const { |
| WritingMode mode = style()->getWritingMode(); |
| if (!isColumnFlow()) { |
| static_assert( |
| static_cast<TransformedWritingMode>(TopToBottomWritingMode) == |
| TransformedWritingMode::TopToBottomWritingMode && |
| static_cast<TransformedWritingMode>(LeftToRightWritingMode) == |
| TransformedWritingMode::LeftToRightWritingMode && |
| static_cast<TransformedWritingMode>(RightToLeftWritingMode) == |
| TransformedWritingMode::RightToLeftWritingMode, |
| "WritingMode and TransformedWritingMode must match values."); |
| return static_cast<TransformedWritingMode>(mode); |
| } |
| |
| switch (mode) { |
| case TopToBottomWritingMode: |
| return style()->isLeftToRightDirection() |
| ? TransformedWritingMode::LeftToRightWritingMode |
| : TransformedWritingMode::RightToLeftWritingMode; |
| case LeftToRightWritingMode: |
| case RightToLeftWritingMode: |
| return style()->isLeftToRightDirection() |
| ? TransformedWritingMode::TopToBottomWritingMode |
| : TransformedWritingMode::BottomToTopWritingMode; |
| } |
| NOTREACHED(); |
| return TransformedWritingMode::TopToBottomWritingMode; |
| } |
| |
| LayoutUnit LayoutFlexibleBox::flowAwareBorderStart() const { |
| if (isHorizontalFlow()) |
| return LayoutUnit(isLeftToRightFlow() ? borderLeft() : borderRight()); |
| return LayoutUnit(isLeftToRightFlow() ? borderTop() : borderBottom()); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::flowAwareBorderEnd() const { |
| if (isHorizontalFlow()) |
| return LayoutUnit(isLeftToRightFlow() ? borderRight() : borderLeft()); |
| return LayoutUnit(isLeftToRightFlow() ? borderBottom() : borderTop()); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::flowAwareBorderBefore() const { |
| switch (getTransformedWritingMode()) { |
| case TransformedWritingMode::TopToBottomWritingMode: |
| return LayoutUnit(borderTop()); |
| case TransformedWritingMode::BottomToTopWritingMode: |
| return LayoutUnit(borderBottom()); |
| case TransformedWritingMode::LeftToRightWritingMode: |
| return LayoutUnit(borderLeft()); |
| case TransformedWritingMode::RightToLeftWritingMode: |
| return LayoutUnit(borderRight()); |
| } |
| NOTREACHED(); |
| return LayoutUnit(borderTop()); |
| } |
| |
| DISABLE_CFI_PERF |
| LayoutUnit LayoutFlexibleBox::flowAwareBorderAfter() const { |
| switch (getTransformedWritingMode()) { |
| case TransformedWritingMode::TopToBottomWritingMode: |
| return LayoutUnit(borderBottom()); |
| case TransformedWritingMode::BottomToTopWritingMode: |
| return LayoutUnit(borderTop()); |
| case TransformedWritingMode::LeftToRightWritingMode: |
| return LayoutUnit(borderRight()); |
| case TransformedWritingMode::RightToLeftWritingMode: |
| return LayoutUnit(borderLeft()); |
| } |
| NOTREACHED(); |
| return LayoutUnit(borderTop()); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::flowAwarePaddingStart() const { |
| if (isHorizontalFlow()) |
| return isLeftToRightFlow() ? paddingLeft() : paddingRight(); |
| return isLeftToRightFlow() ? paddingTop() : paddingBottom(); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::flowAwarePaddingEnd() const { |
| if (isHorizontalFlow()) |
| return isLeftToRightFlow() ? paddingRight() : paddingLeft(); |
| return isLeftToRightFlow() ? paddingBottom() : paddingTop(); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::flowAwarePaddingBefore() const { |
| switch (getTransformedWritingMode()) { |
| case TransformedWritingMode::TopToBottomWritingMode: |
| return paddingTop(); |
| case TransformedWritingMode::BottomToTopWritingMode: |
| return paddingBottom(); |
| case TransformedWritingMode::LeftToRightWritingMode: |
| return paddingLeft(); |
| case TransformedWritingMode::RightToLeftWritingMode: |
| return paddingRight(); |
| } |
| NOTREACHED(); |
| return paddingTop(); |
| } |
| |
| DISABLE_CFI_PERF |
| LayoutUnit LayoutFlexibleBox::flowAwarePaddingAfter() const { |
| switch (getTransformedWritingMode()) { |
| case TransformedWritingMode::TopToBottomWritingMode: |
| return paddingBottom(); |
| case TransformedWritingMode::BottomToTopWritingMode: |
| return paddingTop(); |
| case TransformedWritingMode::LeftToRightWritingMode: |
| return paddingRight(); |
| case TransformedWritingMode::RightToLeftWritingMode: |
| return paddingLeft(); |
| } |
| NOTREACHED(); |
| return paddingTop(); |
| } |
| |
| DISABLE_CFI_PERF |
| LayoutUnit LayoutFlexibleBox::flowAwareMarginStartForChild( |
| const LayoutBox& child) const { |
| if (isHorizontalFlow()) |
| return isLeftToRightFlow() ? child.marginLeft() : child.marginRight(); |
| return isLeftToRightFlow() ? child.marginTop() : child.marginBottom(); |
| } |
| |
| DISABLE_CFI_PERF |
| LayoutUnit LayoutFlexibleBox::flowAwareMarginEndForChild( |
| const LayoutBox& child) const { |
| if (isHorizontalFlow()) |
| return isLeftToRightFlow() ? child.marginRight() : child.marginLeft(); |
| return isLeftToRightFlow() ? child.marginBottom() : child.marginTop(); |
| } |
| |
| DISABLE_CFI_PERF |
| LayoutUnit LayoutFlexibleBox::flowAwareMarginBeforeForChild( |
| const LayoutBox& child) const { |
| switch (getTransformedWritingMode()) { |
| case TransformedWritingMode::TopToBottomWritingMode: |
| return child.marginTop(); |
| case TransformedWritingMode::BottomToTopWritingMode: |
| return child.marginBottom(); |
| case TransformedWritingMode::LeftToRightWritingMode: |
| return child.marginLeft(); |
| case TransformedWritingMode::RightToLeftWritingMode: |
| return child.marginRight(); |
| } |
| NOTREACHED(); |
| return marginTop(); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::crossAxisMarginExtentForChild( |
| const LayoutBox& child) const { |
| return isHorizontalFlow() ? child.marginHeight() : child.marginWidth(); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::crossAxisScrollbarExtent() const { |
| return LayoutUnit(isHorizontalFlow() ? horizontalScrollbarHeight() |
| : verticalScrollbarWidth()); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::crossAxisScrollbarExtentForChild( |
| const LayoutBox& child) const { |
| return LayoutUnit(isHorizontalFlow() ? child.horizontalScrollbarHeight() |
| : child.verticalScrollbarWidth()); |
| } |
| |
| LayoutPoint LayoutFlexibleBox::flowAwareLocationForChild( |
| const LayoutBox& child) const { |
| return isHorizontalFlow() ? child.location() |
| : child.location().transposedPoint(); |
| } |
| |
| bool LayoutFlexibleBox::useChildAspectRatio(const LayoutBox& child) const { |
| if (!hasAspectRatio(child)) |
| return false; |
| if (child.intrinsicSize().height() == 0) { |
| // We can't compute a ratio in this case. |
| return false; |
| } |
| Length crossSize; |
| if (isHorizontalFlow()) |
| crossSize = child.styleRef().height(); |
| else |
| crossSize = child.styleRef().width(); |
| return crossAxisLengthIsDefinite(child, crossSize); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::computeMainSizeFromAspectRatioUsing( |
| const LayoutBox& child, |
| Length crossSizeLength) const { |
| DCHECK(hasAspectRatio(child)); |
| DCHECK_NE(child.intrinsicSize().height(), 0); |
| |
| LayoutUnit crossSize; |
| if (crossSizeLength.isFixed()) { |
| crossSize = LayoutUnit(crossSizeLength.value()); |
| } else { |
| DCHECK(crossSizeLength.isPercentOrCalc()); |
| crossSize = hasOrthogonalFlow(child) |
| ? adjustBorderBoxLogicalWidthForBoxSizing( |
| valueForLength(crossSizeLength, contentWidth())) |
| : child.computePercentageLogicalHeight(crossSizeLength); |
| } |
| |
| const LayoutSize& childIntrinsicSize = child.intrinsicSize(); |
| double ratio = childIntrinsicSize.width().toFloat() / |
| childIntrinsicSize.height().toFloat(); |
| if (isHorizontalFlow()) |
| return LayoutUnit(crossSize * ratio); |
| return LayoutUnit(crossSize / ratio); |
| } |
| |
| void LayoutFlexibleBox::setFlowAwareLocationForChild( |
| LayoutBox& child, |
| const LayoutPoint& location) { |
| if (isHorizontalFlow()) |
| child.setLocationAndUpdateOverflowControlsIfNeeded(location); |
| else |
| child.setLocationAndUpdateOverflowControlsIfNeeded( |
| location.transposedPoint()); |
| } |
| |
| bool LayoutFlexibleBox::mainAxisLengthIsDefinite( |
| const LayoutBox& child, |
| const Length& flexBasis) const { |
| if (flexBasis.isAuto()) |
| return false; |
| if (flexBasis.isPercentOrCalc()) { |
| if (!isColumnFlow() || m_hasDefiniteHeight == SizeDefiniteness::Definite) |
| return true; |
| if (m_hasDefiniteHeight == SizeDefiniteness::Indefinite) |
| return false; |
| bool definite = child.computePercentageLogicalHeight(flexBasis) != -1; |
| m_hasDefiniteHeight = |
| definite ? SizeDefiniteness::Definite : SizeDefiniteness::Indefinite; |
| return definite; |
| } |
| return true; |
| } |
| |
| bool LayoutFlexibleBox::crossAxisLengthIsDefinite(const LayoutBox& child, |
| const Length& length) const { |
| if (length.isAuto()) |
| return false; |
| if (length.isPercentOrCalc()) { |
| if (hasOrthogonalFlow(child) || |
| m_hasDefiniteHeight == SizeDefiniteness::Definite) |
| return true; |
| if (m_hasDefiniteHeight == SizeDefiniteness::Indefinite) |
| return false; |
| bool definite = child.computePercentageLogicalHeight(length) != -1; |
| m_hasDefiniteHeight = |
| definite ? SizeDefiniteness::Definite : SizeDefiniteness::Indefinite; |
| return definite; |
| } |
| // TODO(cbiesinger): Eventually we should support other types of sizes here. |
| // Requires updating computeMainSizeFromAspectRatioUsing. |
| return length.isFixed(); |
| } |
| |
| void LayoutFlexibleBox::cacheChildMainSize(const LayoutBox& child) { |
| DCHECK(!child.needsLayout()); |
| LayoutUnit mainSize; |
| if (hasOrthogonalFlow(child)) { |
| mainSize = child.logicalHeight(); |
| } else { |
| // The max preferred logical width includes the intrinsic scrollbar logical |
| // width, which is only set for overflow: scroll. To handle overflow: auto, |
| // we have to take scrollbarLogicalWidth() into account, and then subtract |
| // the intrinsic width again so as to not double-count overflow: scroll |
| // scrollbars. |
| mainSize = child.maxPreferredLogicalWidth() + |
| child.scrollbarLogicalWidth() - child.scrollbarLogicalWidth(); |
| } |
| m_intrinsicSizeAlongMainAxis.set(&child, mainSize); |
| m_relaidOutChildren.add(&child); |
| } |
| |
| void LayoutFlexibleBox::clearCachedMainSizeForChild(const LayoutBox& child) { |
| m_intrinsicSizeAlongMainAxis.remove(&child); |
| } |
| |
| DISABLE_CFI_PERF |
| LayoutUnit LayoutFlexibleBox::computeInnerFlexBaseSizeForChild( |
| LayoutBox& child, |
| LayoutUnit mainAxisBorderAndPadding, |
| ChildLayoutType childLayoutType) { |
| child.clearOverrideSize(); |
| |
| if (child.isImage() || child.isVideo() || child.isCanvas()) |
| UseCounter::count(document(), UseCounter::AspectRatioFlexItem); |
| |
| Length flexBasis = flexBasisForChild(child); |
| if (mainAxisLengthIsDefinite(child, flexBasis)) |
| return std::max(LayoutUnit(), computeMainAxisExtentForChild( |
| child, MainOrPreferredSize, flexBasis)); |
| |
| if (child.styleRef().containsSize()) |
| return LayoutUnit(); |
| |
| // The flex basis is indefinite (=auto), so we need to compute the actual |
| // width of the child. For the logical width axis we just use the preferred |
| // width; for the height we need to lay out the child. |
| LayoutUnit mainAxisExtent; |
| if (hasOrthogonalFlow(child)) { |
| if (childLayoutType == NeverLayout) |
| return LayoutUnit(); |
| |
| updateBlockChildDirtyBitsBeforeLayout(childLayoutType == ForceLayout, |
| child); |
| if (child.needsLayout() || childLayoutType == ForceLayout || |
| !m_intrinsicSizeAlongMainAxis.contains(&child)) { |
| child.forceChildLayout(); |
| cacheChildMainSize(child); |
| } |
| mainAxisExtent = m_intrinsicSizeAlongMainAxis.get(&child); |
| } else { |
| // We don't need to add scrollbarLogicalWidth here because the preferred |
| // width includes the scrollbar, even for overflow: auto. |
| mainAxisExtent = child.maxPreferredLogicalWidth(); |
| } |
| DCHECK_GE(mainAxisExtent - mainAxisBorderAndPadding, LayoutUnit()) |
| << mainAxisExtent << " - " << mainAxisBorderAndPadding; |
| return mainAxisExtent - mainAxisBorderAndPadding; |
| } |
| |
| void LayoutFlexibleBox::layoutFlexItems(bool relayoutChildren, |
| SubtreeLayoutScope& layoutScope) { |
| Vector<LineContext> lineContexts; |
| LayoutUnit sumFlexBaseSize; |
| double totalFlexGrow; |
| double totalFlexShrink; |
| double totalWeightedFlexShrink; |
| LayoutUnit sumHypotheticalMainSize; |
| |
| PaintLayerScrollableArea::PreventRelayoutScope preventRelayoutScope( |
| layoutScope); |
| |
| |
| // Set up our master list of flex items. All of the rest of the algorithm |
| // should work off this list of a subset. |
| // TODO(cbiesinger): That second part is not yet true. |
| ChildLayoutType layoutType = relayoutChildren ? ForceLayout : LayoutIfNeeded; |
| Vector<FlexItem> allItems; |
| 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)); |
| } |
| |
| 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, |
| totalWeightedFlexShrink, sumHypotheticalMainSize)) { |
| DCHECK_GE(lineItems.size(), 0ULL); |
| LayoutUnit containerMainInnerSize = |
| mainAxisContentExtent(sumHypotheticalMainSize); |
| // availableFreeSpace is the initial amount of free space in this flexbox. |
| // remainingFreeSpace starts out at the same value but as we place and lay |
| // out flex items we subtract from it. Note that both values can be |
| // negative. |
| LayoutUnit remainingFreeSpace = containerMainInnerSize - sumFlexBaseSize; |
| FlexSign flexSign = (sumHypotheticalMainSize < containerMainInnerSize) |
| ? PositiveFlexibility |
| : NegativeFlexibility; |
| freezeInflexibleItems(flexSign, lineItems, remainingFreeSpace, |
| totalFlexGrow, totalFlexShrink, |
| totalWeightedFlexShrink); |
| // The initial free space gets calculated after freezing inflexible items. |
| // https://drafts.csswg.org/css-flexbox/#resolve-flexible-lengths step 3 |
| const LayoutUnit initialFreeSpace = remainingFreeSpace; |
| while (!resolveFlexibleLengths(flexSign, lineItems, initialFreeSpace, |
| remainingFreeSpace, totalFlexGrow, |
| totalFlexShrink, totalWeightedFlexShrink)) { |
| DCHECK_GE(totalFlexGrow, 0); |
| DCHECK_GE(totalWeightedFlexShrink, 0); |
| } |
| |
| // Recalculate the remaining free space. The adjustment for flex factors |
| // between 0..1 means we can't just use remainingFreeSpace here. |
| remainingFreeSpace = containerMainInnerSize; |
| for (size_t i = 0; i < lineItems.size(); ++i) { |
| FlexItem& flexItem = lineItems[i]; |
| DCHECK(!flexItem.box->isOutOfFlowPositioned()); |
| remainingFreeSpace -= flexItem.flexedMarginBoxSize(); |
| } |
| // This will std::move lineItems into a newly-created LineContext. |
| layoutAndPlaceChildren(crossAxisOffset, lineItems, remainingFreeSpace, |
| relayoutChildren, layoutScope, lineContexts); |
| } |
| if (hasLineIfEmpty()) { |
| // Even if ComputeNextFlexLine returns true, the flexbox might not have |
| // a line because all our children might be out of flow positioned. |
| // Instead of just checking if we have a line, make sure the flexbox |
| // has at least a line's worth of height to cover this case. |
| LayoutUnit minHeight = minimumLogicalHeightForEmptyLine(); |
| if (size().height() < minHeight) |
| setLogicalHeight(minHeight); |
| } |
| |
| updateLogicalHeight(); |
| repositionLogicalHeightDependentFlexItems(lineContexts); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::autoMarginOffsetInMainAxis( |
| const Vector<FlexItem>& children, |
| LayoutUnit& availableFreeSpace) { |
| if (availableFreeSpace <= LayoutUnit()) |
| return LayoutUnit(); |
| |
| int numberOfAutoMargins = 0; |
| bool isHorizontal = isHorizontalFlow(); |
| for (size_t i = 0; i < children.size(); ++i) { |
| LayoutBox* child = children[i].box; |
| DCHECK(!child->isOutOfFlowPositioned()); |
| if (isHorizontal) { |
| if (child->style()->marginLeft().isAuto()) |
| ++numberOfAutoMargins; |
| if (child->style()->marginRight().isAuto()) |
| ++numberOfAutoMargins; |
| } else { |
| if (child->style()->marginTop().isAuto()) |
| ++numberOfAutoMargins; |
| if (child->style()->marginBottom().isAuto()) |
| ++numberOfAutoMargins; |
| } |
| } |
| if (!numberOfAutoMargins) |
| return LayoutUnit(); |
| |
| LayoutUnit sizeOfAutoMargin = availableFreeSpace / numberOfAutoMargins; |
| availableFreeSpace = LayoutUnit(); |
| return sizeOfAutoMargin; |
| } |
| |
| void LayoutFlexibleBox::updateAutoMarginsInMainAxis( |
| LayoutBox& child, |
| LayoutUnit autoMarginOffset) { |
| DCHECK_GE(autoMarginOffset, LayoutUnit()); |
| |
| if (isHorizontalFlow()) { |
| if (child.style()->marginLeft().isAuto()) |
| child.setMarginLeft(autoMarginOffset); |
| if (child.style()->marginRight().isAuto()) |
| child.setMarginRight(autoMarginOffset); |
| } else { |
| if (child.style()->marginTop().isAuto()) |
| child.setMarginTop(autoMarginOffset); |
| if (child.style()->marginBottom().isAuto()) |
| child.setMarginBottom(autoMarginOffset); |
| } |
| } |
| |
| bool LayoutFlexibleBox::hasAutoMarginsInCrossAxis( |
| const LayoutBox& child) const { |
| if (isHorizontalFlow()) |
| return child.style()->marginTop().isAuto() || |
| child.style()->marginBottom().isAuto(); |
| return child.style()->marginLeft().isAuto() || |
| child.style()->marginRight().isAuto(); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::availableAlignmentSpaceForChild( |
| LayoutUnit lineCrossAxisExtent, |
| const LayoutBox& child) { |
| DCHECK(!child.isOutOfFlowPositioned()); |
| LayoutUnit childCrossExtent = |
| crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child); |
| return lineCrossAxisExtent - childCrossExtent; |
| } |
| |
| LayoutUnit LayoutFlexibleBox::availableAlignmentSpaceForChildBeforeStretching( |
| LayoutUnit lineCrossAxisExtent, |
| const LayoutBox& child) { |
| DCHECK(!child.isOutOfFlowPositioned()); |
| LayoutUnit childCrossExtent = crossAxisMarginExtentForChild(child) + |
| crossAxisIntrinsicExtentForChild(child); |
| return lineCrossAxisExtent - childCrossExtent; |
| } |
| |
| bool LayoutFlexibleBox::updateAutoMarginsInCrossAxis( |
| LayoutBox& child, |
| LayoutUnit availableAlignmentSpace) { |
| DCHECK(!child.isOutOfFlowPositioned()); |
| DCHECK_GE(availableAlignmentSpace, LayoutUnit()); |
| |
| bool isHorizontal = isHorizontalFlow(); |
| Length topOrLeft = |
| isHorizontal ? child.style()->marginTop() : child.style()->marginLeft(); |
| Length bottomOrRight = isHorizontal ? child.style()->marginBottom() |
| : child.style()->marginRight(); |
| if (topOrLeft.isAuto() && bottomOrRight.isAuto()) { |
| adjustAlignmentForChild(child, availableAlignmentSpace / 2); |
| if (isHorizontal) { |
| child.setMarginTop(availableAlignmentSpace / 2); |
| child.setMarginBottom(availableAlignmentSpace / 2); |
| } else { |
| child.setMarginLeft(availableAlignmentSpace / 2); |
| child.setMarginRight(availableAlignmentSpace / 2); |
| } |
| return true; |
| } |
| bool shouldAdjustTopOrLeft = true; |
| if (isColumnFlow() && !child.style()->isLeftToRightDirection()) { |
| // For column flows, only make this adjustment if topOrLeft corresponds to |
| // the "before" margin, so that flipForRightToLeftColumn will do the right |
| // thing. |
| shouldAdjustTopOrLeft = false; |
| } |
| if (!isColumnFlow() && child.style()->isFlippedBlocksWritingMode()) { |
| // If we are a flipped writing mode, we need to adjust the opposite side. |
| // This is only needed for row flows because this only affects the |
| // block-direction axis. |
| shouldAdjustTopOrLeft = false; |
| } |
| |
| if (topOrLeft.isAuto()) { |
| if (shouldAdjustTopOrLeft) |
| adjustAlignmentForChild(child, availableAlignmentSpace); |
| |
| if (isHorizontal) |
| child.setMarginTop(availableAlignmentSpace); |
| else |
| child.setMarginLeft(availableAlignmentSpace); |
| return true; |
| } |
| if (bottomOrRight.isAuto()) { |
| if (!shouldAdjustTopOrLeft) |
| adjustAlignmentForChild(child, availableAlignmentSpace); |
| |
| if (isHorizontal) |
| child.setMarginBottom(availableAlignmentSpace); |
| else |
| child.setMarginRight(availableAlignmentSpace); |
| return true; |
| } |
| return false; |
| } |
| |
| DISABLE_CFI_PERF |
| LayoutUnit LayoutFlexibleBox::marginBoxAscentForChild(const LayoutBox& child) { |
| LayoutUnit ascent(child.firstLineBoxBaseline()); |
| if (ascent == -1) |
| ascent = crossAxisExtentForChild(child); |
| return ascent + flowAwareMarginBeforeForChild(child); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::computeChildMarginValue(Length margin) { |
| // 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); |
| } |
| |
| void LayoutFlexibleBox::prepareOrderIteratorAndMargins() { |
| OrderIteratorPopulator populator(m_orderIterator); |
| |
| for (LayoutBox* child = firstChildBox(); child; |
| child = child->nextSiblingBox()) { |
| 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())); |
| child->setMarginRight( |
| computeChildMarginValue(child->style()->marginRight())); |
| } else { |
| child->setMarginTop(computeChildMarginValue(child->style()->marginTop())); |
| child->setMarginBottom( |
| computeChildMarginValue(child->style()->marginBottom())); |
| } |
| } |
| } |
| |
| DISABLE_CFI_PERF |
| LayoutUnit LayoutFlexibleBox::adjustChildSizeForMinAndMax( |
| const LayoutBox& child, |
| LayoutUnit childSize) { |
| Length max = isHorizontalFlow() ? child.style()->maxWidth() |
| : child.style()->maxHeight(); |
| LayoutUnit maxExtent(-1); |
| if (max.isSpecifiedOrIntrinsic()) { |
| maxExtent = computeMainAxisExtentForChild(child, MaxSize, max); |
| DCHECK_GE(maxExtent, LayoutUnit(-1)); |
| if (maxExtent != -1 && childSize > maxExtent) |
| childSize = maxExtent; |
| } |
| |
| Length min = isHorizontalFlow() ? child.style()->minWidth() |
| : child.style()->minHeight(); |
| LayoutUnit minExtent; |
| if (min.isSpecifiedOrIntrinsic()) { |
| minExtent = computeMainAxisExtentForChild(child, MinSize, min); |
| // computeMainAxisExtentForChild can return -1 when the child has a |
| // percentage min size, but we have an indefinite size in that axis. |
| minExtent = std::max(LayoutUnit(), minExtent); |
| } else if (min.isAuto() && !child.styleRef().containsSize() && |
| mainAxisOverflowForChild(child) == EOverflow::Visible && |
| !(isColumnFlow() && child.isFlexibleBox())) { |
| // TODO(cbiesinger): For now, we do not handle min-height: auto for nested |
| // column flexboxes. We need to implement |
| // https://drafts.csswg.org/css-flexbox/#intrinsic-sizes before that |
| // produces reasonable results. Tracking bug: https://crbug.com/581553 |
| // css-flexbox section 4.5 |
| LayoutUnit contentSize = |
| computeMainAxisExtentForChild(child, MinSize, Length(MinContent)); |
| DCHECK_GE(contentSize, LayoutUnit()); |
| if (hasAspectRatio(child) && child.intrinsicSize().height() > 0) |
| contentSize = |
| adjustChildSizeForAspectRatioCrossAxisMinAndMax(child, contentSize); |
| if (maxExtent != -1 && contentSize > maxExtent) |
| contentSize = maxExtent; |
| |
| Length mainSize = isHorizontalFlow() ? child.styleRef().width() |
| : child.styleRef().height(); |
| if (mainAxisLengthIsDefinite(child, mainSize)) { |
| LayoutUnit resolvedMainSize = |
| computeMainAxisExtentForChild(child, MainOrPreferredSize, mainSize); |
| DCHECK_GE(resolvedMainSize, LayoutUnit()); |
| LayoutUnit specifiedSize = maxExtent != -1 |
| ? std::min(resolvedMainSize, maxExtent) |
| : resolvedMainSize; |
| |
| minExtent = std::min(specifiedSize, contentSize); |
| } else if (useChildAspectRatio(child)) { |
| Length crossSizeLength = isHorizontalFlow() ? child.styleRef().height() |
| : child.styleRef().width(); |
| LayoutUnit transferredSize = |
| computeMainSizeFromAspectRatioUsing(child, crossSizeLength); |
| transferredSize = adjustChildSizeForAspectRatioCrossAxisMinAndMax( |
| child, transferredSize); |
| minExtent = std::min(transferredSize, contentSize); |
| } else { |
| minExtent = contentSize; |
| } |
| } |
| DCHECK_GE(minExtent, LayoutUnit()); |
| return std::max(childSize, minExtent); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::crossSizeForPercentageResolution( |
| const LayoutBox& child) { |
| if (alignmentForChild(child) != ItemPositionStretch) |
| return LayoutUnit(-1); |
| |
| // Here we implement https://drafts.csswg.org/css-flexbox/#algo-stretch |
| if (hasOrthogonalFlow(child) && child.hasOverrideLogicalContentWidth()) |
| return child.overrideLogicalContentWidth(); |
| if (!hasOrthogonalFlow(child) && child.hasOverrideLogicalContentHeight()) |
| return child.overrideLogicalContentHeight(); |
| |
| // We don't currently implement the optimization from |
| // https://drafts.csswg.org/css-flexbox/#definite-sizes case 1. While that |
| // could speed up a specialized case, it requires determining if we have a |
| // definite size, which itself is not cheap. We can consider implementing it |
| // at a later time. (The correctness is ensured by redoing layout in |
| // applyStretchAlignmentToChild) |
| return LayoutUnit(-1); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::mainSizeForPercentageResolution( |
| const LayoutBox& child) { |
| // This function implements section 9.8. Definite and Indefinite Sizes, case |
| // 2) of the flexbox spec. |
| // We need to check for the flexbox to have a definite main size, and for the |
| // flex item to have a definite flex basis. |
| const Length& flexBasis = flexBasisForChild(child); |
| if (!mainAxisLengthIsDefinite(child, flexBasis)) |
| return LayoutUnit(-1); |
| if (!flexBasis.isPercentOrCalc()) { |
| // If flex basis had a percentage, our size is guaranteed to be definite or |
| // the flex item's size could not be definite. Otherwise, we make up a |
| // percentage to check whether we have a definite size. |
| if (!mainAxisLengthIsDefinite(child, Length(0, Percent))) |
| return LayoutUnit(-1); |
| } |
| |
| if (hasOrthogonalFlow(child)) |
| return child.hasOverrideLogicalContentHeight() |
| ? child.overrideLogicalContentHeight() |
| : LayoutUnit(-1); |
| return child.hasOverrideLogicalContentWidth() |
| ? child.overrideLogicalContentWidth() |
| : LayoutUnit(-1); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::childLogicalHeightForPercentageResolution( |
| const LayoutBox& child) { |
| if (!hasOrthogonalFlow(child)) |
| return crossSizeForPercentageResolution(child); |
| return mainSizeForPercentageResolution(child); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::adjustChildSizeForAspectRatioCrossAxisMinAndMax( |
| const LayoutBox& child, |
| LayoutUnit childSize) { |
| Length crossMin = isHorizontalFlow() ? child.style()->minHeight() |
| : child.style()->minWidth(); |
| Length crossMax = isHorizontalFlow() ? child.style()->maxHeight() |
| : child.style()->maxWidth(); |
| |
| if (crossAxisLengthIsDefinite(child, crossMax)) { |
| LayoutUnit maxValue = computeMainSizeFromAspectRatioUsing(child, crossMax); |
| childSize = std::min(maxValue, childSize); |
| } |
| |
| if (crossAxisLengthIsDefinite(child, crossMin)) { |
| LayoutUnit minValue = computeMainSizeFromAspectRatioUsing(child, crossMin); |
| childSize = std::max(minValue, childSize); |
| } |
| |
| return childSize; |
| } |
| |
| DISABLE_CFI_PERF |
| FlexItem LayoutFlexibleBox::constructFlexItem(LayoutBox& child, |
| ChildLayoutType layoutType) { |
| // If this condition is true, then computeMainAxisExtentForChild will call |
| // child.intrinsicContentLogicalHeight() and |
| // child.scrollbarLogicalHeight(), so if the child has intrinsic |
| // min/max/preferred size, run layout on it now to make sure its logical |
| // height and scroll bars are up to date. |
| if (layoutType != NeverLayout && childHasIntrinsicMainAxisSize(child) && |
| child.needsLayout()) { |
| child.clearOverrideSize(); |
| child.forceChildLayout(); |
| cacheChildMainSize(child); |
| layoutType = LayoutIfNeeded; |
| } |
| |
| LayoutUnit borderAndPadding = isHorizontalFlow() |
| ? child.borderAndPaddingWidth() |
| : child.borderAndPaddingHeight(); |
| LayoutUnit childInnerFlexBaseSize = |
| computeInnerFlexBaseSizeForChild(child, borderAndPadding, layoutType); |
| LayoutUnit childMinMaxAppliedMainAxisExtent = |
| adjustChildSizeForMinAndMax(child, childInnerFlexBaseSize); |
| LayoutUnit margin = |
| isHorizontalFlow() ? child.marginWidth() : child.marginHeight(); |
| return FlexItem(&child, childInnerFlexBaseSize, |
| childMinMaxAppliedMainAxisExtent, borderAndPadding, margin); |
| } |
| |
| void LayoutFlexibleBox::freezeViolations(Vector<FlexItem*>& violations, |
| LayoutUnit& availableFreeSpace, |
| double& totalFlexGrow, |
| double& totalFlexShrink, |
| double& totalWeightedFlexShrink) { |
| for (size_t i = 0; i < violations.size(); ++i) { |
| DCHECK(!violations[i]->frozen) << i; |
| LayoutBox* child = violations[i]->box; |
| LayoutUnit childSize = violations[i]->flexedContentSize; |
| availableFreeSpace -= childSize - violations[i]->flexBaseContentSize; |
| totalFlexGrow -= child->style()->flexGrow(); |
| totalFlexShrink -= child->style()->flexShrink(); |
| totalWeightedFlexShrink -= |
| child->style()->flexShrink() * violations[i]->flexBaseContentSize; |
| // totalWeightedFlexShrink can be negative when we exceed the precision of |
| // a double when we initially calcuate totalWeightedFlexShrink. We then |
| // subtract each child's weighted flex shrink with full precision, now |
| // leading to a negative result. See |
| // css3/flexbox/large-flex-shrink-assert.html |
| totalWeightedFlexShrink = std::max(totalWeightedFlexShrink, 0.0); |
| violations[i]->frozen = true; |
| } |
| } |
| |
| void LayoutFlexibleBox::freezeInflexibleItems(FlexSign flexSign, |
| Vector<FlexItem>& children, |
| LayoutUnit& remainingFreeSpace, |
| double& totalFlexGrow, |
| double& totalFlexShrink, |
| double& totalWeightedFlexShrink) { |
| // Per https://drafts.csswg.org/css-flexbox/#resolve-flexible-lengths step 2, |
| // we freeze all items with a flex factor of 0 as well as those with a min/max |
| // size violation. |
| Vector<FlexItem*> newInflexibleItems; |
| for (size_t i = 0; i < children.size(); ++i) { |
| FlexItem& flexItem = children[i]; |
| LayoutBox* child = flexItem.box; |
| DCHECK(!flexItem.box->isOutOfFlowPositioned()); |
| 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); |
| } |
| } |
| 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, |
| LayoutUnit initialFreeSpace, |
| LayoutUnit& remainingFreeSpace, |
| double& totalFlexGrow, |
| double& totalFlexShrink, |
| double& totalWeightedFlexShrink) { |
| LayoutUnit totalViolation; |
| LayoutUnit usedFreeSpace; |
| Vector<FlexItem*> minViolations; |
| Vector<FlexItem*> maxViolations; |
| |
| double sumFlexFactors = |
| (flexSign == PositiveFlexibility) ? totalFlexGrow : totalFlexShrink; |
| if (sumFlexFactors > 0 && sumFlexFactors < 1) { |
| LayoutUnit fractional(initialFreeSpace * sumFlexFactors); |
| if (fractional.abs() < remainingFreeSpace.abs()) |
| remainingFreeSpace = fractional; |
| } |
| |
| for (size_t i = 0; i < children.size(); ++i) { |
| FlexItem& flexItem = children[i]; |
| LayoutBox* child = flexItem.box; |
| |
| // This check also covers out-of-flow children. |
| if (flexItem.frozen) |
| continue; |
| |
| LayoutUnit childSize = flexItem.flexBaseContentSize; |
| double extraSpace = 0; |
| if (remainingFreeSpace > 0 && totalFlexGrow > 0 && |
| flexSign == PositiveFlexibility && std::isfinite(totalFlexGrow)) { |
| extraSpace = |
| remainingFreeSpace * child->style()->flexGrow() / totalFlexGrow; |
| } else if (remainingFreeSpace < 0 && totalWeightedFlexShrink > 0 && |
| flexSign == NegativeFlexibility && |
| std::isfinite(totalWeightedFlexShrink) && |
| child->style()->flexShrink()) { |
| extraSpace = remainingFreeSpace * child->style()->flexShrink() * |
| flexItem.flexBaseContentSize / totalWeightedFlexShrink; |
| } |
| if (std::isfinite(extraSpace)) |
| 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); |
| else if (violation < 0) |
| maxViolations.append(&flexItem); |
| totalViolation += violation; |
| } |
| |
| if (totalViolation) |
| freezeViolations(totalViolation < 0 ? maxViolations : minViolations, |
| remainingFreeSpace, totalFlexGrow, totalFlexShrink, |
| totalWeightedFlexShrink); |
| else |
| remainingFreeSpace -= usedFreeSpace; |
| |
| return !totalViolation; |
| } |
| |
| static LayoutUnit initialJustifyContentOffset( |
| LayoutUnit availableFreeSpace, |
| ContentPosition justifyContent, |
| ContentDistributionType justifyContentDistribution, |
| unsigned numberOfChildren) { |
| if (justifyContent == ContentPositionFlexEnd) |
| return availableFreeSpace; |
| if (justifyContent == ContentPositionCenter) |
| return availableFreeSpace / 2; |
| if (justifyContentDistribution == ContentDistributionSpaceAround) { |
| if (availableFreeSpace > 0 && numberOfChildren) |
| return availableFreeSpace / (2 * numberOfChildren); |
| |
| return availableFreeSpace / 2; |
| } |
| return LayoutUnit(); |
| } |
| |
| static LayoutUnit justifyContentSpaceBetweenChildren( |
| LayoutUnit availableFreeSpace, |
| ContentDistributionType justifyContentDistribution, |
| unsigned numberOfChildren) { |
| if (availableFreeSpace > 0 && numberOfChildren > 1) { |
| if (justifyContentDistribution == ContentDistributionSpaceBetween) |
| return availableFreeSpace / (numberOfChildren - 1); |
| if (justifyContentDistribution == ContentDistributionSpaceAround) |
| return availableFreeSpace / numberOfChildren; |
| } |
| return LayoutUnit(); |
| } |
| |
| static LayoutUnit alignmentOffset(LayoutUnit availableFreeSpace, |
| ItemPosition position, |
| LayoutUnit ascent, |
| LayoutUnit maxAscent, |
| bool isWrapReverse) { |
| switch (position) { |
| case ItemPositionAuto: |
| case ItemPositionNormal: |
| NOTREACHED(); |
| break; |
| case ItemPositionStretch: |
| // Actual stretching must be handled by the caller. Since wrap-reverse |
| // flips cross start and cross end, stretch children should be aligned |
| // with the cross end. This matters because applyStretchAlignment |
| // doesn't always stretch or stretch fully (explicit cross size given, or |
| // stretching constrained by max-height/max-width). For flex-start and |
| // flex-end this is handled by alignmentForChild(). |
| if (isWrapReverse) |
| return availableFreeSpace; |
| break; |
| case ItemPositionFlexStart: |
| break; |
| case ItemPositionFlexEnd: |
| return availableFreeSpace; |
| case ItemPositionCenter: |
| return availableFreeSpace / 2; |
| case ItemPositionBaseline: |
| // FIXME: If we get here in columns, we want the use the descent, except |
| // we currently can't get the ascent/descent of orthogonal children. |
| // https://bugs.webkit.org/show_bug.cgi?id=98076 |
| return maxAscent - ascent; |
| case ItemPositionLastBaseline: |
| case ItemPositionSelfStart: |
| case ItemPositionSelfEnd: |
| case ItemPositionStart: |
| case ItemPositionEnd: |
| case ItemPositionLeft: |
| case ItemPositionRight: |
| // FIXME: Implement these (https://crbug.com/507690). The extended grammar |
| // is not enabled by default so we shouldn't hit this codepath. |
| // The new grammar is only used when Grid Layout feature is enabled. |
| DCHECK(RuntimeEnabledFeatures::cssGridLayoutEnabled()); |
| break; |
| } |
| return LayoutUnit(); |
| } |
| |
| void LayoutFlexibleBox::setOverrideMainAxisContentSizeForChild( |
| LayoutBox& child, |
| LayoutUnit childPreferredSize) { |
| if (hasOrthogonalFlow(child)) |
| child.setOverrideLogicalContentHeight(childPreferredSize); |
| else |
| child.setOverrideLogicalContentWidth(childPreferredSize); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::staticMainAxisPositionForPositionedChild( |
| const LayoutBox& child) { |
| const LayoutUnit availableSpace = |
| mainAxisContentExtent(contentLogicalHeight()) - |
| mainAxisExtentForChild(child); |
| |
| ContentPosition position = styleRef().resolvedJustifyContentPosition( |
| contentAlignmentNormalBehavior()); |
| ContentDistributionType distribution = |
| styleRef().resolvedJustifyContentDistribution( |
| contentAlignmentNormalBehavior()); |
| LayoutUnit offset = |
| initialJustifyContentOffset(availableSpace, position, distribution, 1); |
| if (styleRef().flexDirection() == FlowRowReverse || |
| styleRef().flexDirection() == FlowColumnReverse) |
| offset = availableSpace - offset; |
| return offset; |
| } |
| |
| LayoutUnit LayoutFlexibleBox::staticCrossAxisPositionForPositionedChild( |
| const LayoutBox& child) { |
| LayoutUnit availableSpace = |
| crossAxisContentExtent() - crossAxisExtentForChild(child); |
| return alignmentOffset(availableSpace, alignmentForChild(child), LayoutUnit(), |
| LayoutUnit(), |
| styleRef().flexWrap() == FlexWrapReverse); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::staticInlinePositionForPositionedChild( |
| const LayoutBox& child) { |
| return startOffsetForContent() + |
| (isColumnFlow() ? staticCrossAxisPositionForPositionedChild(child) |
| : staticMainAxisPositionForPositionedChild(child)); |
| } |
| |
| LayoutUnit LayoutFlexibleBox::staticBlockPositionForPositionedChild( |
| const LayoutBox& child) { |
| return borderAndPaddingBefore() + |
| (isColumnFlow() ? staticMainAxisPositionForPositionedChild(child) |
| : staticCrossAxisPositionForPositionedChild(child)); |
| } |
| |
| bool LayoutFlexibleBox::setStaticPositionForPositionedLayout(LayoutBox& child) { |
| bool positionChanged = false; |
| PaintLayer* childLayer = child.layer(); |
| if (child.styleRef().hasStaticInlinePosition( |
| styleRef().isHorizontalWritingMode())) { |
| LayoutUnit inlinePosition = staticInlinePositionForPositionedChild(child); |
| if (childLayer->staticInlinePosition() != inlinePosition) { |
| childLayer->setStaticInlinePosition(inlinePosition); |
| positionChanged = true; |
| } |
| } |
| if (child.styleRef().hasStaticBlockPosition( |
| styleRef().isHorizontalWritingMode())) { |
| LayoutUnit blockPosition = staticBlockPositionForPositionedChild(child); |
| if (childLayer->staticBlockPosition() != blockPosition) { |
| childLayer->setStaticBlockPosition(blockPosition); |
| positionChanged = true; |
| } |
| } |
| return positionChanged; |
| } |
| |
| void LayoutFlexibleBox::prepareChildForPositionedLayout(LayoutBox& child) { |
| DCHECK(child.isOutOfFlowPositioned()); |
| child.containingBlock()->insertPositionedObject(&child); |
| PaintLayer* childLayer = child.layer(); |
| LayoutUnit staticInlinePosition = |
| flowAwareBorderStart() + flowAwarePaddingStart(); |
| if (childLayer->staticInlinePosition() != staticInlinePosition) { |
| childLayer->setStaticInlinePosition(staticInlinePosition); |
| if (child.style()->hasStaticInlinePosition( |
| style()->isHorizontalWritingMode())) |
| child.setChildNeedsLayout(MarkOnlyThis); |
| } |
| |
| LayoutUnit staticBlockPosition = |
| flowAwareBorderBefore() + flowAwarePaddingBefore(); |
| if (childLayer->staticBlockPosition() != staticBlockPosition) { |
| childLayer->setStaticBlockPosition(staticBlockPosition); |
| if (child.style()->hasStaticBlockPosition( |
| style()->isHorizontalWritingMode())) |
| child.setChildNeedsLayout(MarkOnlyThis); |
| } |
| } |
| |
| ItemPosition LayoutFlexibleBox::alignmentForChild( |
| const LayoutBox& child) const { |
| ItemPosition align = |
| child.styleRef() |
| .resolvedAlignSelf(selfAlignmentNormalBehavior(), |
| child.isAnonymous() ? style() : nullptr) |
| .position(); |
| DCHECK(align != ItemPositionAuto && align != ItemPositionNormal); |
| |
| if (align == ItemPositionBaseline && hasOrthogonalFlow(child)) |
| align = ItemPositionFlexStart; |
| |
| if (style()->flexWrap() == FlexWrapReverse) { |
| if (align == ItemPositionFlexStart) |
| align = ItemPositionFlexEnd; |
| else if (align == ItemPositionFlexEnd) |
| align = ItemPositionFlexStart; |
| } |
| |
| return align; |
| } |
| |
| void LayoutFlexibleBox::resetAutoMarginsAndLogicalTopInCrossAxis( |
| LayoutBox& child) { |
| if (hasAutoMarginsInCrossAxis(child)) { |
| child.updateLogicalHeight(); |
| if (isHorizontalFlow()) { |
| if (child.style()->marginTop().isAuto()) |
| child.setMarginTop(LayoutUnit()); |
| if (child.style()->marginBottom().isAuto()) |
| child.setMarginBottom(LayoutUnit()); |
| } else { |
| if (child.style()->marginLeft().isAuto()) |
| child.setMarginLeft(LayoutUnit()); |
| if (child.style()->marginRight().isAuto()) |
| child.setMarginRight(LayoutUnit()); |
| } |
| } |
| } |
| |
| bool LayoutFlexibleBox::needToStretchChildLogicalHeight( |
| const LayoutBox& child) const { |
| // This function is a little bit magical. It relies on the fact that blocks |
| // intrinsically "stretch" themselves in their inline axis, i.e. a <div> has |
| // an implicit width: 100%. So the child will automatically stretch if our |
| // cross axis is the child's inline axis. That's the case if: |
| // - We are horizontal and the child is in vertical writing mode |
| // - We are vertical and the child is in horizontal writing mode |
| // Otherwise, we need to stretch if the cross axis size is auto. |
| if (alignmentForChild(child) != ItemPositionStretch) |
| return false; |
| |
| if (isHorizontalFlow() != child.styleRef().isHorizontalWritingMode()) |
| return false; |
| |
| return child.styleRef().logicalHeight().isAuto(); |
| } |
| |
| bool LayoutFlexibleBox::childHasIntrinsicMainAxisSize( |
| const LayoutBox& child) const { |
| bool result = false; |
| if (isHorizontalFlow() != child.styleRef().isHorizontalWritingMode()) { |
| Length childFlexBasis = flexBasisForChild(child); |
| Length childMinSize = isHorizontalFlow() ? child.style()->minWidth() |
| : child.style()->minHeight(); |
| Length childMaxSize = isHorizontalFlow() ? child.style()->maxWidth() |
| : child.style()->maxHeight(); |
| if (childFlexBasis.isIntrinsic() || childMinSize.isIntrinsicOrAuto() || |
| childMaxSize.isIntrinsic()) |
| result = true; |
| } |
| return result; |
| } |
| |
| EOverflow LayoutFlexibleBox::mainAxisOverflowForChild( |
| const LayoutBox& child) const { |
| if (isHorizontalFlow()) |
| return child.styleRef().overflowX(); |
| return child.styleRef().overflowY(); |
| } |
| |
| EOverflow LayoutFlexibleBox::crossAxisOverflowForChild( |
| const LayoutBox& child) const { |
| if (isHorizontalFlow()) |
| return child.styleRef().overflowY(); |
| return child.styleRef().overflowX(); |
| } |
| |
| DISABLE_CFI_PERF |
| void LayoutFlexibleBox::layoutAndPlaceChildren( |
| LayoutUnit& crossAxisOffset, |
| Vector<FlexItem>& children, |
| LayoutUnit availableFreeSpace, |
| bool relayoutChildren, |
| SubtreeLayoutScope& layoutScope, |
| Vector<LineContext>& lineContexts) { |
| ContentPosition position = styleRef().resolvedJustifyContentPosition( |
| contentAlignmentNormalBehavior()); |
| ContentDistributionType distribution = |
| styleRef().resolvedJustifyContentDistribution( |
| contentAlignmentNormalBehavior()); |
| |
| LayoutUnit autoMarginOffset = |
| autoMarginOffsetInMainAxis(children, availableFreeSpace); |
| LayoutUnit mainAxisOffset = flowAwareBorderStart() + flowAwarePaddingStart(); |
| mainAxisOffset += initialJustifyContentOffset(availableFreeSpace, position, |
| distribution, children.size()); |
| if (style()->flexDirection() == FlowRowReverse && |
| shouldPlaceBlockDirectionScrollbarOnLogicalLeft()) |
| mainAxisOffset += isHorizontalFlow() ? verticalScrollbarWidth() |
| : horizontalScrollbarHeight(); |
| |
| LayoutUnit totalMainExtent = mainAxisExtent(); |
| if (!shouldPlaceBlockDirectionScrollbarOnLogicalLeft()) |
| totalMainExtent -= isHorizontalFlow() ? verticalScrollbarWidth() |
| : horizontalScrollbarHeight(); |
| LayoutUnit maxAscent, maxDescent; // Used when align-items: baseline. |
| LayoutUnit maxChildCrossAxisExtent; |
| bool shouldFlipMainAxis = !isColumnFlow() && !isLeftToRightFlow(); |
| bool isPaginated = view()->layoutState()->isPaginated(); |
| for (size_t i = 0; i < children.size(); ++i) { |
| const FlexItem& flexItem = children[i]; |
| LayoutBox* child = flexItem.box; |
| |
| DCHECK(!flexItem.box->isOutOfFlowPositioned()); |
| |
| child->setMayNeedPaintInvalidation(); |
| |
| setOverrideMainAxisContentSizeForChild(*child, flexItem.flexedContentSize); |
| // The flexed content size and the override size include the scrollbar |
| // width, so we need to compare to the size including the scrollbar. |
| // TODO(cbiesinger): Should it include the scrollbar? |
| if (flexItem.flexedContentSize != |
| mainAxisContentExtentForChildIncludingScrollbar(*child)) { |
| child->setChildNeedsLayout(MarkOnlyThis); |
| } else { |
| // To avoid double applying margin changes in |
| // updateAutoMarginsInCrossAxis, we reset the margins here. |
| resetAutoMarginsAndLogicalTopInCrossAxis(*child); |
| } |
| // We may have already forced relayout for orthogonal flowing children in |
| // computeInnerFlexBaseSizeForChild. |
| bool forceChildRelayout = |
| relayoutChildren && !m_relaidOutChildren.contains(child); |
| if (child->isLayoutBlock() && |
| toLayoutBlock(*child).hasPercentHeightDescendants()) { |
| // Have to force another relayout even though the child is sized |
| // correctly, because its descendants are not sized correctly yet. Our |
| // previous layout of the child was done without an override height set. |
| // So, redo it here. |
| forceChildRelayout = true; |
| } |
| updateBlockChildDirtyBitsBeforeLayout(forceChildRelayout, *child); |
| if (!child->needsLayout()) |
| markChildForPaginationRelayoutIfNeeded(*child, layoutScope); |
| if (child->needsLayout()) |
| m_relaidOutChildren.add(child); |
| child->layoutIfNeeded(); |
| |
| updateAutoMarginsInMainAxis(*child, autoMarginOffset); |
| |
| LayoutUnit childCrossAxisMarginBoxExtent; |
| if (alignmentForChild(*child) == ItemPositionBaseline && |
| !hasAutoMarginsInCrossAxis(*child)) { |
| LayoutUnit ascent = marginBoxAscentForChild(*child); |
| LayoutUnit descent = (crossAxisMarginExtentForChild(*child) + |
| crossAxisExtentForChild(*child)) - |
| ascent; |
| |
| maxAscent = std::max(maxAscent, ascent); |
| maxDescent = std::max(maxDescent, descent); |
| |
| // TODO(cbiesinger): Take scrollbar into account |
| childCrossAxisMarginBoxExtent = maxAscent + maxDescent; |
| } else { |
| childCrossAxisMarginBoxExtent = crossAxisIntrinsicExtentForChild(*child) + |
| crossAxisMarginExtentForChild(*child) + |
| crossAxisScrollbarExtentForChild(*child); |
| } |
| if (!isColumnFlow()) |
| setLogicalHeight(std::max( |
| logicalHeight(), |
| crossAxisOffset + flowAwareBorderAfter() + flowAwarePaddingAfter() + |
| childCrossAxisMarginBoxExtent + crossAxisScrollbarExtent())); |
| maxChildCrossAxisExtent = |
| std::max(maxChildCrossAxisExtent, childCrossAxisMarginBoxExtent); |
| |
| mainAxisOffset += flowAwareMarginStartForChild(*child); |
| |
| LayoutUnit childMainExtent = mainAxisExtentForChild(*child); |
| // In an RTL column situation, this will apply the margin-right/margin-end |
| // on the left. This will be fixed later in flipForRightToLeftColumn. |
| LayoutPoint childLocation( |
| shouldFlipMainAxis ? totalMainExtent - mainAxisOffset - childMainExtent |
| : mainAxisOffset, |
| crossAxisOffset + flowAwareMarginBeforeForChild(*child)); |
| setFlowAwareLocationForChild(*child, childLocation); |
| mainAxisOffset += childMainExtent + flowAwareMarginEndForChild(*child); |
| |
| mainAxisOffset += justifyContentSpaceBetweenChildren( |
| availableFreeSpace, distribution, children.size()); |
| |
| if (isPaginated) |
| updateFragmentationInfoForChild(*child); |
| } |
| |
| if (isColumnFlow()) |
| setLogicalHeight(std::max( |
| logicalHeight(), mainAxisOffset + flowAwareBorderEnd() + |
| flowAwarePaddingEnd() + scrollbarLogicalHeight())); |
| |
| 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))); |
| crossAxisOffset += maxChildCrossAxisExtent; |
| } |
| |
| void LayoutFlexibleBox::layoutColumnReverse(const Vector<FlexItem>& children, |
| LayoutUnit crossAxisOffset, |
| LayoutUnit availableFreeSpace) { |
| ContentPosition position = styleRef().resolvedJustifyContentPosition( |
| contentAlignmentNormalBehavior()); |
| ContentDistributionType distribution = |
| styleRef().resolvedJustifyContentDistribution( |
| contentAlignmentNormalBehavior()); |
| |
| // This is similar to the logic in layoutAndPlaceChildren, except we place |
| // the children starting from the end of the flexbox. We also don't need to |
| // layout anything since we're just moving the children to a new position. |
| LayoutUnit mainAxisOffset = |
| logicalHeight() - flowAwareBorderEnd() - flowAwarePaddingEnd(); |
| mainAxisOffset -= initialJustifyContentOffset(availableFreeSpace, position, |
| distribution, children.size()); |
| mainAxisOffset -= isHorizontalFlow() ? verticalScrollbarWidth() |
| : horizontalScrollbarHeight(); |
| |
| for (size_t i = 0; i < children.size(); ++i) { |
| LayoutBox* child = children[i].box; |
| |
| DCHECK(!child->isOutOfFlowPositioned()); |
| |
| mainAxisOffset -= |
| mainAxisExtentForChild(*child) + flowAwareMarginEndForChild(*child); |
| |
| setFlowAwareLocationForChild( |
| *child, |
| LayoutPoint(mainAxisOffset, |
| crossAxisOffset + flowAwareMarginBeforeForChild(*child))); |
| |
| mainAxisOffset -= flowAwareMarginStartForChild(*child); |
| |
| mainAxisOffset -= justifyContentSpaceBetweenChildren( |
| availableFreeSpace, distribution, children.size()); |
| } |
| } |
| |
| static LayoutUnit initialAlignContentOffset( |
| LayoutUnit availableFreeSpace, |
| ContentPosition alignContent, |
| ContentDistributionType alignContentDistribution, |
| unsigned numberOfLines) { |
| if (numberOfLines <= 1) |
| return LayoutUnit(); |
| if (alignContent == ContentPositionFlexEnd) |
| return availableFreeSpace; |
| if (alignContent == ContentPositionCenter) |
| return availableFreeSpace / 2; |
| if (alignContentDistribution == ContentDistributionSpaceAround) { |
| if (availableFreeSpace > 0 && numberOfLines) |
| return availableFreeSpace / (2 * numberOfLines); |
| if (availableFreeSpace < 0) |
| return availableFreeSpace / 2; |
| } |
| return LayoutUnit(); |
| } |
| |
| static LayoutUnit alignContentSpaceBetweenChildren( |
| LayoutUnit availableFreeSpace, |
| ContentDistributionType alignContentDistribution, |
| unsigned numberOfLines) { |
| if (availableFreeSpace > 0 && numberOfLines > 1) { |
| if (alignContentDistribution == ContentDistributionSpaceBetween) |
| return availableFreeSpace / (numberOfLines - 1); |
| if (alignContentDistribution == ContentDistributionSpaceAround || |
| alignContentDistribution == ContentDistributionStretch) |
| return availableFreeSpace / numberOfLines; |
| } |
| return LayoutUnit(); |
| } |
| |
| void LayoutFlexibleBox::alignFlexLines(Vector<LineContext>& lineContexts) { |
| ContentPosition position = |
| styleRef().resolvedAlignContentPosition(contentAlignmentNormalBehavior()); |
| ContentDistributionType distribution = |
| styleRef().resolvedAlignContentDistribution( |
| contentAlignmentNormalBehavior()); |
| |
| // If we have a single line flexbox or a multiline line flexbox with only one |
| // flex line, the line height is all the available space. For |
| // flex-direction: row, this means we need to use the height, so we do this |
| // after calling updateLogicalHeight. |
| if (lineContexts.size() == 1) { |
| lineContexts[0].crossAxisExtent = crossAxisContentExtent(); |
| return; |
| } |
| |
| if (position == ContentPositionFlexStart) |
| return; |
| |
| LayoutUnit availableCrossAxisSpace = crossAxisContentExtent(); |
| for (size_t i = 0; i < lineContexts.size(); ++i) |
| availableCrossAxisSpace -= lineContexts[i].crossAxisExtent; |
| |
| LayoutUnit lineOffset = initialAlignContentOffset( |
| availableCrossAxisSpace, position, distribution, lineContexts.size()); |
| for (unsigned lineNumber = 0; lineNumber < lineContexts.size(); |
| ++lineNumber) { |
| LineContext& lineContext = lineContexts[lineNumber]; |
| lineContext.crossAxisOffset += lineOffset; |
| for (size_t childNumber = 0; childNumber < lineContext.flexItems.size(); |
| ++childNumber) { |
| FlexItem& flexItem = lineContext.flexItems[childNumber]; |
| adjustAlignmentForChild(*flexItem.box, lineOffset); |
| } |
| |
| if (distribution == ContentDistributionStretch && |
| availableCrossAxisSpace > 0) |
| lineContexts[lineNumber].crossAxisExtent += |
| availableCrossAxisSpace / static_cast<unsigned>(lineContexts.size()); |
| |
| lineOffset += alignContentSpaceBetweenChildren( |
| availableCrossAxisSpace, distribution, lineContexts.size()); |
| } |
| } |
| |
| void LayoutFlexibleBox::adjustAlignmentForChild(LayoutBox& child, |
| LayoutUnit delta) { |
| DCHECK(!child.isOutOfFlowPositioned()); |
| |
| setFlowAwareLocationForChild(child, flowAwareLocationForChild(child) + |
| LayoutSize(LayoutUnit(), delta)); |
| } |
| |
| void LayoutFlexibleBox::alignChildren(const Vector<LineContext>& lineContexts) { |
| // Keep track of the space between the baseline edge and the after edge of |
| // the box for each line. |
| Vector<LayoutUnit> minMarginAfterBaselines; |
| |
| for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) { |
| const LineContext& lineContext = lineContexts[lineNumber]; |
| |
| LayoutUnit minMarginAfterBaseline = LayoutUnit::max(); |
| LayoutUnit lineCrossAxisExtent = lineContext.crossAxisExtent; |
| LayoutUnit maxAscent = lineContext.maxAscent; |
| |
| for (size_t childNumber = 0; childNumber < lineContext.flexItems.size(); |
| ++childNumber) { |
| const FlexItem& flexItem = lineContext.flexItems[childNumber]; |
| DCHECK(!flexItem.box->isOutOfFlowPositioned()); |
| |
| if (updateAutoMarginsInCrossAxis( |
| *flexItem.box, |
| std::max(LayoutUnit(), availableAlignmentSpaceForChild( |
| lineCrossAxisExtent, *flexItem.box)))) |
| continue; |
| |
| ItemPosition position = alignmentForChild(*flexItem.box); |
| if (position == ItemPositionStretch) |
| applyStretchAlignmentToChild(*flexItem.box, lineCrossAxisExtent); |
| LayoutUnit availableSpace = |
| availableAlignmentSpaceForChild(lineCrossAxisExtent, *flexItem.box); |
| LayoutUnit offset = alignmentOffset( |
| availableSpace, position, marginBoxAscentForChild(*flexItem.box), |
| 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); |
| } |
| |
| 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]; |
| LayoutUnit minMarginAfterBaseline = minMarginAfterBaselines[lineNumber]; |
| for (size_t childNumber = 0; childNumber < lineContext.flexItems.size(); |
| ++childNumber) { |
| const FlexItem& flexItem = lineContext.flexItems[childNumber]; |
| if (alignmentForChild(*flexItem.box) == ItemPositionBaseline && |
| !hasAutoMarginsInCrossAxis(*flexItem.box) && minMarginAfterBaseline) |
| adjustAlignmentForChild(*flexItem.box, minMarginAfterBaseline); |
| } |
| } |
| } |
| |
| void LayoutFlexibleBox::applyStretchAlignmentToChild( |
| LayoutBox& child, |
| LayoutUnit lineCrossAxisExtent) { |
| if (!hasOrthogonalFlow(child) && child.style()->logicalHeight().isAuto()) { |
| LayoutUnit heightBeforeStretching = childIntrinsicLogicalHeight(child); |
| LayoutUnit stretchedLogicalHeight = |
| std::max(child.borderAndPaddingLogicalHeight(), |
| heightBeforeStretching + |
| availableAlignmentSpaceForChildBeforeStretching( |
| lineCrossAxisExtent, child)); |
| DCHECK(!child.needsLayout()); |
| LayoutUnit desiredLogicalHeight = child.constrainLogicalHeightByMinMax( |
| stretchedLogicalHeight, |
| heightBeforeStretching - child.borderAndPaddingLogicalHeight()); |
| |
| // FIXME: Can avoid laying out here in some cases. See |
| // https://webkit.org/b/87905. |
| bool childNeedsRelayout = desiredLogicalHeight != child.logicalHeight(); |
| if (child.isLayoutBlock() && |
| toLayoutBlock(child).hasPercentHeightDescendants() && |
| m_relaidOutChildren.contains(&child)) { |
| // Have to force another relayout even though the child is sized |
| // correctly, because its descendants are not sized correctly yet. Our |
| // previous layout of the child was done without an override height set. |
| // So, redo it here. |
| childNeedsRelayout = true; |
| } |
| if (childNeedsRelayout || !child.hasOverrideLogicalContentHeight()) |
| child.setOverrideLogicalContentHeight( |
| desiredLogicalHeight - child.borderAndPaddingLogicalHeight()); |
| if (childNeedsRelayout) { |
| child.setLogicalHeight(LayoutUnit()); |
| // We cache the child's intrinsic content logical height to avoid it being |
| // reset to the stretched height. |
| // FIXME: This is fragile. LayoutBoxes should be smart enough to |
| // determine their intrinsic content logical height correctly even when |
| // there's an overrideHeight. |
| LayoutUnit childIntrinsicContentLogicalHeight = |
| child.intrinsicContentLogicalHeight(); |
| child.forceChildLayout(); |
| child.setIntrinsicContentLogicalHeight( |
| childIntrinsicContentLogicalHeight); |
| } |
| } else if (hasOrthogonalFlow(child) && |
| child.style()->logicalWidth().isAuto()) { |
| LayoutUnit childWidth = |
| (lineCrossAxisExtent - crossAxisMarginExtentForChild(child)) |
| .clampNegativeToZero(); |
| childWidth = |
| child.constrainLogicalWidthByMinMax(childWidth, childWidth, this); |
| |
| if (childWidth != child.logicalWidth()) { |
| child.setOverrideLogicalContentWidth( |
| childWidth - child.borderAndPaddingLogicalWidth()); |
| child.forceChildLayout(); |
| } |
| } |
| } |
| |
| void LayoutFlexibleBox::flipForRightToLeftColumn( |
| const Vector<LineContext>& lineContexts) { |
| if (style()->isLeftToRightDirection() || !isColumnFlow()) |
| return; |
| |
| LayoutUnit crossExtent = crossAxisExtent(); |
| for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) { |
| const LineContext& lineContext = lineContexts[lineNumber]; |
| for (size_t childNumber = 0; childNumber < lineContext.flexItems.size(); |
| ++childNumber) { |
| const FlexItem& flexItem = lineContext.flexItems[childNumber]; |
| DCHECK(!flexItem.box->isOutOfFlowPositioned()); |
| |
| LayoutPoint location = flowAwareLocationForChild(*flexItem.box); |
| // For vertical flows, setFlowAwareLocationForChild will transpose x and |
| // y, |
| // so using the y axis for a column cross axis extent is correct. |
| location.setY(crossExtent - crossAxisExtentForChild(*flexItem.box) - |
| location.y()); |
| if (!isHorizontalWritingMode()) |
| location.move(LayoutSize(0, -horizontalScrollbarHeight())); |
| setFlowAwareLocationForChild(*flexItem.box, location); |
| } |
| } |
| } |
| |
| void LayoutFlexibleBox::flipForWrapReverse( |
| const Vector<LineContext>& lineContexts, |
| LayoutUnit crossAxisStartEdge) { |
| LayoutUnit contentExtent = crossAxisContentExtent(); |
| for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) { |
| const LineContext& lineContext = lineContexts[lineNumber]; |
| for (size_t childNumber = 0; childNumber < lineContext.flexItems.size(); |
| ++childNumber) { |
| const FlexItem& flexItem = lineContext.flexItems[childNumber]; |
| LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent; |
| LayoutUnit originalOffset = |
| lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge; |
| LayoutUnit newOffset = |
| contentExtent - originalOffset - lineCrossAxisExtent; |
| adjustAlignmentForChild(*flexItem.box, newOffset - originalOffset); |
| } |
| } |
| } |
| |
| } // namespace blink |