Diff
Modified: trunk/Source/WebCore/ChangeLog (268918 => 268919)
--- trunk/Source/WebCore/ChangeLog 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/ChangeLog 2020-10-23 09:55:25 UTC (rev 268919)
@@ -1,3 +1,158 @@
+2020-10-21 Sergio Villar Senin <[email protected]>
+
+ Rename override sizes to overriding sizes
+ https://bugs.webkit.org/show_bug.cgi?id=217898
+
+ Reviewed by Darin Adler.
+
+ We've been traditionally using the word "override" to refer to those sizes that were explicitly set by
+ layout systems like tables, flex or grid. However that's a grammatical mistake. override is a verb which
+ does not work well as a noun. It'd be more correct to refer to them as "overriding" sizes.
+
+ No new tests required as this is just a renaming.
+
+ * WebCore.order:
+ * rendering/ComplexLineLayout.cpp:
+ (WebCore::ComplexLineLayout::updateRubyForJustifiedText):
+ * rendering/GridLayoutFunctions.cpp:
+ (WebCore::GridLayoutFunctions::hasOverridingContainingBlockContentSizeForChild):
+ (WebCore::GridLayoutFunctions::overridingContainingBlockContentSizeForChild):
+ (WebCore::GridLayoutFunctions::hasOverrideContainingBlockContentSizeForChild): Deleted.
+ (WebCore::GridLayoutFunctions::overrideContainingBlockContentSizeForChild): Deleted.
+ * rendering/GridLayoutFunctions.h:
+ * rendering/GridTrackSizingAlgorithm.cpp:
+ (WebCore::shouldClearOverridingContainingBlockContentSizeForChild):
+ (WebCore::setOverridingContainingBlockContentSizeForChild):
+ (WebCore::GridTrackSizingAlgorithmStrategy::logicalHeightForChild const):
+ (WebCore::GridTrackSizingAlgorithmStrategy::minContentForChild const):
+ (WebCore::GridTrackSizingAlgorithmStrategy::maxContentForChild const):
+ (WebCore::GridTrackSizingAlgorithmStrategy::updateOverridingContainingBlockContentSizeForChild const):
+ (WebCore::GridTrackSizingAlgorithmStrategy::minLogicalSizeForChild const):
+ (WebCore::DefiniteSizeStrategy::minLogicalSizeForChild const):
+ (WebCore::DefiniteSizeStrategy::minContentForChild const):
+ (WebCore::shouldClearOverrideContainingBlockContentSizeForChild): Deleted.
+ (WebCore::setOverrideContainingBlockContentSizeForChild): Deleted.
+ (WebCore::GridTrackSizingAlgorithmStrategy::updateOverrideContainingBlockContentSizeForChild const): Deleted.
+ * rendering/GridTrackSizingAlgorithm.h:
+ * rendering/RenderBlock.cpp:
+ (WebCore::RenderBlock::insertPositionedObject):
+ (WebCore::RenderBlock::computeChildPreferredLogicalWidths const):
+ (WebCore::RenderBlock::availableLogicalHeightForPercentageComputation const):
+ * rendering/RenderBlockFlow.cpp:
+ (WebCore::RenderBlockFlow::fitBorderToLinesIfNeeded):
+ * rendering/RenderBox.cpp:
+ (WebCore::RenderBox::willBeDestroyed):
+ (WebCore::RenderBox::styleDidChange):
+ (WebCore::RenderBox::hasOverridingLogicalHeight const):
+ (WebCore::RenderBox::hasOverridingLogicalWidth const):
+ (WebCore::RenderBox::setOverridingLogicalHeight):
+ (WebCore::RenderBox::setOverridingLogicalWidth):
+ (WebCore::RenderBox::clearOverridingLogicalHeight):
+ (WebCore::RenderBox::clearOverridingLogicalWidth):
+ (WebCore::RenderBox::clearOverridingContentSize):
+ (WebCore::RenderBox::overridingLogicalWidth const):
+ (WebCore::RenderBox::overridingLogicalHeight const):
+ (WebCore::RenderBox::overridingContainingBlockContentWidth const):
+ (WebCore::RenderBox::overridingContainingBlockContentHeight const):
+ (WebCore::RenderBox::hasOverridingContainingBlockContentWidth const):
+ (WebCore::RenderBox::hasOverridingContainingBlockContentHeight const):
+ (WebCore::RenderBox::overridingContainingBlockContentLogicalWidth const):
+ (WebCore::RenderBox::overridingContainingBlockContentLogicalHeight const):
+ (WebCore::RenderBox::hasOverridingContainingBlockContentLogicalWidth const):
+ (WebCore::RenderBox::hasOverridingContainingBlockContentLogicalHeight const):
+ (WebCore::RenderBox::setOverridingContainingBlockContentLogicalWidth):
+ (WebCore::RenderBox::setOverridingContainingBlockContentLogicalHeight):
+ (WebCore::RenderBox::clearOverridingContainingBlockContentSize):
+ (WebCore::RenderBox::clearOverridingContainingBlockContentLogicalHeight):
+ (WebCore::RenderBox::containingBlockLogicalWidthForContent const):
+ (WebCore::RenderBox::containingBlockLogicalHeightForContent const):
+ (WebCore::RenderBox::perpendicularContainingBlockLogicalHeight const):
+ (WebCore::RenderBox::computeLogicalWidthInFragment const):
+ (WebCore::RenderBox::cacheIntrinsicContentLogicalHeightForFlexItem 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):
+ (WebCore::RenderBox::hasOverrideLogicalHeight const): Deleted.
+ (WebCore::RenderBox::hasOverrideLogicalWidth const): Deleted.
+ (WebCore::RenderBox::setOverrideLogicalHeight): Deleted.
+ (WebCore::RenderBox::setOverrideLogicalWidth): Deleted.
+ (WebCore::RenderBox::clearOverrideLogicalHeight): Deleted.
+ (WebCore::RenderBox::clearOverrideLogicalWidth): Deleted.
+ (WebCore::RenderBox::clearOverrideContentSize): Deleted.
+ (WebCore::RenderBox::overrideLogicalWidth const): Deleted.
+ (WebCore::RenderBox::overrideLogicalHeight const): Deleted.
+ (WebCore::RenderBox::overrideContainingBlockContentWidth const): Deleted.
+ (WebCore::RenderBox::overrideContainingBlockContentHeight const): Deleted.
+ (WebCore::RenderBox::hasOverrideContainingBlockContentWidth const): Deleted.
+ (WebCore::RenderBox::hasOverrideContainingBlockContentHeight const): Deleted.
+ (WebCore::RenderBox::overrideContainingBlockContentLogicalWidth const): Deleted.
+ (WebCore::RenderBox::overrideContainingBlockContentLogicalHeight const): Deleted.
+ (WebCore::RenderBox::hasOverrideContainingBlockContentLogicalWidth const): Deleted.
+ (WebCore::RenderBox::hasOverrideContainingBlockContentLogicalHeight const): Deleted.
+ (WebCore::RenderBox::setOverrideContainingBlockContentLogicalWidth): Deleted.
+ (WebCore::RenderBox::setOverrideContainingBlockContentLogicalHeight): Deleted.
+ (WebCore::RenderBox::clearOverrideContainingBlockContentSize): Deleted.
+ (WebCore::RenderBox::clearOverrideContainingBlockContentLogicalHeight): Deleted.
+ * rendering/RenderBox.h:
+ (WebCore::RenderBox::overridingContentLogicalWidth const):
+ (WebCore::RenderBox::overridingContentLogicalHeight const):
+ (WebCore::RenderBox::overrideContentLogicalWidth const): Deleted.
+ (WebCore::RenderBox::overrideContentLogicalHeight const): Deleted.
+ * rendering/RenderBoxModelObject.cpp:
+ (WebCore::RenderBoxModelObject::hasAutoHeightOrContainingBlockWithAutoHeight const):
+ (WebCore::RenderBoxModelObject::relativePositionOffset const):
+ * rendering/RenderBoxModelObject.h:
+ (WebCore::RenderBoxModelObject::overridingContainingBlockContentWidth const):
+ (WebCore::RenderBoxModelObject::overridingContainingBlockContentHeight const):
+ (WebCore::RenderBoxModelObject::hasOverridingContainingBlockContentWidth const):
+ (WebCore::RenderBoxModelObject::hasOverridingContainingBlockContentHeight const):
+ (WebCore::RenderBoxModelObject::overrideContainingBlockContentWidth const): Deleted.
+ (WebCore::RenderBoxModelObject::overrideContainingBlockContentHeight const): Deleted.
+ (WebCore::RenderBoxModelObject::hasOverrideContainingBlockContentWidth const): Deleted.
+ (WebCore::RenderBoxModelObject::hasOverrideContainingBlockContentHeight const): Deleted.
+ * rendering/RenderDeprecatedFlexibleBox.cpp:
+ (WebCore::widthForChild):
+ (WebCore::heightForChild):
+ (WebCore::gatherFlexChildrenInfo):
+ (WebCore::RenderDeprecatedFlexibleBox::layoutHorizontalBox):
+ (WebCore::RenderDeprecatedFlexibleBox::layoutVerticalBox):
+ (WebCore::RenderDeprecatedFlexibleBox::applyLineClamp):
+ (WebCore::RenderDeprecatedFlexibleBox::clearLineClamp):
+ * rendering/RenderFlexibleBox.cpp:
+ (WebCore::RenderFlexibleBox::childIntrinsicLogicalWidth const):
+ (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::placeItemsOnGrid const):
+ (WebCore::overrideSizeChanged):
+ (WebCore::RenderGrid::updateGridAreaLogicalSize const):
+ (WebCore::RenderGrid::layoutPositionedObject):
+ (WebCore::RenderGrid::applyStretchAlignmentToChildIfNeeded):
+ (WebCore::RenderGrid::updateAutoMarginsInRowAxisIfNeeded):
+ (WebCore::RenderGrid::updateAutoMarginsInColumnAxisIfNeeded):
+ (WebCore::RenderGrid::gridAreaPositionForOutOfFlowChild const):
+ * rendering/RenderRubyBase.cpp:
+ (WebCore::RenderRubyBase::adjustInlineDirectionLineBounds const):
+ * rendering/RenderTable.cpp:
+ (WebCore::RenderTable::updateLogicalWidth):
+ * rendering/RenderTableCell.cpp:
+ (WebCore::RenderTableCell::setOverridingLogicalHeightFromRowHeight):
+ (WebCore::RenderTableCell::setOverrideLogicalHeightFromRowHeight): Deleted.
+ * rendering/RenderTableCell.h:
+ * rendering/RenderTableSection.cpp:
+ (WebCore::RenderTableSection::calcRowLogicalHeight):
+ (WebCore::RenderTableSection::relayoutCellIfFlexed):
+
2020-10-23 Philippe Normand <[email protected]>
[GStreamer] Replace USE(WEBAUDIO_GSTREAMER) with USE(GSTREAMER)
Modified: trunk/Source/WebCore/WebCore.order (268918 => 268919)
--- trunk/Source/WebCore/WebCore.order 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/WebCore.order 2020-10-23 09:55:25 UTC (rev 268919)
@@ -9701,7 +9701,7 @@
__ZN7WebCore17RenderFlexibleBox22layoutAndPlaceChildrenERNS_10LayoutUnitERKN3WTF6VectorIPNS_9RenderBoxELm0ENS3_15CrashOnOverflowEEERKNS4_IS1_Lm0ES7_EES1_bRNS4_INS0_11LineContextELm0ES7_EE
__ZN7WebCore17RenderFlexibleBox26autoMarginOffsetInMainAxisERKN3WTF6VectorIPNS_9RenderBoxELm0ENS1_15CrashOnOverflowEEERNS_10LayoutUnitE
__ZN7WebCore17RenderFlexibleBox22setLogicalOverrideSizeEPNS_9RenderBoxENS_10LayoutUnitE
-__ZN7WebCore9RenderBox30setOverrideLogicalContentWidthENS_10LayoutUnitE
+__ZN7WebCore9RenderBox32setOverridingLogicalContentWidthENS_10LayoutUnitE
__ZN7WebCore17RenderFlexibleBox18needToStretchChildEPNS_9RenderBoxE
__ZN7WebCore11RenderBlock37updateBlockChildDirtyBitsBeforeLayoutEbPNS_9RenderBoxE
__ZN3WTF9HashTableIPKN7WebCore9RenderBoxENS_12KeyValuePairIS4_NS1_10LayoutUnitEEENS_24KeyValuePairKeyExtractorIS7_EENS_7PtrHashIS4_EENS_18HashMapValueTraitsINS_10HashTraitsIS4_EENSD_IS6_EEEESE_E16lookupForWritingINS_22IdentityHashTranslatorISB_EES4_EENSt3__14pairIPS7_bEERKT0_
@@ -15059,8 +15059,8 @@
__ZN7WebCore14DateComponents40setMillisecondsSinceEpochForDateInternalEd
__ZNSt3__17__sort5IRPFbRKNS_4pairIPN3WTF16AtomicStringImplENS2_12AtomicStringEEES8_EPS6_EEjT0_SD_SD_SD_SD_T_
__ZN7WebCore13HTMLBRElement36collectStyleForPresentationAttributeERKNS_13QualifiedNameERKN3WTF12AtomicStringEPNS_23MutableStylePropertySetE
-__ZN7WebCore15RenderTableCell44setOverrideLogicalContentHeightFromRowHeightENS_10LayoutUnitE
-__ZN7WebCore9RenderBox31setOverrideLogicalContentHeightENS_10LayoutUnitE
+__ZN7WebCore15RenderTableCell46setOverridingLogicalContentHeightFromRowHeightENS_10LayoutUnitE
+__ZN7WebCore9RenderBox33setOverridingLogicalContentHeightENS_10LayoutUnitE
__ZNK7WebCore17HTMLScriptElement14isURLAttributeERKNS_9AttributeE
__ZNK7WebCore16HTMLImageElement14isURLAttributeERKNS_9AttributeE
__ZNK7WebCore15HTMLFormElement14isURLAttributeERKNS_9AttributeE
@@ -27360,8 +27360,8 @@
__ZGVZN7WebCore11RenderBlock25checkLinesForTextOverflowEvE11ellipsisStr.b
__ZN7WebCoreL18gOverrideHeightMapE
__ZN7WebCoreL17gOverrideWidthMapE
-__ZN7WebCoreL39gOverrideContainingBlockLogicalWidthMapE
-__ZN7WebCoreL40gOverrideContainingBlockLogicalHeightMapE
+__ZN7WebCoreL41gOverridingContainingBlockLogicalWidthMapE
+__ZN7WebCoreL42gOverridingContainingBlockLogicalHeightMapE
__ZN7WebCoreL15continuationMapE
__ZN7WebCoreL27firstLetterRemainingTextMapE
__ZZN7WebCoreL13newlineStringEvE6string
Modified: trunk/Source/WebCore/rendering/ComplexLineLayout.cpp (268918 => 268919)
--- trunk/Source/WebCore/rendering/ComplexLineLayout.cpp 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/rendering/ComplexLineLayout.cpp 2020-10-23 09:55:25 UTC (rev 268919)
@@ -590,11 +590,11 @@
totalOpportunitiesInRun += opportunitiesInRun;
}
- ASSERT(!rubyRun.hasOverrideLogicalWidth());
+ ASSERT(!rubyRun.hasOverridingLogicalWidth());
float newBaseWidth = rubyRun.logicalWidth() + totalExpansion + m_flow.marginStartForChild(rubyRun) + m_flow.marginEndForChild(rubyRun);
float newRubyRunWidth = rubyRun.logicalWidth() + totalExpansion;
rubyBase.setInitialOffset((newRubyRunWidth - newBaseWidth) / 2);
- rubyRun.setOverrideLogicalWidth(LayoutUnit(newRubyRunWidth));
+ rubyRun.setOverridingLogicalWidth(LayoutUnit(newRubyRunWidth));
rubyRun.setNeedsLayout(MarkOnlyThis);
rootBox.markDirty();
if (RenderRubyText* rubyText = rubyRun.rubyText()) {
@@ -602,7 +602,7 @@
textRootBox->markDirty();
}
rubyRun.layoutBlock(true);
- rubyRun.clearOverrideLogicalWidth();
+ rubyRun.clearOverridingLogicalWidth();
r.box()->setExpansion(newRubyRunWidth - r.box()->logicalWidth());
totalLogicalWidth += totalExpansion;
Modified: trunk/Source/WebCore/rendering/GridLayoutFunctions.cpp (268918 => 268919)
--- trunk/Source/WebCore/rendering/GridLayoutFunctions.cpp 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/rendering/GridLayoutFunctions.cpp 2020-10-23 09:55:25 UTC (rev 268919)
@@ -87,14 +87,14 @@
return !isOrthogonalChild(grid, child) ? direction : (direction == ForColumns ? ForRows : ForColumns);
}
-bool hasOverrideContainingBlockContentSizeForChild(const RenderBox& child, GridTrackSizingDirection direction)
+bool hasOverridingContainingBlockContentSizeForChild(const RenderBox& child, GridTrackSizingDirection direction)
{
- return direction == ForColumns ? child.hasOverrideContainingBlockContentLogicalWidth() : child.hasOverrideContainingBlockContentLogicalHeight();
+ return direction == ForColumns ? child.hasOverridingContainingBlockContentLogicalWidth() : child.hasOverridingContainingBlockContentLogicalHeight();
}
-Optional<LayoutUnit> overrideContainingBlockContentSizeForChild(const RenderBox& child, GridTrackSizingDirection direction)
+Optional<LayoutUnit> overridingContainingBlockContentSizeForChild(const RenderBox& child, GridTrackSizingDirection direction)
{
- return direction == ForColumns ? child.overrideContainingBlockContentLogicalWidth() : child.overrideContainingBlockContentLogicalHeight();
+ return direction == ForColumns ? child.overridingContainingBlockContentLogicalWidth() : child.overridingContainingBlockContentLogicalHeight();
}
} // namespace GridLayoutFunctions
Modified: trunk/Source/WebCore/rendering/GridLayoutFunctions.h (268918 => 268919)
--- trunk/Source/WebCore/rendering/GridLayoutFunctions.h 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/rendering/GridLayoutFunctions.h 2020-10-23 09:55:25 UTC (rev 268919)
@@ -41,8 +41,8 @@
LayoutUnit marginLogicalSizeForChild(const RenderGrid&, GridTrackSizingDirection, const RenderBox&);
bool isOrthogonalChild(const RenderGrid&, const RenderBox&);
GridTrackSizingDirection flowAwareDirectionForChild(const RenderGrid&, const RenderBox&, GridTrackSizingDirection);
-bool hasOverrideContainingBlockContentSizeForChild(const RenderBox&, GridTrackSizingDirection);
-Optional<LayoutUnit> overrideContainingBlockContentSizeForChild(const RenderBox&, GridTrackSizingDirection);
+bool hasOverridingContainingBlockContentSizeForChild(const RenderBox&, GridTrackSizingDirection);
+Optional<LayoutUnit> overridingContainingBlockContentSizeForChild(const RenderBox&, GridTrackSizingDirection);
}
Modified: trunk/Source/WebCore/rendering/GridTrackSizingAlgorithm.cpp (268918 => 268919)
--- trunk/Source/WebCore/rendering/GridTrackSizingAlgorithm.cpp 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/rendering/GridTrackSizingAlgorithm.cpp 2020-10-23 09:55:25 UTC (rev 268919)
@@ -120,17 +120,17 @@
return child.hasRelativeLogicalHeight() || child.style().logicalHeight().isIntrinsicOrAuto();
}
-static bool shouldClearOverrideContainingBlockContentSizeForChild(const RenderBox& child, GridTrackSizingDirection direction)
+static bool shouldClearOverridingContainingBlockContentSizeForChild(const RenderBox& child, GridTrackSizingDirection direction)
{
return hasRelativeOrIntrinsicSizeForChild(child, direction) || hasRelativeMarginOrPaddingForChild(child, direction);
}
-static void setOverrideContainingBlockContentSizeForChild(RenderBox& child, GridTrackSizingDirection direction, Optional<LayoutUnit> size)
+static void setOverridingContainingBlockContentSizeForChild(RenderBox& child, GridTrackSizingDirection direction, Optional<LayoutUnit> size)
{
if (direction == ForColumns)
- child.setOverrideContainingBlockContentLogicalWidth(size);
+ child.setOverridingContainingBlockContentLogicalWidth(size);
else
- child.setOverrideContainingBlockContentLogicalHeight(size);
+ child.setOverridingContainingBlockContentLogicalHeight(size);
}
// GridTrackSizingAlgorithm private.
@@ -756,14 +756,14 @@
GridTrackSizingDirection childBlockDirection = GridLayoutFunctions::flowAwareDirectionForChild(*renderGrid(), child, ForRows);
// 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 block-axis override size to -1 (no possible resolution).
- if (shouldClearOverrideContainingBlockContentSizeForChild(child, ForRows)) {
- setOverrideContainingBlockContentSizeForChild(child, childBlockDirection, WTF::nullopt);
+ if (shouldClearOverridingContainingBlockContentSizeForChild(child, ForRows)) {
+ setOverridingContainingBlockContentSizeForChild(child, childBlockDirection, WTF::nullopt);
child.setNeedsLayout(MarkOnlyThis);
}
// We need to clear the stretched height to properly compute logical height during layout.
if (child.needsLayout())
- child.clearOverrideLogicalHeight();
+ child.clearOverridingLogicalHeight();
child.layoutIfNeeded();
return child.logicalHeight() + GridLayoutFunctions::marginLogicalSizeForChild(*renderGrid(), childBlockDirection, child) + m_algorithm.baselineOffsetForChild(child, gridAxisForDirection(direction()));
@@ -778,7 +778,7 @@
return child.minPreferredLogicalWidth() + GridLayoutFunctions::marginLogicalSizeForChild(*renderGrid(), childInlineDirection, child) + m_algorithm.baselineOffsetForChild(child, gridAxisForDirection(direction()));
}
- if (updateOverrideContainingBlockContentSizeForChild(child, childInlineDirection))
+ if (updateOverridingContainingBlockContentSizeForChild(child, childInlineDirection))
child.setNeedsLayout(MarkOnlyThis);
return logicalHeightForChild(child);
}
@@ -792,7 +792,7 @@
return child.maxPreferredLogicalWidth() + GridLayoutFunctions::marginLogicalSizeForChild(*renderGrid(), childInlineDirection, child) + m_algorithm.baselineOffsetForChild(child, gridAxisForDirection(direction()));
}
- if (updateOverrideContainingBlockContentSizeForChild(child, childInlineDirection))
+ if (updateOverridingContainingBlockContentSizeForChild(child, childInlineDirection))
child.setNeedsLayout(MarkOnlyThis);
return logicalHeightForChild(child);
}
@@ -899,14 +899,14 @@
m_rowBaselineItemsMap = source.m_rowBaselineItemsMap;
}
-bool GridTrackSizingAlgorithmStrategy::updateOverrideContainingBlockContentSizeForChild(RenderBox& child, GridTrackSizingDirection direction, Optional<LayoutUnit> overrideSize) const
+bool GridTrackSizingAlgorithmStrategy::updateOverridingContainingBlockContentSizeForChild(RenderBox& child, GridTrackSizingDirection direction, Optional<LayoutUnit> overrideSize) const
{
if (!overrideSize)
overrideSize = m_algorithm.gridAreaBreadthForChild(child, direction);
- if (GridLayoutFunctions::hasOverrideContainingBlockContentSizeForChild(child, direction) && GridLayoutFunctions::overrideContainingBlockContentSizeForChild(child, direction) == overrideSize)
+ if (GridLayoutFunctions::hasOverridingContainingBlockContentSizeForChild(child, direction) && GridLayoutFunctions::overridingContainingBlockContentSizeForChild(child, direction) == overrideSize)
return false;
- setOverrideContainingBlockContentSizeForChild(child, direction, overrideSize);
+ setOverridingContainingBlockContentSizeForChild(child, direction, overrideSize);
return true;
}
@@ -916,7 +916,7 @@
bool isRowAxis = direction() == childInlineDirection;
if (isRowAxis)
return child.computeLogicalWidthInFragmentUsing(MinSize, childMinSize, availableSize, *renderGrid(), nullptr) + GridLayoutFunctions::marginLogicalSizeForChild(*renderGrid(), childInlineDirection, child);
- bool overrideSizeHasChanged = updateOverrideContainingBlockContentSizeForChild(child, childInlineDirection, availableSize);
+ bool overrideSizeHasChanged = updateOverridingContainingBlockContentSizeForChild(child, childInlineDirection, availableSize);
layoutGridItemForMinSizeComputation(child, overrideSizeHasChanged);
GridTrackSizingDirection childBlockDirection = GridLayoutFunctions::flowAwareDirectionForChild(*renderGrid(), child, ForRows);
return child.computeLogicalHeightUsing(MinSize, childMinSize, WTF::nullopt).valueOr(0) + GridLayoutFunctions::marginLogicalSizeForChild(*renderGrid(), childBlockDirection, child);
@@ -1050,7 +1050,7 @@
LayoutUnit indefiniteSize = direction() == childInlineDirection ? LayoutUnit() : LayoutUnit(-1);
GridTrackSizingDirection flowAwareDirection = GridLayoutFunctions::flowAwareDirectionForChild(*renderGrid(), child, direction());
if (hasRelativeMarginOrPaddingForChild(child, flowAwareDirection) || (direction() != childInlineDirection && hasRelativeOrIntrinsicSizeForChild(child, flowAwareDirection)))
- setOverrideContainingBlockContentSizeForChild(child, direction(), indefiniteSize);
+ setOverridingContainingBlockContentSizeForChild(child, direction(), indefiniteSize);
return GridTrackSizingAlgorithmStrategy::minLogicalSizeForChild(child, childMinSize, availableSize);
}
@@ -1093,8 +1093,8 @@
LayoutUnit DefiniteSizeStrategy::minContentForChild(RenderBox& child) const
{
GridTrackSizingDirection childInlineDirection = GridLayoutFunctions::flowAwareDirectionForChild(*renderGrid(), child, ForColumns);
- if (direction() == childInlineDirection && child.needsLayout() && shouldClearOverrideContainingBlockContentSizeForChild(child, ForColumns))
- setOverrideContainingBlockContentSizeForChild(child, childInlineDirection, LayoutUnit());
+ if (direction() == childInlineDirection && child.needsLayout() && shouldClearOverridingContainingBlockContentSizeForChild(child, ForColumns))
+ setOverridingContainingBlockContentSizeForChild(child, childInlineDirection, LayoutUnit());
return GridTrackSizingAlgorithmStrategy::minContentForChild(child);
}
Modified: trunk/Source/WebCore/rendering/GridTrackSizingAlgorithm.h (268918 => 268919)
--- trunk/Source/WebCore/rendering/GridTrackSizingAlgorithm.h 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/rendering/GridTrackSizingAlgorithm.h 2020-10-23 09:55:25 UTC (rev 268919)
@@ -271,7 +271,7 @@
virtual void layoutGridItemForMinSizeComputation(RenderBox&, bool overrideSizeHasChanged) const = 0;
LayoutUnit logicalHeightForChild(RenderBox&) const;
- bool updateOverrideContainingBlockContentSizeForChild(RenderBox&, GridTrackSizingDirection, Optional<LayoutUnit> = WTF::nullopt) const;
+ bool updateOverridingContainingBlockContentSizeForChild(RenderBox&, GridTrackSizingDirection, Optional<LayoutUnit> = WTF::nullopt) const;
// GridTrackSizingAlgorithm accessors for subclasses.
LayoutUnit computeTrackBasedSize() const { return m_algorithm.computeTrackBasedSize(); }
Modified: trunk/Source/WebCore/rendering/RenderBlock.cpp (268918 => 268919)
--- trunk/Source/WebCore/rendering/RenderBlock.cpp 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/rendering/RenderBlock.cpp 2020-10-23 09:55:25 UTC (rev 268919)
@@ -1768,7 +1768,7 @@
{
ASSERT(!isAnonymousBlock());
- positioned.clearOverrideContainingBlockContentSize();
+ positioned.clearOverridingContainingBlockContentSize();
if (positioned.isRenderFragmentedFlow())
return;
@@ -2417,19 +2417,19 @@
return;
}
- // The preferred widths of flexbox children should never depend on override sizes. They should
+ // The preferred widths of flexbox children should never depend on overriding sizes. They should
// always be computed without regard for any overrides that are present.
- Optional<LayoutUnit> overrideHeight;
- Optional<LayoutUnit> overrideWidth;
+ Optional<LayoutUnit> overridingHeight;
+ Optional<LayoutUnit> overridingWidth;
if (child.isBox()) {
auto& box = downcast<RenderBox>(child);
if (box.isFlexItem()) {
- if (box.hasOverrideLogicalHeight())
- overrideHeight = Optional<LayoutUnit>(box.overrideLogicalHeight());
- if (box.hasOverrideLogicalWidth())
- overrideWidth = Optional<LayoutUnit>(box.overrideLogicalWidth());
- box.clearOverrideContentSize();
+ if (box.hasOverridingLogicalHeight())
+ overridingHeight = Optional<LayoutUnit>(box.overridingLogicalHeight());
+ if (box.hasOverridingLogicalWidth())
+ overridingWidth = Optional<LayoutUnit>(box.overridingLogicalWidth());
+ box.clearOverridingContentSize();
}
}
@@ -2438,10 +2438,10 @@
if (child.isBox()) {
auto& box = downcast<RenderBox>(child);
- if (overrideHeight)
- box.setOverrideLogicalHeight(overrideHeight.value());
- if (overrideWidth)
- box.setOverrideLogicalWidth(overrideWidth.value());
+ if (overridingHeight)
+ box.setOverridingLogicalHeight(overridingHeight.value());
+ if (overridingWidth)
+ box.setOverridingLogicalWidth(overridingWidth.value());
}
// For non-replaced blocks if the inline size is min|max-content or a definite
@@ -3219,8 +3219,8 @@
if (stretchedFlexHeight)
availableHeight = stretchedFlexHeight;
- else if (isGridItem() && hasOverrideLogicalHeight())
- availableHeight = overrideLogicalHeight();
+ else if (isGridItem() && hasOverridingLogicalHeight())
+ availableHeight = overridingLogicalHeight();
else if (styleToUse.logicalHeight().isFixed()) {
LayoutUnit contentBoxHeight = adjustContentBoxLogicalHeightForBoxSizing((LayoutUnit)styleToUse.logicalHeight().value());
availableHeight = std::max(0_lu, constrainContentBoxLogicalHeightByMinMax(contentBoxHeight - scrollbarLogicalHeight(), WTF::nullopt));
Modified: trunk/Source/WebCore/rendering/RenderBlockFlow.cpp (268918 => 268919)
--- trunk/Source/WebCore/rendering/RenderBlockFlow.cpp 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/rendering/RenderBlockFlow.cpp 2020-10-23 09:55:25 UTC (rev 268919)
@@ -3045,7 +3045,7 @@
void RenderBlockFlow::fitBorderToLinesIfNeeded()
{
- if (style().borderFit() == BorderFit::Border || hasOverrideLogicalWidth())
+ if (style().borderFit() == BorderFit::Border || hasOverridingLogicalWidth())
return;
// Walk any normal flow lines to snugly fit.
@@ -3064,9 +3064,9 @@
if (newContentWidth == oldWidth)
return;
- setOverrideLogicalWidth(newContentWidth + borderAndPaddingLogicalWidth());
+ setOverridingLogicalWidth(newContentWidth + borderAndPaddingLogicalWidth());
layoutBlock(false);
- clearOverrideLogicalWidth();
+ clearOverridingLogicalWidth();
}
void RenderBlockFlow::markLinesDirtyInBlockRange(LayoutUnit logicalTop, LayoutUnit logicalBottom, RootInlineBox* highest)
Modified: trunk/Source/WebCore/rendering/RenderBox.cpp (268918 => 268919)
--- trunk/Source/WebCore/rendering/RenderBox.cpp 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/rendering/RenderBox.cpp 2020-10-23 09:55:25 UTC (rev 268919)
@@ -94,13 +94,13 @@
using namespace HTMLNames;
typedef WTF::HashMap<const RenderBox*, LayoutUnit> OverrideSizeMap;
-static OverrideSizeMap* gOverrideLogicalHeightMap = nullptr;
-static OverrideSizeMap* gOverrideLogicalWidthMap = nullptr;
+static OverrideSizeMap* gOverridingLogicalHeightMap = nullptr;
+static OverrideSizeMap* gOverridingLogicalWidthMap = nullptr;
// FIXME: We should store these based on physical direction.
typedef WTF::HashMap<const RenderBox*, Optional<LayoutUnit>> OverrideOptionalSizeMap;
-static OverrideOptionalSizeMap* gOverrideContainingBlockContentLogicalHeightMap = nullptr;
-static OverrideOptionalSizeMap* gOverrideContainingBlockContentLogicalWidthMap = nullptr;
+static OverrideOptionalSizeMap* gOverridingContainingBlockContentLogicalHeightMap = nullptr;
+static OverrideOptionalSizeMap* gOverridingContainingBlockContentLogicalWidthMap = nullptr;
// Size of border belt for autoscroll. When mouse pointer in border belt,
// autoscroll is started.
@@ -150,8 +150,8 @@
if (frame().eventHandler().autoscrollRenderer() == this)
frame().eventHandler().stopAutoscrollTimer(true);
- clearOverrideContentSize();
- clearOverrideContainingBlockContentSize();
+ clearOverridingContentSize();
+ clearOverridingContainingBlockContentSize();
RenderBlock::removePercentHeightDescendantIfNeeded(*this);
@@ -407,7 +407,7 @@
// children of a flex/grid box are out-of-flow, and thus, not flex/grid items. This means that we need to clear
// any override content size set by our container, because it would likely be incorrect after the style change.
if (isOutOfFlowPositioned() && parent() && parent()->style().isDisplayFlexibleOrGridBox())
- clearOverrideContentSize();
+ clearOverridingContentSize();
#if ENABLE(LAYOUT_FORMATTING_CONTEXT)
if (diff == StyleDifference::Layout) {
@@ -1088,77 +1088,77 @@
return m_maxPreferredLogicalWidth;
}
-bool RenderBox::hasOverrideLogicalHeight() const
+bool RenderBox::hasOverridingLogicalHeight() const
{
- return gOverrideLogicalHeightMap && gOverrideLogicalHeightMap->contains(this);
+ return gOverridingLogicalHeightMap && gOverridingLogicalHeightMap->contains(this);
}
-bool RenderBox::hasOverrideLogicalWidth() const
+bool RenderBox::hasOverridingLogicalWidth() const
{
- return gOverrideLogicalWidthMap && gOverrideLogicalWidthMap->contains(this);
+ return gOverridingLogicalWidthMap && gOverridingLogicalWidthMap->contains(this);
}
-void RenderBox::setOverrideLogicalHeight(LayoutUnit height)
+void RenderBox::setOverridingLogicalHeight(LayoutUnit height)
{
- if (!gOverrideLogicalHeightMap)
- gOverrideLogicalHeightMap = new OverrideSizeMap();
- gOverrideLogicalHeightMap->set(this, height);
+ if (!gOverridingLogicalHeightMap)
+ gOverridingLogicalHeightMap = new OverrideSizeMap();
+ gOverridingLogicalHeightMap->set(this, height);
}
-void RenderBox::setOverrideLogicalWidth(LayoutUnit width)
+void RenderBox::setOverridingLogicalWidth(LayoutUnit width)
{
- if (!gOverrideLogicalWidthMap)
- gOverrideLogicalWidthMap = new OverrideSizeMap();
- gOverrideLogicalWidthMap->set(this, width);
+ if (!gOverridingLogicalWidthMap)
+ gOverridingLogicalWidthMap = new OverrideSizeMap();
+ gOverridingLogicalWidthMap->set(this, width);
}
-void RenderBox::clearOverrideLogicalHeight()
+void RenderBox::clearOverridingLogicalHeight()
{
- if (gOverrideLogicalHeightMap)
- gOverrideLogicalHeightMap->remove(this);
+ if (gOverridingLogicalHeightMap)
+ gOverridingLogicalHeightMap->remove(this);
}
-void RenderBox::clearOverrideLogicalWidth()
+void RenderBox::clearOverridingLogicalWidth()
{
- if (gOverrideLogicalWidthMap)
- gOverrideLogicalWidthMap->remove(this);
+ if (gOverridingLogicalWidthMap)
+ gOverridingLogicalWidthMap->remove(this);
}
-void RenderBox::clearOverrideContentSize()
+void RenderBox::clearOverridingContentSize()
{
- clearOverrideLogicalHeight();
- clearOverrideLogicalWidth();
+ clearOverridingLogicalHeight();
+ clearOverridingLogicalWidth();
}
-LayoutUnit RenderBox::overrideLogicalWidth() const
+LayoutUnit RenderBox::overridingLogicalWidth() const
{
- ASSERT(hasOverrideLogicalWidth());
- return gOverrideLogicalWidthMap->get(this);
+ ASSERT(hasOverridingLogicalWidth());
+ return gOverridingLogicalWidthMap->get(this);
}
-LayoutUnit RenderBox::overrideLogicalHeight() const
+LayoutUnit RenderBox::overridingLogicalHeight() const
{
- ASSERT(hasOverrideLogicalHeight());
- return gOverrideLogicalHeightMap->get(this);
+ ASSERT(hasOverridingLogicalHeight());
+ return gOverridingLogicalHeightMap->get(this);
}
-Optional<LayoutUnit> RenderBox::overrideContainingBlockContentWidth() const
+Optional<LayoutUnit> RenderBox::overridingContainingBlockContentWidth() const
{
- ASSERT(hasOverrideContainingBlockContentWidth());
+ ASSERT(hasOverridingContainingBlockContentWidth());
return containingBlock()->style().isHorizontalWritingMode()
- ? gOverrideContainingBlockContentLogicalWidthMap->get(this)
- : gOverrideContainingBlockContentLogicalHeightMap->get(this);
+ ? gOverridingContainingBlockContentLogicalWidthMap->get(this)
+ : gOverridingContainingBlockContentLogicalHeightMap->get(this);
}
-Optional<LayoutUnit> RenderBox::overrideContainingBlockContentHeight() const
+Optional<LayoutUnit> RenderBox::overridingContainingBlockContentHeight() const
{
- ASSERT(hasOverrideContainingBlockContentHeight());
+ ASSERT(hasOverridingContainingBlockContentHeight());
return containingBlock()->style().isHorizontalWritingMode()
- ? gOverrideContainingBlockContentLogicalHeightMap->get(this)
- : gOverrideContainingBlockContentLogicalWidthMap->get(this);
+ ? gOverridingContainingBlockContentLogicalHeightMap->get(this)
+ : gOverridingContainingBlockContentLogicalWidthMap->get(this);
}
-bool RenderBox::hasOverrideContainingBlockContentWidth() const
+bool RenderBox::hasOverridingContainingBlockContentWidth() const
{
RenderBlock* cb = containingBlock();
if (!cb)
@@ -1165,11 +1165,11 @@
return false;
return cb->style().isHorizontalWritingMode()
- ? gOverrideContainingBlockContentLogicalWidthMap && gOverrideContainingBlockContentLogicalWidthMap->contains(this)
- : gOverrideContainingBlockContentLogicalHeightMap && gOverrideContainingBlockContentLogicalHeightMap->contains(this);
+ ? gOverridingContainingBlockContentLogicalWidthMap && gOverridingContainingBlockContentLogicalWidthMap->contains(this)
+ : gOverridingContainingBlockContentLogicalHeightMap && gOverridingContainingBlockContentLogicalHeightMap->contains(this);
}
-bool RenderBox::hasOverrideContainingBlockContentHeight() const
+bool RenderBox::hasOverridingContainingBlockContentHeight() const
{
RenderBlock* cb = containingBlock();
if (!cb)
@@ -1176,57 +1176,57 @@
return false;
return cb->style().isHorizontalWritingMode()
- ? gOverrideContainingBlockContentLogicalHeightMap && gOverrideContainingBlockContentLogicalHeightMap->contains(this)
- : gOverrideContainingBlockContentLogicalHeightMap && gOverrideContainingBlockContentLogicalHeightMap->contains(this);
+ ? gOverridingContainingBlockContentLogicalHeightMap && gOverridingContainingBlockContentLogicalHeightMap->contains(this)
+ : gOverridingContainingBlockContentLogicalHeightMap && gOverridingContainingBlockContentLogicalHeightMap->contains(this);
}
-Optional<LayoutUnit> RenderBox::overrideContainingBlockContentLogicalWidth() const
+Optional<LayoutUnit> RenderBox::overridingContainingBlockContentLogicalWidth() const
{
- ASSERT(hasOverrideContainingBlockContentLogicalWidth());
- return gOverrideContainingBlockContentLogicalWidthMap->get(this);
+ ASSERT(hasOverridingContainingBlockContentLogicalWidth());
+ return gOverridingContainingBlockContentLogicalWidthMap->get(this);
}
-Optional<LayoutUnit> RenderBox::overrideContainingBlockContentLogicalHeight() const
+Optional<LayoutUnit> RenderBox::overridingContainingBlockContentLogicalHeight() const
{
- ASSERT(hasOverrideContainingBlockContentLogicalHeight());
- return gOverrideContainingBlockContentLogicalHeightMap->get(this);
+ ASSERT(hasOverridingContainingBlockContentLogicalHeight());
+ return gOverridingContainingBlockContentLogicalHeightMap->get(this);
}
-bool RenderBox::hasOverrideContainingBlockContentLogicalWidth() const
+bool RenderBox::hasOverridingContainingBlockContentLogicalWidth() const
{
- return gOverrideContainingBlockContentLogicalWidthMap && gOverrideContainingBlockContentLogicalWidthMap->contains(this);
+ return gOverridingContainingBlockContentLogicalWidthMap && gOverridingContainingBlockContentLogicalWidthMap->contains(this);
}
-bool RenderBox::hasOverrideContainingBlockContentLogicalHeight() const
+bool RenderBox::hasOverridingContainingBlockContentLogicalHeight() const
{
- return gOverrideContainingBlockContentLogicalHeightMap && gOverrideContainingBlockContentLogicalHeightMap->contains(this);
+ return gOverridingContainingBlockContentLogicalHeightMap && gOverridingContainingBlockContentLogicalHeightMap->contains(this);
}
-void RenderBox::setOverrideContainingBlockContentLogicalWidth(Optional<LayoutUnit> logicalWidth)
+void RenderBox::setOverridingContainingBlockContentLogicalWidth(Optional<LayoutUnit> logicalWidth)
{
- if (!gOverrideContainingBlockContentLogicalWidthMap)
- gOverrideContainingBlockContentLogicalWidthMap = new OverrideOptionalSizeMap;
- gOverrideContainingBlockContentLogicalWidthMap->set(this, logicalWidth);
+ if (!gOverridingContainingBlockContentLogicalWidthMap)
+ gOverridingContainingBlockContentLogicalWidthMap = new OverrideOptionalSizeMap;
+ gOverridingContainingBlockContentLogicalWidthMap->set(this, logicalWidth);
}
-void RenderBox::setOverrideContainingBlockContentLogicalHeight(Optional<LayoutUnit> logicalHeight)
+void RenderBox::setOverridingContainingBlockContentLogicalHeight(Optional<LayoutUnit> logicalHeight)
{
- if (!gOverrideContainingBlockContentLogicalHeightMap)
- gOverrideContainingBlockContentLogicalHeightMap = new OverrideOptionalSizeMap;
- gOverrideContainingBlockContentLogicalHeightMap->set(this, logicalHeight);
+ if (!gOverridingContainingBlockContentLogicalHeightMap)
+ gOverridingContainingBlockContentLogicalHeightMap = new OverrideOptionalSizeMap;
+ gOverridingContainingBlockContentLogicalHeightMap->set(this, logicalHeight);
}
-void RenderBox::clearOverrideContainingBlockContentSize()
+void RenderBox::clearOverridingContainingBlockContentSize()
{
- if (gOverrideContainingBlockContentLogicalWidthMap)
- gOverrideContainingBlockContentLogicalWidthMap->remove(this);
- clearOverrideContainingBlockContentLogicalHeight();
+ if (gOverridingContainingBlockContentLogicalWidthMap)
+ gOverridingContainingBlockContentLogicalWidthMap->remove(this);
+ clearOverridingContainingBlockContentLogicalHeight();
}
-void RenderBox::clearOverrideContainingBlockContentLogicalHeight()
+void RenderBox::clearOverridingContainingBlockContentLogicalHeight()
{
- if (gOverrideContainingBlockContentLogicalHeightMap)
- gOverrideContainingBlockContentLogicalHeightMap->remove(this);
+ if (gOverridingContainingBlockContentLogicalHeightMap)
+ gOverridingContainingBlockContentLogicalHeightMap->remove(this);
}
LayoutUnit RenderBox::adjustBorderBoxLogicalWidthForBoxSizing(LayoutUnit width) const
@@ -1973,9 +1973,9 @@
LayoutUnit RenderBox::containingBlockLogicalWidthForContent() const
{
- if (hasOverrideContainingBlockContentLogicalWidth()) {
- if (auto overrideLogicalWidth = overrideContainingBlockContentLogicalWidth())
- return overrideLogicalWidth.value();
+ if (hasOverridingContainingBlockContentLogicalWidth()) {
+ if (auto width = overridingContainingBlockContentLogicalWidth())
+ return width.value();
}
if (RenderBlock* cb = containingBlock())
@@ -1985,9 +1985,9 @@
LayoutUnit RenderBox::containingBlockLogicalHeightForContent(AvailableLogicalHeightType heightType) const
{
- if (hasOverrideContainingBlockContentLogicalHeight()) {
- if (auto overrideLogicalHeight = overrideContainingBlockContentLogicalHeight())
- return overrideLogicalHeight.value();
+ if (hasOverridingContainingBlockContentLogicalHeight()) {
+ if (auto height = overridingContainingBlockContentLogicalHeight())
+ return height.value();
}
if (RenderBlock* cb = containingBlock())
@@ -2026,14 +2026,14 @@
LayoutUnit RenderBox::perpendicularContainingBlockLogicalHeight() const
{
- if (hasOverrideContainingBlockContentLogicalHeight()) {
- if (auto overrideLogicalHeight = overrideContainingBlockContentLogicalHeight())
- return overrideLogicalHeight.value();
+ if (hasOverridingContainingBlockContentLogicalHeight()) {
+ if (auto height = overridingContainingBlockContentLogicalHeight())
+ return height.value();
}
RenderBlock* cb = containingBlock();
- if (cb->hasOverrideLogicalHeight())
- return cb->overrideContentLogicalHeight();
+ if (cb->hasOverridingLogicalHeight())
+ return cb->overridingContentLogicalHeight();
const RenderStyle& containingBlockStyle = cb->style();
Length logicalHeightLength = containingBlockStyle.logicalHeight();
@@ -2439,8 +2439,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 (hasOverrideLogicalWidth() && (isRubyRun() || style().borderFit() == BorderFit::Lines || (parent()->isFlexibleBoxIncludingDeprecated()))) {
- computedValues.m_extent = overrideLogicalWidth();
+ if (hasOverridingLogicalWidth() && (isRubyRun() || style().borderFit() == BorderFit::Lines || (parent()->isFlexibleBoxIncludingDeprecated()))) {
+ computedValues.m_extent = overridingLogicalWidth();
return;
}
@@ -2782,10 +2782,10 @@
void RenderBox::cacheIntrinsicContentLogicalHeightForFlexItem(LayoutUnit height) const
{
- // FIXME: it should be enough with checking hasOverrideLogicalHeight() as this logic could be shared
+ // FIXME: it should be enough with checking hasOverridingLogicalHeight() as this logic could be shared
// by any layout system using overrides like grid or flex. However this causes a never ending sequence of calls
// between layoutBlock() <-> relayoutToAvoidWidows().
- if (isFloatingOrOutOfFlowPositioned() || !parent() || !parent()->isFlexibleBox() || hasOverrideLogicalHeight())
+ if (isFloatingOrOutOfFlowPositioned() || !parent() || !parent()->isFlexibleBox() || hasOverridingLogicalHeight())
return;
downcast<RenderFlexibleBox>(parent())->setCachedChildIntrinsicContentLogicalHeight(*this, height);
}
@@ -2846,8 +2846,8 @@
// grab our cached flexible height.
// FIXME: Account for block-flow in flexible boxes.
// https://bugs.webkit.org/show_bug.cgi?id=46418
- if (hasOverrideLogicalHeight() && (parent()->isFlexibleBoxIncludingDeprecated() || parent()->isRenderGrid())) {
- h = Length(overrideLogicalHeight(), Fixed);
+ if (hasOverridingLogicalHeight() && (parent()->isFlexibleBoxIncludingDeprecated() || parent()->isRenderGrid())) {
+ h = Length(overridingLogicalHeight(), Fixed);
} else if (treatAsReplaced)
h = Length(computeReplacedLogicalHeight() + borderAndPaddingLogicalHeight(), Fixed);
else {
@@ -3031,17 +3031,17 @@
if (isHorizontal != cb->isHorizontalWritingMode())
availableHeight = containingBlockChild->containingBlockLogicalWidthForContent();
- else if (hasOverrideContainingBlockContentLogicalHeight())
- availableHeight = overrideContainingBlockContentLogicalHeight();
+ else if (hasOverridingContainingBlockContentLogicalHeight())
+ availableHeight = overridingContainingBlockContentLogicalHeight();
else if (is<RenderTableCell>(*cb)) {
if (!skippedAutoHeightContainingBlock) {
// 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->hasOverrideLogicalHeight())
+ if (!cb->hasOverridingLogicalHeight())
return tableCellShouldHaveZeroInitialSize(*cb, *this, scrollsOverflowY()) ? Optional<LayoutUnit>(0) : WTF::nullopt;
- availableHeight = cb->overrideLogicalHeight() - cb->computedCSSPaddingBefore() - cb->computedCSSPaddingAfter() - cb->borderBefore() - cb->borderAfter();
+ availableHeight = cb->overridingLogicalHeight() - cb->computedCSSPaddingBefore() - cb->computedCSSPaddingAfter() - cb->borderBefore() - cb->borderAfter();
}
} else
availableHeight = cb->availableLogicalHeightForPercentageComputation();
@@ -3051,13 +3051,13 @@
LayoutUnit result = valueForLength(height, availableHeight.value() - rootMarginBorderPaddingHeight + (isTable() && isOutOfFlowPositioned() ? cb->paddingBefore() + cb->paddingAfter() : 0_lu));
- // |overrideLogicalHeight| is the maximum height made available by the
+ // |overridingLogicalHeight| 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 |overrideLogicalHeight|) to arrive
+ // |availableHeight| (given by |overridingLogicalHeight|) to arrive
// at the child's computed height.
- bool subtractBorderAndPadding = isTable() || (is<RenderTableCell>(*cb) && !skippedAutoHeightContainingBlock && cb->hasOverrideLogicalHeight());
+ bool subtractBorderAndPadding = isTable() || (is<RenderTableCell>(*cb) && !skippedAutoHeightContainingBlock && cb->hasOverridingLogicalHeight());
if (subtractBorderAndPadding) {
result -= borderAndPaddingLogicalHeight();
return std::max(0_lu, result);
@@ -3196,8 +3196,8 @@
block->addPercentHeightDescendant(*const_cast<RenderBox*>(this));
if (block->isFlexItem())
stretchedHeight = downcast<RenderFlexibleBox>(block->parent())->childLogicalHeightForPercentageResolution(*block);
- else if (block->isGridItem() && block->hasOverrideLogicalHeight())
- stretchedHeight = block->overrideLogicalHeight() - block->borderAndPaddingLogicalHeight();
+ else if (block->isGridItem() && block->hasOverridingLogicalHeight())
+ stretchedHeight = block->overridingLogicalHeight() - block->borderAndPaddingLogicalHeight();
}
// FIXME: This calculation is not patched for block-flow yet.
@@ -3262,8 +3262,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 (hasOverrideLogicalHeight())
- return overrideLogicalHeight() - computedCSSPaddingBefore() - computedCSSPaddingAfter() - borderBefore() - borderAfter();
+ if (hasOverridingLogicalHeight())
+ return overridingLogicalHeight() - computedCSSPaddingBefore() - computedCSSPaddingAfter() - borderBefore() - borderAfter();
return logicalHeight() - borderAndPaddingLogicalHeight();
}
@@ -3332,9 +3332,9 @@
if (checkForPerpendicularWritingMode && containingBlock.isHorizontalWritingMode() != isHorizontalWritingMode())
return containingBlockLogicalHeightForPositioned(containingBlock, false);
- if (hasOverrideContainingBlockContentLogicalWidth()) {
- if (auto overrideLogicalWidth = overrideContainingBlockContentLogicalWidth())
- return overrideLogicalWidth.value();
+ if (hasOverridingContainingBlockContentLogicalWidth()) {
+ if (auto width = overridingContainingBlockContentLogicalWidth())
+ return width.value();
}
if (is<RenderBox>(containingBlock)) {
@@ -3397,9 +3397,9 @@
if (checkForPerpendicularWritingMode && containingBlock.isHorizontalWritingMode() != isHorizontalWritingMode())
return containingBlockLogicalWidthForPositioned(containingBlock, nullptr, false);
- if (hasOverrideContainingBlockContentLogicalHeight()) {
- if (auto overrideLogicalHeight = overrideContainingBlockContentLogicalHeight())
- return overrideLogicalHeight.value();
+ if (hasOverridingContainingBlockContentLogicalHeight()) {
+ if (auto height = overridingContainingBlockContentLogicalHeight())
+ return height.value();
}
if (containingBlock.isBox()) {
Modified: trunk/Source/WebCore/rendering/RenderBox.h (268918 => 268919)
--- trunk/Source/WebCore/rendering/RenderBox.h 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/rendering/RenderBox.h 2020-10-23 09:55:25 UTC (rev 268919)
@@ -307,31 +307,31 @@
LayoutUnit minPreferredLogicalWidth() const override;
LayoutUnit maxPreferredLogicalWidth() const override;
- LayoutUnit overrideLogicalWidth() const;
- LayoutUnit overrideLogicalHeight() const;
- bool hasOverrideLogicalHeight() const;
- bool hasOverrideLogicalWidth() const;
- void setOverrideLogicalHeight(LayoutUnit);
- void setOverrideLogicalWidth(LayoutUnit);
- void clearOverrideContentSize();
- void clearOverrideLogicalHeight();
- void clearOverrideLogicalWidth();
+ LayoutUnit overridingLogicalWidth() const;
+ LayoutUnit overridingLogicalHeight() const;
+ bool hasOverridingLogicalHeight() const;
+ bool hasOverridingLogicalWidth() const;
+ void setOverridingLogicalHeight(LayoutUnit);
+ void setOverridingLogicalWidth(LayoutUnit);
+ void clearOverridingContentSize();
+ void clearOverridingLogicalHeight();
+ void clearOverridingLogicalWidth();
- LayoutUnit overrideContentLogicalWidth() const { return overrideLogicalWidth() - borderAndPaddingLogicalWidth() - scrollbarLogicalWidth(); }
- LayoutUnit overrideContentLogicalHeight() const { return overrideLogicalHeight() - borderAndPaddingLogicalHeight() - scrollbarLogicalHeight(); }
+ LayoutUnit overridingContentLogicalWidth() const { return overridingLogicalWidth() - borderAndPaddingLogicalWidth() - scrollbarLogicalWidth(); }
+ LayoutUnit overridingContentLogicalHeight() const { return overridingLogicalHeight() - borderAndPaddingLogicalHeight() - scrollbarLogicalHeight(); }
- Optional<LayoutUnit> overrideContainingBlockContentWidth() const override;
- Optional<LayoutUnit> overrideContainingBlockContentHeight() const override;
- bool hasOverrideContainingBlockContentWidth() const override;
- bool hasOverrideContainingBlockContentHeight() const override;
- Optional<LayoutUnit> overrideContainingBlockContentLogicalWidth() const;
- Optional<LayoutUnit> overrideContainingBlockContentLogicalHeight() const;
- bool hasOverrideContainingBlockContentLogicalWidth() const;
- bool hasOverrideContainingBlockContentLogicalHeight() const;
- void setOverrideContainingBlockContentLogicalWidth(Optional<LayoutUnit>);
- void setOverrideContainingBlockContentLogicalHeight(Optional<LayoutUnit>);
- void clearOverrideContainingBlockContentSize();
- void clearOverrideContainingBlockContentLogicalHeight();
+ Optional<LayoutUnit> overridingContainingBlockContentWidth() const override;
+ Optional<LayoutUnit> overridingContainingBlockContentHeight() const override;
+ bool hasOverridingContainingBlockContentWidth() const override;
+ bool hasOverridingContainingBlockContentHeight() const override;
+ Optional<LayoutUnit> overridingContainingBlockContentLogicalWidth() const;
+ Optional<LayoutUnit> overridingContainingBlockContentLogicalHeight() const;
+ bool hasOverridingContainingBlockContentLogicalWidth() const;
+ bool hasOverridingContainingBlockContentLogicalHeight() const;
+ void setOverridingContainingBlockContentLogicalWidth(Optional<LayoutUnit>);
+ void setOverridingContainingBlockContentLogicalHeight(Optional<LayoutUnit>);
+ void clearOverridingContainingBlockContentSize();
+ void clearOverridingContainingBlockContentLogicalHeight();
LayoutSize offsetFromContainer(RenderElement&, const LayoutPoint&, bool* offsetDependsOnPoint = nullptr) const override;
Modified: trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp (268918 => 268919)
--- trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp 2020-10-23 09:55:25 UTC (rev 268919)
@@ -280,7 +280,7 @@
return false;
}
- if (thisBox && thisBox->isGridItem() && thisBox->hasOverrideContainingBlockContentLogicalHeight())
+ if (thisBox && thisBox->isGridItem() && thisBox->hasOverridingContainingBlockContentLogicalHeight())
return false;
if (logicalHeightLength.isAuto() && !isOutOfFlowPositionedWithImplicitHeight(*this))
@@ -348,8 +348,8 @@
// However for grid items the containing block is the grid area, so offsets should be resolved against that:
// https://drafts.csswg.org/css-grid/#grid-item-sizing
if (!style().left().isAuto() || !style().right().isAuto()) {
- LayoutUnit availableWidth = hasOverrideContainingBlockContentWidth()
- ? overrideContainingBlockContentWidth().valueOr(LayoutUnit()) : containingBlock()->availableWidth();
+ LayoutUnit availableWidth = hasOverridingContainingBlockContentWidth()
+ ? overridingContainingBlockContentWidth().valueOr(LayoutUnit()) : containingBlock()->availableWidth();
if (!style().left().isAuto()) {
if (!style().right().isAuto() && !containingBlock()->style().isLeftToRightDirection())
offset.setWidth(-valueForLength(style().right(), !style().right().isFixed() ? availableWidth : 0_lu));
@@ -371,21 +371,21 @@
&& (!style().top().isPercentOrCalculated()
|| !containingBlock()->hasAutoHeightOrContainingBlockWithAutoHeight()
|| containingBlock()->stretchesToViewport()
- || hasOverrideContainingBlockContentHeight())) {
+ || hasOverridingContainingBlockContentHeight())) {
// FIXME: The computation of the available height is repeated later for "bottom".
// We could refactor this and move it to some common code for both ifs, however moving it outside of the ifs
// is not possible as it'd cause performance regressions.
offset.expand(0_lu, valueForLength(style().top(), !style().top().isFixed()
- ? (hasOverrideContainingBlockContentHeight() ? overrideContainingBlockContentHeight().valueOr(0_lu) : containingBlock()->availableHeight())
+ ? (hasOverridingContainingBlockContentHeight() ? overridingContainingBlockContentHeight().valueOr(0_lu) : containingBlock()->availableHeight())
: LayoutUnit()));
} else if (!style().bottom().isAuto()
&& (!style().bottom().isPercentOrCalculated()
|| !containingBlock()->hasAutoHeightOrContainingBlockWithAutoHeight()
|| containingBlock()->stretchesToViewport()
- || hasOverrideContainingBlockContentHeight())) {
+ || hasOverridingContainingBlockContentHeight())) {
// FIXME: Check comment above for "top", it applies here too.
offset.expand(0_lu, -valueForLength(style().bottom(), !style().bottom().isFixed()
- ? (hasOverrideContainingBlockContentHeight() ? overrideContainingBlockContentHeight().valueOr(0_lu) : containingBlock()->availableHeight())
+ ? (hasOverridingContainingBlockContentHeight() ? overridingContainingBlockContentHeight().valueOr(0_lu) : containingBlock()->availableHeight())
: LayoutUnit()));
}
Modified: trunk/Source/WebCore/rendering/RenderBoxModelObject.h (268918 => 268919)
--- trunk/Source/WebCore/rendering/RenderBoxModelObject.h 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/rendering/RenderBoxModelObject.h 2020-10-23 09:55:25 UTC (rev 268919)
@@ -233,10 +233,10 @@
bool hasRunningAcceleratedAnimations() const;
- virtual Optional<LayoutUnit> overrideContainingBlockContentWidth() const { ASSERT_NOT_REACHED(); return -1_lu; }
- virtual Optional<LayoutUnit> overrideContainingBlockContentHeight() const { ASSERT_NOT_REACHED(); return -1_lu; }
- virtual bool hasOverrideContainingBlockContentWidth() const { return false; }
- virtual bool hasOverrideContainingBlockContentHeight() const { return false; }
+ virtual Optional<LayoutUnit> overridingContainingBlockContentWidth() const { ASSERT_NOT_REACHED(); return -1_lu; }
+ virtual Optional<LayoutUnit> overridingContainingBlockContentHeight() const { ASSERT_NOT_REACHED(); return -1_lu; }
+ virtual bool hasOverridingContainingBlockContentWidth() const { return false; }
+ virtual bool hasOverridingContainingBlockContentHeight() const { return false; }
protected:
RenderBoxModelObject(Element&, RenderStyle&&, BaseTypeFlags);
Modified: trunk/Source/WebCore/rendering/RenderDeprecatedFlexibleBox.cpp (268918 => 268919)
--- trunk/Source/WebCore/rendering/RenderDeprecatedFlexibleBox.cpp 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/rendering/RenderDeprecatedFlexibleBox.cpp 2020-10-23 09:55:25 UTC (rev 268919)
@@ -153,15 +153,15 @@
static LayoutUnit widthForChild(RenderBox* child)
{
- if (child->hasOverrideLogicalWidth())
- return child->overrideLogicalWidth();
+ if (child->hasOverridingLogicalWidth())
+ return child->overridingLogicalWidth();
return child->logicalWidth();
}
static LayoutUnit heightForChild(RenderBox* child)
{
- if (child->hasOverrideLogicalHeight())
- return child->overrideLogicalHeight();
+ if (child->hasOverridingLogicalHeight())
+ return child->overridingLogicalHeight();
return child->logicalHeight();
}
@@ -367,7 +367,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->clearOverrideContentSize();
+ child->clearOverridingContentSize();
if (!relayoutChildren)
child->setChildNeedsLayout(MarkOnlyThis);
haveFlex = true;
@@ -595,7 +595,7 @@
if (allowedChildFlex(child, expanding, i)) {
LayoutUnit spaceAdd = LayoutUnit(spaceAvailableThisPass * (child->style().boxFlex() / totalFlex));
if (spaceAdd) {
- child->setOverrideLogicalWidth(widthForChild(child) + spaceAdd);
+ child->setOverridingLogicalWidth(widthForChild(child) + spaceAdd);
flexingChildren = true;
relayoutChildren = true;
}
@@ -612,7 +612,7 @@
LayoutUnit spaceAdd = groupRemainingSpace > 0 ? 1 : -1;
for (RenderBox* child = iterator.first(); child && groupRemainingSpace; child = iterator.next()) {
if (allowedChildFlex(child, expanding, i)) {
- child->setOverrideLogicalWidth(widthForChild(child) + spaceAdd);
+ child->setOverridingLogicalWidth(widthForChild(child) + spaceAdd);
flexingChildren = true;
relayoutChildren = true;
remainingSpace -= spaceAdd;
@@ -852,7 +852,7 @@
if (allowedChildFlex(child, expanding, i)) {
LayoutUnit spaceAdd { spaceAvailableThisPass * (child->style().boxFlex() / totalFlex) };
if (spaceAdd) {
- child->setOverrideLogicalHeight(heightForChild(child) + spaceAdd);
+ child->setOverridingLogicalHeight(heightForChild(child) + spaceAdd);
flexingChildren = true;
relayoutChildren = true;
}
@@ -869,7 +869,7 @@
LayoutUnit spaceAdd = groupRemainingSpace > 0 ? 1 : -1;
for (RenderBox* child = iterator.first(); child && groupRemainingSpace; child = iterator.next()) {
if (allowedChildFlex(child, expanding, i)) {
- child->setOverrideLogicalHeight(heightForChild(child) + spaceAdd);
+ child->setOverridingLogicalHeight(heightForChild(child) + spaceAdd);
flexingChildren = true;
relayoutChildren = true;
remainingSpace -= spaceAdd;
@@ -947,7 +947,7 @@
if (childDoesNotAffectWidthOrFlexing(child))
continue;
- child->clearOverrideContentSize();
+ child->clearOverridingContentSize();
if (relayoutChildren || (child->isReplaced() && (child->style().width().isPercentOrCalculated() || child->style().height().isPercentOrCalculated()))
|| (child->style().height().isAuto() && is<RenderBlockFlow>(*child))) {
child->setChildNeedsLayout(MarkOnlyThis);
@@ -984,7 +984,7 @@
continue;
child->setChildNeedsLayout(MarkOnlyThis);
- child->setOverrideLogicalHeight(newHeight);
+ child->setOverridingLogicalHeight(newHeight);
child->layoutIfNeeded();
// FIXME: For now don't support RTL.
@@ -1049,7 +1049,7 @@
if (childDoesNotAffectWidthOrFlexing(child))
continue;
- child->clearOverrideContentSize();
+ child->clearOverridingContentSize();
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 (268918 => 268919)
--- trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp 2020-10-23 09:55:25 UTC (rev 268919)
@@ -480,14 +480,14 @@
return child.logicalWidth();
// Temporarily clear potential overrides to compute the logical width otherwise it'll return the override size.
- bool childHasOverrideWidth = child.hasOverrideLogicalWidth();
- auto overrideWidth = childHasOverrideWidth ? child.overrideLogicalWidth() : -1_lu;
+ bool childHasOverrideWidth = child.hasOverridingLogicalWidth();
+ auto overrideWidth = childHasOverrideWidth ? child.overridingLogicalWidth() : -1_lu;
if (childHasOverrideWidth)
- const_cast<RenderBox*>(&child)->clearOverrideLogicalWidth();
+ const_cast<RenderBox*>(&child)->clearOverridingLogicalWidth();
LogicalExtentComputedValues values;
child.computeLogicalWidthInFragment(values);
if (childHasOverrideWidth)
- const_cast<RenderBox*>(&child)->setOverrideLogicalWidth(overrideWidth);
+ const_cast<RenderBox*>(&child)->setOverridingLogicalWidth(overrideWidth);
return values.m_extent;
}
@@ -844,7 +844,7 @@
LayoutUnit RenderFlexibleBox::computeInnerFlexBaseSizeForChild(RenderBox& child, LayoutUnit mainAxisBorderAndPadding, bool relayoutChildren)
{
- child.clearOverrideContentSize();
+ child.clearOverridingContentSize();
Length flexBasis = flexBasisForChild(child);
if (mainAxisLengthIsDefinite(child, flexBasis))
@@ -1169,8 +1169,8 @@
return WTF::nullopt;
// Here we implement https://drafts.csswg.org/css-flexbox/#algo-stretch
- if (child.hasOverrideLogicalHeight())
- return child.overrideContentLogicalHeight();
+ if (child.hasOverridingLogicalHeight())
+ return child.overridingContentLogicalHeight();
// We don't currently implement the optimization from
// https://drafts.csswg.org/css-flexbox/#definite-sizes case 1. While that
@@ -1190,7 +1190,7 @@
if (!mainAxisLengthIsDefinite(child, Length(0, Percent)))
return WTF::nullopt;
- return child.hasOverrideLogicalHeight() ? Optional<LayoutUnit>(child.overrideContentLogicalHeight()) : WTF::nullopt;
+ return child.hasOverridingLogicalHeight() ? Optional<LayoutUnit>(child.overridingContentLogicalHeight()) : WTF::nullopt;
}
Optional<LayoutUnit> RenderFlexibleBox::childLogicalHeightForPercentageResolution(const RenderBox& child)
@@ -1231,15 +1231,15 @@
// by definition we have an indefinite flex basis here and thus percentages should not resolve.
if (child.needsLayout() || !m_intrinsicSizeAlongMainAxis.contains(&child)) {
if (isHorizontalWritingMode() == child.isHorizontalWritingMode())
- child.setOverrideContainingBlockContentLogicalHeight(WTF::nullopt);
+ child.setOverridingContainingBlockContentLogicalHeight(WTF::nullopt);
else
- child.setOverrideContainingBlockContentLogicalWidth(WTF::nullopt);
- child.clearOverrideContentSize();
+ child.setOverridingContainingBlockContentLogicalWidth(WTF::nullopt);
+ child.clearOverridingContentSize();
child.setChildNeedsLayout(MarkOnlyThis);
child.layoutIfNeeded();
cacheChildMainSize(child);
relayoutChildren = false;
- child.clearOverrideContainingBlockContentSize();
+ child.clearOverridingContainingBlockContentSize();
}
}
@@ -1424,9 +1424,9 @@
void RenderFlexibleBox::setOverrideMainAxisContentSizeForChild(RenderBox& child, LayoutUnit childPreferredSize)
{
if (hasOrthogonalFlow(child))
- child.setOverrideLogicalHeight(childPreferredSize + child.borderAndPaddingLogicalHeight());
+ child.setOverridingLogicalHeight(childPreferredSize + child.borderAndPaddingLogicalHeight());
else
- child.setOverrideLogicalWidth(childPreferredSize + child.borderAndPaddingLogicalWidth());
+ child.setOverridingLogicalWidth(childPreferredSize + child.borderAndPaddingLogicalWidth());
}
LayoutUnit RenderFlexibleBox::staticMainAxisPositionForPositionedChild(const RenderBox& child)
@@ -1883,8 +1883,8 @@
// So, redo it here.
childNeedsRelayout = true;
}
- if (childNeedsRelayout || !child.hasOverrideLogicalHeight())
- child.setOverrideLogicalHeight(desiredLogicalHeight);
+ if (childNeedsRelayout || !child.hasOverridingLogicalHeight())
+ child.setOverridingLogicalHeight(desiredLogicalHeight);
if (childNeedsRelayout) {
SetForScope<bool> resetChildLogicalHeight(m_shouldResetChildLogicalHeightBeforeLayout, true);
// We cache the child's intrinsic content logical height to avoid it being
@@ -1905,7 +1905,7 @@
childWidth = child.constrainLogicalWidthInFragmentByMinMax(childWidth, crossAxisContentExtent(), *this, nullptr);
if (childWidth != child.logicalWidth()) {
- child.setOverrideLogicalWidth(childWidth);
+ child.setOverridingLogicalWidth(childWidth);
child.setChildNeedsLayout(MarkOnlyThis);
child.layoutIfNeeded();
}
Modified: trunk/Source/WebCore/rendering/RenderFullScreen.cpp (268918 => 268919)
--- trunk/Source/WebCore/rendering/RenderFullScreen.cpp 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/rendering/RenderFullScreen.cpp 2020-10-23 09:55:25 UTC (rev 268919)
@@ -171,7 +171,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).clearOverrideContentSize();
+ downcast<RenderBox>(*child).clearOverridingContentSize();
auto childToMove = builder.detach(*child->parent(), *child);
builder.attach(*parent(), WTFMove(childToMove), this);
parent()->setNeedsLayoutAndPrefWidthsRecalc();
Modified: trunk/Source/WebCore/rendering/RenderGrid.cpp (268918 => 268919)
--- trunk/Source/WebCore/rendering/RenderGrid.cpp 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/rendering/RenderGrid.cpp 2020-10-23 09:55:25 UTC (rev 268919)
@@ -193,7 +193,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 = hasOverrideLogicalHeight() || computeContentLogicalHeight(MainOrPreferredSize, style().logicalHeight(), WTF::nullopt);
+ bool hasDefiniteLogicalHeight = hasOverridingLogicalHeight() || computeContentLogicalHeight(MainOrPreferredSize, style().logicalHeight(), WTF::nullopt);
m_hasAnyOrthogonalItem = false;
for (auto* child = firstChildBox(); child; child = child->nextSiblingBox()) {
@@ -202,7 +202,7 @@
// Grid's layout logic controls the grid item's override height, hence we need to
// clear any override height set previously, so it doesn't interfere in current layout
// execution. Grid never uses the override width, that's why we don't need to clear it.
- child->clearOverrideLogicalHeight();
+ child->clearOverridingLogicalHeight();
// We may need to repeat the track sizing in case of any grid item was orthogonal.
if (GridLayoutFunctions::isOrthogonalChild(*this, *child))
@@ -610,10 +610,10 @@
// Grid items should use the grid area sizes instead of the containing block (grid container)
// sizes, we initialize the overrides here if needed to ensure it.
- if (!child->hasOverrideContainingBlockContentLogicalWidth())
- child->setOverrideContainingBlockContentLogicalWidth(LayoutUnit());
- if (!child->hasOverrideContainingBlockContentLogicalHeight())
- child->setOverrideContainingBlockContentLogicalHeight(LayoutUnit(-1));
+ if (!child->hasOverridingContainingBlockContentLogicalWidth())
+ child->setOverridingContainingBlockContentLogicalWidth(LayoutUnit());
+ if (!child->hasOverridingContainingBlockContentLogicalHeight())
+ child->setOverridingContainingBlockContentLogicalHeight(LayoutUnit(-1));
GridArea area = grid.gridItemArea(*child);
if (!area.rows.isIndefinite())
@@ -902,8 +902,8 @@
static bool overrideSizeChanged(const RenderBox& child, GridTrackSizingDirection direction, LayoutSize size)
{
if (direction == ForColumns)
- return !child.hasOverrideContainingBlockContentLogicalWidth() || child.overrideContainingBlockContentLogicalWidth() != size.width();
- return !child.hasOverrideContainingBlockContentLogicalHeight() || child.overrideContainingBlockContentLogicalHeight() != size.height();
+ return !child.hasOverridingContainingBlockContentLogicalWidth() || child.overridingContainingBlockContentLogicalWidth() != size.width();
+ return !child.hasOverridingContainingBlockContentLogicalHeight() || child.overridingContainingBlockContentLogicalHeight() != size.height();
}
static bool hasRelativeBlockAxisSize(const RenderGrid& grid, const RenderBox& child)
@@ -920,8 +920,8 @@
if (gridAreaWidthChanged || (gridAreaHeightChanged && hasRelativeBlockAxisSize(*this, child)))
child.setNeedsLayout(MarkOnlyThis);
- child.setOverrideContainingBlockContentLogicalWidth(gridAreaLogicalSize.width());
- child.setOverrideContainingBlockContentLogicalHeight(gridAreaLogicalSize.height());
+ child.setOverridingContainingBlockContentLogicalWidth(gridAreaLogicalSize.width());
+ child.setOverridingContainingBlockContentLogicalHeight(gridAreaLogicalSize.height());
}
void RenderGrid::layoutGridItems()
@@ -986,8 +986,8 @@
LayoutUnit columnBreadth = gridAreaBreadthForOutOfFlowChild(child, ForColumns);
LayoutUnit rowBreadth = gridAreaBreadthForOutOfFlowChild(child, ForRows);
- child.setOverrideContainingBlockContentLogicalWidth(columnBreadth);
- child.setOverrideContainingBlockContentLogicalHeight(rowBreadth);
+ child.setOverridingContainingBlockContentLogicalWidth(columnBreadth);
+ child.setOverridingContainingBlockContentLogicalHeight(rowBreadth);
// Mark for layout as we're resetting the position before and we relay in generic layout logic
// for positioned items in order to get the offsets properly resolved.
@@ -1125,19 +1125,19 @@
// FIXME: This logic is shared by RenderFlexibleBox, so it should be moved to RenderBox.
void RenderGrid::applyStretchAlignmentToChildIfNeeded(RenderBox& child)
{
- ASSERT(child.overrideContainingBlockContentLogicalHeight());
+ ASSERT(child.overridingContainingBlockContentLogicalHeight());
// 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.clearOverrideLogicalHeight();
+ child.clearOverridingLogicalHeight();
GridTrackSizingDirection childBlockDirection = GridLayoutFunctions::flowAwareDirectionForChild(*this, child, ForRows);
bool blockFlowIsColumnAxis = childBlockDirection == ForRows;
bool allowedToStretchChildBlockSize = blockFlowIsColumnAxis ? allowedToStretchChildAlongColumnAxis(child) : allowedToStretchChildAlongRowAxis(child);
if (allowedToStretchChildBlockSize) {
- LayoutUnit stretchedLogicalHeight = availableAlignmentSpaceForChildBeforeStretching(GridLayoutFunctions::overrideContainingBlockContentSizeForChild(child, childBlockDirection).value(), child);
+ LayoutUnit stretchedLogicalHeight = availableAlignmentSpaceForChildBeforeStretching(GridLayoutFunctions::overridingContainingBlockContentSizeForChild(child, childBlockDirection).value(), child);
LayoutUnit desiredLogicalHeight = child.constrainLogicalHeightByMinMax(stretchedLogicalHeight, -1_lu);
- child.setOverrideLogicalHeight(desiredLogicalHeight);
+ child.setOverridingLogicalHeight(desiredLogicalHeight);
if (desiredLogicalHeight != child.logicalHeight()) {
// FIXME: Can avoid laying out here in some cases. See https://webkit.org/b/87905.
child.setLogicalHeight(0_lu);
@@ -1179,7 +1179,7 @@
if (!marginEnd.isAuto())
marginLogicalWidth += child.marginEnd();
- LayoutUnit availableAlignmentSpace = child.overrideContainingBlockContentLogicalWidth().value() - child.logicalWidth() - marginLogicalWidth;
+ LayoutUnit availableAlignmentSpace = child.overridingContainingBlockContentLogicalWidth().value() - child.logicalWidth() - marginLogicalWidth;
if (availableAlignmentSpace <= 0)
return;
@@ -1210,7 +1210,7 @@
if (!marginAfter.isAuto())
marginLogicalHeight += child.marginAfter();
- LayoutUnit availableAlignmentSpace = child.overrideContainingBlockContentLogicalHeight().value() - child.logicalHeight() - marginLogicalHeight;
+ LayoutUnit availableAlignmentSpace = child.overridingContainingBlockContentLogicalHeight().value() - child.logicalHeight() - marginLogicalHeight;
if (availableAlignmentSpace <= 0)
return;
@@ -1591,8 +1591,8 @@
void RenderGrid::gridAreaPositionForOutOfFlowChild(const RenderBox& child, GridTrackSizingDirection direction, LayoutUnit& start, LayoutUnit& end) const
{
ASSERT(child.isOutOfFlowPositioned());
- ASSERT(GridLayoutFunctions::hasOverrideContainingBlockContentSizeForChild(child, direction));
- LayoutUnit trackBreadth = GridLayoutFunctions::overrideContainingBlockContentSizeForChild(child, direction).value();
+ ASSERT(GridLayoutFunctions::hasOverridingContainingBlockContentSizeForChild(child, direction));
+ LayoutUnit trackBreadth = GridLayoutFunctions::overridingContainingBlockContentSizeForChild(child, direction).value();
bool isRowAxis = direction == ForColumns;
auto& outOfFlowItemLine = isRowAxis ? m_outOfFlowItemColumn : m_outOfFlowItemRow;
start = isRowAxis ? borderLogicalLeft() : borderBefore();
Modified: trunk/Source/WebCore/rendering/RenderRubyBase.cpp (268918 => 268919)
--- trunk/Source/WebCore/rendering/RenderRubyBase.cpp 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/rendering/RenderRubyBase.cpp 2020-10-23 09:55:25 UTC (rev 268919)
@@ -67,13 +67,13 @@
void RenderRubyBase::adjustInlineDirectionLineBounds(int expansionOpportunityCount, float& logicalLeft, float& logicalWidth) const
{
- if (rubyRun()->hasOverrideLogicalWidth() && firstRootBox() && !firstRootBox()->nextRootBox()) {
+ if (rubyRun()->hasOverridingLogicalWidth() && firstRootBox() && !firstRootBox()->nextRootBox()) {
logicalLeft += m_initialOffset;
logicalWidth -= 2 * m_initialOffset;
return;
}
- LayoutUnit maxPreferredLogicalWidth = rubyRun() && rubyRun()->hasOverrideLogicalWidth() ? rubyRun()->overrideLogicalWidth() : this->maxPreferredLogicalWidth();
+ LayoutUnit maxPreferredLogicalWidth = rubyRun() && rubyRun()->hasOverridingLogicalWidth() ? rubyRun()->overridingLogicalWidth() : this->maxPreferredLogicalWidth();
if (maxPreferredLogicalWidth >= logicalWidth)
return;
Modified: trunk/Source/WebCore/rendering/RenderTable.cpp (268918 => 268919)
--- trunk/Source/WebCore/rendering/RenderTable.cpp 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/rendering/RenderTable.cpp 2020-10-23 09:55:25 UTC (rev 268919)
@@ -282,8 +282,8 @@
// Our parent might have set an override content logical width on us, so we must respect it. This
// is how flexbox containers flex or stretch us.
- if (hasOverrideLogicalWidth())
- setLogicalWidth(std::max(logicalWidth(), overrideLogicalWidth()));
+ if (hasOverridingLogicalWidth())
+ setLogicalWidth(std::max(logicalWidth(), overridingLogicalWidth()));
// Ensure we aren't bigger than our max-width style.
Length styleMaxLogicalWidth = style().logicalMaxWidth();
Modified: trunk/Source/WebCore/rendering/RenderTableCell.cpp (268918 => 268919)
--- trunk/Source/WebCore/rendering/RenderTableCell.cpp 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/rendering/RenderTableCell.cpp 2020-10-23 09:55:25 UTC (rev 268919)
@@ -330,10 +330,10 @@
return computedCSSPaddingAfter() + intrinsicPaddingAfter();
}
-void RenderTableCell::setOverrideLogicalHeightFromRowHeight(LayoutUnit rowHeight)
+void RenderTableCell::setOverridingLogicalHeightFromRowHeight(LayoutUnit rowHeight)
{
clearIntrinsicPadding();
- setOverrideLogicalHeight(rowHeight);
+ setOverridingLogicalHeight(rowHeight);
}
LayoutSize RenderTableCell::offsetFromContainer(RenderElement& container, const LayoutPoint& point, bool* offsetDependsOnPoint) const
Modified: trunk/Source/WebCore/rendering/RenderTableCell.h (268918 => 268919)
--- trunk/Source/WebCore/rendering/RenderTableCell.h 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/rendering/RenderTableCell.h 2020-10-23 09:55:25 UTC (rev 268919)
@@ -102,7 +102,7 @@
LayoutUnit paddingBefore() const override;
LayoutUnit paddingAfter() const override;
- void setOverrideLogicalHeightFromRowHeight(LayoutUnit);
+ void setOverridingLogicalHeightFromRowHeight(LayoutUnit);
void scrollbarsChanged(bool horizontalScrollbarChanged, bool verticalScrollbarChanged) override;
Modified: trunk/Source/WebCore/rendering/RenderTableSection.cpp (268918 => 268919)
--- trunk/Source/WebCore/rendering/RenderTableSection.cpp 2020-10-23 09:44:14 UTC (rev 268918)
+++ trunk/Source/WebCore/rendering/RenderTableSection.cpp 2020-10-23 09:55:25 UTC (rev 268919)
@@ -283,9 +283,9 @@
// For row spanning cells, |r| is the last row in the span.
unsigned cellStartRow = cell->rowIndex();
- if (cell->hasOverrideLogicalHeight()) {
+ if (cell->hasOverridingLogicalHeight()) {
cell->clearIntrinsicPadding();
- cell->clearOverrideContentSize();
+ cell->clearOverridingContentSize();
cell->setChildNeedsLayout(MarkOnlyThis);
cell->layoutIfNeeded();
}
@@ -522,7 +522,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.setOverrideLogicalHeightFromRowHeight(rowHeight);
+ cell.setOverridingLogicalHeightFromRowHeight(rowHeight);
cell.layoutIfNeeded();
if (!cell.isBaselineAligned())
