Changeset 268919 in webkit

Timestamp:

Oct 23, 2020, 2:55:25 AM (6 years ago)

Author:

svillar@igalia.com

Message:

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):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• WebCore.order (modified) (3 diffs)
• rendering/ComplexLineLayout.cpp (modified) (2 diffs)
• rendering/GridLayoutFunctions.cpp (modified) (1 diff)
• rendering/GridLayoutFunctions.h (modified) (1 diff)
• rendering/GridTrackSizingAlgorithm.cpp (modified) (9 diffs)
• rendering/GridTrackSizingAlgorithm.h (modified) (1 diff)
• rendering/RenderBlock.cpp (modified) (4 diffs)
• rendering/RenderBlockFlow.cpp (modified) (2 diffs)
• rendering/RenderBox.cpp (modified) (19 diffs)
• rendering/RenderBox.h (modified) (1 diff)
• rendering/RenderBoxModelObject.cpp (modified) (4 diffs)
• rendering/RenderBoxModelObject.h (modified) (1 diff)
• rendering/RenderDeprecatedFlexibleBox.cpp (modified) (10 diffs)
• rendering/RenderFlexibleBox.cpp (modified) (8 diffs)
• rendering/RenderFullScreen.cpp (modified) (1 diff)
• rendering/RenderGrid.cpp (modified) (11 diffs)
• rendering/RenderRubyBase.cpp (modified) (2 diffs)
• rendering/RenderTable.cpp (modified) (1 diff)
• rendering/RenderTableCell.cpp (modified) (1 diff)
• rendering/RenderTableCell.h (modified) (1 diff)
• rendering/RenderTableSection.cpp (modified) (2 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2020-10-21  Sergio Villar Senin  <svillar@igalia.com>
+
+        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  <pnormand@igalia.com>
 

trunk/Source/WebCore/WebCore.order

@@ -9702 +9702 @@
 __ZN7WebCore17RenderFlexibleBox26autoMarginOffsetInMainAxisERKN3WTF6VectorIPNS_9RenderBoxELm0ENS1_15CrashOnOverflowEEERNS_10LayoutUnitE
 __ZN7WebCore17RenderFlexibleBox22setLogicalOverrideSizeEPNS_9RenderBoxENS_10LayoutUnitE
-__ZN7WebCore9RenderBox30setOverrideLogicalContentWidthENS_10LayoutUnitE
+__ZN7WebCore9RenderBox32setOverridingLogicalContentWidthENS_10LayoutUnitE
 __ZN7WebCore17RenderFlexibleBox18needToStretchChildEPNS_9RenderBoxE
 __ZN7WebCore11RenderBlock37updateBlockChildDirtyBitsBeforeLayoutEbPNS_9RenderBoxE
@@ -15060 +15060 @@
 __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
@@ -27361 +27361 @@
 __ZN7WebCoreL18gOverrideHeightMapE
 __ZN7WebCoreL17gOverrideWidthMapE
-__ZN7WebCoreL39gOverrideContainingBlockLogicalWidthMapE
-__ZN7WebCoreL40gOverrideContainingBlockLogicalHeightMapE
+__ZN7WebCoreL41gOverridingContainingBlockLogicalWidthMapE
+__ZN7WebCoreL42gOverridingContainingBlockLogicalHeightMapE
 __ZN7WebCoreL15continuationMapE
 __ZN7WebCoreL27firstLetterRemainingTextMapE

trunk/Source/WebCore/rendering/ComplexLineLayout.cpp

@@ -591 +591 @@
     }
 
-    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();
@@ -603 +603 @@
     }
     rubyRun.layoutBlock(true);
-    rubyRun.clearOverrideLogicalWidth();
+    rubyRun.clearOverridingLogicalWidth();
     r.box()->setExpansion(newRubyRunWidth - r.box()->logicalWidth());
 

trunk/Source/WebCore/rendering/GridLayoutFunctions.cpp

@@ -88 +88 @@
 }
 
-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();
 }
 

trunk/Source/WebCore/rendering/GridLayoutFunctions.h

@@ -42 +42 @@
 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);
 
 }

trunk/Source/WebCore/rendering/GridTrackSizingAlgorithm.cpp

@@ -121 +121 @@
 }
 
-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);
 }
 
@@ -757 +757 @@
     // 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);
     }
@@ -764 +764 @@
     // We need to clear the stretched height to properly compute logical height during layout.
     if (child.needsLayout())
-        child.clearOverrideLogicalHeight();
+        child.clearOverridingLogicalHeight();
 
     child.layoutIfNeeded();
@@ -779 +779 @@
     }
 
-    if (updateOverrideContainingBlockContentSizeForChild(child, childInlineDirection))
+    if (updateOverridingContainingBlockContentSizeForChild(child, childInlineDirection))
         child.setNeedsLayout(MarkOnlyThis);
     return logicalHeightForChild(child);
@@ -793 +793 @@
     }
 
-    if (updateOverrideContainingBlockContentSizeForChild(child, childInlineDirection))
+    if (updateOverridingContainingBlockContentSizeForChild(child, childInlineDirection))
         child.setNeedsLayout(MarkOnlyThis);
     return logicalHeightForChild(child);
@@ -900 +900 @@
 }
 
-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;
 }
@@ -917 +917 @@
     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);
@@ -1051 +1051 @@
     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);
 }
@@ -1094 +1094 @@
 {
     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);
 }

trunk/Source/WebCore/rendering/GridTrackSizingAlgorithm.h

@@ -272 +272 @@
 
     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.

trunk/Source/WebCore/rendering/RenderBlock.cpp

@@ -1769 +1769 @@
     ASSERT(!isAnonymousBlock());
 
-    positioned.clearOverrideContainingBlockContentSize();
+    positioned.clearOverridingContainingBlockContentSize();
 
     if (positioned.isRenderFragmentedFlow())
@@ -2418 +2418 @@
     }
     
-    // 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();
         }
     }
@@ -2439 +2439 @@
     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());
     }
 
@@ -3220 +3220 @@
     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());

trunk/Source/WebCore/rendering/RenderBlockFlow.cpp

@@ -3046 +3046 @@
 void RenderBlockFlow::fitBorderToLinesIfNeeded()
 {
-    if (style().borderFit() == BorderFit::Border || hasOverrideLogicalWidth())
+    if (style().borderFit() == BorderFit::Border || hasOverridingLogicalWidth())
         return;
 
@@ -3065 +3065 @@
         return;
 
-    setOverrideLogicalWidth(newContentWidth + borderAndPaddingLogicalWidth());
+    setOverridingLogicalWidth(newContentWidth + borderAndPaddingLogicalWidth());
     layoutBlock(false);
-    clearOverrideLogicalWidth();
+    clearOverridingLogicalWidth();
 }
 

trunk/Source/WebCore/rendering/RenderBox.cpp

@@ -95 +95 @@
 
 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,
@@ -151 +151 @@
         frame().eventHandler().stopAutoscrollTimer(true);
 
-    clearOverrideContentSize();
-    clearOverrideContainingBlockContentSize();
+    clearOverridingContentSize();
+    clearOverridingContainingBlockContentSize();
 
     RenderBlock::removePercentHeightDescendantIfNeeded(*this);
@@ -408 +408 @@
     // 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)
@@ -1089 +1089 @@
 }
 
-bool RenderBox::hasOverrideLogicalHeight() const
-{
-    return gOverrideLogicalHeightMap && gOverrideLogicalHeightMap->contains(this);
-}
-
-bool RenderBox::hasOverrideLogicalWidth() const
-{
-    return gOverrideLogicalWidthMap && gOverrideLogicalWidthMap->contains(this);
-}
-
-void RenderBox::setOverrideLogicalHeight(LayoutUnit height)
-{
-    if (!gOverrideLogicalHeightMap)
-        gOverrideLogicalHeightMap = new OverrideSizeMap();
-    gOverrideLogicalHeightMap->set(this, height);
-}
-
-void RenderBox::setOverrideLogicalWidth(LayoutUnit width)
-{
-    if (!gOverrideLogicalWidthMap)
-        gOverrideLogicalWidthMap = new OverrideSizeMap();
-    gOverrideLogicalWidthMap->set(this, width);
-}
-
-void RenderBox::clearOverrideLogicalHeight()
-{
-    if (gOverrideLogicalHeightMap)
-        gOverrideLogicalHeightMap->remove(this);
-}
-
-void RenderBox::clearOverrideLogicalWidth()
-{
-    if (gOverrideLogicalWidthMap)
-        gOverrideLogicalWidthMap->remove(this);
-}
-
-void RenderBox::clearOverrideContentSize()
-{
-    clearOverrideLogicalHeight();
-    clearOverrideLogicalWidth();
-}
-
-LayoutUnit RenderBox::overrideLogicalWidth() const
-{
-    ASSERT(hasOverrideLogicalWidth());
-    return gOverrideLogicalWidthMap->get(this);
-}
-
-LayoutUnit RenderBox::overrideLogicalHeight() const
-{
-    ASSERT(hasOverrideLogicalHeight());
-    return gOverrideLogicalHeightMap->get(this);
-}
-
-Optional<LayoutUnit> RenderBox::overrideContainingBlockContentWidth() const
-{
-    ASSERT(hasOverrideContainingBlockContentWidth());
+bool RenderBox::hasOverridingLogicalHeight() const
+{
+    return gOverridingLogicalHeightMap && gOverridingLogicalHeightMap->contains(this);
+}
+
+bool RenderBox::hasOverridingLogicalWidth() const
+{
+    return gOverridingLogicalWidthMap && gOverridingLogicalWidthMap->contains(this);
+}
+
+void RenderBox::setOverridingLogicalHeight(LayoutUnit height)
+{
+    if (!gOverridingLogicalHeightMap)
+        gOverridingLogicalHeightMap = new OverrideSizeMap();
+    gOverridingLogicalHeightMap->set(this, height);
+}
+
+void RenderBox::setOverridingLogicalWidth(LayoutUnit width)
+{
+    if (!gOverridingLogicalWidthMap)
+        gOverridingLogicalWidthMap = new OverrideSizeMap();
+    gOverridingLogicalWidthMap->set(this, width);
+}
+
+void RenderBox::clearOverridingLogicalHeight()
+{
+    if (gOverridingLogicalHeightMap)
+        gOverridingLogicalHeightMap->remove(this);
+}
+
+void RenderBox::clearOverridingLogicalWidth()
+{
+    if (gOverridingLogicalWidthMap)
+        gOverridingLogicalWidthMap->remove(this);
+}
+
+void RenderBox::clearOverridingContentSize()
+{
+    clearOverridingLogicalHeight();
+    clearOverridingLogicalWidth();
+}
+
+LayoutUnit RenderBox::overridingLogicalWidth() const
+{
+    ASSERT(hasOverridingLogicalWidth());
+    return gOverridingLogicalWidthMap->get(this);
+}
+
+LayoutUnit RenderBox::overridingLogicalHeight() const
+{
+    ASSERT(hasOverridingLogicalHeight());
+    return gOverridingLogicalHeightMap->get(this);
+}
+
+Optional<LayoutUnit> RenderBox::overridingContainingBlockContentWidth() const
+{
+    ASSERT(hasOverridingContainingBlockContentWidth());
     return containingBlock()->style().isHorizontalWritingMode()
-        ? gOverrideContainingBlockContentLogicalWidthMap->get(this)
-        : gOverrideContainingBlockContentLogicalHeightMap->get(this);
-}
-
-Optional<LayoutUnit> RenderBox::overrideContainingBlockContentHeight() const
-{
-    ASSERT(hasOverrideContainingBlockContentHeight());
+        ? gOverridingContainingBlockContentLogicalWidthMap->get(this)
+        : gOverridingContainingBlockContentLogicalHeightMap->get(this);
+}
+
+Optional<LayoutUnit> RenderBox::overridingContainingBlockContentHeight() const
+{
+    ASSERT(hasOverridingContainingBlockContentHeight());
     return containingBlock()->style().isHorizontalWritingMode()
-        ? gOverrideContainingBlockContentLogicalHeightMap->get(this)
-        : gOverrideContainingBlockContentLogicalWidthMap->get(this);
-}
-
-bool RenderBox::hasOverrideContainingBlockContentWidth() const
+        ? gOverridingContainingBlockContentLogicalHeightMap->get(this)
+        : gOverridingContainingBlockContentLogicalWidthMap->get(this);
+}
+
+bool RenderBox::hasOverridingContainingBlockContentWidth() const
 {
     RenderBlock* cb = containingBlock();
@@ -1166 +1166 @@
 
     return cb->style().isHorizontalWritingMode()
-        ? gOverrideContainingBlockContentLogicalWidthMap && gOverrideContainingBlockContentLogicalWidthMap->contains(this)
-        : gOverrideContainingBlockContentLogicalHeightMap && gOverrideContainingBlockContentLogicalHeightMap->contains(this);
-}
-
-bool RenderBox::hasOverrideContainingBlockContentHeight() const
+        ? gOverridingContainingBlockContentLogicalWidthMap && gOverridingContainingBlockContentLogicalWidthMap->contains(this)
+        : gOverridingContainingBlockContentLogicalHeightMap && gOverridingContainingBlockContentLogicalHeightMap->contains(this);
+}
+
+bool RenderBox::hasOverridingContainingBlockContentHeight() const
 {
     RenderBlock* cb = containingBlock();
@@ -1177 +1177 @@
 
     return cb->style().isHorizontalWritingMode()
-        ? gOverrideContainingBlockContentLogicalHeightMap && gOverrideContainingBlockContentLogicalHeightMap->contains(this)
-        : gOverrideContainingBlockContentLogicalHeightMap && gOverrideContainingBlockContentLogicalHeightMap->contains(this);
-}
-
-Optional<LayoutUnit> RenderBox::overrideContainingBlockContentLogicalWidth() const
-{
-    ASSERT(hasOverrideContainingBlockContentLogicalWidth());
-    return gOverrideContainingBlockContentLogicalWidthMap->get(this);
-}
-
-Optional<LayoutUnit> RenderBox::overrideContainingBlockContentLogicalHeight() const
-{
-    ASSERT(hasOverrideContainingBlockContentLogicalHeight());
-    return gOverrideContainingBlockContentLogicalHeightMap->get(this);
-}
-
-bool RenderBox::hasOverrideContainingBlockContentLogicalWidth() const
-{
-    return gOverrideContainingBlockContentLogicalWidthMap && gOverrideContainingBlockContentLogicalWidthMap->contains(this);
-}
-
-bool RenderBox::hasOverrideContainingBlockContentLogicalHeight() const
-{
-    return gOverrideContainingBlockContentLogicalHeightMap && gOverrideContainingBlockContentLogicalHeightMap->contains(this);
-}
-
-void RenderBox::setOverrideContainingBlockContentLogicalWidth(Optional<LayoutUnit> logicalWidth)
-{
-    if (!gOverrideContainingBlockContentLogicalWidthMap)
-        gOverrideContainingBlockContentLogicalWidthMap = new OverrideOptionalSizeMap;
-    gOverrideContainingBlockContentLogicalWidthMap->set(this, logicalWidth);
-}
-
-void RenderBox::setOverrideContainingBlockContentLogicalHeight(Optional<LayoutUnit> logicalHeight)
-{
-    if (!gOverrideContainingBlockContentLogicalHeightMap)
-        gOverrideContainingBlockContentLogicalHeightMap = new OverrideOptionalSizeMap;
-    gOverrideContainingBlockContentLogicalHeightMap->set(this, logicalHeight);
-}
-
-void RenderBox::clearOverrideContainingBlockContentSize()
-{
-    if (gOverrideContainingBlockContentLogicalWidthMap)
-        gOverrideContainingBlockContentLogicalWidthMap->remove(this);
-    clearOverrideContainingBlockContentLogicalHeight();
-}
-
-void RenderBox::clearOverrideContainingBlockContentLogicalHeight()
-{
-    if (gOverrideContainingBlockContentLogicalHeightMap)
-        gOverrideContainingBlockContentLogicalHeightMap->remove(this);
+        ? gOverridingContainingBlockContentLogicalHeightMap && gOverridingContainingBlockContentLogicalHeightMap->contains(this)
+        : gOverridingContainingBlockContentLogicalHeightMap && gOverridingContainingBlockContentLogicalHeightMap->contains(this);
+}
+
+Optional<LayoutUnit> RenderBox::overridingContainingBlockContentLogicalWidth() const
+{
+    ASSERT(hasOverridingContainingBlockContentLogicalWidth());
+    return gOverridingContainingBlockContentLogicalWidthMap->get(this);
+}
+
+Optional<LayoutUnit> RenderBox::overridingContainingBlockContentLogicalHeight() const
+{
+    ASSERT(hasOverridingContainingBlockContentLogicalHeight());
+    return gOverridingContainingBlockContentLogicalHeightMap->get(this);
+}
+
+bool RenderBox::hasOverridingContainingBlockContentLogicalWidth() const
+{
+    return gOverridingContainingBlockContentLogicalWidthMap && gOverridingContainingBlockContentLogicalWidthMap->contains(this);
+}
+
+bool RenderBox::hasOverridingContainingBlockContentLogicalHeight() const
+{
+    return gOverridingContainingBlockContentLogicalHeightMap && gOverridingContainingBlockContentLogicalHeightMap->contains(this);
+}
+
+void RenderBox::setOverridingContainingBlockContentLogicalWidth(Optional<LayoutUnit> logicalWidth)
+{
+    if (!gOverridingContainingBlockContentLogicalWidthMap)
+        gOverridingContainingBlockContentLogicalWidthMap = new OverrideOptionalSizeMap;
+    gOverridingContainingBlockContentLogicalWidthMap->set(this, logicalWidth);
+}
+
+void RenderBox::setOverridingContainingBlockContentLogicalHeight(Optional<LayoutUnit> logicalHeight)
+{
+    if (!gOverridingContainingBlockContentLogicalHeightMap)
+        gOverridingContainingBlockContentLogicalHeightMap = new OverrideOptionalSizeMap;
+    gOverridingContainingBlockContentLogicalHeightMap->set(this, logicalHeight);
+}
+
+void RenderBox::clearOverridingContainingBlockContentSize()
+{
+    if (gOverridingContainingBlockContentLogicalWidthMap)
+        gOverridingContainingBlockContentLogicalWidthMap->remove(this);
+    clearOverridingContainingBlockContentLogicalHeight();
+}
+
+void RenderBox::clearOverridingContainingBlockContentLogicalHeight()
+{
+    if (gOverridingContainingBlockContentLogicalHeightMap)
+        gOverridingContainingBlockContentLogicalHeightMap->remove(this);
 }
 
@@ -1974 +1974 @@
 LayoutUnit RenderBox::containingBlockLogicalWidthForContent() const
 {
-    if (hasOverrideContainingBlockContentLogicalWidth()) {
-        if (auto overrideLogicalWidth = overrideContainingBlockContentLogicalWidth())
-            return overrideLogicalWidth.value();
+    if (hasOverridingContainingBlockContentLogicalWidth()) {
+        if (auto width = overridingContainingBlockContentLogicalWidth())
+            return width.value();
     }
 
@@ -1986 +1986 @@
 LayoutUnit RenderBox::containingBlockLogicalHeightForContent(AvailableLogicalHeightType heightType) const
 {
-    if (hasOverrideContainingBlockContentLogicalHeight()) {
-        if (auto overrideLogicalHeight = overrideContainingBlockContentLogicalHeight())
-            return overrideLogicalHeight.value();
+    if (hasOverridingContainingBlockContentLogicalHeight()) {
+        if (auto height = overridingContainingBlockContentLogicalHeight())
+            return height.value();
     }
 
@@ -2027 +2027 @@
 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();
@@ -2440 +2440 @@
     // 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;
     }
@@ -2783 +2783 @@
 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);
@@ -2847 +2847 @@
         // 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);
@@ -3032 +3032 @@
     if (isHorizontal != cb->isHorizontalWritingMode())
         availableHeight = containingBlockChild->containingBlockLogicalWidthForContent();
-    else if (hasOverrideContainingBlockContentLogicalHeight())
-        availableHeight = overrideContainingBlockContentLogicalHeight();
+    else if (hasOverridingContainingBlockContentLogicalHeight())
+        availableHeight = overridingContainingBlockContentLogicalHeight();
     else if (is<RenderTableCell>(*cb)) {
         if (!skippedAutoHeightContainingBlock) {
@@ -3039 +3039 @@
             // 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
@@ -3052 +3052 @@
     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();
@@ -3197 +3197 @@
                 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();
             }
 
@@ -3263 +3263 @@
     // 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();
     }
@@ -3333 +3333 @@
         return containingBlockLogicalHeightForPositioned(containingBlock, false);
 
-    if (hasOverrideContainingBlockContentLogicalWidth()) {
-        if (auto overrideLogicalWidth = overrideContainingBlockContentLogicalWidth())
-            return overrideLogicalWidth.value();
+    if (hasOverridingContainingBlockContentLogicalWidth()) {
+        if (auto width = overridingContainingBlockContentLogicalWidth())
+            return width.value();
     }
 
@@ -3398 +3398 @@
         return containingBlockLogicalWidthForPositioned(containingBlock, nullptr, false);
 
-    if (hasOverrideContainingBlockContentLogicalHeight()) {
-        if (auto overrideLogicalHeight = overrideContainingBlockContentLogicalHeight())
-            return overrideLogicalHeight.value();
+    if (hasOverridingContainingBlockContentLogicalHeight()) {
+        if (auto height = overridingContainingBlockContentLogicalHeight())
+            return height.value();
     }
 

trunk/Source/WebCore/rendering/RenderBox.h

@@ -308 +308 @@
     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 overrideContentLogicalWidth() const { return overrideLogicalWidth() - borderAndPaddingLogicalWidth() - scrollbarLogicalWidth(); }
-    LayoutUnit overrideContentLogicalHeight() const { return overrideLogicalHeight() - 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();
+    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 overridingContentLogicalWidth() const { return overridingLogicalWidth() - borderAndPaddingLogicalWidth() - scrollbarLogicalWidth(); }
+    LayoutUnit overridingContentLogicalHeight() const { return overridingLogicalHeight() - borderAndPaddingLogicalHeight() - scrollbarLogicalHeight(); }
+
+    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;

trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp

@@ -281 +281 @@
     }
     
-    if (thisBox && thisBox->isGridItem() && thisBox->hasOverrideContainingBlockContentLogicalHeight())
+    if (thisBox && thisBox->isGridItem() && thisBox->hasOverridingContainingBlockContentLogicalHeight())
         return false;
     
@@ -349 +349 @@
     // 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())
@@ -372 +372 @@
             || !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()
@@ -383 +383 @@
             || !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()));
     }

trunk/Source/WebCore/rendering/RenderBoxModelObject.h

@@ -234 +234 @@
     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:

trunk/Source/WebCore/rendering/RenderDeprecatedFlexibleBox.cpp

@@ -154 +154 @@
 static LayoutUnit widthForChild(RenderBox* child)
 {
-    if (child->hasOverrideLogicalWidth())
-        return child->overrideLogicalWidth();
+    if (child->hasOverridingLogicalWidth())
+        return child->overridingLogicalWidth();
     return child->logicalWidth();
 }
@@ -161 +161 @@
 static LayoutUnit heightForChild(RenderBox* child)
 {
-    if (child->hasOverrideLogicalHeight())
-        return child->overrideLogicalHeight();
+    if (child->hasOverridingLogicalHeight())
+        return child->overridingLogicalHeight();
     return child->logicalHeight();
 }
@@ -368 +368 @@
             // 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);
@@ -596 +596 @@
                             LayoutUnit spaceAdd = LayoutUnit(spaceAvailableThisPass * (child->style().boxFlex() / totalFlex));
                             if (spaceAdd) {
-                                child->setOverrideLogicalWidth(widthForChild(child) + spaceAdd);
+                                child->setOverridingLogicalWidth(widthForChild(child) + spaceAdd);
                                 flexingChildren = true;
                                 relayoutChildren = true;
@@ -613 +613 @@
                         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;
@@ -853 +853 @@
                             LayoutUnit spaceAdd { spaceAvailableThisPass * (child->style().boxFlex() / totalFlex) };
                             if (spaceAdd) {
-                                child->setOverrideLogicalHeight(heightForChild(child) + spaceAdd);
+                                child->setOverridingLogicalHeight(heightForChild(child) + spaceAdd);
                                 flexingChildren = true;
                                 relayoutChildren = true;
@@ -870 +870 @@
                         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;
@@ -948 +948 @@
             continue;
 
-        child->clearOverrideContentSize();
+        child->clearOverridingContentSize();
         if (relayoutChildren || (child->isReplaced() && (child->style().width().isPercentOrCalculated() || child->style().height().isPercentOrCalculated()))
             || (child->style().height().isAuto() && is<RenderBlockFlow>(*child))) {
@@ -985 +985 @@
 
         child->setChildNeedsLayout(MarkOnlyThis);
-        child->setOverrideLogicalHeight(newHeight);
+        child->setOverridingLogicalHeight(newHeight);
         child->layoutIfNeeded();
 
@@ -1050 +1050 @@
             continue;
 
-        child->clearOverrideContentSize();
+        child->clearOverridingContentSize();
         if ((child->isReplaced() && (child->style().width().isPercentOrCalculated() || child->style().height().isPercentOrCalculated()))
             || (child->style().height().isAuto() && is<RenderBlockFlow>(*child))) {

trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp

@@ -481 +481 @@
 
     // 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;
 }
@@ -845 +845 @@
 LayoutUnit RenderFlexibleBox::computeInnerFlexBaseSizeForChild(RenderBox& child, LayoutUnit mainAxisBorderAndPadding, bool relayoutChildren)
 {
-    child.clearOverrideContentSize();
+    child.clearOverridingContentSize();
     
     Length flexBasis = flexBasisForChild(child);
@@ -1170 +1170 @@
 
     // 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
@@ -1191 +1191 @@
         return WTF::nullopt;
 
-    return child.hasOverrideLogicalHeight() ? Optional<LayoutUnit>(child.overrideContentLogicalHeight()) : WTF::nullopt;
+    return child.hasOverridingLogicalHeight() ? Optional<LayoutUnit>(child.overridingContentLogicalHeight()) : WTF::nullopt;
 }
 
@@ -1232 +1232 @@
         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();
         }
     }
@@ -1425 +1425 @@
 {
     if (hasOrthogonalFlow(child))
-        child.setOverrideLogicalHeight(childPreferredSize + child.borderAndPaddingLogicalHeight());
+        child.setOverridingLogicalHeight(childPreferredSize + child.borderAndPaddingLogicalHeight());
     else
-        child.setOverrideLogicalWidth(childPreferredSize + child.borderAndPaddingLogicalWidth());
+        child.setOverridingLogicalWidth(childPreferredSize + child.borderAndPaddingLogicalWidth());
 }
 
@@ -1884 +1884 @@
             childNeedsRelayout = true;
         }
-        if (childNeedsRelayout || !child.hasOverrideLogicalHeight())
-            child.setOverrideLogicalHeight(desiredLogicalHeight);
+        if (childNeedsRelayout || !child.hasOverridingLogicalHeight())
+            child.setOverridingLogicalHeight(desiredLogicalHeight);
         if (childNeedsRelayout) {
             SetForScope<bool> resetChildLogicalHeight(m_shouldResetChildLogicalHeightBeforeLayout, true);
@@ -1906 +1906 @@
         
         if (childWidth != child.logicalWidth()) {
-            child.setOverrideLogicalWidth(childWidth);
+            child.setOverridingLogicalWidth(childWidth);
             child.setChildNeedsLayout(MarkOnlyThis);
             child.layoutIfNeeded();

trunk/Source/WebCore/rendering/RenderFullScreen.cpp

@@ -172 +172 @@
             // 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);

trunk/Source/WebCore/rendering/RenderGrid.cpp

@@ -194 +194 @@
         // 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;
@@ -203 +203 @@
             // 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.
@@ -611 +611 @@
         // 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);
@@ -903 +903 @@
 {
     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();
 }
 
@@ -921 +921 @@
         child.setNeedsLayout(MarkOnlyThis);
 
-    child.setOverrideContainingBlockContentLogicalWidth(gridAreaLogicalSize.width());
-    child.setOverrideContainingBlockContentLogicalHeight(gridAreaLogicalSize.height());
+    child.setOverridingContainingBlockContentLogicalWidth(gridAreaLogicalSize.width());
+    child.setOverridingContainingBlockContentLogicalHeight(gridAreaLogicalSize.height());
 }
 
@@ -987 +987 @@
     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
@@ -1126 +1126 @@
 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);
@@ -1136 +1136 @@
     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.
@@ -1180 +1180 @@
         marginLogicalWidth += child.marginEnd();
 
-    LayoutUnit availableAlignmentSpace = child.overrideContainingBlockContentLogicalWidth().value() - child.logicalWidth() - marginLogicalWidth;
+    LayoutUnit availableAlignmentSpace = child.overridingContainingBlockContentLogicalWidth().value() - child.logicalWidth() - marginLogicalWidth;
     if (availableAlignmentSpace <= 0)
         return;
@@ -1211 +1211 @@
         marginLogicalHeight += child.marginAfter();
 
-    LayoutUnit availableAlignmentSpace = child.overrideContainingBlockContentLogicalHeight().value() - child.logicalHeight() - marginLogicalHeight;
+    LayoutUnit availableAlignmentSpace = child.overridingContainingBlockContentLogicalHeight().value() - child.logicalHeight() - marginLogicalHeight;
     if (availableAlignmentSpace <= 0)
         return;
@@ -1592 +1592 @@
 {
     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;

trunk/Source/WebCore/rendering/RenderRubyBase.cpp

@@ -68 +68 @@
 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;
@@ -74 +74 @@
     }
 
-    LayoutUnit maxPreferredLogicalWidth = rubyRun() && rubyRun()->hasOverrideLogicalWidth() ? rubyRun()->overrideLogicalWidth() : this->maxPreferredLogicalWidth();
+    LayoutUnit maxPreferredLogicalWidth = rubyRun() && rubyRun()->hasOverridingLogicalWidth() ? rubyRun()->overridingLogicalWidth() : this->maxPreferredLogicalWidth();
     if (maxPreferredLogicalWidth >= logicalWidth)
         return;

trunk/Source/WebCore/rendering/RenderTable.cpp

@@ -283 +283 @@
     // 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.

trunk/Source/WebCore/rendering/RenderTableCell.cpp

@@ -331 +331 @@
 }
 
-void RenderTableCell::setOverrideLogicalHeightFromRowHeight(LayoutUnit rowHeight)
+void RenderTableCell::setOverridingLogicalHeightFromRowHeight(LayoutUnit rowHeight)
 {
     clearIntrinsicPadding();
-    setOverrideLogicalHeight(rowHeight);
+    setOverridingLogicalHeight(rowHeight);
 }
 

trunk/Source/WebCore/rendering/RenderTableCell.h

@@ -103 +103 @@
     LayoutUnit paddingAfter() const override;
 
-    void setOverrideLogicalHeightFromRowHeight(LayoutUnit);
+    void setOverridingLogicalHeightFromRowHeight(LayoutUnit);
 
     void scrollbarsChanged(bool horizontalScrollbarChanged, bool verticalScrollbarChanged) override;

trunk/Source/WebCore/rendering/RenderTableSection.cpp

@@ -284 +284 @@
                 unsigned cellStartRow = cell->rowIndex();
 
-                if (cell->hasOverrideLogicalHeight()) {
+                if (cell->hasOverridingLogicalHeight()) {
                     cell->clearIntrinsicPadding();
-                    cell->clearOverrideContentSize();
+                    cell->clearOverridingContentSize();
                     cell->setChildNeedsLayout(MarkOnlyThis);
                     cell->layoutIfNeeded();
@@ -523 +523 @@
     // height, which becomes irrelevant once the cell has
     // been resized based off its percentage.
-    cell.setOverrideLogicalHeightFromRowHeight(rowHeight);
+    cell.setOverridingLogicalHeightFromRowHeight(rowHeight);
     cell.layoutIfNeeded();