Diff
Modified: trunk/Source/WebCore/ChangeLog (231756 => 231757)
--- trunk/Source/WebCore/ChangeLog 2018-05-14 14:52:50 UTC (rev 231756)
+++ trunk/Source/WebCore/ChangeLog 2018-05-14 15:20:47 UTC (rev 231757)
@@ -1,3 +1,88 @@
+2018-05-14 Manuel Rego Casasnovas <r...@igalia.com>
+
+ Renaming of overrides in LayoutBox
+ https://bugs.webkit.org/show_bug.cgi?id=185609
+
+ Reviewed by Javier Fernandez.
+
+ The names of the methods for the overrides were not consistent,
+ this patch fixes it by using the same structure in all the cases.
+
+ No new tests, no change of behavior.
+
+ * rendering/GridLayoutFunctions.cpp:
+ (WebCore::GridLayoutFunctions::hasOverrideContainingBlockContentSizeForChild):
+ * rendering/GridTrackSizingAlgorithm.cpp:
+ (WebCore::GridTrackSizingAlgorithmStrategy::logicalHeightForChild const):
+ * rendering/RenderBlock.cpp:
+ (WebCore::RenderBlock::computeChildPreferredLogicalWidths const):
+ (WebCore::RenderBlock::availableLogicalHeightForPercentageComputation const):
+ * rendering/RenderBlockFlow.cpp:
+ (WebCore::RenderBlockFlow::fitBorderToLinesIfNeeded):
+ * rendering/RenderBlockLineLayout.cpp:
+ (WebCore::RenderBlockFlow::updateRubyForJustifiedText):
+ * rendering/RenderBox.cpp:
+ (WebCore::RenderBox::willBeDestroyed):
+ (WebCore::RenderBox::hasOverrideContentLogicalHeight const):
+ (WebCore::RenderBox::hasOverrideContentLogicalWidth const):
+ (WebCore::RenderBox::setOverrideContentLogicalHeight):
+ (WebCore::RenderBox::setOverrideContentLogicalWidth):
+ (WebCore::RenderBox::clearOverrideContentLogicalHeight):
+ (WebCore::RenderBox::clearOverrideContentLogicalWidth):
+ (WebCore::RenderBox::clearOverrideContentSize):
+ (WebCore::RenderBox::overrideContentLogicalWidth const):
+ (WebCore::RenderBox::overrideContentLogicalHeight const):
+ (WebCore::RenderBox::overrideContainingBlockContentLogicalWidth const):
+ (WebCore::RenderBox::overrideContainingBlockContentLogicalHeight const):
+ (WebCore::RenderBox::hasOverrideContainingBlockContentLogicalWidth const):
+ (WebCore::RenderBox::hasOverrideContainingBlockContentLogicalHeight const):
+ (WebCore::RenderBox::setOverrideContainingBlockContentLogicalWidth):
+ (WebCore::RenderBox::setOverrideContainingBlockContentLogicalHeight):
+ (WebCore::RenderBox::clearOverrideContainingBlockContentSize):
+ (WebCore::RenderBox::clearOverrideContainingBlockContentLogicalHeight):
+ (WebCore::RenderBox::containingBlockLogicalWidthForContent const):
+ (WebCore::RenderBox::containingBlockLogicalHeightForContent const):
+ (WebCore::RenderBox::perpendicularContainingBlockLogicalHeight const):
+ (WebCore::RenderBox::computeLogicalWidthInFragment const):
+ (WebCore::RenderBox::computeLogicalHeight const):
+ (WebCore::RenderBox::computePercentageLogicalHeight const):
+ (WebCore::RenderBox::computeReplacedLogicalHeightUsing const):
+ (WebCore::RenderBox::availableLogicalHeightUsing const):
+ (WebCore::RenderBox::containingBlockLogicalWidthForPositioned const):
+ (WebCore::RenderBox::containingBlockLogicalHeightForPositioned const):
+ * rendering/RenderBox.h:
+ * rendering/RenderBoxModelObject.cpp:
+ (WebCore::RenderBoxModelObject::hasAutoHeightOrContainingBlockWithAutoHeight const):
+ * rendering/RenderDeprecatedFlexibleBox.cpp:
+ (WebCore::contentWidthForChild):
+ (WebCore::contentHeightForChild):
+ (WebCore::gatherFlexChildrenInfo):
+ (WebCore::RenderDeprecatedFlexibleBox::layoutHorizontalBox):
+ (WebCore::RenderDeprecatedFlexibleBox::layoutVerticalBox):
+ (WebCore::RenderDeprecatedFlexibleBox::applyLineClamp):
+ (WebCore::RenderDeprecatedFlexibleBox::clearLineClamp):
+ * rendering/RenderFlexibleBox.cpp:
+ (WebCore::RenderFlexibleBox::computeInnerFlexBaseSizeForChild):
+ (WebCore::RenderFlexibleBox::crossSizeForPercentageResolution):
+ (WebCore::RenderFlexibleBox::mainSizeForPercentageResolution):
+ (WebCore::RenderFlexibleBox::constructFlexItem):
+ (WebCore::RenderFlexibleBox::setOverrideMainAxisContentSizeForChild):
+ (WebCore::RenderFlexibleBox::applyStretchAlignmentToChild):
+ * rendering/RenderFullScreen.cpp:
+ (WebCore::RenderFullScreen::unwrapRenderer):
+ * rendering/RenderGrid.cpp:
+ (WebCore::RenderGrid::layoutBlock):
+ (WebCore::RenderGrid::layoutGridItems):
+ (WebCore::RenderGrid::applyStretchAlignmentToChildIfNeeded):
+ * rendering/RenderRubyBase.cpp:
+ (WebCore::RenderRubyBase::adjustInlineDirectionLineBounds const):
+ * rendering/RenderTableCell.cpp:
+ (WebCore::RenderTableCell::setOverrideContentLogicalHeightFromRowHeight):
+ * rendering/RenderTableCell.h:
+ * rendering/RenderTableSection.cpp:
+ (WebCore::RenderTableSection::calcRowLogicalHeight):
+ (WebCore::RenderTableSection::relayoutCellIfFlexed):
+
2018-05-14 Zalan Bujtas <za...@apple.com>
[LFC] Implement width computation for non-replaced out of flow elements.
Modified: trunk/Source/WebCore/rendering/GridLayoutFunctions.cpp (231756 => 231757)
--- trunk/Source/WebCore/rendering/GridLayoutFunctions.cpp 2018-05-14 14:52:50 UTC (rev 231756)
+++ trunk/Source/WebCore/rendering/GridLayoutFunctions.cpp 2018-05-14 15:20:47 UTC (rev 231757)
@@ -86,7 +86,7 @@
bool hasOverrideContainingBlockContentSizeForChild(const RenderBox& child, GridTrackSizingDirection direction)
{
- return direction == ForColumns ? child.hasOverrideContainingBlockLogicalWidth() : child.hasOverrideContainingBlockLogicalHeight();
+ return direction == ForColumns ? child.hasOverrideContainingBlockContentLogicalWidth() : child.hasOverrideContainingBlockContentLogicalHeight();
}
std::optional<LayoutUnit> overrideContainingBlockContentSizeForChild(const RenderBox& child, GridTrackSizingDirection direction)
Modified: trunk/Source/WebCore/rendering/GridTrackSizingAlgorithm.cpp (231756 => 231757)
--- trunk/Source/WebCore/rendering/GridTrackSizingAlgorithm.cpp 2018-05-14 14:52:50 UTC (rev 231756)
+++ trunk/Source/WebCore/rendering/GridTrackSizingAlgorithm.cpp 2018-05-14 15:20:47 UTC (rev 231757)
@@ -704,7 +704,7 @@
// We need to clear the stretched height to properly compute logical height during layout.
if (child.needsLayout())
- child.clearOverrideLogicalContentHeight();
+ child.clearOverrideContentLogicalHeight();
child.layoutIfNeeded();
return child.logicalHeight() + GridLayoutFunctions::marginLogicalSizeForChild(*renderGrid(), childBlockDirection, child);
Modified: trunk/Source/WebCore/rendering/RenderBlock.cpp (231756 => 231757)
--- trunk/Source/WebCore/rendering/RenderBlock.cpp 2018-05-14 14:52:50 UTC (rev 231756)
+++ trunk/Source/WebCore/rendering/RenderBlock.cpp 2018-05-14 15:20:47 UTC (rev 231757)
@@ -2378,11 +2378,11 @@
if (child.isBox()) {
auto& box = downcast<RenderBox>(child);
if (box.isFlexItem()) {
- if (box.hasOverrideLogicalContentHeight())
- overrideHeight = std::optional<LayoutUnit>(box.overrideLogicalContentHeight());
- if (box.hasOverrideLogicalContentWidth())
- overrideWidth = std::optional<LayoutUnit>(box.overrideLogicalContentWidth());
- box.clearOverrideSize();
+ if (box.hasOverrideContentLogicalHeight())
+ overrideHeight = std::optional<LayoutUnit>(box.overrideContentLogicalHeight());
+ if (box.hasOverrideContentLogicalWidth())
+ overrideWidth = std::optional<LayoutUnit>(box.overrideContentLogicalWidth());
+ box.clearOverrideContentSize();
}
}
@@ -2392,9 +2392,9 @@
if (child.isBox()) {
auto& box = downcast<RenderBox>(child);
if (overrideHeight)
- box.setOverrideLogicalContentHeight(overrideHeight.value());
+ box.setOverrideContentLogicalHeight(overrideHeight.value());
if (overrideWidth)
- box.setOverrideLogicalContentWidth(overrideWidth.value());
+ box.setOverrideContentLogicalWidth(overrideWidth.value());
}
// For non-replaced blocks if the inline size is min|max-content or a definite
@@ -3178,8 +3178,8 @@
if (stretchedFlexHeight)
availableHeight = stretchedFlexHeight;
- else if (isGridItem() && hasOverrideLogicalContentHeight())
- availableHeight = overrideLogicalContentHeight();
+ else if (isGridItem() && hasOverrideContentLogicalHeight())
+ availableHeight = overrideContentLogicalHeight();
else if (styleToUse.logicalHeight().isFixed()) {
LayoutUnit contentBoxHeight = adjustContentBoxLogicalHeightForBoxSizing((LayoutUnit)styleToUse.logicalHeight().value());
availableHeight = std::max(LayoutUnit(), constrainContentBoxLogicalHeightByMinMax(contentBoxHeight - scrollbarLogicalHeight(), std::nullopt));
Modified: trunk/Source/WebCore/rendering/RenderBlockFlow.cpp (231756 => 231757)
--- trunk/Source/WebCore/rendering/RenderBlockFlow.cpp 2018-05-14 14:52:50 UTC (rev 231756)
+++ trunk/Source/WebCore/rendering/RenderBlockFlow.cpp 2018-05-14 15:20:47 UTC (rev 231757)
@@ -2953,7 +2953,7 @@
void RenderBlockFlow::fitBorderToLinesIfNeeded()
{
- if (style().borderFit() == BorderFitBorder || hasOverrideLogicalContentWidth())
+ if (style().borderFit() == BorderFitBorder || hasOverrideContentLogicalWidth())
return;
// Walk any normal flow lines to snugly fit.
@@ -2972,9 +2972,9 @@
if (newContentWidth == oldWidth)
return;
- setOverrideLogicalContentWidth(newContentWidth);
+ setOverrideContentLogicalWidth(newContentWidth);
layoutBlock(false);
- clearOverrideLogicalContentWidth();
+ clearOverrideContentLogicalWidth();
}
void RenderBlockFlow::markLinesDirtyInBlockRange(LayoutUnit logicalTop, LayoutUnit logicalBottom, RootInlineBox* highest)
Modified: trunk/Source/WebCore/rendering/RenderBlockLineLayout.cpp (231756 => 231757)
--- trunk/Source/WebCore/rendering/RenderBlockLineLayout.cpp 2018-05-14 14:52:50 UTC (rev 231756)
+++ trunk/Source/WebCore/rendering/RenderBlockLineLayout.cpp 2018-05-14 15:20:47 UTC (rev 231757)
@@ -564,11 +564,11 @@
totalOpportunitiesInRun += opportunitiesInRun;
}
- ASSERT(!rubyRun.hasOverrideLogicalContentWidth());
+ ASSERT(!rubyRun.hasOverrideContentLogicalWidth());
float newBaseWidth = rubyRun.logicalWidth() + totalExpansion + marginStartForChild(rubyRun) + marginEndForChild(rubyRun);
float newRubyRunWidth = rubyRun.logicalWidth() + totalExpansion;
rubyBase.setInitialOffset((newRubyRunWidth - newBaseWidth) / 2);
- rubyRun.setOverrideLogicalContentWidth(newRubyRunWidth);
+ rubyRun.setOverrideContentLogicalWidth(newRubyRunWidth);
rubyRun.setNeedsLayout(MarkOnlyThis);
rootBox.markDirty();
if (RenderRubyText* rubyText = rubyRun.rubyText()) {
@@ -576,7 +576,7 @@
textRootBox->markDirty();
}
rubyRun.layoutBlock(true);
- rubyRun.clearOverrideLogicalContentWidth();
+ rubyRun.clearOverrideContentLogicalWidth();
r.box()->setExpansion(newRubyRunWidth - r.box()->logicalWidth());
totalLogicalWidth += totalExpansion;
Modified: trunk/Source/WebCore/rendering/RenderBox.cpp (231756 => 231757)
--- trunk/Source/WebCore/rendering/RenderBox.cpp 2018-05-14 14:52:50 UTC (rev 231756)
+++ trunk/Source/WebCore/rendering/RenderBox.cpp 2018-05-14 15:20:47 UTC (rev 231757)
@@ -98,13 +98,13 @@
// Used by flexible boxes when flexing this element and by table cells.
typedef WTF::HashMap<const RenderBox*, LayoutUnit> OverrideSizeMap;
-static OverrideSizeMap* gOverrideHeightMap = nullptr;
-static OverrideSizeMap* gOverrideWidthMap = nullptr;
+static OverrideSizeMap* gOverrideContentLogicalHeightMap = nullptr;
+static OverrideSizeMap* gOverrideContentLogicalWidthMap = nullptr;
// Used by grid elements to properly size their grid items.
typedef WTF::HashMap<const RenderBox*, std::optional<LayoutUnit>> OverrideOptionalSizeMap;
-static OverrideOptionalSizeMap* gOverrideContainingBlockLogicalHeightMap = nullptr;
-static OverrideOptionalSizeMap* gOverrideContainingBlockLogicalWidthMap = nullptr;
+static OverrideOptionalSizeMap* gOverrideContainingBlockContentLogicalHeightMap = nullptr;
+static OverrideOptionalSizeMap* gOverrideContainingBlockContentLogicalWidthMap = nullptr;
// Size of border belt for autoscroll. When mouse pointer in border belt,
// autoscroll is started.
@@ -154,8 +154,8 @@
if (frame().eventHandler().autoscrollRenderer() == this)
frame().eventHandler().stopAutoscrollTimer(true);
- clearOverrideSize();
- clearContainingBlockOverrideSize();
+ clearOverrideContentSize();
+ clearOverrideContainingBlockContentSize();
RenderBlock::removePercentHeightDescendantIfNeeded(*this);
@@ -1020,107 +1020,107 @@
return m_maxPreferredLogicalWidth;
}
-bool RenderBox::hasOverrideLogicalContentHeight() const
+bool RenderBox::hasOverrideContentLogicalHeight() const
{
- return gOverrideHeightMap && gOverrideHeightMap->contains(this);
+ return gOverrideContentLogicalHeightMap && gOverrideContentLogicalHeightMap->contains(this);
}
-bool RenderBox::hasOverrideLogicalContentWidth() const
+bool RenderBox::hasOverrideContentLogicalWidth() const
{
- return gOverrideWidthMap && gOverrideWidthMap->contains(this);
+ return gOverrideContentLogicalWidthMap && gOverrideContentLogicalWidthMap->contains(this);
}
-void RenderBox::setOverrideLogicalContentHeight(LayoutUnit height)
+void RenderBox::setOverrideContentLogicalHeight(LayoutUnit height)
{
- if (!gOverrideHeightMap)
- gOverrideHeightMap = new OverrideSizeMap();
- gOverrideHeightMap->set(this, height);
+ if (!gOverrideContentLogicalHeightMap)
+ gOverrideContentLogicalHeightMap = new OverrideSizeMap();
+ gOverrideContentLogicalHeightMap->set(this, height);
}
-void RenderBox::setOverrideLogicalContentWidth(LayoutUnit width)
+void RenderBox::setOverrideContentLogicalWidth(LayoutUnit width)
{
- if (!gOverrideWidthMap)
- gOverrideWidthMap = new OverrideSizeMap();
- gOverrideWidthMap->set(this, width);
+ if (!gOverrideContentLogicalWidthMap)
+ gOverrideContentLogicalWidthMap = new OverrideSizeMap();
+ gOverrideContentLogicalWidthMap->set(this, width);
}
-void RenderBox::clearOverrideLogicalContentHeight()
+void RenderBox::clearOverrideContentLogicalHeight()
{
- if (gOverrideHeightMap)
- gOverrideHeightMap->remove(this);
+ if (gOverrideContentLogicalHeightMap)
+ gOverrideContentLogicalHeightMap->remove(this);
}
-void RenderBox::clearOverrideLogicalContentWidth()
+void RenderBox::clearOverrideContentLogicalWidth()
{
- if (gOverrideWidthMap)
- gOverrideWidthMap->remove(this);
+ if (gOverrideContentLogicalWidthMap)
+ gOverrideContentLogicalWidthMap->remove(this);
}
-void RenderBox::clearOverrideSize()
+void RenderBox::clearOverrideContentSize()
{
- clearOverrideLogicalContentHeight();
- clearOverrideLogicalContentWidth();
+ clearOverrideContentLogicalHeight();
+ clearOverrideContentLogicalWidth();
}
-LayoutUnit RenderBox::overrideLogicalContentWidth() const
+LayoutUnit RenderBox::overrideContentLogicalWidth() const
{
- ASSERT(hasOverrideLogicalContentWidth());
- return gOverrideWidthMap->get(this);
+ ASSERT(hasOverrideContentLogicalWidth());
+ return gOverrideContentLogicalWidthMap->get(this);
}
-LayoutUnit RenderBox::overrideLogicalContentHeight() const
+LayoutUnit RenderBox::overrideContentLogicalHeight() const
{
- ASSERT(hasOverrideLogicalContentHeight());
- return gOverrideHeightMap->get(this);
+ ASSERT(hasOverrideContentLogicalHeight());
+ return gOverrideContentLogicalHeightMap->get(this);
}
std::optional<LayoutUnit> RenderBox::overrideContainingBlockContentLogicalWidth() const
{
- ASSERT(hasOverrideContainingBlockLogicalWidth());
- return gOverrideContainingBlockLogicalWidthMap->get(this);
+ ASSERT(hasOverrideContainingBlockContentLogicalWidth());
+ return gOverrideContainingBlockContentLogicalWidthMap->get(this);
}
std::optional<LayoutUnit> RenderBox::overrideContainingBlockContentLogicalHeight() const
{
- ASSERT(hasOverrideContainingBlockLogicalHeight());
- return gOverrideContainingBlockLogicalHeightMap->get(this);
+ ASSERT(hasOverrideContainingBlockContentLogicalHeight());
+ return gOverrideContainingBlockContentLogicalHeightMap->get(this);
}
-bool RenderBox::hasOverrideContainingBlockLogicalWidth() const
+bool RenderBox::hasOverrideContainingBlockContentLogicalWidth() const
{
- return gOverrideContainingBlockLogicalWidthMap && gOverrideContainingBlockLogicalWidthMap->contains(this);
+ return gOverrideContainingBlockContentLogicalWidthMap && gOverrideContainingBlockContentLogicalWidthMap->contains(this);
}
-bool RenderBox::hasOverrideContainingBlockLogicalHeight() const
+bool RenderBox::hasOverrideContainingBlockContentLogicalHeight() const
{
- return gOverrideContainingBlockLogicalHeightMap && gOverrideContainingBlockLogicalHeightMap->contains(this);
+ return gOverrideContainingBlockContentLogicalHeightMap && gOverrideContainingBlockContentLogicalHeightMap->contains(this);
}
void RenderBox::setOverrideContainingBlockContentLogicalWidth(std::optional<LayoutUnit> logicalWidth)
{
- if (!gOverrideContainingBlockLogicalWidthMap)
- gOverrideContainingBlockLogicalWidthMap = new OverrideOptionalSizeMap;
- gOverrideContainingBlockLogicalWidthMap->set(this, logicalWidth);
+ if (!gOverrideContainingBlockContentLogicalWidthMap)
+ gOverrideContainingBlockContentLogicalWidthMap = new OverrideOptionalSizeMap;
+ gOverrideContainingBlockContentLogicalWidthMap->set(this, logicalWidth);
}
void RenderBox::setOverrideContainingBlockContentLogicalHeight(std::optional<LayoutUnit> logicalHeight)
{
- if (!gOverrideContainingBlockLogicalHeightMap)
- gOverrideContainingBlockLogicalHeightMap = new OverrideOptionalSizeMap;
- gOverrideContainingBlockLogicalHeightMap->set(this, logicalHeight);
+ if (!gOverrideContainingBlockContentLogicalHeightMap)
+ gOverrideContainingBlockContentLogicalHeightMap = new OverrideOptionalSizeMap;
+ gOverrideContainingBlockContentLogicalHeightMap->set(this, logicalHeight);
}
-void RenderBox::clearContainingBlockOverrideSize()
+void RenderBox::clearOverrideContainingBlockContentSize()
{
- if (gOverrideContainingBlockLogicalWidthMap)
- gOverrideContainingBlockLogicalWidthMap->remove(this);
+ if (gOverrideContainingBlockContentLogicalWidthMap)
+ gOverrideContainingBlockContentLogicalWidthMap->remove(this);
clearOverrideContainingBlockContentLogicalHeight();
}
void RenderBox::clearOverrideContainingBlockContentLogicalHeight()
{
- if (gOverrideContainingBlockLogicalHeightMap)
- gOverrideContainingBlockLogicalHeightMap->remove(this);
+ if (gOverrideContainingBlockContentLogicalHeightMap)
+ gOverrideContainingBlockContentLogicalHeightMap->remove(this);
}
LayoutUnit RenderBox::adjustBorderBoxLogicalWidthForBoxSizing(LayoutUnit width) const
@@ -1842,7 +1842,7 @@
LayoutUnit RenderBox::containingBlockLogicalWidthForContent() const
{
- if (hasOverrideContainingBlockLogicalWidth()) {
+ if (hasOverrideContainingBlockContentLogicalWidth()) {
if (auto overrideLogicalWidth = overrideContainingBlockContentLogicalWidth())
return overrideLogicalWidth.value();
}
@@ -1854,7 +1854,7 @@
LayoutUnit RenderBox::containingBlockLogicalHeightForContent(AvailableLogicalHeightType heightType) const
{
- if (hasOverrideContainingBlockLogicalHeight()) {
+ if (hasOverrideContainingBlockContentLogicalHeight()) {
if (auto overrideLogicalHeight = overrideContainingBlockContentLogicalHeight())
return overrideLogicalHeight.value();
}
@@ -1895,14 +1895,14 @@
LayoutUnit RenderBox::perpendicularContainingBlockLogicalHeight() const
{
- if (hasOverrideContainingBlockLogicalHeight()) {
+ if (hasOverrideContainingBlockContentLogicalHeight()) {
if (auto overrideLogicalHeight = overrideContainingBlockContentLogicalHeight())
return overrideLogicalHeight.value();
}
RenderBlock* cb = containingBlock();
- if (cb->hasOverrideLogicalContentHeight())
- return cb->overrideLogicalContentHeight();
+ if (cb->hasOverrideContentLogicalHeight())
+ return cb->overrideContentLogicalHeight();
const RenderStyle& containingBlockStyle = cb->style();
Length logicalHeightLength = containingBlockStyle.logicalHeight();
@@ -2312,8 +2312,8 @@
// width. Use the width from the style context.
// FIXME: Account for block-flow in flexible boxes.
// https://bugs.webkit.org/show_bug.cgi?id=46418
- if (hasOverrideLogicalContentWidth() && (isRubyRun() || style().borderFit() == BorderFitLines || (parent()->isFlexibleBoxIncludingDeprecated()))) {
- computedValues.m_extent = overrideLogicalContentWidth() + borderAndPaddingLogicalWidth();
+ if (hasOverrideContentLogicalWidth() && (isRubyRun() || style().borderFit() == BorderFitLines || (parent()->isFlexibleBoxIncludingDeprecated()))) {
+ computedValues.m_extent = overrideContentLogicalWidth() + borderAndPaddingLogicalWidth();
return;
}
@@ -2716,8 +2716,8 @@
// grab our cached flexible height.
// FIXME: Account for block-flow in flexible boxes.
// https://bugs.webkit.org/show_bug.cgi?id=46418
- if (hasOverrideLogicalContentHeight() && (parent()->isFlexibleBoxIncludingDeprecated() || parent()->isRenderGrid())) {
- h = Length(overrideLogicalContentHeight(), Fixed);
+ if (hasOverrideContentLogicalHeight() && (parent()->isFlexibleBoxIncludingDeprecated() || parent()->isRenderGrid())) {
+ h = Length(overrideContentLogicalHeight(), Fixed);
} else if (treatAsReplaced)
h = Length(computeReplacedLogicalHeight(), Fixed);
else {
@@ -2904,7 +2904,7 @@
if (isHorizontal != cb->isHorizontalWritingMode())
availableHeight = containingBlockChild->containingBlockLogicalWidthForContent();
- else if (hasOverrideContainingBlockLogicalHeight())
+ else if (hasOverrideContainingBlockContentLogicalHeight())
availableHeight = overrideContainingBlockContentLogicalHeight();
else if (is<RenderTableCell>(*cb)) {
if (!skippedAutoHeightContainingBlock) {
@@ -2911,10 +2911,10 @@
// Table cells violate what the CSS spec says to do with heights. Basically we
// don't care if the cell specified a height or not. We just always make ourselves
// be a percentage of the cell's current content height.
- if (!cb->hasOverrideLogicalContentHeight())
+ if (!cb->hasOverrideContentLogicalHeight())
return tableCellShouldHaveZeroInitialSize(*cb, *this, scrollsOverflowY()) ? std::optional<LayoutUnit>(0) : std::nullopt;
- availableHeight = cb->overrideLogicalContentHeight();
+ availableHeight = cb->overrideContentLogicalHeight();
}
} else
availableHeight = cb->availableLogicalHeightForPercentageComputation();
@@ -2924,13 +2924,13 @@
LayoutUnit result = valueForLength(height, availableHeight.value() - rootMarginBorderPaddingHeight + (isTable() && isOutOfFlowPositioned() ? cb->paddingBefore() + cb->paddingAfter() : LayoutUnit()));
- // |overrideLogicalContentHeight| is the maximum height made available by the
+ // |overrideContentLogicalHeight| is the maximum height made available by the
// cell to its percent height children when we decide they can determine the
// height of the cell. If the percent height child is box-sizing:content-box
// then we must subtract the border and padding from the cell's
- // |availableHeight| (given by |overrideLogicalContentHeight|) to arrive
+ // |availableHeight| (given by |overrideContentLogicalHeight|) to arrive
// at the child's computed height.
- bool subtractBorderAndPadding = isTable() || (is<RenderTableCell>(*cb) && !skippedAutoHeightContainingBlock && cb->hasOverrideLogicalContentHeight());
+ bool subtractBorderAndPadding = isTable() || (is<RenderTableCell>(*cb) && !skippedAutoHeightContainingBlock && cb->hasOverrideContentLogicalHeight());
if (subtractBorderAndPadding) {
result -= borderAndPaddingLogicalHeight();
return std::max(LayoutUnit(), result);
@@ -3069,8 +3069,8 @@
block->addPercentHeightDescendant(*const_cast<RenderBox*>(this));
if (block->isFlexItem())
stretchedHeight = downcast<RenderFlexibleBox>(block->parent())->childLogicalHeightForPercentageResolution(*block);
- else if (block->isGridItem() && block->hasOverrideLogicalContentHeight())
- stretchedHeight = block->overrideLogicalContentHeight();
+ else if (block->isGridItem() && block->hasOverrideContentLogicalHeight())
+ stretchedHeight = block->overrideContentLogicalHeight();
}
// FIXME: This calculation is not patched for block-flow yet.
@@ -3135,8 +3135,8 @@
// artificially. We're going to rely on this cell getting expanded to some new
// height, and then when we lay out again we'll use the calculation below.
if (isTableCell() && (h.isAuto() || h.isPercentOrCalculated())) {
- if (hasOverrideLogicalContentHeight())
- return overrideLogicalContentHeight();
+ if (hasOverrideContentLogicalHeight())
+ return overrideContentLogicalHeight();
return logicalHeight() - borderAndPaddingLogicalHeight();
}
@@ -3205,7 +3205,7 @@
if (checkForPerpendicularWritingMode && containingBlock.isHorizontalWritingMode() != isHorizontalWritingMode())
return containingBlockLogicalHeightForPositioned(containingBlock, false);
- if (hasOverrideContainingBlockLogicalWidth()) {
+ if (hasOverrideContainingBlockContentLogicalWidth()) {
if (auto overrideLogicalWidth = overrideContainingBlockContentLogicalWidth())
return overrideLogicalWidth.value();
}
@@ -3270,7 +3270,7 @@
if (checkForPerpendicularWritingMode && containingBlock.isHorizontalWritingMode() != isHorizontalWritingMode())
return containingBlockLogicalWidthForPositioned(containingBlock, nullptr, false);
- if (hasOverrideContainingBlockLogicalHeight()) {
+ if (hasOverrideContainingBlockContentLogicalHeight()) {
if (auto overrideLogicalHeight = overrideContainingBlockContentLogicalHeight())
return overrideLogicalHeight.value();
}
Modified: trunk/Source/WebCore/rendering/RenderBox.h (231756 => 231757)
--- trunk/Source/WebCore/rendering/RenderBox.h 2018-05-14 14:52:50 UTC (rev 231756)
+++ trunk/Source/WebCore/rendering/RenderBox.h 2018-05-14 15:20:47 UTC (rev 231757)
@@ -302,23 +302,23 @@
// the border-box height/width like the regular height/width accessors on RenderBox.
// Right now, these are different than contentHeight/contentWidth because they still
// include the scrollbar height/width.
- LayoutUnit overrideLogicalContentWidth() const;
- LayoutUnit overrideLogicalContentHeight() const;
- bool hasOverrideLogicalContentHeight() const;
- bool hasOverrideLogicalContentWidth() const;
- void setOverrideLogicalContentHeight(LayoutUnit);
- void setOverrideLogicalContentWidth(LayoutUnit);
- void clearOverrideSize();
- void clearOverrideLogicalContentHeight();
- void clearOverrideLogicalContentWidth();
+ LayoutUnit overrideContentLogicalWidth() const;
+ LayoutUnit overrideContentLogicalHeight() const;
+ bool hasOverrideContentLogicalHeight() const;
+ bool hasOverrideContentLogicalWidth() const;
+ void setOverrideContentLogicalHeight(LayoutUnit);
+ void setOverrideContentLogicalWidth(LayoutUnit);
+ void clearOverrideContentSize();
+ void clearOverrideContentLogicalHeight();
+ void clearOverrideContentLogicalWidth();
std::optional<LayoutUnit> overrideContainingBlockContentLogicalWidth() const;
std::optional<LayoutUnit> overrideContainingBlockContentLogicalHeight() const;
- bool hasOverrideContainingBlockLogicalWidth() const;
- bool hasOverrideContainingBlockLogicalHeight() const;
+ bool hasOverrideContainingBlockContentLogicalWidth() const;
+ bool hasOverrideContainingBlockContentLogicalHeight() const;
void setOverrideContainingBlockContentLogicalWidth(std::optional<LayoutUnit>);
void setOverrideContainingBlockContentLogicalHeight(std::optional<LayoutUnit>);
- void clearContainingBlockOverrideSize();
+ void clearOverrideContainingBlockContentSize();
void clearOverrideContainingBlockContentLogicalHeight();
LayoutSize offsetFromContainer(RenderElement&, const LayoutPoint&, bool* offsetDependsOnPoint = nullptr) const override;
Modified: trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp (231756 => 231757)
--- trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp 2018-05-14 14:52:50 UTC (rev 231756)
+++ trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp 2018-05-14 15:20:47 UTC (rev 231757)
@@ -333,7 +333,7 @@
return false;
}
- if (thisBox && thisBox->isGridItem() && thisBox->hasOverrideContainingBlockLogicalHeight())
+ if (thisBox && thisBox->isGridItem() && thisBox->hasOverrideContainingBlockContentLogicalHeight())
return false;
if (logicalHeightLength.isAuto() && !isOutOfFlowPositionedWithImplicitHeight(*this))
Modified: trunk/Source/WebCore/rendering/RenderDeprecatedFlexibleBox.cpp (231756 => 231757)
--- trunk/Source/WebCore/rendering/RenderDeprecatedFlexibleBox.cpp 2018-05-14 14:52:50 UTC (rev 231756)
+++ trunk/Source/WebCore/rendering/RenderDeprecatedFlexibleBox.cpp 2018-05-14 15:20:47 UTC (rev 231757)
@@ -152,15 +152,15 @@
static LayoutUnit contentWidthForChild(RenderBox* child)
{
- if (child->hasOverrideLogicalContentWidth())
- return child->overrideLogicalContentWidth();
+ if (child->hasOverrideContentLogicalWidth())
+ return child->overrideContentLogicalWidth();
return child->logicalWidth() - child->borderAndPaddingLogicalWidth();
}
static LayoutUnit contentHeightForChild(RenderBox* child)
{
- if (child->hasOverrideLogicalContentHeight())
- return child->overrideLogicalContentHeight();
+ if (child->hasOverrideContentLogicalHeight())
+ return child->overrideContentLogicalHeight();
return child->logicalHeight() - child->borderAndPaddingLogicalHeight();
}
@@ -355,7 +355,7 @@
if (!childDoesNotAffectWidthOrFlexing(child) && child->style().boxFlex() > 0.0f) {
// We always have to lay out flexible objects again, since the flex distribution
// may have changed, and we need to reallocate space.
- child->clearOverrideSize();
+ child->clearOverrideContentSize();
if (!relayoutChildren)
child->setChildNeedsLayout(MarkOnlyThis);
haveFlex = true;
@@ -583,7 +583,7 @@
if (allowedChildFlex(child, expanding, i)) {
LayoutUnit spaceAdd = LayoutUnit(spaceAvailableThisPass * (child->style().boxFlex() / totalFlex));
if (spaceAdd) {
- child->setOverrideLogicalContentWidth(contentWidthForChild(child) + spaceAdd);
+ child->setOverrideContentLogicalWidth(contentWidthForChild(child) + spaceAdd);
flexingChildren = true;
relayoutChildren = true;
}
@@ -600,7 +600,7 @@
LayoutUnit spaceAdd = groupRemainingSpace > 0 ? 1 : -1;
for (RenderBox* child = iterator.first(); child && groupRemainingSpace; child = iterator.next()) {
if (allowedChildFlex(child, expanding, i)) {
- child->setOverrideLogicalContentWidth(contentWidthForChild(child) + spaceAdd);
+ child->setOverrideContentLogicalWidth(contentWidthForChild(child) + spaceAdd);
flexingChildren = true;
relayoutChildren = true;
remainingSpace -= spaceAdd;
@@ -840,7 +840,7 @@
if (allowedChildFlex(child, expanding, i)) {
LayoutUnit spaceAdd = spaceAvailableThisPass * (child->style().boxFlex() / totalFlex);
if (spaceAdd) {
- child->setOverrideLogicalContentHeight(contentHeightForChild(child) + spaceAdd);
+ child->setOverrideContentLogicalHeight(contentHeightForChild(child) + spaceAdd);
flexingChildren = true;
relayoutChildren = true;
}
@@ -857,7 +857,7 @@
LayoutUnit spaceAdd = groupRemainingSpace > 0 ? 1 : -1;
for (RenderBox* child = iterator.first(); child && groupRemainingSpace; child = iterator.next()) {
if (allowedChildFlex(child, expanding, i)) {
- child->setOverrideLogicalContentHeight(contentHeightForChild(child) + spaceAdd);
+ child->setOverrideContentLogicalHeight(contentHeightForChild(child) + spaceAdd);
flexingChildren = true;
relayoutChildren = true;
remainingSpace -= spaceAdd;
@@ -935,7 +935,7 @@
if (childDoesNotAffectWidthOrFlexing(child))
continue;
- child->clearOverrideSize();
+ child->clearOverrideContentSize();
if (relayoutChildren || (child->isReplaced() && (child->style().width().isPercentOrCalculated() || child->style().height().isPercentOrCalculated()))
|| (child->style().height().isAuto() && is<RenderBlockFlow>(*child))) {
child->setChildNeedsLayout(MarkOnlyThis);
@@ -972,7 +972,7 @@
continue;
child->setChildNeedsLayout(MarkOnlyThis);
- child->setOverrideLogicalContentHeight(newHeight - child->verticalBorderAndPaddingExtent());
+ child->setOverrideContentLogicalHeight(newHeight - child->verticalBorderAndPaddingExtent());
child->layoutIfNeeded();
// FIXME: For now don't support RTL.
@@ -1035,7 +1035,7 @@
if (childDoesNotAffectWidthOrFlexing(child))
continue;
- child->clearOverrideSize();
+ child->clearOverrideContentSize();
if ((child->isReplaced() && (child->style().width().isPercentOrCalculated() || child->style().height().isPercentOrCalculated()))
|| (child->style().height().isAuto() && is<RenderBlockFlow>(*child))) {
child->setChildNeedsLayout();
Modified: trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp (231756 => 231757)
--- trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp 2018-05-14 14:52:50 UTC (rev 231756)
+++ trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp 2018-05-14 15:20:47 UTC (rev 231757)
@@ -817,7 +817,7 @@
LayoutUnit RenderFlexibleBox::computeInnerFlexBaseSizeForChild(RenderBox& child, LayoutUnit mainAxisBorderAndPadding, bool relayoutChildren)
{
- child.clearOverrideSize();
+ child.clearOverrideContentSize();
Length flexBasis = flexBasisForChild(child);
if (mainAxisLengthIsDefinite(child, flexBasis))
@@ -1122,10 +1122,10 @@
return std::nullopt;
// 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();
+ if (hasOrthogonalFlow(child) && child.hasOverrideContentLogicalWidth())
+ return child.overrideContentLogicalWidth();
+ if (!hasOrthogonalFlow(child) && child.hasOverrideContentLogicalHeight())
+ return child.overrideContentLogicalHeight();
// We don't currently implement the optimization from
// https://drafts.csswg.org/css-flexbox/#definite-sizes case 1. While that
@@ -1154,8 +1154,8 @@
}
if (hasOrthogonalFlow(child))
- return child.hasOverrideLogicalContentHeight() ? std::optional<LayoutUnit>(child.overrideLogicalContentHeight()) : std::nullopt;
- return child.hasOverrideLogicalContentWidth() ? std::optional<LayoutUnit>(child.overrideLogicalContentWidth()) : std::nullopt;
+ return child.hasOverrideContentLogicalHeight() ? std::optional<LayoutUnit>(child.overrideContentLogicalHeight()) : std::nullopt;
+ return child.hasOverrideContentLogicalWidth() ? std::optional<LayoutUnit>(child.overrideContentLogicalWidth()) : std::nullopt;
}
std::optional<LayoutUnit> RenderFlexibleBox::childLogicalHeightForPercentageResolution(const RenderBox& child)
@@ -1191,7 +1191,7 @@
// min/max/preferred size, run layout on it now to make sure its logical
// height and scroll bars are up to date.
if (childHasIntrinsicMainAxisSize(child) && child.needsLayout()) {
- child.clearOverrideSize();
+ child.clearOverrideContentSize();
child.setChildNeedsLayout(MarkOnlyThis);
child.layoutIfNeeded();
cacheChildMainSize(child);
@@ -1379,9 +1379,9 @@
void RenderFlexibleBox::setOverrideMainAxisContentSizeForChild(RenderBox& child, LayoutUnit childPreferredSize)
{
if (hasOrthogonalFlow(child))
- child.setOverrideLogicalContentHeight(childPreferredSize);
+ child.setOverrideContentLogicalHeight(childPreferredSize);
else
- child.setOverrideLogicalContentWidth(childPreferredSize);
+ child.setOverrideContentLogicalWidth(childPreferredSize);
}
LayoutUnit RenderFlexibleBox::staticMainAxisPositionForPositionedChild(const RenderBox& child)
@@ -1810,8 +1810,8 @@
// So, redo it here.
childNeedsRelayout = true;
}
- if (childNeedsRelayout || !child.hasOverrideLogicalContentHeight())
- child.setOverrideLogicalContentHeight(desiredLogicalHeight - child.borderAndPaddingLogicalHeight());
+ if (childNeedsRelayout || !child.hasOverrideContentLogicalHeight())
+ child.setOverrideContentLogicalHeight(desiredLogicalHeight - child.borderAndPaddingLogicalHeight());
if (childNeedsRelayout) {
child.setLogicalHeight(LayoutUnit());
// We cache the child's intrinsic content logical height to avoid it being
@@ -1832,7 +1832,7 @@
childWidth = child.constrainLogicalWidthInFragmentByMinMax(childWidth, crossAxisContentExtent(), *this, nullptr);
if (childWidth != child.logicalWidth()) {
- child.setOverrideLogicalContentWidth(childWidth - child.borderAndPaddingLogicalWidth());
+ child.setOverrideContentLogicalWidth(childWidth - child.borderAndPaddingLogicalWidth());
child.setChildNeedsLayout(MarkOnlyThis);
child.layoutIfNeeded();
}
Modified: trunk/Source/WebCore/rendering/RenderFullScreen.cpp (231756 => 231757)
--- trunk/Source/WebCore/rendering/RenderFullScreen.cpp 2018-05-14 14:52:50 UTC (rev 231756)
+++ trunk/Source/WebCore/rendering/RenderFullScreen.cpp 2018-05-14 15:20:47 UTC (rev 231757)
@@ -170,7 +170,7 @@
// may have set one on the child, and we don't want to leave that
// lying around on the child.
if (is<RenderBox>(*child))
- downcast<RenderBox>(*child).clearOverrideSize();
+ downcast<RenderBox>(*child).clearOverrideContentSize();
auto childToMove = builder.detach(*child->parent(), *child);
builder.attach(*parent(), WTFMove(childToMove), this);
parent()->setNeedsLayoutAndPrefWidthsRecalc();
Modified: trunk/Source/WebCore/rendering/RenderGrid.cpp (231756 => 231757)
--- trunk/Source/WebCore/rendering/RenderGrid.cpp 2018-05-14 14:52:50 UTC (rev 231756)
+++ trunk/Source/WebCore/rendering/RenderGrid.cpp 2018-05-14 15:20:47 UTC (rev 231757)
@@ -213,7 +213,7 @@
LayoutSize previousSize = size();
// FIXME: We should use RenderBlock::hasDefiniteLogicalHeight() but it does not work for positioned stuff.
// FIXME: Consider caching the hasDefiniteLogicalHeight value throughout the layout.
- bool hasDefiniteLogicalHeight = hasOverrideLogicalContentHeight() || computeContentLogicalHeight(MainOrPreferredSize, style().logicalHeight(), std::nullopt);
+ bool hasDefiniteLogicalHeight = hasOverrideContentLogicalHeight() || computeContentLogicalHeight(MainOrPreferredSize, style().logicalHeight(), std::nullopt);
// We need to clear both own and containingBlock override sizes of orthogonal items to ensure we get the
// same result when grid's intrinsic size is computed again in the updateLogicalWidth call bellow.
@@ -221,8 +221,8 @@
for (auto* child = firstChildBox(); child; child = child->nextSiblingBox()) {
if (child->isOutOfFlowPositioned() || !GridLayoutFunctions::isOrthogonalChild(*this, *child))
continue;
- child->clearOverrideSize();
- child->clearContainingBlockOverrideSize();
+ child->clearOverrideContentSize();
+ child->clearOverrideContainingBlockContentSize();
child->setNeedsLayout();
child->layoutIfNeeded();
}
@@ -874,8 +874,8 @@
// Because the grid area cannot be styled, we don't need to adjust
// the grid breadth to account for 'box-sizing'.
- std::optional<LayoutUnit> oldOverrideContainingBlockContentLogicalWidth = child->hasOverrideContainingBlockLogicalWidth() ? child->overrideContainingBlockContentLogicalWidth() : LayoutUnit();
- std::optional<LayoutUnit> oldOverrideContainingBlockContentLogicalHeight = child->hasOverrideContainingBlockLogicalHeight() ? child->overrideContainingBlockContentLogicalHeight() : LayoutUnit();
+ std::optional<LayoutUnit> oldOverrideContainingBlockContentLogicalWidth = child->hasOverrideContainingBlockContentLogicalWidth() ? child->overrideContainingBlockContentLogicalWidth() : LayoutUnit();
+ std::optional<LayoutUnit> oldOverrideContainingBlockContentLogicalHeight = child->hasOverrideContainingBlockContentLogicalHeight() ? child->overrideContainingBlockContentLogicalHeight() : LayoutUnit();
LayoutUnit overrideContainingBlockContentLogicalWidth = gridAreaBreadthForChildIncludingAlignmentOffsets(*child, ForColumns);
LayoutUnit overrideContainingBlockContentLogicalHeight = gridAreaBreadthForChildIncludingAlignmentOffsets(*child, ForRows);
@@ -1065,7 +1065,7 @@
// We clear height override values because we will decide now whether it's allowed or
// not, evaluating the conditions which might have changed since the old values were set.
- child.clearOverrideLogicalContentHeight();
+ child.clearOverrideContentLogicalHeight();
GridTrackSizingDirection childBlockDirection = GridLayoutFunctions::flowAwareDirectionForChild(*this, child, ForRows);
bool blockFlowIsColumnAxis = childBlockDirection == ForRows;
@@ -1073,7 +1073,7 @@
if (allowedToStretchChildBlockSize) {
LayoutUnit stretchedLogicalHeight = availableAlignmentSpaceForChildBeforeStretching(GridLayoutFunctions::overrideContainingBlockContentSizeForChild(child, childBlockDirection).value(), child);
LayoutUnit desiredLogicalHeight = child.constrainLogicalHeightByMinMax(stretchedLogicalHeight, LayoutUnit(-1));
- child.setOverrideLogicalContentHeight(desiredLogicalHeight - child.borderAndPaddingLogicalHeight());
+ child.setOverrideContentLogicalHeight(desiredLogicalHeight - child.borderAndPaddingLogicalHeight());
if (desiredLogicalHeight != child.logicalHeight()) {
// FIXME: Can avoid laying out here in some cases. See https://webkit.org/b/87905.
child.setLogicalHeight(LayoutUnit());
Modified: trunk/Source/WebCore/rendering/RenderRubyBase.cpp (231756 => 231757)
--- trunk/Source/WebCore/rendering/RenderRubyBase.cpp 2018-05-14 14:52:50 UTC (rev 231756)
+++ trunk/Source/WebCore/rendering/RenderRubyBase.cpp 2018-05-14 15:20:47 UTC (rev 231757)
@@ -67,13 +67,13 @@
void RenderRubyBase::adjustInlineDirectionLineBounds(int expansionOpportunityCount, float& logicalLeft, float& logicalWidth) const
{
- if (rubyRun()->hasOverrideLogicalContentWidth() && firstRootBox() && !firstRootBox()->nextRootBox()) {
+ if (rubyRun()->hasOverrideContentLogicalWidth() && firstRootBox() && !firstRootBox()->nextRootBox()) {
logicalLeft += m_initialOffset;
logicalWidth -= 2 * m_initialOffset;
return;
}
- LayoutUnit maxPreferredLogicalWidth = rubyRun() && rubyRun()->hasOverrideLogicalContentWidth() ? rubyRun()->overrideLogicalContentWidth() : this->maxPreferredLogicalWidth();
+ LayoutUnit maxPreferredLogicalWidth = rubyRun() && rubyRun()->hasOverrideContentLogicalWidth() ? rubyRun()->overrideContentLogicalWidth() : this->maxPreferredLogicalWidth();
if (maxPreferredLogicalWidth >= logicalWidth)
return;
Modified: trunk/Source/WebCore/rendering/RenderTableCell.cpp (231756 => 231757)
--- trunk/Source/WebCore/rendering/RenderTableCell.cpp 2018-05-14 14:52:50 UTC (rev 231756)
+++ trunk/Source/WebCore/rendering/RenderTableCell.cpp 2018-05-14 15:20:47 UTC (rev 231757)
@@ -328,10 +328,10 @@
return computedCSSPaddingAfter() + intrinsicPaddingAfter();
}
-void RenderTableCell::setOverrideLogicalContentHeightFromRowHeight(LayoutUnit rowHeight)
+void RenderTableCell::setOverrideContentLogicalHeightFromRowHeight(LayoutUnit rowHeight)
{
clearIntrinsicPadding();
- setOverrideLogicalContentHeight(std::max<LayoutUnit>(0, rowHeight - borderAndPaddingLogicalHeight()));
+ setOverrideContentLogicalHeight(std::max<LayoutUnit>(0, rowHeight - borderAndPaddingLogicalHeight()));
}
LayoutSize RenderTableCell::offsetFromContainer(RenderElement& container, const LayoutPoint& point, bool* offsetDependsOnPoint) const
Modified: trunk/Source/WebCore/rendering/RenderTableCell.h (231756 => 231757)
--- trunk/Source/WebCore/rendering/RenderTableCell.h 2018-05-14 14:52:50 UTC (rev 231756)
+++ trunk/Source/WebCore/rendering/RenderTableCell.h 2018-05-14 15:20:47 UTC (rev 231757)
@@ -102,7 +102,7 @@
LayoutUnit paddingBefore() const override;
LayoutUnit paddingAfter() const override;
- void setOverrideLogicalContentHeightFromRowHeight(LayoutUnit);
+ void setOverrideContentLogicalHeightFromRowHeight(LayoutUnit);
void scrollbarsChanged(bool horizontalScrollbarChanged, bool verticalScrollbarChanged) override;
Modified: trunk/Source/WebCore/rendering/RenderTableSection.cpp (231756 => 231757)
--- trunk/Source/WebCore/rendering/RenderTableSection.cpp 2018-05-14 14:52:50 UTC (rev 231756)
+++ trunk/Source/WebCore/rendering/RenderTableSection.cpp 2018-05-14 15:20:47 UTC (rev 231757)
@@ -285,9 +285,9 @@
// For row spanning cells, |r| is the last row in the span.
unsigned cellStartRow = cell->rowIndex();
- if (cell->hasOverrideLogicalContentHeight()) {
+ if (cell->hasOverrideContentLogicalHeight()) {
cell->clearIntrinsicPadding();
- cell->clearOverrideSize();
+ cell->clearOverrideContentSize();
cell->setChildNeedsLayout(MarkOnlyThis);
cell->layoutIfNeeded();
}
@@ -524,7 +524,7 @@
// Alignment within a cell is based off the calculated
// height, which becomes irrelevant once the cell has
// been resized based off its percentage.
- cell.setOverrideLogicalContentHeightFromRowHeight(rowHeight);
+ cell.setOverrideContentLogicalHeightFromRowHeight(rowHeight);
cell.layoutIfNeeded();
if (!cell.isBaselineAligned())
