ChangeLog

2011-11-29  Fady Samuel  <fsamuel@chromium.org>

        -webkit-aspect-ratio Layout Implementation

        https://bugs.webkit.org/show_bug.cgi?id=73277

        Reviewed by NOBODY (OOPS!).

        Tests: css3/aspect-ratio/absolute-ratio-absolute-left-right.html

               css3/aspect-ratio/aspect-ratio-absolute-height.html

               css3/aspect-ratio/aspect-ratio-absolute-width.html

               css3/aspect-ratio/aspect-ratio-auto-height.html

               css3/aspect-ratio/aspect-ratio-float.html

               css3/aspect-ratio/aspect-ratio-inherit.html

               css3/aspect-ratio/aspect-ratio-stretch-to-fill.html

        * rendering/RenderBlock.cpp:

        (WebCore::RenderBlock::layoutBlock):

        (WebCore::RenderBlock::layoutBlockChildren):

        * rendering/RenderBox.cpp:

        (WebCore::RenderBox::isWidthDeterminedUsing):

        (WebCore::RenderBox::isHeightDeterminedUsing):

        (WebCore::RenderBox::useAspectRatioForWidth):

        (WebCore::RenderBox::useAspectRatioForHeight):

        (WebCore::RenderBox::computeLogicalWidthInRegion):

        (WebCore::RenderBox::computeLogicalWidthUsing):

        (WebCore::RenderBox::computeLogicalHeight):

        (WebCore::RenderBox::computeLogicalHeightUsing):

        (WebCore::RenderBox::computePositionedLogicalWidth):

        (WebCore::RenderBox::computePositionedLogicalWidthUsing):

        (WebCore::RenderBox::computePositionedLogicalHeight):

        (WebCore::RenderBox::computePositionedLogicalHeightUsing):

        * rendering/RenderBox.h:

        * rendering/style/RenderStyle.cpp:

        (WebCore::RenderStyle::diff):

2011-11-28  Vsevolod Vlasov  <vsevik@chromium.org>

        Web Inspector: TextPrompt should show suggest above or under so that it has maximal height.

Source/WebCore/rendering/RenderBlock.cpp

@@void RenderBlock::layoutBlock(bool relayoutChildren, LayoutUnit pageLogicalHeigh

    LayoutUnit oldWidth = logicalWidth();

    LayoutUnit oldColumnWidth = desiredColumnWidth();

  
    LayoutUnit previousHeight = logicalHeight();

    setLogicalHeight(0);

    computeLogicalWidth();

    calcColumnWidth();

@@void RenderBlock::layoutBlock(bool relayoutChildren, LayoutUnit pageLogicalHeigh

        floatsLayoutPass = PositionedFloatLayoutPass;

    clearFloats(floatsLayoutPass);

1222 LayoutUnit previousHeight = logicalHeight();

1223 setLogicalHeight(0);

    bool hasSpecifiedPageLogicalHeight = false;

    bool pageLogicalHeightChanged = false;

    ColumnInfo* colInfo = columnInfo();

@@void RenderBlock::layoutBlock(bool relayoutChildren, LayoutUnit pageLogicalHeigh

    LayoutUnit oldClientAfterEdge = clientLogicalBottom();

    computeLogicalHeight();

    LayoutUnit newHeight = logicalHeight();

1326

    if (oldHeight != newHeight) {

        if (oldHeight > newHeight && maxFloatLogicalBottom > newHeight && !childrenInline()) {

            // One of our children's floats may have become an overhanging float for us. We need to look for it.

@@void RenderBlock::layoutBlock(bool relayoutChildren, LayoutUnit pageLogicalHeigh

    if (previousHeight != newHeight)

        relayoutChildren = true;

    // FIXME: Only recompute logical width if aspect ratio is not satisfied

    oldWidth = logicalWidth();

    if (style()->hasAspectRatio())

        computeLogicalWidth();

    if (oldWidth != logicalWidth())

        relayoutChildren = true;

    bool needAnotherLayoutPass = layoutPositionedObjects(relayoutChildren || isRoot());

    if (inRenderFlowThread())

@@void RenderBlock::layoutBlockChildren(bool relayoutChildren, LayoutUnit& maxFloa

1972

    LayoutUnit beforeEdge = borderBefore() + paddingBefore();

    LayoutUnit afterEdge = borderAfter() + paddingAfter() + scrollbarLogicalHeight();

@@void RenderBlock::layoutBlockChildren(bool relayoutChildren, LayoutUnit& maxFloa

        // Make sure we layout children if they need it.

        // FIXME: Technically percentage height objects only need a relayout if their percentage isn't going to be turned into

        // an auto value.  Add a method to determine this, so that we can avoid the relayout.

2001 if (relayoutChildren || ((child->style()->logicalHeight().isPercent() || child->style()->logicalMinHeight().isPercent() || child->style()->logicalMaxHeight().isPercent()) && !isRenderView()))

2009 if (relayoutChildren || ((child->style()->hasAspectRatio() || child->style()->logicalHeight().isPercent() || child->style()->logicalMinHeight().isPercent() || child->style()->logicalMaxHeight().isPercent()) && !isRenderView()))

            child->setChildNeedsLayout(true, false);

        // If relayoutChildren is set and the child has percentage padding or an embedded content box, we also need to invalidate the childs pref widths.

Source/WebCore/rendering/RenderBox.cpp

@@void RenderBox::repaintDuringLayoutIfMoved(const LayoutRect& rect)

    }

}

bool RenderBox::isWidthDeterminedUsing(const Length& logicalWidth, const Length& logicalLeft, const Length& logicalRight) const

{

    bool widthIsAuto = logicalWidth.isAuto();

    bool logicalMinWidthIsSpecified = !style()->logicalMinWidth().isAuto() && style()->logicalMinWidth().isPositive();

    bool leftIsAuto = logicalLeft.isAuto();

    bool rightIsAuto = logicalRight.isAuto();

    bool hasAspectRatio = style()->hasAspectRatio();

    // Width is determined if the width is specified or left and right are specified on a positioned box.

    return !widthIsAuto || logicalMinWidthIsSpecified || (!leftIsAuto && widthIsAuto && !rightIsAuto && !hasAspectRatio && isPositioned());

}

bool RenderBox::isHeightDeterminedUsing(const Length& logicalHeight, const Length& logicalTop, const Length& logicalBottom) const

{

    bool heightIsAuto = logicalHeight.isAuto();

    bool logicalMinHeightIsSpecified = !style()->logicalMinHeight().isAuto() && style()->logicalMinHeight().isPositive();

    bool topIsAuto = logicalTop.isAuto();

    bool bottomIsAuto = logicalBottom.isAuto();

    bool hasAspectRatio = style()->hasAspectRatio();

    // Height is determined if height is specificed or top and bottom are specified on a positioned box.

    return !heightIsAuto || logicalMinHeightIsSpecified || (!topIsAuto && heightIsAuto && !bottomIsAuto && !hasAspectRatio && isPositioned());

}

bool RenderBox::useAspectRatioForWidth(const Length& logicalWidth, const Length& logicalLeft, const Length& logicalRight) const

{

    return !isWidthDeterminedUsing(logicalWidth, logicalLeft, logicalRight) && style()->hasAspectRatio();

}

bool RenderBox::useAspectRatioForHeight(const Length& logicalHeight, const Length& logicalTop, const Length& logicalBottom) const

{

    return !isHeightDeterminedUsing(logicalHeight, logicalTop, logicalBottom) && style()->hasAspectRatio();

}

void RenderBox::computeLogicalWidth()

{

    computeLogicalWidthInRegion();

@@void RenderBox::computeLogicalWidthInRegion(RenderRegion* region, LayoutUnit off

    }

    // Margin calculations.

1743 if (logicalWidthLength.isAuto() || hasPerpendicularContainingBlock) {

1775 if ((logicalWidthLength.isAuto() && !style()->hasAspectRatio()) || hasPerpendicularContainingBlock) {

        setMarginStart(style()->marginStart().calcMinValue(containerLogicalWidth));

        setMarginEnd(style()->marginEnd().calcMinValue(containerLogicalWidth));

    } else

@@void RenderBox::computeLogicalWidthInRegion(RenderRegion* region, LayoutUnit off

LayoutUnit RenderBox::computeLogicalWidthUsing(LogicalWidthType widthType, LayoutUnit availableLogicalWidth)

{

    LayoutUnit logicalWidthResult = logicalWidth();

1789 const LayoutUnit bordersPlusPadding = borderAndPaddingLogicalWidth();

17571790 Length logicalWidth;

1758 if (widthType == LogicalWidth)

1791 switch (widthType) {

1792 case LogicalWidth:

17591793 logicalWidth = style()->logicalWidth();

1760 else if (widthType == MinLogicalWidth)

1794 break;

1795 case MinLogicalWidth:

17611796 logicalWidth = style()->logicalMinWidth();

1762 else

1797 break;

1798 case MaxLogicalWidth:

17631799 logicalWidth = style()->logicalMaxWidth();

        break;

    case MinPreferredLogicalWidth:

        ASSERT_NOT_REACHED();

        logicalWidth =  Length(minPreferredLogicalWidth() - bordersPlusPadding, Fixed);

        break;

    }

    if (logicalWidth.isIntrinsicOrAuto()) {

        LayoutUnit marginStart = style()->marginStart().calcMinValue(availableLogicalWidth);

        LayoutUnit marginEnd = style()->marginEnd().calcMinValue(availableLogicalWidth);

        logicalWidthResult = availableLogicalWidth - marginStart - marginEnd;

        bool useAspectRatio = style()->hasAspectRatio();

        if (useAspectRatio) {

            float requiredRatio = style()->aspectRatio();

            if (logicalHeight()) {

                int widthForAspectRatio = static_cast<int>(logicalHeight() * requiredRatio);

                if (widthType == LogicalWidth)

                    logicalWidthResult = min(widthForAspectRatio, logicalWidthResult);

            } 

        }

        if (sizesToIntrinsicLogicalWidth(widthType)) {

            logicalWidthResult = max(logicalWidthResult, minPreferredLogicalWidth());

@@void RenderBox::computeLogicalHeight()

        LayoutUnit heightResult;

        if (checkMinMaxHeight) {

2012 heightResult = computeLogicalHeightUsing(~~style()->l~~ogicalHeight());

2063 heightResult = computeLogicalHeightUsing(LogicalHeight);

            // FIXME: Use < 0 or roughlyEquals when we move to float, see https://bugs.webkit.org/show_bug.cgi?id=66148

            if (heightResult == -1)

                heightResult = logicalHeight();

2016 LayoutUnit minH = computeLogicalHeightUsing(~~style()->l~~ogical~~Min~~Height()); // Leave as -1 if unset.

2017 LayoutUnit maxH = style()->logicalMaxHeight().isUndefined() ? heightResult : computeLogicalHeightUsing(~~style()->l~~ogical~~Max~~Height());

2067 LayoutUnit minH = computeLogicalHeightUsing(MinLogicalHeight); // Leave as -1 if unset.

2068 LayoutUnit maxH = style()->logicalMaxHeight().isUndefined() ? heightResult : computeLogicalHeightUsing(MaxLogicalHeight);

            if (maxH == -1)

                maxH = heightResult;

            heightResult = min(maxH, heightResult);

@@void RenderBox::computeLogicalHeight()

    }

}

2064 LayoutUnit RenderBox::computeLogicalHeightUsing(~~const Length&~~ h)

2115LayoutUnit RenderBox::computeLogicalHeightUsing(LogicalHeightType heightType)

20652116{

2066 LayoutUnit logicalHeight = -1;

    Length h;

    switch (heightType) {

    case LogicalHeight:

        h = style()->logicalHeight();

        break;

    case MinLogicalHeight:

        h = style()->logicalMinHeight();

        break;

    case MaxLogicalHeight:

        h = style()->logicalMaxHeight();

        break;

    }

    LayoutUnit logicalHeightValue = -1;

20672131 if (!h.isAuto()) {

20682132 if (h.isFixed())

2069 logicalHeight = h.value();

2133 logicalHeightValue = h.value();

20702134 else if (h.isPercent())

2071 logicalHeight = computePercentageLogicalHeight(h);

2135 logicalHeightValue = computePercentageLogicalHeight(h);

20722136 // FIXME: Use < 0 or roughlyEquals when we move to float, see https://bugs.webkit.org/show_bug.cgi?id=66148

        if (logicalHeight != -1) {

            logicalHeight = computeBorderBoxLogicalHeight(logicalHeight);

            return logicalHeight;

        if (logicalHeightValue != -1) {

            logicalHeightValue = computeBorderBoxLogicalHeight(logicalHeightValue);

            return logicalHeightValue;

        }

    } else if (style()->hasAspectRatio() && !logicalHeight() && heightType == LogicalHeight) {

        if (logicalWidth()) {

            float requiredRatio = style()->aspectRatioDenominator() / style()->aspectRatioNumerator();

            int heightForAspectRatio = static_cast<int>(logicalWidth() * requiredRatio);

            logicalHeightValue = heightForAspectRatio;

20762146 }

20772147 }

2078 return logicalHeight;

2148 return logicalHeightValue;

}

LayoutUnit RenderBox::computePercentageLogicalHeight(const Length& height)

@@void RenderBox::computePositionedLogicalWidth(RenderRegion* region, LayoutUnit o

    // Calculate constraint equation values for 'width' case.

    LayoutUnit logicalWidthResult;

    LayoutUnit logicalLeftResult;

2538 computePositionedLogicalWidthUsing(~~style()->l~~ogicalWidth(), containerBlock, containerDirection,

2608 computePositionedLogicalWidthUsing(LogicalWidth, containerBlock, containerDirection,

                                       containerLogicalWidth, bordersPlusPadding,

                                       logicalLeftLength, logicalRightLength, marginLogicalLeft, marginLogicalRight,

                                       logicalWidthResult, marginLogicalLeftAlias, marginLogicalRightAlias, logicalLeftResult);

2612

    setLogicalWidth(logicalWidthResult);

    setLogicalLeft(logicalLeftResult);

@@void RenderBox::computePositionedLogicalWidth(RenderRegion* region, LayoutUnit o

        LayoutUnit maxMarginLogicalRight;

        LayoutUnit maxLogicalLeftPos;

2552 computePositionedLogicalWidthUsing(~~style()->l~~ogical~~Max~~Width(), containerBlock, containerDirection,

2623 computePositionedLogicalWidthUsing(MaxLogicalWidth, containerBlock, containerDirection,

                                           containerLogicalWidth, bordersPlusPadding,

                                           logicalLeftLength, logicalRightLength, marginLogicalLeft, marginLogicalRight,

                                           maxLogicalWidth, maxMarginLogicalLeft, maxMarginLogicalRight, maxLogicalLeftPos);

2628

        if (logicalWidth() > maxLogicalWidth) {

            setLogicalWidth(maxLogicalWidth);

            marginLogicalLeftAlias = maxMarginLogicalLeft;

@@void RenderBox::computePositionedLogicalWidth(RenderRegion* region, LayoutUnit o

        LayoutUnit minMarginLogicalRight;

        LayoutUnit minLogicalLeftPos;

2572 computePositionedLogicalWidthUsing(~~style()->l~~ogical~~Min~~Width(), containerBlock, containerDirection,

2644 computePositionedLogicalWidthUsing(MinLogicalWidth, containerBlock, containerDirection,

                                           containerLogicalWidth, bordersPlusPadding,

                                           logicalLeftLength, logicalRightLength, marginLogicalLeft, marginLogicalRight,

                                           minLogicalWidth, minMarginLogicalLeft, minMarginLogicalRight, minLogicalLeftPos);

@@void RenderBox::computePositionedLogicalWidth(RenderRegion* region, LayoutUnit o

    }

    if (stretchesToMinIntrinsicLogicalWidth() && logicalWidth() < minPreferredLogicalWidth() - bordersPlusPadding) {

2586 computePositionedLogicalWidthUsing(~~Length(m~~inPreferredLogicalWidth~~() - bordersPlusPadding, Fixed)~~, containerBlock, containerDirection,

2658 computePositionedLogicalWidthUsing(MinPreferredLogicalWidth, containerBlock, containerDirection,

                                           containerLogicalWidth, bordersPlusPadding,

                                           logicalLeftLength, logicalRightLength, marginLogicalLeft, marginLogicalRight,

                                           logicalWidthResult, marginLogicalLeftAlias, marginLogicalRightAlias, logicalLeftResult);

@@static void computeLogicalLeftPositionedOffset(LayoutUnit& logicalLeftPos, const

        logicalLeftPos += (child->isHorizontalWritingMode() ? containerBlock->borderLeft() : containerBlock->borderTop());

}

2623 void RenderBox::computePositionedLogicalWidthUsing(L~~ength l~~ogicalWidth, const RenderBoxModelObject* containerBlock, TextDirection containerDirection,

2695void RenderBox::computePositionedLogicalWidthUsing(LogicalWidthType widthType, const RenderBoxModelObject* containerBlock, TextDirection containerDirection,

                                                   LayoutUnit containerLogicalWidth, LayoutUnit bordersPlusPadding,

                                                   Length logicalLeft, Length logicalRight, Length marginLogicalLeft, Length marginLogicalRight,

                                                   LayoutUnit& logicalWidthValue, LayoutUnit& marginLogicalLeftValue, LayoutUnit& marginLogicalRightValue, LayoutUnit& logicalLeftPos)

@@void RenderBox::computePositionedLogicalWidthUsing(Length logicalWidth, const Re

    // 'left' and 'right' cannot both be 'auto' because one would of been

    // converted to the static position already

    ASSERT(!(logicalLeft.isAuto() && logicalRight.isAuto()));

    Length logicalWidth;

    switch (widthType) {

    case LogicalWidth:

        logicalWidth = style()->logicalWidth();

        break;

    case MinLogicalWidth:

        logicalWidth = style()->logicalMinWidth();

        break;

    case MaxLogicalWidth:

        logicalWidth = style()->logicalMaxWidth();

        break;

    case MinPreferredLogicalWidth:

        logicalWidth =  Length(minPreferredLogicalWidth() - bordersPlusPadding, Fixed);

        break;

    }

    LayoutUnit logicalLeftValue = 0;

    bool logicalWidthIsAuto = logicalWidth.isIntrinsicOrAuto();

    bool logicalLeftIsAuto = logicalLeft.isAuto();

    bool logicalRightIsAuto = logicalRight.isAuto();

    bool useAspectRatio = useAspectRatioForWidth(logicalWidth, logicalLeft, logicalRight);

    // If we are using aspect-ratio for width then there is a constraint on width.

    bool logicalWidthIsUnconstrained = logicalWidth.isIntrinsicOrAuto() && !useAspectRatio;

    bool logicalLeftIsUnconstrained = logicalLeft.isAuto();

    bool logicalRightIsUnconstrained = logicalRight.isAuto();

26372726

2638 if (!logicalLeftIsAuto && !logicalWidthIsAuto && !logicalRightIsAuto) {

2727 if (!logicalLeftIsUnconstrained && !logicalWidthIsUnconstrained && !logicalRightIsUnconstrained) {

        /*-----------------------------------------------------------------------*\

         * If none of the three is 'auto': If both 'margin-left' and 'margin-

         * right' are 'auto', solve the equation under the extra constraint that

@@void RenderBox::computePositionedLogicalWidthUsing(Length logicalWidth, const Re

        logicalLeftValue = logicalLeft.calcValue(containerLogicalWidth);

        logicalWidthValue = computeContentBoxLogicalWidth(logicalWidth.calcValue(containerLogicalWidth));

        if (useAspectRatio) {

            float requiredRatio = style()->aspectRatio();

            if (logicalHeight()) {

                int widthForAspectRatio = static_cast<int>(logicalHeight() * requiredRatio);

                if (widthType == LogicalWidth)

                    logicalWidthValue =  widthForAspectRatio;

            } else {

                // Height is not determined so LogicalWidth is the container's content width.

                // widthType will be LogicalMinWidth or LogicalMaxWidth only if they are specified in which

                // case they have to be respected.

                if (widthType == LogicalWidth) {

                    LayoutUnit availableContainerWidth = containerLogicalWidth - (logicalLeftValue + bordersPlusPadding);

                    logicalWidthValue = availableContainerWidth;

                }

            }

        }

        const LayoutUnit availableSpace = containerLogicalWidth - (logicalLeftValue + logicalWidthValue + logicalRight.calcValue(containerLogicalWidth) + bordersPlusPadding);

@@void RenderBox::computePositionedLogicalWidthUsing(Length logicalWidth, const Re

        // FIXME: Is there a faster way to find the correct case?

        // Use rule/case that applies.

2744 if (logicalLeftIsAuto && logicalWidthIsAuto && !logicalRightIsAuto) {

2850 if (logicalLeftIsUnconstrained && logicalWidthIsUnconstrained && !logicalRightIsUnconstrained) {

            // RULE 1: (use shrink-to-fit for width, and solve of left)

            LayoutUnit logicalRightValue = logicalRight.calcValue(containerLogicalWidth);

@@void RenderBox::computePositionedLogicalWidthUsing(Length logicalWidth, const Re

            LayoutUnit availableWidth = availableSpace - logicalRightValue;

            logicalWidthValue = min(max(preferredMinWidth, availableWidth), preferredWidth);

            logicalLeftValue = availableSpace - (logicalWidthValue + logicalRightValue);

2754 } else if (!logicalLeftIsAuto && logicalWidthIsAuto && logicalRightIsAuto) {

2860 } else if (!logicalLeftIsUnconstrained && logicalWidthIsUnconstrained && logicalRightIsUnconstrained) {

            // RULE 3: (use shrink-to-fit for width, and no need solve of right)

            logicalLeftValue = logicalLeft.calcValue(containerLogicalWidth);

@@void RenderBox::computePositionedLogicalWidthUsing(Length logicalWidth, const Re

            LayoutUnit preferredMinWidth = minPreferredLogicalWidth() - bordersPlusPadding;

            LayoutUnit availableWidth = availableSpace - logicalLeftValue;

            logicalWidthValue = min(max(preferredMinWidth, availableWidth), preferredWidth);

2763 } else if (logicalLeftIsAuto && !logicalWidthIsAuto && !logicalRightIsAuto) {

2869 } else if (logicalLeftIsUnconstrained && !logicalWidthIsUnconstrained && !logicalRightIsUnconstrained) {

27642870 // RULE 4: (solve for left)

27652871 logicalWidthValue = computeContentBoxLogicalWidth(logicalWidth.calcValue(containerLogicalWidth));

            if (useAspectRatio) {

                float requiredRatio = style()->aspectRatio();

                // FIXME: Refactor this.

                if (logicalHeight()) {

                    int widthForAspectRatio = static_cast<int>(logicalHeight() * requiredRatio);

                    if (widthType == LogicalWidth)

                        logicalWidthValue =  widthForAspectRatio;

                } else {

                    // Height is not determined so LogicalWidth is the container's content width.

                    // widthType will be LogicalMinWidth or LogicalMaxWidth only if they are specified in which

                    // case they have to be respected.

                    if (widthType == LogicalWidth) {

                        LayoutUnit availableContainerWidth = containerLogicalWidth - (logicalRight.calcMinValue(containerLogicalWidth) + bordersPlusPadding);

                        logicalWidthValue = availableContainerWidth;

                    }

                }

            }

27662890 logicalLeftValue = availableSpace - (logicalWidthValue + logicalRight.calcValue(containerLogicalWidth));

2767 } else if (!logicalLeftIsAuto && logicalWidthIsAuto && !logicalRightIsAuto) {

2891 } else if (!logicalLeftIsUnconstrained && logicalWidthIsUnconstrained && !logicalRightIsUnconstrained) {

            // RULE 5: (solve for width)

            logicalLeftValue = logicalLeft.calcValue(containerLogicalWidth);

            logicalWidthValue = availableSpace - (logicalLeftValue + logicalRight.calcValue(containerLogicalWidth));

2771 } else if (!logicalLeftIsAuto && !logicalWidthIsAuto && logicalRightIsAuto) {

2895 } else if (!logicalLeftIsUnconstrained && !logicalWidthIsUnconstrained && logicalRightIsUnconstrained) {

            // RULE 6: (no need solve for right)

            logicalLeftValue = logicalLeft.calcValue(containerLogicalWidth);

            logicalWidthValue = computeContentBoxLogicalWidth(logicalWidth.calcValue(containerLogicalWidth));

            if (useAspectRatio) {

                float requiredRatio = style()->aspectRatio();

                if (logicalHeight()) {

                    int widthForAspectRatio = static_cast<int>(logicalHeight() * requiredRatio);

                    if (widthType == LogicalWidth)

                        logicalWidthValue =  widthForAspectRatio;

                } else {

                    // Height is not determined so LogicalWidth is the container's content width.

                    // widthType will be LogicalMinWidth or LogicalMaxWidth only if they are specified in which

                    // case they have to be respected.

                    if (widthType == LogicalWidth) {

                        LayoutUnit availableContainerWidth = containerLogicalWidth - (logicalLeftValue + bordersPlusPadding);

                        logicalWidthValue = availableContainerWidth;

                    }

                }

            }

        }

    }

@@void RenderBox::computePositionedLogicalHeight()

    LayoutUnit logicalTopPos;

    // Calculate constraint equation values for 'height' case.

2867 computePositionedLogicalHeightUsing(~~style()->l~~ogicalHeight(), containerBlock, containerLogicalHeight, bordersPlusPadding,

3008 computePositionedLogicalHeightUsing(LogicalHeight, containerBlock, containerLogicalHeight, bordersPlusPadding,

                                        logicalTopLength, logicalBottomLength, marginBefore, marginAfter,

                                        logicalHeightResult, marginBeforeAlias, marginAfterAlias, logicalTopPos);

    setLogicalTop(logicalTopPos);

@@void RenderBox::computePositionedLogicalHeight()

        LayoutUnit maxMarginAfter;

        LayoutUnit maxLogicalTopPos;

2882 computePositionedLogicalHeightUsing(~~style()->l~~ogical~~Max~~Height(), containerBlock, containerLogicalHeight, bordersPlusPadding,

3023 computePositionedLogicalHeightUsing(MaxLogicalHeight, containerBlock, containerLogicalHeight, bordersPlusPadding,

                                            logicalTopLength, logicalBottomLength, marginBefore, marginAfter,

                                            maxLogicalHeight, maxMarginBefore, maxMarginAfter, maxLogicalTopPos);

@@void RenderBox::computePositionedLogicalHeight()

        LayoutUnit minMarginAfter;

        LayoutUnit minLogicalTopPos;

2901 computePositionedLogicalHeightUsing(~~style()->l~~ogical~~Min~~Height(), containerBlock, containerLogicalHeight, bordersPlusPadding,

3042 computePositionedLogicalHeightUsing(MinLogicalHeight, containerBlock, containerLogicalHeight, bordersPlusPadding,

                                            logicalTopLength, logicalBottomLength, marginBefore, marginAfter,

                                            minLogicalHeight, minMarginBefore, minMarginAfter, minLogicalTopPos);

@@static void computeLogicalTopPositionedOffset(LayoutUnit& logicalTopPos, const R

    }

}

2953 void RenderBox::computePositionedLogicalHeightUsing(L~~ength l~~ogicalHeightLength, const RenderBoxModelObject* containerBlock,

3094void RenderBox::computePositionedLogicalHeightUsing(LogicalHeightType heightType, const RenderBoxModelObject* containerBlock,

                                                    LayoutUnit containerLogicalHeight, LayoutUnit bordersPlusPadding,

                                                    Length logicalTop, Length logicalBottom, Length marginBefore, Length marginAfter,

                                                    LayoutUnit& logicalHeightValue, LayoutUnit& marginBeforeValue, LayoutUnit& marginAfterValue, LayoutUnit& logicalTopPos)

@@void RenderBox::computePositionedLogicalHeightUsing(Length logicalHeightLength,

    // 'top' and 'bottom' cannot both be 'auto' because 'top would of been

    // converted to the static position in computePositionedLogicalHeight()

    ASSERT(!(logicalTop.isAuto() && logicalBottom.isAuto()));

    Length logicalHeightLength;

    switch (heightType) {

    case LogicalHeight:

        logicalHeightLength = style()->logicalHeight();

        break;

    case MinLogicalHeight:

        logicalHeightLength = style()->logicalMinHeight();

        break;

    case MaxLogicalHeight:

        logicalHeightLength = style()->logicalMaxHeight();

        break;

    }

    LayoutUnit contentLogicalHeight = logicalHeight() - bordersPlusPadding;

    LayoutUnit logicalTopValue = 0;

    bool logicalHeightIsAuto = logicalHeightLength.isAuto();

    bool logicalTopIsAuto = logicalTop.isAuto();

    bool logicalBottomIsAuto = logicalBottom.isAuto();

    bool useAspectRatio = useAspectRatioForHeight(logicalHeightLength, logicalTop, logicalBottom);

    bool logicalHeightIsUnconstrained = logicalHeightLength.isAuto() && !useAspectRatio;

    bool logicalTopIsUnconstrained = logicalTop.isAuto();

    bool logicalBottomIsUnconstrained = logicalBottom.isAuto();

    // Height is never unsolved for tables.

    if (isTable()) {

        logicalHeightLength.setValue(Fixed, contentLogicalHeight);

2973 logicalHeightIsAuto = false;

3127 logicalHeightIsUnconstrained = false;

29743128 }

29753129

2976 if (!logicalTopIsAuto && !logicalHeightIsAuto && !logicalBottomIsAuto) {

3130 if (!logicalTopIsUnconstrained && !logicalHeightIsUnconstrained && !logicalBottomIsUnconstrained) {

        /*-----------------------------------------------------------------------*\

         * If none of the three are 'auto': If both 'margin-top' and 'margin-

         * bottom' are 'auto', solve the equation under the extra constraint that

@@void RenderBox::computePositionedLogicalHeightUsing(Length logicalHeightLength,

        // NOTE:  It is not necessary to solve for 'bottom' in the over constrained

        // case because the value is not used for any further calculations.

2988 logicalHeightValue = computeContentBoxLogicalHeight(logicalHeightLength.calcValue(containerLogicalHeight));

29893142 logicalTopValue = logicalTop.calcValue(containerLogicalHeight);

2990

        logicalHeightValue = computeContentBoxLogicalHeight(logicalHeightLength.calcValue(containerLogicalHeight));

        if (useAspectRatio) {

            float requiredRatio = style()->aspectRatioDenominator() / style()->aspectRatioNumerator();

            if (logicalWidth()) {

                int heightForAspectRatio = static_cast<int>(logicalWidth() * requiredRatio);

                if (heightType == LogicalHeight)

                    logicalHeightValue = heightForAspectRatio;

            } else {

                if (heightType == LogicalHeight) {

                    LayoutUnit availableContainerHeight = containerLogicalHeight - (logicalTopValue + logicalBottom.calcValue(containerLogicalHeight) + bordersPlusPadding);

                    logicalHeightValue = availableContainerHeight;

                }

            }

        }

        const LayoutUnit availableSpace = containerLogicalHeight - (logicalTopValue + logicalHeightValue + logicalBottom.calcValue(containerLogicalHeight) + bordersPlusPadding);

        // Margins are now the only unknown

@@void RenderBox::computePositionedLogicalHeightUsing(Length logicalHeightLength,

        const LayoutUnit availableSpace = containerLogicalHeight - (marginBeforeValue + marginAfterValue + bordersPlusPadding);

        // Use rule/case that applies.

3045 if (logicalTopIsAuto && logicalHeightIsAuto && !logicalBottomIsAuto) {

3211 if (logicalTopIsUnconstrained && logicalHeightIsUnconstrained && !logicalBottomIsUnconstrained) {

            // RULE 1: (height is content based, solve of top)

            logicalHeightValue = contentLogicalHeight;

            logicalTopValue = availableSpace - (logicalHeightValue + logicalBottom.calcValue(containerLogicalHeight));

3049 } else if (!logicalTopIsAuto && logicalHeightIsAuto && logicalBottomIsAuto) {

3215 } else if (!logicalTopIsUnconstrained && logicalHeightIsUnconstrained && logicalBottomIsUnconstrained) {

            // RULE 3: (height is content based, no need solve of bottom)

            logicalTopValue = logicalTop.calcValue(containerLogicalHeight);

            logicalHeightValue = contentLogicalHeight;

3053 } else if (logicalTopIsAuto && !logicalHeightIsAuto && !logicalBottomIsAuto) {

3219 } else if (logicalTopIsUnconstrained && !logicalHeightIsUnconstrained && !logicalBottomIsUnconstrained) {

            // RULE 4: (solve of top)

            logicalHeightValue = computeContentBoxLogicalHeight(logicalHeightLength.calcValue(containerLogicalHeight));

            logicalTopValue = availableSpace - (logicalHeightValue + logicalBottom.calcValue(containerLogicalHeight));

3057 } else if (!logicalTopIsAuto && logicalHeightIsAuto && !logicalBottomIsAuto) {

            if (useAspectRatio) {

                float requiredRatio = style()->aspectRatioDenominator() / style()->aspectRatioNumerator();

                if (logicalWidth()) {

                    int heightForAspectRatio = static_cast<int>(logicalWidth() * requiredRatio);

                    if (heightType == LogicalHeight)

                        logicalHeightValue = heightForAspectRatio;

                } else {

                    if (heightType == LogicalHeight) {

                        LayoutUnit availableContainerHeight = containerLogicalHeight - (logicalTopValue + logicalBottom.calcValue(containerLogicalHeight) + bordersPlusPadding);

                        logicalHeightValue = availableContainerHeight;

                    }

                }

            }

        } else if (!logicalTopIsUnconstrained && logicalHeightIsUnconstrained && !logicalBottomIsUnconstrained) {

            // RULE 5: (solve of height)

            logicalTopValue = logicalTop.calcValue(containerLogicalHeight);

            logicalHeightValue = max<LayoutUnit>(0, availableSpace - (logicalTopValue + logicalBottom.calcValue(containerLogicalHeight)));

3061 } else if (!logicalTopIsAuto && !logicalHeightIsAuto && logicalBottomIsAuto) {

3240 } else if (!logicalTopIsUnconstrained && !logicalHeightIsUnconstrained && logicalBottomIsUnconstrained) {

            // RULE 6: (no need solve of bottom)

            logicalHeightValue = computeContentBoxLogicalHeight(logicalHeightLength.calcValue(containerLogicalHeight));

            logicalTopValue = logicalTop.calcValue(containerLogicalHeight);

            if (useAspectRatio) {

                float requiredRatio = style()->aspectRatioDenominator() / style()->aspectRatioNumerator();

                if (logicalWidth()) {

                    int heightForAspectRatio = static_cast<int>(logicalWidth() * requiredRatio);

                    if (heightType == LogicalHeight)

                        logicalHeightValue = heightForAspectRatio;

                } else {

                    if (heightType == LogicalHeight) {

                        LayoutUnit availableContainerHeight = containerLogicalHeight - (logicalTopValue + logicalBottom.calcValue(containerLogicalHeight) + bordersPlusPadding);

                        logicalHeightValue = availableContainerHeight;

                    }

                }

            }

        }

    }

Source/WebCore/rendering/RenderBox.h

@@class RenderBoxRegionInfo;

class RenderRegion;

struct PaintInfo;

36 enum LogicalWidthType { LogicalWidth, MinLogicalWidth, MaxLogicalWidth };

36enum LogicalWidthType { LogicalWidth, MinLogicalWidth, MaxLogicalWidth, MinPreferredLogicalWidth };

37enum LogicalHeightType { LogicalHeight, MinLogicalHeight, MaxLogicalHeight };

enum OverlayScrollbarSizeRelevancy { IgnoreOverlayScrollbarSize, IncludeOverlayScrollbarSize };

@@public:

    LayoutUnit containingBlockLogicalWidthForContentInRegion(RenderRegion*, LayoutUnit offsetFromLogicalTopOfFirstPage) const;

    LayoutUnit perpendicularContainingBlockLogicalHeight() const;

    virtual bool isWidthDeterminedUsing(const Length& logicalWidth, const Length& logicalLeft, const Length& logicalRight) const;

    virtual bool isHeightDeterminedUsing(const Length& logicalHeight, const Length& logicalTop, const Length& logicalBottom) const;

    bool useAspectRatioForWidth(const Length& logicalWidth, const Length& logicalLeft, const Length& logicalRight) const;

    bool useAspectRatioForHeight(const Length& logicalHeight, const Length& logicalTop, const Length& logicalBottom) const;

    virtual void computeLogicalWidth();

    virtual void computeLogicalHeight();

@@public:

    virtual bool stretchesToMinIntrinsicLogicalWidth() const { return false; }

    LayoutUnit computeLogicalWidthUsing(LogicalWidthType, LayoutUnit availableLogicalWidth);

322 LayoutUnit computeLogicalHeightUsing(~~const Length& h~~eight);

329 LayoutUnit computeLogicalHeightUsing(LogicalHeightType);

    LayoutUnit computeReplacedLogicalWidthUsing(Length width) const;

    LayoutUnit computeReplacedLogicalWidthRespectingMinMaxWidth(LayoutUnit logicalWidth, bool includeMaxWidth = true) const;

    LayoutUnit computeReplacedLogicalHeightUsing(Length height) const;

@@private:

    LayoutUnit containingBlockLogicalHeightForPositioned(const RenderBoxModelObject* containingBlock, bool checkForPerpendicularWritingMode = true) const;

    void computePositionedLogicalHeight();

476 void computePositionedLogicalWidthUsing(L~~ength l~~ogicalWidth, const RenderBoxModelObject* containerBlock, TextDirection containerDirection,

483 void computePositionedLogicalWidthUsing(LogicalWidthType, const RenderBoxModelObject* containerBlock, TextDirection containerDirection,

                                            LayoutUnit containerLogicalWidth, LayoutUnit bordersPlusPadding,

                                            Length logicalLeft, Length logicalRight, Length marginLogicalLeft, Length marginLogicalRight,

                                            LayoutUnit& logicalWidthValue, LayoutUnit& marginLogicalLeftValue, LayoutUnit& marginLogicalRightValue, LayoutUnit& logicalLeftPos);

480 void computePositionedLogicalHeightUsing(L~~ength l~~ogicalHeight, const RenderBoxModelObject* containerBlock,

487 void computePositionedLogicalHeightUsing(LogicalHeightType, const RenderBoxModelObject* containerBlock,

                                             LayoutUnit containerLogicalHeight, LayoutUnit bordersPlusPadding,

                                             Length logicalTop, Length logicalBottom, Length marginLogicalTop, Length marginLogicalBottom,

                                             LayoutUnit& logicalHeightValue, LayoutUnit& marginLogicalTopValue, LayoutUnit& marginLogicalBottomValue, LayoutUnit& logicalTopPos);

Source/WebCore/rendering/style/RenderStyle.cpp

@@StyleDifference RenderStyle::diff(const RenderStyle* other, unsigned& changedCon

            || rareNonInheritedData->textOverflow != other->rareNonInheritedData->textOverflow)

            return StyleDifferenceLayout;

        if (rareNonInheritedData->m_hasAspectRatio != other->rareNonInheritedData->m_hasAspectRatio)

            return StyleDifferenceLayout;

        if (rareNonInheritedData->m_hasAspectRatio) {

            float aspectRatio = rareNonInheritedData->m_aspectRatioNumerator / rareNonInheritedData->m_aspectRatioDenominator;

            float otherAspectRatio = other->rareNonInheritedData->m_aspectRatioNumerator / other->rareNonInheritedData->m_aspectRatioDenominator;

            if (aspectRatio != otherAspectRatio)

                return StyleDifferenceLayout;

        }

        if (rareNonInheritedData->m_regionOverflow != other->rareNonInheritedData->m_regionOverflow)

            return StyleDifferenceLayout;

LayoutTests/ChangeLog

2011-11-29  Fady Samuel  <fsamuel@chromium.org>

        -webkit-aspect-ratio Layout Implementation

        https://bugs.webkit.org/show_bug.cgi?id=73277

        Reviewed by NOBODY (OOPS!).

        * css3/aspect-ratio/absolute-ratio-absolute-left-right.html: Added.

        * css3/aspect-ratio/aspect-ratio-absolute-height.html: Added.

        * css3/aspect-ratio/aspect-ratio-absolute-width.html: Added.

        * css3/aspect-ratio/aspect-ratio-auto-height.html: Added.

        * css3/aspect-ratio/aspect-ratio-float.html: Added.

        * css3/aspect-ratio/aspect-ratio-inherit.html: Added.

        * css3/aspect-ratio/aspect-ratio-stretch-to-fill.html: Added.

        * platform/chromium-linux/css3/aspect-ratio/absolute-ratio-absolute-left-right-expected.png: Added.

        * platform/chromium-linux/css3/aspect-ratio/absolute-ratio-absolute-left-right-expected.txt: Added.

        * platform/chromium-linux/css3/aspect-ratio/aspect-ratio-absolute-height-expected.png: Added.

        * platform/chromium-linux/css3/aspect-ratio/aspect-ratio-absolute-height-expected.txt: Added.

        * platform/chromium-linux/css3/aspect-ratio/aspect-ratio-absolute-width-expected.png: Added.

        * platform/chromium-linux/css3/aspect-ratio/aspect-ratio-absolute-width-expected.txt: Added.

        * platform/chromium-linux/css3/aspect-ratio/aspect-ratio-auto-height-expected.png: Added.

        * platform/chromium-linux/css3/aspect-ratio/aspect-ratio-auto-height-expected.txt: Added.

        * platform/chromium-linux/css3/aspect-ratio/aspect-ratio-float-expected.png: Added.

        * platform/chromium-linux/css3/aspect-ratio/aspect-ratio-float-expected.txt: Added.

        * platform/chromium-linux/css3/aspect-ratio/aspect-ratio-inherit-expected.png: Added.

        * platform/chromium-linux/css3/aspect-ratio/aspect-ratio-inherit-expected.txt: Added.

        * platform/chromium-linux/css3/aspect-ratio/aspect-ratio-stretch-to-fill-expected.png: Added.

        * platform/chromium-linux/css3/aspect-ratio/aspect-ratio-stretch-to-fill-expected.txt: Added.

2011-11-29  Csaba Osztrogonác  <ossy@webkit.org>

        [Qt] Unreviewed evening gardening.

LayoutTests/css3/aspect-ratio/absolute-ratio-absolute-left-right.html

<html>

  <head>

  </head>

  <body>

    <div style="position: absolute; top: 10px; left: 10px; right: 10px; -webkit-aspect-ratio: 16 / 9; background-color: green;"></div>

  </body>

</html>

LayoutTests/css3/aspect-ratio/aspect-ratio-absolute-height.html

<html>

  <head>

  </head>

  <body>

    <div style="position: absolute; height: 50px; top: 10px; left:10px; -webkit-aspect-ratio: 9/16; background-color: green;"></div>

  </body>

</html>

LayoutTests/css3/aspect-ratio/aspect-ratio-absolute-width.html

<html>

  <head>

  </head>

  <body>

    <div style="position: absolute; width: 50px; top: 10px; left:10px; -webkit-aspect-ratio: 9/16; background-color: green;"></div>

  </body>

</html>

LayoutTests/css3/aspect-ratio/aspect-ratio-auto-height.html

<html>

  <head>

  </head>

  <body>

    <div style="position: absolute; left: 10px; width: 200px; -webkit-aspect-ratio: 16 / 9; background-color: green;"></div>

  </body>

</html>

LayoutTests/css3/aspect-ratio/aspect-ratio-float.html

<div style="width: 600px; height: 200px; background-color: red;">

  <div style="float: right; width: 50px; -webkit-aspect-ratio: 1/4; background-color: green;"></div>

</div>

LayoutTests/css3/aspect-ratio/aspect-ratio-inherit.html

<html>

  <head>

  </head>

  <body>

    <div style="position: fixed; top: 10px; bottom: 10px; left: 10px; right: 10px; -webkit-aspect-ratio: 20 / 9; background-color: red;">

      <div style="position: relative; left: 50px; top: 50px; width: 300px; background-color: green; -webkit-aspect-ratio: inherit;"></div>

    </div>

  </body>

</html>

LayoutTests/css3/aspect-ratio/aspect-ratio-stretch-to-fill.html

<html>

  <head>

  </head>

  <body>

    <div style="position:absolute; top: 0px; bottom: 0px; left: 0px; right: 0px; -webkit-aspect-ratio: 16 / 9; margin: auto; background-color: green; max-height: 640px;"></div>

  </body>

</html>

LayoutTests/platform/chromium-linux/css3/aspect-ratio/absolute-ratio-absolute-left-right-expected.png