Diff
Modified: trunk/Source/WebCore/ChangeLog (188872 => 188873)
--- trunk/Source/WebCore/ChangeLog 2015-08-24 18:46:44 UTC (rev 188872)
+++ trunk/Source/WebCore/ChangeLog 2015-08-24 18:48:51 UTC (rev 188873)
@@ -1,3 +1,56 @@
+2015-08-24 Myles C. Maxfield <mmaxfi...@apple.com>
+
+ Use Optionals in RenderBox height computations
+ https://bugs.webkit.org/show_bug.cgi?id=147253
+
+ Reviewed by David Hyatt.
+
+ No new tests because there is no behavior change.
+
+ * rendering/RenderBox.cpp:
+ (WebCore::RenderBox::constrainLogicalHeightByMinMax):
+ (WebCore::RenderBox::constrainContentBoxLogicalHeightByMinMax):
+ (WebCore::RenderBox::overrideContainingBlockContentLogicalWidth):
+ (WebCore::RenderBox::overrideContainingBlockContentLogicalHeight):
+ (WebCore::RenderBox::setOverrideContainingBlockContentLogicalWidth):
+ (WebCore::RenderBox::setOverrideContainingBlockContentLogicalHeight):
+ (WebCore::RenderBox::adjustContentBoxLogicalHeightForBoxSizing):
+ (WebCore::RenderBox::containingBlockLogicalWidthForContent):
+ (WebCore::RenderBox::containingBlockLogicalHeightForContent):
+ (WebCore::RenderBox::perpendicularContainingBlockLogicalHeight):
+ (WebCore::RenderBox::computeLogicalHeight):
+ (WebCore::RenderBox::computeLogicalHeightUsing):
+ (WebCore::RenderBox::computeContentLogicalHeight):
+ (WebCore::RenderBox::computeIntrinsicLogicalContentHeightUsing):
+ (WebCore::RenderBox::computeContentAndScrollbarLogicalHeightUsing):
+ (WebCore::RenderBox::computePercentageLogicalHeight):
+ (WebCore::RenderBox::computeReplacedLogicalHeightUsing):
+ (WebCore::RenderBox::availableLogicalHeight):
+ (WebCore::RenderBox::availableLogicalHeightUsing):
+ (WebCore::RenderBox::computePositionedLogicalHeightUsing):
+ (WebCore::logicalWidthIsResolvable):
+ (WebCore::RenderBox::percentageLogicalHeightIsResolvableFromBlock):
+ (WebCore::RenderBox::hasDefiniteLogicalHeight):
+ * rendering/RenderBox.h:
+ * rendering/RenderFlexibleBox.cpp:
+ (WebCore::RenderFlexibleBox::computeMainAxisExtentForChild):
+ (WebCore::RenderFlexibleBox::preferredMainAxisContentExtentForChild):
+ (WebCore::RenderFlexibleBox::adjustChildSizeForMinAndMax):
+ * rendering/RenderFlexibleBox.h:
+ * rendering/RenderFlowThread.cpp:
+ (WebCore::RenderFlowThread::addForcedRegionBreak):
+ * rendering/RenderGrid.cpp:
+ (WebCore::RenderGrid::computeUsedBreadthOfSpecifiedLength):
+ (WebCore::RenderGrid::logicalContentHeightForChild):
+ (WebCore::RenderGrid::minContentForChild):
+ (WebCore::RenderGrid::maxContentForChild):
+ (WebCore::RenderGrid::layoutGridItems):
+ (WebCore::RenderGrid::applyStretchAlignmentToChildIfNeeded):
+ * rendering/RenderMultiColumnSet.cpp:
+ (WebCore::RenderMultiColumnSet::calculateMaxColumnHeight):
+ * rendering/RenderTable.cpp:
+ (WebCore::RenderTable::convertStyleLogicalHeightToComputedHeight):
+
2015-08-24 Anders Carlsson <ander...@apple.com>
Fix failing tests.
Modified: trunk/Source/WebCore/rendering/RenderBox.cpp (188872 => 188873)
--- trunk/Source/WebCore/rendering/RenderBox.cpp 2015-08-24 18:46:44 UTC (rev 188872)
+++ trunk/Source/WebCore/rendering/RenderBox.cpp 2015-08-24 18:48:51 UTC (rev 188873)
@@ -92,8 +92,9 @@
#if ENABLE(CSS_GRID_LAYOUT)
// Used by grid elements to properly size their grid items.
-static OverrideSizeMap* gOverrideContainingBlockLogicalHeightMap = nullptr;
-static OverrideSizeMap* gOverrideContainingBlockLogicalWidthMap = nullptr;
+typedef WTF::HashMap<const RenderBox*, Optional<LayoutUnit>> OverrideOptionalSizeMap;
+static OverrideOptionalSizeMap* gOverrideContainingBlockLogicalHeightMap = nullptr;
+static OverrideOptionalSizeMap* gOverrideContainingBlockLogicalWidthMap = nullptr;
#endif
// Size of border belt for autoscroll. When mouse pointer in border belt,
@@ -663,26 +664,28 @@
return std::max(logicalWidth, computeLogicalWidthInRegionUsing(MinSize, styleToUse.logicalMinWidth(), availableWidth, cb, region));
}
-LayoutUnit RenderBox::constrainLogicalHeightByMinMax(LayoutUnit logicalHeight, LayoutUnit intrinsicContentHeight) const
+LayoutUnit RenderBox::constrainLogicalHeightByMinMax(LayoutUnit logicalHeight, Optional<LayoutUnit> intrinsicContentHeight) const
{
const RenderStyle& styleToUse = style();
if (!styleToUse.logicalMaxHeight().isUndefined()) {
- LayoutUnit maxH = computeLogicalHeightUsing(styleToUse.logicalMaxHeight(), intrinsicContentHeight);
- if (maxH != -1)
- logicalHeight = std::min(logicalHeight, maxH);
+ if (Optional<LayoutUnit> maxH = computeLogicalHeightUsing(styleToUse.logicalMaxHeight(), intrinsicContentHeight))
+ logicalHeight = std::min(logicalHeight, maxH.value());
}
- return std::max(logicalHeight, computeLogicalHeightUsing(styleToUse.logicalMinHeight(), intrinsicContentHeight));
+ if (Optional<LayoutUnit> computedLogicalHeight = computeLogicalHeightUsing(styleToUse.logicalMinHeight(), intrinsicContentHeight))
+ return std::max(logicalHeight, computedLogicalHeight.value());
+ return logicalHeight;
}
-LayoutUnit RenderBox::constrainContentBoxLogicalHeightByMinMax(LayoutUnit logicalHeight, LayoutUnit intrinsicContentHeight) const
+LayoutUnit RenderBox::constrainContentBoxLogicalHeightByMinMax(LayoutUnit logicalHeight, Optional<LayoutUnit> intrinsicContentHeight) const
{
const RenderStyle& styleToUse = style();
if (!styleToUse.logicalMaxHeight().isUndefined()) {
- LayoutUnit maxH = computeContentLogicalHeight(styleToUse.logicalMaxHeight(), intrinsicContentHeight);
- if (maxH != -1)
- logicalHeight = std::min(logicalHeight, maxH);
+ if (Optional<LayoutUnit> maxH = computeContentLogicalHeight(styleToUse.logicalMaxHeight(), intrinsicContentHeight))
+ logicalHeight = std::min(logicalHeight, maxH.value());
}
- return std::max(logicalHeight, computeContentLogicalHeight(styleToUse.logicalMinHeight(), intrinsicContentHeight));
+ if (Optional<LayoutUnit> computedContentLogicalHeight = computeContentLogicalHeight(styleToUse.logicalMinHeight(), intrinsicContentHeight))
+ return std::max(logicalHeight, computedContentLogicalHeight.value());
+ return logicalHeight;
}
RoundedRect::Radii RenderBox::borderRadii() const
@@ -1108,13 +1111,13 @@
}
#if ENABLE(CSS_GRID_LAYOUT)
-LayoutUnit RenderBox::overrideContainingBlockContentLogicalWidth() const
+Optional<LayoutUnit> RenderBox::overrideContainingBlockContentLogicalWidth() const
{
ASSERT(hasOverrideContainingBlockLogicalWidth());
return gOverrideContainingBlockLogicalWidthMap->get(this);
}
-LayoutUnit RenderBox::overrideContainingBlockContentLogicalHeight() const
+Optional<LayoutUnit> RenderBox::overrideContainingBlockContentLogicalHeight() const
{
ASSERT(hasOverrideContainingBlockLogicalHeight());
return gOverrideContainingBlockLogicalHeightMap->get(this);
@@ -1130,17 +1133,17 @@
return gOverrideContainingBlockLogicalHeightMap && gOverrideContainingBlockLogicalHeightMap->contains(this);
}
-void RenderBox::setOverrideContainingBlockContentLogicalWidth(LayoutUnit logicalWidth)
+void RenderBox::setOverrideContainingBlockContentLogicalWidth(Optional<LayoutUnit> logicalWidth)
{
if (!gOverrideContainingBlockLogicalWidthMap)
- gOverrideContainingBlockLogicalWidthMap = new OverrideSizeMap;
+ gOverrideContainingBlockLogicalWidthMap = new OverrideOptionalSizeMap;
gOverrideContainingBlockLogicalWidthMap->set(this, logicalWidth);
}
-void RenderBox::setOverrideContainingBlockContentLogicalHeight(LayoutUnit logicalHeight)
+void RenderBox::setOverrideContainingBlockContentLogicalHeight(Optional<LayoutUnit> logicalHeight)
{
if (!gOverrideContainingBlockLogicalHeightMap)
- gOverrideContainingBlockLogicalHeightMap = new OverrideSizeMap;
+ gOverrideContainingBlockLogicalHeightMap = new OverrideOptionalSizeMap;
gOverrideContainingBlockLogicalHeightMap->set(this, logicalHeight);
}
@@ -1181,11 +1184,14 @@
return std::max<LayoutUnit>(0, width);
}
-LayoutUnit RenderBox::adjustContentBoxLogicalHeightForBoxSizing(LayoutUnit height) const
+LayoutUnit RenderBox::adjustContentBoxLogicalHeightForBoxSizing(Optional<LayoutUnit> height) const
{
+ if (!height)
+ return 0;
+ LayoutUnit result = height.value();
if (style().boxSizing() == BORDER_BOX)
- height -= borderAndPaddingLogicalHeight();
- return std::max<LayoutUnit>(0, height);
+ result -= borderAndPaddingLogicalHeight();
+ return std::max(LayoutUnit(), result);
}
// Hit Testing
@@ -1874,26 +1880,24 @@
{
#if ENABLE(CSS_GRID_LAYOUT)
if (hasOverrideContainingBlockLogicalWidth())
- return overrideContainingBlockContentLogicalWidth();
+ return overrideContainingBlockContentLogicalWidth().valueOr(-1);
#endif
- RenderBlock* cb = containingBlock();
- if (!cb)
- return LayoutUnit();
- return cb->availableLogicalWidth();
+ if (RenderBlock* cb = containingBlock())
+ return cb->availableLogicalWidth();
+ return LayoutUnit();
}
LayoutUnit RenderBox::containingBlockLogicalHeightForContent(AvailableLogicalHeightType heightType) const
{
#if ENABLE(CSS_GRID_LAYOUT)
if (hasOverrideContainingBlockLogicalHeight())
- return overrideContainingBlockContentLogicalHeight();
+ return overrideContainingBlockContentLogicalHeight().valueOr(-1);
#endif
- RenderBlock* cb = containingBlock();
- if (!cb)
- return LayoutUnit();
- return cb->availableLogicalHeight(heightType);
+ if (RenderBlock* cb = containingBlock())
+ return cb->availableLogicalHeight(heightType);
+ return LayoutUnit();
}
LayoutUnit RenderBox::containingBlockLogicalWidthForContentInRegion(RenderRegion* region) const
@@ -1929,7 +1933,7 @@
{
#if ENABLE(CSS_GRID_LAYOUT)
if (hasOverrideContainingBlockLogicalHeight())
- return overrideContainingBlockContentLogicalHeight();
+ return overrideContainingBlockContentLogicalHeight().valueOr(-1);
#endif
RenderBlock* cb = containingBlock();
@@ -1947,7 +1951,7 @@
}
// Use the content box logical height as specified by the style.
- return cb->adjustContentBoxLogicalHeightForBoxSizing(logicalHeightLength.value());
+ return cb->adjustContentBoxLogicalHeightForBoxSizing(LayoutUnit(logicalHeightLength.value()));
}
void RenderBox::mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed) const
@@ -2767,9 +2771,7 @@
LayoutUnit heightResult;
if (checkMinMaxHeight) {
LayoutUnit intrinsicHeight = computedValues.m_extent - borderAndPaddingLogicalHeight();
- heightResult = computeLogicalHeightUsing(style().logicalHeight(), intrinsicHeight);
- if (heightResult == -1)
- heightResult = computedValues.m_extent;
+ heightResult = computeLogicalHeightUsing(style().logicalHeight(), intrinsicHeight).valueOr(computedValues.m_extent);
heightResult = constrainLogicalHeightByMinMax(heightResult, intrinsicHeight);
} else {
// The only times we don't check min/max height are when a fixed length has
@@ -2808,23 +2810,21 @@
}
}
-LayoutUnit RenderBox::computeLogicalHeightUsing(const Length& height, LayoutUnit intrinsicContentHeight) const
+Optional<LayoutUnit> RenderBox::computeLogicalHeightUsing(const Length& height, Optional<LayoutUnit> intrinsicContentHeight) const
{
- LayoutUnit logicalHeight = computeContentAndScrollbarLogicalHeightUsing(height, intrinsicContentHeight);
- if (logicalHeight != -1)
- logicalHeight = adjustBorderBoxLogicalHeightForBoxSizing(logicalHeight);
- return logicalHeight;
+ if (Optional<LayoutUnit> logicalHeight = computeContentAndScrollbarLogicalHeightUsing(height, intrinsicContentHeight))
+ return adjustBorderBoxLogicalHeightForBoxSizing(logicalHeight.value());
+ return Nullopt;
}
-LayoutUnit RenderBox::computeContentLogicalHeight(const Length& height, LayoutUnit intrinsicContentHeight) const
+Optional<LayoutUnit> RenderBox::computeContentLogicalHeight(const Length& height, Optional<LayoutUnit> intrinsicContentHeight) const
{
- LayoutUnit heightIncludingScrollbar = computeContentAndScrollbarLogicalHeightUsing(height, intrinsicContentHeight);
- if (heightIncludingScrollbar == -1)
- return -1;
- return std::max<LayoutUnit>(0, adjustContentBoxLogicalHeightForBoxSizing(heightIncludingScrollbar) - scrollbarLogicalHeight());
+ if (Optional<LayoutUnit> heightIncludingScrollbar = computeContentAndScrollbarLogicalHeightUsing(height, intrinsicContentHeight))
+ return std::max<LayoutUnit>(0, adjustContentBoxLogicalHeightForBoxSizing(heightIncludingScrollbar) - scrollbarLogicalHeight());
+ return Nullopt;
}
-LayoutUnit RenderBox::computeIntrinsicLogicalContentHeightUsing(Length logicalHeightLength, LayoutUnit intrinsicContentHeight, LayoutUnit borderAndPadding) const
+Optional<LayoutUnit> RenderBox::computeIntrinsicLogicalContentHeightUsing(Length logicalHeightLength, Optional<LayoutUnit> intrinsicContentHeight, LayoutUnit borderAndPadding) const
{
// FIXME: The CSS sizing spec is considering changing what min-content/max-content should resolve to.
// If that happens, this code will have to change.
@@ -2833,20 +2833,20 @@
if (logicalHeightLength.isFillAvailable())
return containingBlock()->availableLogicalHeight(ExcludeMarginBorderPadding) - borderAndPadding;
ASSERT_NOT_REACHED();
- return 0;
+ return LayoutUnit(0);
}
-LayoutUnit RenderBox::computeContentAndScrollbarLogicalHeightUsing(const Length& height, LayoutUnit intrinsicContentHeight) const
+Optional<LayoutUnit> RenderBox::computeContentAndScrollbarLogicalHeightUsing(const Length& height, Optional<LayoutUnit> intrinsicContentHeight) const
{
// FIXME: The CSS sizing spec is considering changing what min-content/max-content should resolve to.
// If that happens, this code will have to change.
if (height.isIntrinsic())
return computeIntrinsicLogicalContentHeightUsing(height, intrinsicContentHeight, borderAndPaddingLogicalHeight());
if (height.isFixed())
- return height.value();
+ return LayoutUnit(height.value());
if (height.isPercentOrCalculated())
return computePercentageLogicalHeight(height);
- return -1;
+ return Nullopt;
}
bool RenderBox::skipContainingBlockForPercentHeightCalculation(const RenderBox* containingBlock, bool isPerpendicularWritingMode) const
@@ -2863,9 +2863,9 @@
return !containingBlock->isTableCell() && !containingBlock->isOutOfFlowPositioned() && containingBlock->style().logicalHeight().isAuto() && isHorizontalWritingMode() == containingBlock->isHorizontalWritingMode();
}
-LayoutUnit RenderBox::computePercentageLogicalHeight(const Length& height) const
+Optional<LayoutUnit> RenderBox::computePercentageLogicalHeight(const Length& height) const
{
- LayoutUnit availableHeight = -1;
+ Optional<LayoutUnit> availableHeight;
bool skippedAutoHeightContainingBlock = false;
RenderBlock* cb = containingBlock();
@@ -2910,25 +2910,24 @@
// preferable to the alternative (sizing intrinsically and making the row end up too big).
RenderTableCell& cell = downcast<RenderTableCell>(*cb);
if (scrollsOverflowY() && (!cell.style().logicalHeight().isAuto() || !cell.table()->style().logicalHeight().isAuto()))
- return 0;
- return -1;
+ return LayoutUnit(0);
+ return Nullopt;
}
availableHeight = cb->overrideLogicalContentHeight();
includeBorderPadding = true;
}
} else if (cbstyle.logicalHeight().isFixed()) {
- LayoutUnit contentBoxHeight = cb->adjustContentBoxLogicalHeightForBoxSizing(cbstyle.logicalHeight().value());
- availableHeight = std::max<LayoutUnit>(0, cb->constrainContentBoxLogicalHeightByMinMax(contentBoxHeight - cb->scrollbarLogicalHeight(), -1));
+ LayoutUnit contentBoxHeight = cb->adjustContentBoxLogicalHeightForBoxSizing(LayoutUnit(cbstyle.logicalHeight().value()));
+ availableHeight = std::max<LayoutUnit>(0, cb->constrainContentBoxLogicalHeightByMinMax(contentBoxHeight - cb->scrollbarLogicalHeight(), Nullopt));
} else if (cbstyle.logicalHeight().isPercentOrCalculated() && !isOutOfFlowPositionedWithSpecifiedHeight) {
// We need to recur and compute the percentage height for our containing block.
- LayoutUnit heightWithScrollbar = cb->computePercentageLogicalHeight(cbstyle.logicalHeight());
- if (heightWithScrollbar != -1) {
+ if (Optional<LayoutUnit> heightWithScrollbar = cb->computePercentageLogicalHeight(cbstyle.logicalHeight())) {
LayoutUnit contentBoxHeightWithScrollbar = cb->adjustContentBoxLogicalHeightForBoxSizing(heightWithScrollbar);
// We need to adjust for min/max height because this method does not
// handle the min/max of the current block, its caller does. So the
// return value from the recursive call will not have been adjusted
// yet.
- LayoutUnit contentBoxHeight = cb->constrainContentBoxLogicalHeightByMinMax(contentBoxHeightWithScrollbar - cb->scrollbarLogicalHeight(), -1);
+ LayoutUnit contentBoxHeight = cb->constrainContentBoxLogicalHeightByMinMax(contentBoxHeightWithScrollbar - cb->scrollbarLogicalHeight(), Nullopt);
availableHeight = std::max<LayoutUnit>(0, contentBoxHeight);
}
} else if (isOutOfFlowPositionedWithSpecifiedHeight) {
@@ -2940,12 +2939,10 @@
} else if (cb->isRenderView())
availableHeight = view().pageOrViewLogicalHeight();
- if (availableHeight == -1)
+ if (!availableHeight)
return availableHeight;
- availableHeight -= rootMarginBorderPaddingHeight;
-
- LayoutUnit result = valueForLength(height, availableHeight);
+ LayoutUnit result = valueForLength(height, availableHeight.value() - rootMarginBorderPaddingHeight);
if (includeBorderPadding) {
// FIXME: Table cells should default to box-sizing: border-box so we can avoid this hack.
// It is necessary to use the border-box to match WinIE's broken
@@ -3025,7 +3022,7 @@
{
switch (logicalHeight.type()) {
case Fixed:
- return adjustContentBoxLogicalHeightForBoxSizing(logicalHeight.value());
+ return adjustContentBoxLogicalHeightForBoxSizing(LayoutUnit(logicalHeight.value()));
case Percent:
case Calculated:
{
@@ -3085,7 +3082,7 @@
LayoutUnit RenderBox::availableLogicalHeight(AvailableLogicalHeightType heightType) const
{
- return constrainLogicalHeightByMinMax(availableLogicalHeightUsing(style().logicalHeight(), heightType), -1);
+ return constrainLogicalHeightByMinMax(availableLogicalHeightUsing(style().logicalHeight(), heightType), Nullopt);
}
LayoutUnit RenderBox::availableLogicalHeightUsing(const Length& h, AvailableLogicalHeightType heightType) const
@@ -3105,8 +3102,7 @@
return adjustContentBoxLogicalHeightForBoxSizing(valueForLength(h, availableHeight));
}
- LayoutUnit heightIncludingScrollbar = computeContentAndScrollbarLogicalHeightUsing(h, -1);
- if (heightIncludingScrollbar != -1)
+ if (Optional<LayoutUnit> heightIncludingScrollbar = computeContentAndScrollbarLogicalHeightUsing(h, Nullopt))
return std::max<LayoutUnit>(0, adjustContentBoxLogicalHeightForBoxSizing(heightIncludingScrollbar) - scrollbarLogicalHeight());
// FIXME: Check logicalTop/logicalBottom here to correctly handle vertical writing-mode.
@@ -3808,7 +3804,7 @@
logicalHeightIsAuto = false;
} else {
if (logicalHeightLength.isIntrinsic())
- resolvedLogicalHeight = computeIntrinsicLogicalContentHeightUsing(logicalHeightLength, contentLogicalHeight, bordersPlusPadding);
+ resolvedLogicalHeight = computeIntrinsicLogicalContentHeightUsing(logicalHeightLength, contentLogicalHeight, bordersPlusPadding).value();
else
resolvedLogicalHeight = adjustContentBoxLogicalHeightForBoxSizing(valueForLength(logicalHeightLength, containerLogicalHeight));
}
@@ -4533,7 +4529,7 @@
return true;
#if ENABLE(CSS_GRID_LAYOUT)
if (box->hasOverrideContainingBlockLogicalWidth())
- return box->overrideContainingBlockContentLogicalWidth() != -1;
+ return static_cast<bool>(box->overrideContainingBlockContentLogicalWidth());
#endif
if (box->style().logicalWidth().isPercentOrCalculated())
return logicalWidthIsResolvable(*box->containingBlock());
@@ -4565,7 +4561,7 @@
break;
#if ENABLE(CSS_GRID_LAYOUT)
if (cb->hasOverrideContainingBlockLogicalHeight())
- return cb->overrideContainingBlockContentLogicalHeight() != -1;
+ return static_cast<bool>(cb->overrideContainingBlockContentLogicalHeight());
#endif
cb = cb->containingBlock();
@@ -4611,7 +4607,7 @@
return true;
#if ENABLE(CSS_GRID_LAYOUT)
if (hasOverrideContainingBlockLogicalHeight())
- return overrideContainingBlockContentLogicalHeight() != -1;
+ return static_cast<bool>(overrideContainingBlockContentLogicalHeight());
#endif
if (logicalHeight.isIntrinsicOrAuto())
return false;
Modified: trunk/Source/WebCore/rendering/RenderBox.h (188872 => 188873)
--- trunk/Source/WebCore/rendering/RenderBox.h 2015-08-24 18:46:44 UTC (rev 188872)
+++ trunk/Source/WebCore/rendering/RenderBox.h 2015-08-24 18:48:51 UTC (rev 188873)
@@ -87,8 +87,8 @@
LayoutUnit logicalHeight() const { return style().isHorizontalWritingMode() ? height() : width(); }
LayoutUnit constrainLogicalWidthInRegionByMinMax(LayoutUnit, LayoutUnit, RenderBlock*, RenderRegion* = nullptr) const;
- LayoutUnit constrainLogicalHeightByMinMax(LayoutUnit logicalHeight, LayoutUnit intrinsicContentHeight) const;
- LayoutUnit constrainContentBoxLogicalHeightByMinMax(LayoutUnit logicalHeight, LayoutUnit intrinsicContentHeight) const;
+ LayoutUnit constrainLogicalHeightByMinMax(LayoutUnit logicalHeight, Optional<LayoutUnit> intrinsicContentHeight) const;
+ LayoutUnit constrainContentBoxLogicalHeightByMinMax(LayoutUnit logicalHeight, Optional<LayoutUnit> intrinsicContentHeight) const;
void setLogicalLeft(LayoutUnit left)
{
@@ -318,12 +318,12 @@
void clearOverrideLogicalContentWidth();
#if ENABLE(CSS_GRID_LAYOUT)
- LayoutUnit overrideContainingBlockContentLogicalWidth() const;
- LayoutUnit overrideContainingBlockContentLogicalHeight() const;
+ Optional<LayoutUnit> overrideContainingBlockContentLogicalWidth() const;
+ Optional<LayoutUnit> overrideContainingBlockContentLogicalHeight() const;
bool hasOverrideContainingBlockLogicalWidth() const;
bool hasOverrideContainingBlockLogicalHeight() const;
- void setOverrideContainingBlockContentLogicalWidth(LayoutUnit);
- void setOverrideContainingBlockContentLogicalHeight(LayoutUnit);
+ void setOverrideContainingBlockContentLogicalWidth(Optional<LayoutUnit>);
+ void setOverrideContainingBlockContentLogicalHeight(Optional<LayoutUnit>);
void clearContainingBlockOverrideSize();
void clearOverrideContainingBlockContentLogicalHeight();
#endif
@@ -333,7 +333,7 @@
LayoutUnit adjustBorderBoxLogicalWidthForBoxSizing(LayoutUnit width) const;
LayoutUnit adjustBorderBoxLogicalHeightForBoxSizing(LayoutUnit height) const;
LayoutUnit adjustContentBoxLogicalWidthForBoxSizing(LayoutUnit width) const;
- LayoutUnit adjustContentBoxLogicalHeightForBoxSizing(LayoutUnit height) const;
+ LayoutUnit adjustContentBoxLogicalHeightForBoxSizing(Optional<LayoutUnit> height) const;
struct ComputedMarginValues {
ComputedMarginValues()
@@ -421,9 +421,9 @@
LayoutUnit shrinkLogicalWidthToAvoidFloats(LayoutUnit childMarginStart, LayoutUnit childMarginEnd, const RenderBlock* cb, RenderRegion*) const;
LayoutUnit computeLogicalWidthInRegionUsing(SizeType, Length logicalWidth, LayoutUnit availableLogicalWidth, const RenderBlock* containingBlock, RenderRegion*) const;
- LayoutUnit computeLogicalHeightUsing(const Length& height, LayoutUnit intrinsicContentHeight) const;
- LayoutUnit computeContentLogicalHeight(const Length& height, LayoutUnit intrinsicContentHeight) const;
- LayoutUnit computeContentAndScrollbarLogicalHeightUsing(const Length& height, LayoutUnit intrinsicContentHeight) const;
+ Optional<LayoutUnit> computeLogicalHeightUsing(const Length& height, Optional<LayoutUnit> intrinsicContentHeight) const;
+ Optional<LayoutUnit> computeContentLogicalHeight(const Length& height, Optional<LayoutUnit> intrinsicContentHeight) const;
+ Optional<LayoutUnit> computeContentAndScrollbarLogicalHeightUsing(const Length& height, Optional<LayoutUnit> intrinsicContentHeight) const;
LayoutUnit computeReplacedLogicalWidthUsing(Length width) const;
LayoutUnit computeReplacedLogicalWidthRespectingMinMaxWidth(LayoutUnit logicalWidth, ShouldComputePreferred = ComputeActual) const;
LayoutUnit computeReplacedLogicalHeightUsing(Length height) const;
@@ -435,7 +435,7 @@
bool hasDefiniteLogicalWidth() const;
static bool percentageLogicalHeightIsResolvableFromBlock(const RenderBlock* containingBlock, bool outOfFlowPositioned);
bool hasDefiniteLogicalHeight() const;
- LayoutUnit computePercentageLogicalHeight(const Length& height) const;
+ Optional<LayoutUnit> computePercentageLogicalHeight(const Length& height) const;
virtual LayoutUnit availableLogicalWidth() const { return contentLogicalWidth(); }
virtual LayoutUnit availableLogicalHeight(AvailableLogicalHeightType) const;
@@ -646,7 +646,7 @@
void computePositionedLogicalWidth(LogicalExtentComputedValues&, RenderRegion* = nullptr) const;
LayoutUnit computeIntrinsicLogicalWidthUsing(Length logicalWidthLength, LayoutUnit availableLogicalWidth, LayoutUnit borderAndPadding) const;
- LayoutUnit computeIntrinsicLogicalContentHeightUsing(Length logicalHeightLength, LayoutUnit intrinsicContentHeight, LayoutUnit borderAndPadding) const;
+ Optional<LayoutUnit> computeIntrinsicLogicalContentHeightUsing(Length logicalHeightLength, Optional<LayoutUnit> intrinsicContentHeight, LayoutUnit borderAndPadding) const;
virtual bool shouldComputeSizeAsReplaced() const { return isReplaced() && !isInlineBlockOrInlineTable(); }
Modified: trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp (188872 => 188873)
--- trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp 2015-08-24 18:46:44 UTC (rev 188872)
+++ trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp 2015-08-24 18:48:51 UTC (rev 188873)
@@ -447,12 +447,12 @@
return contentLogicalWidth();
}
-LayoutUnit RenderFlexibleBox::computeMainAxisExtentForChild(RenderBox& child, SizeType sizeType, const Length& size)
+Optional<LayoutUnit> RenderFlexibleBox::computeMainAxisExtentForChild(RenderBox& child, SizeType sizeType, const Length& size)
{
// FIXME: This is wrong for orthogonal flows. It should use the flexbox's writing-mode, not the child's in order
// to figure out the logical height/width.
if (isColumnFlow()) {
- // We don't have to check for "auto" here - computeContentLogicalHeight will just return -1 for that case anyway.
+ // We don't have to check for "auto" here - computeContentLogicalHeight will just return Nullopt for that case anyway.
if (size.isIntrinsic())
child.layoutIfNeeded();
return child.computeContentLogicalHeight(size, child.logicalHeight() - child.borderAndPaddingLogicalHeight());
@@ -668,7 +668,7 @@
ASSERT(mainAxisExtent - mainAxisBorderAndPaddingExtentForChild(child) >= 0);
return mainAxisExtent - mainAxisBorderAndPaddingExtentForChild(child);
}
- return std::max(LayoutUnit::fromPixel(0), computeMainAxisExtentForChild(child, MainOrPreferredSize, flexBasis));
+ return computeMainAxisExtentForChild(child, MainOrPreferredSize, flexBasis).valueOr(0);
}
void RenderFlexibleBox::layoutFlexItems(bool relayoutChildren, Vector<LineContext>& lineContexts)
@@ -845,17 +845,13 @@
LayoutUnit RenderFlexibleBox::adjustChildSizeForMinAndMax(RenderBox& child, LayoutUnit childSize)
{
Length max = isHorizontalFlow() ? child.style().maxWidth() : child.style().maxHeight();
- if (max.isSpecifiedOrIntrinsic()) {
- LayoutUnit maxExtent = computeMainAxisExtentForChild(child, MaxSize, max);
- if (maxExtent != -1 && childSize > maxExtent)
- childSize = maxExtent;
- }
+ if (max.isSpecifiedOrIntrinsic())
+ childSize = std::min(childSize, computeMainAxisExtentForChild(child, MaxSize, max).valueOr(childSize));
Length min = isHorizontalFlow() ? child.style().minWidth() : child.style().minHeight();
- LayoutUnit minExtent = 0;
if (min.isSpecifiedOrIntrinsic())
- minExtent = computeMainAxisExtentForChild(child, MinSize, min);
- return std::max(childSize, minExtent);
+ return std::max(childSize, computeMainAxisExtentForChild(child, MinSize, min).valueOr(childSize));
+ return childSize;
}
bool RenderFlexibleBox::computeNextFlexLine(OrderedFlexItemList& orderedChildren, LayoutUnit& preferredMainAxisExtent, double& totalFlexGrow, double& totalWeightedFlexShrink, LayoutUnit& minMaxAppliedMainAxisExtent, bool& hasInfiniteLineLength)
Modified: trunk/Source/WebCore/rendering/RenderFlexibleBox.h (188872 => 188873)
--- trunk/Source/WebCore/rendering/RenderFlexibleBox.h 2015-08-24 18:46:44 UTC (rev 188872)
+++ trunk/Source/WebCore/rendering/RenderFlexibleBox.h 2015-08-24 18:48:51 UTC (rev 188873)
@@ -98,7 +98,7 @@
LayoutUnit mainAxisExtent() const;
LayoutUnit crossAxisContentExtent() const;
LayoutUnit mainAxisContentExtent(LayoutUnit contentLogicalHeight);
- LayoutUnit computeMainAxisExtentForChild(RenderBox& child, SizeType, const Length& size);
+ Optional<LayoutUnit> computeMainAxisExtentForChild(RenderBox& child, SizeType, const Length& size);
WritingMode transformedWritingMode() const;
LayoutUnit flowAwareBorderStart() const;
LayoutUnit flowAwareBorderEnd() const;
Modified: trunk/Source/WebCore/rendering/RenderFlowThread.cpp (188872 => 188873)
--- trunk/Source/WebCore/rendering/RenderFlowThread.cpp 2015-08-24 18:46:44 UTC (rev 188872)
+++ trunk/Source/WebCore/rendering/RenderFlowThread.cpp 2015-08-24 18:48:51 UTC (rev 188873)
@@ -1094,7 +1094,7 @@
hasComputedAutoHeight = true;
// Compute the region height pretending that the offsetBreakInCurrentRegion is the logicalHeight for the auto-height region.
- LayoutUnit regionComputedAutoHeight = namedFlowFragment.constrainContentBoxLogicalHeightByMinMax(offsetBreakInCurrentRegion, -1);
+ LayoutUnit regionComputedAutoHeight = namedFlowFragment.constrainContentBoxLogicalHeightByMinMax(offsetBreakInCurrentRegion, Nullopt);
// The new height of this region needs to be smaller than the initial value, the max height. A forced break is the only way to change the initial
// height of an auto-height region besides content ending.
Modified: trunk/Source/WebCore/rendering/RenderGrid.cpp (188872 => 188873)
--- trunk/Source/WebCore/rendering/RenderGrid.cpp 2015-08-24 18:46:44 UTC (rev 188872)
+++ trunk/Source/WebCore/rendering/RenderGrid.cpp 2015-08-24 18:48:51 UTC (rev 188873)
@@ -469,7 +469,9 @@
LayoutUnit RenderGrid::computeUsedBreadthOfSpecifiedLength(GridTrackSizingDirection direction, const Length& trackLength) const
{
ASSERT(trackLength.isSpecified());
- return valueForLength(trackLength, direction == ForColumns ? logicalWidth() : std::max(LayoutUnit(), computeContentLogicalHeight(style().logicalHeight(), -1)));
+ if (direction == ForColumns)
+ return valueForLength(trackLength, logicalWidth());
+ return valueForLength(trackLength, computeContentLogicalHeight(style().logicalHeight(), Nullopt).valueOr(0));
}
double RenderGrid::computeNormalizedFractionBreadth(Vector<GridTrack>& tracks, const GridSpan& tracksSpan, GridTrackSizingDirection direction, LayoutUnit spaceToFill) const
@@ -548,9 +550,9 @@
LayoutUnit RenderGrid::logicalContentHeightForChild(RenderBox& child, Vector<GridTrack>& columnTracks)
{
- LayoutUnit oldOverrideContainingBlockContentLogicalWidth = child.hasOverrideContainingBlockLogicalWidth() ? child.overrideContainingBlockContentLogicalWidth() : LayoutUnit();
+ Optional<LayoutUnit> oldOverrideContainingBlockContentLogicalWidth = child.hasOverrideContainingBlockLogicalWidth() ? child.overrideContainingBlockContentLogicalWidth() : LayoutUnit();
LayoutUnit overrideContainingBlockContentLogicalWidth = gridAreaBreadthForChild(child, ForColumns, columnTracks);
- if (child.hasRelativeLogicalHeight() || oldOverrideContainingBlockContentLogicalWidth != overrideContainingBlockContentLogicalWidth) {
+ if (child.hasRelativeLogicalHeight() || !oldOverrideContainingBlockContentLogicalWidth || oldOverrideContainingBlockContentLogicalWidth.value() != overrideContainingBlockContentLogicalWidth) {
child.setNeedsLayout(MarkOnlyThis);
// We need to clear the stretched height to properly compute logical height during layout.
child.clearOverrideLogicalContentHeight();
@@ -558,9 +560,9 @@
child.setOverrideContainingBlockContentLogicalWidth(overrideContainingBlockContentLogicalWidth);
// If |child| has a relative logical height, we shouldn't let it override its intrinsic height, which is
- // what we are interested in here. Thus we need to set the override logical height to -1 (no possible resolution).
+ // what we are interested in here. Thus we need to set the override logical height to Nullopt (no possible resolution).
if (child.hasRelativeLogicalHeight())
- child.setOverrideContainingBlockContentLogicalHeight(-1);
+ child.setOverrideContainingBlockContentLogicalHeight(Nullopt);
child.layoutIfNeeded();
return child.logicalHeight() + child.marginLogicalHeight();
}
@@ -574,9 +576,9 @@
if (direction == ForColumns) {
// If |child| has a relative logical width, we shouldn't let it override its intrinsic width, which is
- // what we are interested in here. Thus we need to set the override logical width to -1 (no possible resolution).
+ // what we are interested in here. Thus we need to set the override logical width to Nullopt (no possible resolution).
if (child.hasRelativeLogicalWidth())
- child.setOverrideContainingBlockContentLogicalWidth(-1);
+ child.setOverrideContainingBlockContentLogicalWidth(Nullopt);
// FIXME: It's unclear if we should return the intrinsic width or the preferred width.
// See http://lists.w3.org/Archives/Public/www-style/2013Jan/0245.html
@@ -595,9 +597,9 @@
if (direction == ForColumns) {
// If |child| has a relative logical width, we shouldn't let it override its intrinsic width, which is
- // what we are interested in here. Thus we need to set the override logical width to -1 (no possible resolution).
+ // what we are interested in here. Thus we need to set the override logical width to Nullopt (no possible resolution).
if (child.hasRelativeLogicalWidth())
- child.setOverrideContainingBlockContentLogicalWidth(-1);
+ child.setOverrideContainingBlockContentLogicalWidth(Nullopt);
// FIXME: It's unclear if we should return the intrinsic width or the preferred width.
// See http://lists.w3.org/Archives/Public/www-style/2013Jan/0245.html
@@ -1174,12 +1176,14 @@
for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
// Because the grid area cannot be styled, we don't need to adjust
// the grid breadth to account for 'box-sizing'.
- LayoutUnit oldOverrideContainingBlockContentLogicalWidth = child->hasOverrideContainingBlockLogicalWidth() ? child->overrideContainingBlockContentLogicalWidth() : LayoutUnit();
- LayoutUnit oldOverrideContainingBlockContentLogicalHeight = child->hasOverrideContainingBlockLogicalHeight() ? child->overrideContainingBlockContentLogicalHeight() : LayoutUnit();
+ Optional<LayoutUnit> oldOverrideContainingBlockContentLogicalWidth = child->hasOverrideContainingBlockLogicalWidth() ? child->overrideContainingBlockContentLogicalWidth() : LayoutUnit();
+ Optional<LayoutUnit> oldOverrideContainingBlockContentLogicalHeight = child->hasOverrideContainingBlockLogicalHeight() ? child->overrideContainingBlockContentLogicalHeight() : LayoutUnit();
LayoutUnit overrideContainingBlockContentLogicalWidth = gridAreaBreadthForChild(*child, ForColumns, sizingData.columnTracks);
LayoutUnit overrideContainingBlockContentLogicalHeight = gridAreaBreadthForChild(*child, ForRows, sizingData.rowTracks);
- if (oldOverrideContainingBlockContentLogicalWidth != overrideContainingBlockContentLogicalWidth || (oldOverrideContainingBlockContentLogicalHeight != overrideContainingBlockContentLogicalHeight && child->hasRelativeLogicalHeight()))
+ if (!oldOverrideContainingBlockContentLogicalWidth || oldOverrideContainingBlockContentLogicalWidth.value() != overrideContainingBlockContentLogicalWidth
+ || ((!oldOverrideContainingBlockContentLogicalHeight || oldOverrideContainingBlockContentLogicalHeight.value() != overrideContainingBlockContentLogicalHeight)
+ && child->hasRelativeLogicalHeight()))
child->setNeedsLayout(MarkOnlyThis);
child->setOverrideContainingBlockContentLogicalWidth(overrideContainingBlockContentLogicalWidth);
@@ -1306,12 +1310,12 @@
bool allowedToStretchChildAlongRowAxis = hasAutoSizeInRowAxis && !childStyle.marginStartUsing(&gridStyle).isAuto() && !childStyle.marginEndUsing(&gridStyle).isAuto();
if (!allowedToStretchChildAlongRowAxis || RenderStyle::resolveJustification(gridStyle, childStyle, ItemPositionStretch) != ItemPositionStretch) {
bool hasAutoMinSizeInRowAxis = isHorizontalMode ? childStyle.minWidth().isAuto() : childStyle.minHeight().isAuto();
- bool canShrinkToFitInRowAxisForChild = !hasAutoMinSizeInRowAxis || child.minPreferredLogicalWidth() <= child.overrideContainingBlockContentLogicalWidth();
+ bool canShrinkToFitInRowAxisForChild = !hasAutoMinSizeInRowAxis || (child.overrideContainingBlockContentLogicalWidth() && child.minPreferredLogicalWidth() <= child.overrideContainingBlockContentLogicalWidth().value());
// TODO(lajava): how to handle orthogonality in this case ?.
// TODO(lajava): grid track sizing and positioning do not support orthogonal modes yet.
if (hasAutoSizeInRowAxis && canShrinkToFitInRowAxisForChild) {
- LayoutUnit childWidthToFitContent = std::max(std::min(child.maxPreferredLogicalWidth(), child.overrideContainingBlockContentLogicalWidth() - child.marginLogicalWidth()), child.minPreferredLogicalWidth());
- LayoutUnit desiredLogicalWidth = child.constrainLogicalHeightByMinMax(childWidthToFitContent, -1);
+ LayoutUnit childWidthToFitContent = std::max(std::min(child.maxPreferredLogicalWidth(), child.overrideContainingBlockContentLogicalWidth().valueOr(-1) - child.marginLogicalWidth()), child.minPreferredLogicalWidth());
+ LayoutUnit desiredLogicalWidth = child.constrainLogicalHeightByMinMax(childWidthToFitContent, Nullopt);
child.setOverrideLogicalContentWidth(desiredLogicalWidth - child.borderAndPaddingLogicalWidth());
if (desiredLogicalWidth != child.logicalWidth())
child.setNeedsLayout();
@@ -1324,8 +1328,8 @@
// TODO (lajava): If the child has orthogonal flow, then it already has an override height set, so use it.
// TODO (lajava): grid track sizing and positioning do not support orthogonal modes yet.
if (child.isHorizontalWritingMode() == isHorizontalMode) {
- LayoutUnit stretchedLogicalHeight = availableAlignmentSpaceForChildBeforeStretching(child.overrideContainingBlockContentLogicalHeight(), child);
- LayoutUnit desiredLogicalHeight = child.constrainLogicalHeightByMinMax(stretchedLogicalHeight, -1);
+ LayoutUnit stretchedLogicalHeight = availableAlignmentSpaceForChildBeforeStretching(child.overrideContainingBlockContentLogicalHeight().valueOr(-1), child);
+ LayoutUnit desiredLogicalHeight = child.constrainLogicalHeightByMinMax(stretchedLogicalHeight, Nullopt);
child.setOverrideLogicalContentHeight(desiredLogicalHeight - child.borderAndPaddingLogicalHeight());
if (desiredLogicalHeight != child.logicalHeight()) {
// TODO (lajava): Can avoid laying out here in some cases. See https://webkit.org/b/87905.
Modified: trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp (188872 => 188873)
--- trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp 2015-08-24 18:46:44 UTC (rev 188872)
+++ trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp 2015-08-24 18:48:51 UTC (rev 188873)
@@ -414,11 +414,8 @@
const RenderStyle& multicolStyle = multicolBlock->style();
LayoutUnit availableHeight = multiColumnFlowThread()->columnHeightAvailable();
LayoutUnit maxColumnHeight = availableHeight ? availableHeight : RenderFlowThread::maxLogicalHeight();
- if (!multicolStyle.logicalMaxHeight().isUndefined()) {
- LayoutUnit logicalMaxHeight = multicolBlock->computeContentLogicalHeight(multicolStyle.logicalMaxHeight(), -1);
- if (logicalMaxHeight != -1 && maxColumnHeight > logicalMaxHeight)
- maxColumnHeight = logicalMaxHeight;
- }
+ if (!multicolStyle.logicalMaxHeight().isUndefined())
+ maxColumnHeight = std::min(maxColumnHeight, multicolBlock->computeContentLogicalHeight(multicolStyle.logicalMaxHeight(), Nullopt).valueOr(maxColumnHeight));
return heightAdjustedForSetOffset(maxColumnHeight);
}
Modified: trunk/Source/WebCore/rendering/RenderTable.cpp (188872 => 188873)
--- trunk/Source/WebCore/rendering/RenderTable.cpp 2015-08-24 18:46:44 UTC (rev 188872)
+++ trunk/Source/WebCore/rendering/RenderTable.cpp 2015-08-24 18:48:51 UTC (rev 188873)
@@ -360,7 +360,6 @@
LayoutUnit borderAndPaddingBefore = borderBefore() + (collapseBorders() ? LayoutUnit() : paddingBefore());
LayoutUnit borderAndPaddingAfter = borderAfter() + (collapseBorders() ? LayoutUnit() : paddingAfter());
LayoutUnit borderAndPadding = borderAndPaddingBefore + borderAndPaddingAfter;
- LayoutUnit computedLogicalHeight = 0;
if (styleLogicalHeight.isFixed()) {
// HTML tables size as though CSS height includes border/padding, CSS tables do not.
LayoutUnit borders = LayoutUnit();
@@ -368,14 +367,14 @@
if (is<HTMLTableElement>(element()) || style().boxSizing() == BORDER_BOX) {
borders = borderAndPadding;
}
- computedLogicalHeight = styleLogicalHeight.value() - borders;
+ return styleLogicalHeight.value() - borders;
} else if (styleLogicalHeight.isPercentOrCalculated())
- computedLogicalHeight = computePercentageLogicalHeight(styleLogicalHeight);
+ return computePercentageLogicalHeight(styleLogicalHeight).valueOr(0);
else if (styleLogicalHeight.isIntrinsic())
- computedLogicalHeight = computeIntrinsicLogicalContentHeightUsing(styleLogicalHeight, logicalHeight() - borderAndPadding, borderAndPadding);
+ return computeIntrinsicLogicalContentHeightUsing(styleLogicalHeight, logicalHeight() - borderAndPadding, borderAndPadding).valueOr(0);
else
ASSERT_NOT_REACHED();
- return std::max<LayoutUnit>(0, computedLogicalHeight);
+ return LayoutUnit();
}
void RenderTable::layoutCaption(RenderTableCaption* caption)
