Changeset 268666 in webkit


Ignore:
Timestamp:
Oct 19, 2020 2:40:15 AM (4 years ago)
Author:
svillar@igalia.com
Message:

Sanitize the usage of override sizes
​https://bugs.webkit.org/show_bug.cgi?id=217479

Reviewed by Manuel Rego Casasnovas.

Source/WebCore:

RenderBox had two values, overrideContentLogicalWidth and overrideContentLogicalHeight which were used by a variety of
layout systems (like tables, grid or flex) in different ways. Although names clearly stated that they were content sizes
the reality is that they were used as either border box sizes, content box sizes, or even content box + scrollbar sizes.

This patch addresses a comment in RenderBox which was precisely advocating for turning overrideContentLogicalXXX back into
overrideLogicalXXX. Most of the changes of this CL are just renames because the code has specific branches to handle specific
situations so it didn't actually matter which kind of size we were actually storing. However there are some tricky replacements
as in the case of flex, grid and tables that required careful modifications. It's critical for these layout systems to know
which size we're storing in the overrides because that would determine whether or not we need to add/substract things like borders,
paddings or scrollbar sizes to use them.

Note that apart from renaming the overrideContentLogicalXXX to overrideLogicalXXX we're "adding" overrideContentLogicalXXX to the
RenderBox interface, so it gives the impression that we are not renaming it. However the new implementation is quite different, they
retrieve the content box sizes from the override (border box) sizes we store.

As a nice side effect a new test is passing now after these changes.

  • rendering/ComplexLineLayout.cpp:

(WebCore::ComplexLineLayout::updateRubyForJustifiedText): Renames.

  • rendering/GridTrackSizingAlgorithm.cpp:

(WebCore::GridTrackSizingAlgorithmStrategy::logicalHeightForChild const): Renames.

  • rendering/RenderBlock.cpp:

(WebCore::RenderBlock::computeChildPreferredLogicalWidths const): Renames.
(WebCore::RenderBlock::availableLogicalHeightForPercentageComputation const): Ditto.

  • rendering/RenderBlockFlow.cpp:

(WebCore::RenderBlockFlow::fitBorderToLinesIfNeeded): Renames + store the border box width instead of the content box's.

  • rendering/RenderBox.cpp:

(WebCore::RenderBox::hasOverrideLogicalHeight const): Renamed.
(WebCore::RenderBox::hasOverrideLogicalWidth const): Ditto.
(WebCore::RenderBox::setOverrideLogicalHeight): Ditto.
(WebCore::RenderBox::setOverrideLogicalWidth): Ditto.
(WebCore::RenderBox::clearOverrideLogicalHeight): Ditto.
(WebCore::RenderBox::clearOverrideLogicalWidth): Ditto.
(WebCore::RenderBox::clearOverrideContentSize): Ditto.
(WebCore::RenderBox::overrideLogicalWidth const): Ditto.
(WebCore::RenderBox::overrideLogicalHeight const): Ditto.
(WebCore::RenderBox::perpendicularContainingBlockLogicalHeight const): Renames.
(WebCore::RenderBox::computeLogicalWidthInFragment const): Renames + return the stored override border box width directly.
(WebCore::RenderBox::cacheIntrinsicContentLogicalHeightForFlexItem const): Renames.
(WebCore::RenderBox::computeLogicalHeight const): Renames. Apart from that moved some code around so all branches work with
border box sizes instead of mixing them with content box sizes.
(WebCore::RenderBox::computePercentageLogicalHeight const): Return the content box size after removing computed paddings and
borders from the stored override size.
(WebCore::RenderBox::computeReplacedLogicalHeightUsing const): Renames + compute the borderbox size from the stored
override size.
(WebCore::RenderBox::availableLogicalHeightUsing const): Return the content box size after removing computed paddings and
borders from the stored override size.
(WebCore::RenderBox::hasOverrideContentLogicalHeight const): Deleted.
(WebCore::RenderBox::hasOverrideContentLogicalWidth const): Deleted.
(WebCore::RenderBox::setOverrideContentLogicalHeight): Deleted.
(WebCore::RenderBox::setOverrideContentLogicalWidth): Deleted.
(WebCore::RenderBox::clearOverrideContentLogicalHeight): Deleted.
(WebCore::RenderBox::clearOverrideContentLogicalWidth): Deleted.
(WebCore::RenderBox::overrideContentLogicalWidth const): Deleted.
(WebCore::RenderBox::overrideContentLogicalHeight const): Deleted.

  • rendering/RenderBox.h:

(WebCore::RenderBox::overrideContentLogicalWidth const): "New" method. It existed before but it was renamed to overrideLogicalWidth.
We're adding a completely different implementation for this one.
(WebCore::RenderBox::overrideContentLogicalHeight const): Ditto.

  • rendering/RenderDeprecatedFlexibleBox.cpp:

(WebCore::widthForChild): New method to retrieve the border box width.
(WebCore::heightForChild): New method to retrieve the border box height.
(WebCore::contentWidthForChild): Use widthForChild() which handles overrides.
(WebCore::contentHeightForChild): Use heightForChild() which handles overrides.
(WebCore::RenderDeprecatedFlexibleBox::layoutHorizontalBox): Ditto.
(WebCore::RenderDeprecatedFlexibleBox::layoutVerticalBox): Ditto.
(WebCore::RenderDeprecatedFlexibleBox::applyLineClamp): Do not substract border and padding before setting the override because
we now store the border box height not the content box height.

  • rendering/RenderFlexibleBox.cpp:

(WebCore::RenderFlexibleBox::childIntrinsicLogicalWidth const): Renames.
(WebCore::RenderFlexibleBox::crossSizeForPercentageResolution): Return the content box size (does not include scrollbar).
(WebCore::RenderFlexibleBox::mainSizeForPercentageResolution): Ditto.
(WebCore::RenderFlexibleBox::setOverrideMainAxisContentSizeForChild): Add border and padding before setting the override.
(WebCore::RenderFlexibleBox::applyStretchAlignmentToChild): Do not substract border and padding before setting the override as we are
storing border box sizes.

  • rendering/RenderGrid.cpp:

(WebCore::RenderGrid::layoutBlock): Renames.
(WebCore::RenderGrid::applyStretchAlignmentToChildIfNeeded): Renames + do not substract border and padding before setting the override
as we are storing border box sizes.

  • rendering/RenderRubyBase.cpp:

(WebCore::RenderRubyBase::adjustInlineDirectionLineBounds const): Renames.

  • rendering/RenderTable.cpp:

(WebCore::RenderTable::updateLogicalWidth): Renames.

  • rendering/RenderTableCell.cpp:

(WebCore::RenderTableCell::setOverrideLogicalHeightFromRowHeight): Renames + do not substract border and padding before setting the override
as we are storing border box sizes.
(WebCore::RenderTableCell::setOverrideContentLogicalHeightFromRowHeight): Deleted.

  • rendering/RenderTableCell.h: Renames.
  • rendering/RenderTableSection.cpp:

(WebCore::RenderTableSection::calcRowLogicalHeight): Renames.
(WebCore::RenderTableSection::relayoutCellIfFlexed): Ditto.

LayoutTests:

The percentage-size-subitems-001.html is passing now after making the overrides work properly.

Apart from that the override sanitization allowed us to remove platform specific expectations for the border-fit-2.html
test even for the GTK port which is working fine now.

  • TestExpectations: Removed a test that passes now.
  • css3/flexbox/flex-flow-auto-margins-no-available-space-assert.html: Fine tuned expectations.
  • fast/borders/border-fit-2-expected.txt: Renamed from LayoutTests/platform/ios/fast/borders/border-fit-2-expected.txt.
  • platform/gtk/TestExpectations: Removed two tests that pass now.
  • platform/gtk/fast/borders/border-fit-2-expected.txt: Removed.
  • platform/gtk/fast/borders/border-fit-expected.txt: Added.
  • platform/mac/fast/borders/border-fit-2-expected.txt: Removed.
  • platform/wincairo/fast/borders/border-fit-2-expected.txt: Removed.
  • platform/wpe/fast/borders/border-fit-2-expected.txt: Removed.
Location:
trunk
Files:
1 added
4 deleted
19 edited
1 moved

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r268665 r268666  
     12020-10-13  Sergio Villar Senin  <svillar@igalia.com>
     2
     3        Sanitize the usage of override sizes
     4        https://bugs.webkit.org/show_bug.cgi?id=217479
     5
     6        Reviewed by Manuel Rego Casasnovas.
     7
     8        The percentage-size-subitems-001.html is passing now after making the overrides work properly.
     9
     10        Apart from that the override sanitization allowed us to remove platform specific expectations for the border-fit-2.html
     11        test even for the GTK port which is working fine now.
     12
     13        * TestExpectations: Removed a test that passes now.
     14        * css3/flexbox/flex-flow-auto-margins-no-available-space-assert.html: Fine tuned expectations.
     15        * fast/borders/border-fit-2-expected.txt: Renamed from LayoutTests/platform/ios/fast/borders/border-fit-2-expected.txt.
     16        * platform/gtk/TestExpectations: Removed two tests that pass now.
     17        * platform/gtk/fast/borders/border-fit-2-expected.txt: Removed.
     18        * platform/gtk/fast/borders/border-fit-expected.txt: Added.
     19        * platform/mac/fast/borders/border-fit-2-expected.txt: Removed.
     20        * platform/wincairo/fast/borders/border-fit-2-expected.txt: Removed.
     21        * platform/wpe/fast/borders/border-fit-2-expected.txt: Removed.
     22
    1232020-10-19  Martin Robinson  <mrobinson@igalia.com>
    224

  • trunk/LayoutTests/TestExpectations

    r268615 r268666  
    38833883webkit.org/b/212046 imported/w3c/web-platform-tests/css/css-flexbox/percentage-heights-007.html [ ImageOnlyFailure ]
    38843884webkit.org/b/212046 imported/w3c/web-platform-tests/css/css-flexbox/percentage-heights-014.html [ ImageOnlyFailure ]
    3885 webkit.org/b/212046 imported/w3c/web-platform-tests/css/css-flexbox/percentage-size-subitems-001.html [ ImageOnlyFailure ]
    38863885webkit.org/b/212046 imported/w3c/web-platform-tests/css/css-flexbox/scrollbars-auto.html [ ImageOnlyFailure ]
    38873886webkit.org/b/212046 imported/w3c/web-platform-tests/css/css-flexbox/scrollbars.html [ ImageOnlyFailure ]

  • trunk/LayoutTests/css3/flexbox/flex-flow-auto-margins-no-available-space-assert.html

    r213149 r268666  
    1111</style>
    1212<script src="../../resources/check-layout.js"></script>
    13 <abbr data-expected-height=30210268>
     13<abbr data-expected-height=30210272>
    1414    <input></input>
    1515</abbr>

  • trunk/LayoutTests/fast/borders/border-fit-2-expected.txt

    • Property svn:eol-style set to LF

  • trunk/LayoutTests/platform/gtk/TestExpectations

    r268611 r268666  
    27192719webkit.org/b/109469 [ Debug ] fast/events/mouse-cursor-image-set.html [ Crash ]
    27202720
    2721 webkit.org/b/111606 fast/borders/border-fit.html [ Failure ]
    2722 webkit.org/b/111606 fast/borders/border-fit-2.html [ Failure ]
    2723 
    27242721webkit.org/b/99893 svg/animations/mozilla/animateMotion-mpath-targetChange-1.svg [ ImageOnlyFailure Pass ]
    27252722

  • trunk/Source/WebCore/ChangeLog

    r268665 r268666  
     12020-10-13  Sergio Villar Senin  <svillar@igalia.com>
     2
     3        Sanitize the usage of override sizes
     4        https://bugs.webkit.org/show_bug.cgi?id=217479
     5
     6        Reviewed by Manuel Rego Casasnovas.
     7
     8        RenderBox had two values, overrideContentLogicalWidth and overrideContentLogicalHeight which were used by a variety of
     9        layout systems (like tables, grid or flex) in different ways. Although names clearly stated that they were content sizes
     10        the reality is that they were used as either border box sizes, content box sizes, or even content box + scrollbar sizes.
     11
     12        This patch addresses a comment in RenderBox which was precisely advocating for turning overrideContentLogicalXXX back into
     13        overrideLogicalXXX. Most of the changes of this CL are just renames because the code has specific branches to handle specific
     14        situations so it didn't actually matter which kind of size we were actually storing. However there are some tricky replacements
     15        as in the case of flex, grid and tables that required careful modifications. It's critical for these layout systems to know
     16        which size we're storing in the overrides because that would determine whether or not we need to add/substract things like borders,
     17        paddings or scrollbar sizes to use them.
     18
     19        Note that apart from renaming the overrideContentLogicalXXX to overrideLogicalXXX we're "adding" overrideContentLogicalXXX to the
     20        RenderBox interface, so it gives the impression that we are not renaming it. However the new implementation is quite different, they
     21        retrieve the content box sizes from the override (border box) sizes we store.
     22
     23        As a nice side effect a new test is passing now after these changes.
     24
     25        * rendering/ComplexLineLayout.cpp:
     26        (WebCore::ComplexLineLayout::updateRubyForJustifiedText): Renames.
     27        * rendering/GridTrackSizingAlgorithm.cpp:
     28        (WebCore::GridTrackSizingAlgorithmStrategy::logicalHeightForChild const): Renames.
     29        * rendering/RenderBlock.cpp:
     30        (WebCore::RenderBlock::computeChildPreferredLogicalWidths const): Renames.
     31        (WebCore::RenderBlock::availableLogicalHeightForPercentageComputation const): Ditto.
     32        * rendering/RenderBlockFlow.cpp:
     33        (WebCore::RenderBlockFlow::fitBorderToLinesIfNeeded): Renames + store the border box width instead of the content box's.
     34        * rendering/RenderBox.cpp:
     35        (WebCore::RenderBox::hasOverrideLogicalHeight const):  Renamed.
     36        (WebCore::RenderBox::hasOverrideLogicalWidth const): Ditto.
     37        (WebCore::RenderBox::setOverrideLogicalHeight): Ditto.
     38        (WebCore::RenderBox::setOverrideLogicalWidth): Ditto.
     39        (WebCore::RenderBox::clearOverrideLogicalHeight): Ditto.
     40        (WebCore::RenderBox::clearOverrideLogicalWidth): Ditto.
     41        (WebCore::RenderBox::clearOverrideContentSize): Ditto.
     42        (WebCore::RenderBox::overrideLogicalWidth const): Ditto.
     43        (WebCore::RenderBox::overrideLogicalHeight const): Ditto.
     44        (WebCore::RenderBox::perpendicularContainingBlockLogicalHeight const): Renames.
     45        (WebCore::RenderBox::computeLogicalWidthInFragment const): Renames + return the stored override border box width directly.
     46        (WebCore::RenderBox::cacheIntrinsicContentLogicalHeightForFlexItem const): Renames.
     47        (WebCore::RenderBox::computeLogicalHeight const): Renames. Apart from that moved some code around so all branches work with
     48        border box sizes instead of mixing them with content box sizes.
     49        (WebCore::RenderBox::computePercentageLogicalHeight const): Return the content box size after removing computed paddings and
     50        borders from the stored override size.
     51        (WebCore::RenderBox::computeReplacedLogicalHeightUsing const): Renames + compute the borderbox size from the stored
     52        override size.
     53        (WebCore::RenderBox::availableLogicalHeightUsing const): Return the content box size after removing computed paddings and
     54        borders from the stored override size.
     55        (WebCore::RenderBox::hasOverrideContentLogicalHeight const): Deleted.
     56        (WebCore::RenderBox::hasOverrideContentLogicalWidth const): Deleted.
     57        (WebCore::RenderBox::setOverrideContentLogicalHeight): Deleted.
     58        (WebCore::RenderBox::setOverrideContentLogicalWidth): Deleted.
     59        (WebCore::RenderBox::clearOverrideContentLogicalHeight): Deleted.
     60        (WebCore::RenderBox::clearOverrideContentLogicalWidth): Deleted.
     61        (WebCore::RenderBox::overrideContentLogicalWidth const): Deleted.
     62        (WebCore::RenderBox::overrideContentLogicalHeight const): Deleted.
     63        * rendering/RenderBox.h:
     64        (WebCore::RenderBox::overrideContentLogicalWidth const): "New" method. It existed before but it was renamed to overrideLogicalWidth.
     65        We're adding a completely different implementation for this one.
     66        (WebCore::RenderBox::overrideContentLogicalHeight const): Ditto.
     67        * rendering/RenderDeprecatedFlexibleBox.cpp:
     68        (WebCore::widthForChild): New method to retrieve the border box width.
     69        (WebCore::heightForChild): New method to retrieve the border box height.
     70        (WebCore::contentWidthForChild): Use widthForChild() which handles overrides.
     71        (WebCore::contentHeightForChild): Use heightForChild() which handles overrides.
     72        (WebCore::RenderDeprecatedFlexibleBox::layoutHorizontalBox): Ditto.
     73        (WebCore::RenderDeprecatedFlexibleBox::layoutVerticalBox): Ditto.
     74        (WebCore::RenderDeprecatedFlexibleBox::applyLineClamp): Do not substract border and padding before setting the override because
     75        we now store the border box height not the content box height.
     76        * rendering/RenderFlexibleBox.cpp:
     77        (WebCore::RenderFlexibleBox::childIntrinsicLogicalWidth const): Renames.
     78        (WebCore::RenderFlexibleBox::crossSizeForPercentageResolution): Return the content box size (does not include scrollbar).
     79        (WebCore::RenderFlexibleBox::mainSizeForPercentageResolution): Ditto.
     80        (WebCore::RenderFlexibleBox::setOverrideMainAxisContentSizeForChild): Add border and padding before setting the override.
     81        (WebCore::RenderFlexibleBox::applyStretchAlignmentToChild): Do not substract border and padding before setting the override as we are
     82        storing border box sizes.
     83        * rendering/RenderGrid.cpp:
     84        (WebCore::RenderGrid::layoutBlock): Renames.
     85        (WebCore::RenderGrid::applyStretchAlignmentToChildIfNeeded): Renames + do not substract border and padding before setting the override
     86        as we are storing border box sizes.
     87        * rendering/RenderRubyBase.cpp:
     88        (WebCore::RenderRubyBase::adjustInlineDirectionLineBounds const): Renames.
     89        * rendering/RenderTable.cpp:
     90        (WebCore::RenderTable::updateLogicalWidth): Renames.
     91        * rendering/RenderTableCell.cpp:
     92        (WebCore::RenderTableCell::setOverrideLogicalHeightFromRowHeight): Renames + do not substract border and padding before setting the override
     93        as we are storing border box sizes.
     94        (WebCore::RenderTableCell::setOverrideContentLogicalHeightFromRowHeight): Deleted.
     95        * rendering/RenderTableCell.h: Renames.
     96        * rendering/RenderTableSection.cpp:
     97        (WebCore::RenderTableSection::calcRowLogicalHeight): Renames.
     98        (WebCore::RenderTableSection::relayoutCellIfFlexed): Ditto.
     99
    11002020-10-19  Martin Robinson  <mrobinson@igalia.com>
    2101

  • trunk/Source/WebCore/rendering/ComplexLineLayout.cpp

    r267565 r268666  
    591591    }
    592592
    593     ASSERT(!rubyRun.hasOverrideContentLogicalWidth());
     593    ASSERT(!rubyRun.hasOverrideLogicalWidth());
    594594    float newBaseWidth = rubyRun.logicalWidth() + totalExpansion + m_flow.marginStartForChild(rubyRun) + m_flow.marginEndForChild(rubyRun);
    595595    float newRubyRunWidth = rubyRun.logicalWidth() + totalExpansion;
    596596    rubyBase.setInitialOffset((newRubyRunWidth - newBaseWidth) / 2);
    597     rubyRun.setOverrideContentLogicalWidth(LayoutUnit(newRubyRunWidth));
     597    rubyRun.setOverrideLogicalWidth(LayoutUnit(newRubyRunWidth));
    598598    rubyRun.setNeedsLayout(MarkOnlyThis);
    599599    rootBox.markDirty();
    … …  
    603603    }
    604604    rubyRun.layoutBlock(true);
    605     rubyRun.clearOverrideContentLogicalWidth();
     605    rubyRun.clearOverrideLogicalWidth();
    606606    r.box()->setExpansion(newRubyRunWidth - r.box()->logicalWidth());
    607607

  • trunk/Source/WebCore/rendering/GridTrackSizingAlgorithm.cpp

    r267503 r268666  
    764764    // We need to clear the stretched height to properly compute logical height during layout.
    765765    if (child.needsLayout())
    766         child.clearOverrideContentLogicalHeight();
     766        child.clearOverrideLogicalHeight();
    767767
    768768    child.layoutIfNeeded();

  • trunk/Source/WebCore/rendering/RenderBlock.cpp

    r266691 r268666  
    24262426        auto& box = downcast<RenderBox>(child);
    24272427        if (box.isFlexItem()) {
    2428             if (box.hasOverrideContentLogicalHeight())
    2429                 overrideHeight = Optional<LayoutUnit>(box.overrideContentLogicalHeight());
    2430             if (box.hasOverrideContentLogicalWidth())
    2431                 overrideWidth = Optional<LayoutUnit>(box.overrideContentLogicalWidth());
     2428            if (box.hasOverrideLogicalHeight())
     2429                overrideHeight = Optional<LayoutUnit>(box.overrideLogicalHeight());
     2430            if (box.hasOverrideLogicalWidth())
     2431                overrideWidth = Optional<LayoutUnit>(box.overrideLogicalWidth());
    24322432            box.clearOverrideContentSize();
    24332433        }
    … …  
    24402440        auto& box = downcast<RenderBox>(child);
    24412441        if (overrideHeight)
    2442             box.setOverrideContentLogicalHeight(overrideHeight.value());
     2442            box.setOverrideLogicalHeight(overrideHeight.value());
    24432443        if (overrideWidth)
    2444             box.setOverrideContentLogicalWidth(overrideWidth.value());
     2444            box.setOverrideLogicalWidth(overrideWidth.value());
    24452445    }
    24462446
    … …  
    32203220    if (stretchedFlexHeight)
    32213221        availableHeight = stretchedFlexHeight;
    3222     else if (isGridItem() && hasOverrideContentLogicalHeight())
    3223         availableHeight = overrideContentLogicalHeight();
     3222    else if (isGridItem() && hasOverrideLogicalHeight())
     3223        availableHeight = overrideLogicalHeight();
    32243224    else if (styleToUse.logicalHeight().isFixed()) {
    32253225        LayoutUnit contentBoxHeight = adjustContentBoxLogicalHeightForBoxSizing((LayoutUnit)styleToUse.logicalHeight().value());

  • trunk/Source/WebCore/rendering/RenderBlockFlow.cpp

    r268598 r268666  
    30463046void RenderBlockFlow::fitBorderToLinesIfNeeded()
    30473047{
    3048     if (style().borderFit() == BorderFit::Border || hasOverrideContentLogicalWidth())
     3048    if (style().borderFit() == BorderFit::Border || hasOverrideLogicalWidth())
    30493049        return;
    30503050
    … …  
    30643064    if (newContentWidth == oldWidth)
    30653065        return;
    3066    
    3067     setOverrideContentLogicalWidth(newContentWidth);
     3066
     3067    setOverrideLogicalWidth(newContentWidth + borderAndPaddingLogicalWidth());
    30683068    layoutBlock(false);
    3069     clearOverrideContentLogicalWidth();
     3069    clearOverrideLogicalWidth();
    30703070}
    30713071

  • trunk/Source/WebCore/rendering/RenderBox.cpp

    r266803 r268666  
    9393using namespace HTMLNames;
    9494
    95 // Used by flexible boxes when flexing this element and by table cells.
    9695typedef WTF::HashMap<const RenderBox*, LayoutUnit> OverrideSizeMap;
    97 static OverrideSizeMap* gOverrideContentLogicalHeightMap = nullptr;
    98 static OverrideSizeMap* gOverrideContentLogicalWidthMap = nullptr;
    99 
    100 // Used by grid elements to properly size their grid items.
     96static OverrideSizeMap* gOverrideLogicalHeightMap = nullptr;
     97static OverrideSizeMap* gOverrideLogicalWidthMap = nullptr;
     98
    10199// FIXME: We should store these based on physical direction.
    102100typedef WTF::HashMap<const RenderBox*, Optional<LayoutUnit>> OverrideOptionalSizeMap;
    … …  
    10831081}
    10841082
    1085 bool RenderBox::hasOverrideContentLogicalHeight() const
    1086 {
    1087     return gOverrideContentLogicalHeightMap && gOverrideContentLogicalHeightMap->contains(this);
    1088 }
    1089 
    1090 bool RenderBox::hasOverrideContentLogicalWidth() const
    1091 {
    1092     return gOverrideContentLogicalWidthMap && gOverrideContentLogicalWidthMap->contains(this);
    1093 }
    1094 
    1095 void RenderBox::setOverrideContentLogicalHeight(LayoutUnit height)
    1096 {
    1097     if (!gOverrideContentLogicalHeightMap)
    1098         gOverrideContentLogicalHeightMap = new OverrideSizeMap();
    1099     gOverrideContentLogicalHeightMap->set(this, height);
    1100 }
    1101 
    1102 void RenderBox::setOverrideContentLogicalWidth(LayoutUnit width)
    1103 {
    1104     if (!gOverrideContentLogicalWidthMap)
    1105         gOverrideContentLogicalWidthMap = new OverrideSizeMap();
    1106     gOverrideContentLogicalWidthMap->set(this, width);
    1107 }
    1108 
    1109 void RenderBox::clearOverrideContentLogicalHeight()
    1110 {
    1111     if (gOverrideContentLogicalHeightMap)
    1112         gOverrideContentLogicalHeightMap->remove(this);
    1113 }
    1114 
    1115 void RenderBox::clearOverrideContentLogicalWidth()
    1116 {
    1117     if (gOverrideContentLogicalWidthMap)
    1118         gOverrideContentLogicalWidthMap->remove(this);
     1083bool RenderBox::hasOverrideLogicalHeight() const
     1084{
     1085    return gOverrideLogicalHeightMap && gOverrideLogicalHeightMap->contains(this);
     1086}
     1087
     1088bool RenderBox::hasOverrideLogicalWidth() const
     1089{
     1090    return gOverrideLogicalWidthMap && gOverrideLogicalWidthMap->contains(this);
     1091}
     1092
     1093void RenderBox::setOverrideLogicalHeight(LayoutUnit height)
     1094{
     1095    if (!gOverrideLogicalHeightMap)
     1096        gOverrideLogicalHeightMap = new OverrideSizeMap();
     1097    gOverrideLogicalHeightMap->set(this, height);
     1098}
     1099
     1100void RenderBox::setOverrideLogicalWidth(LayoutUnit width)
     1101{
     1102    if (!gOverrideLogicalWidthMap)
     1103        gOverrideLogicalWidthMap = new OverrideSizeMap();
     1104    gOverrideLogicalWidthMap->set(this, width);
     1105}
     1106
     1107void RenderBox::clearOverrideLogicalHeight()
     1108{
     1109    if (gOverrideLogicalHeightMap)
     1110        gOverrideLogicalHeightMap->remove(this);
     1111}
     1112
     1113void RenderBox::clearOverrideLogicalWidth()
     1114{
     1115    if (gOverrideLogicalWidthMap)
     1116        gOverrideLogicalWidthMap->remove(this);
    11191117}
    11201118
    11211119void RenderBox::clearOverrideContentSize()
    11221120{
    1123     clearOverrideContentLogicalHeight();
    1124     clearOverrideContentLogicalWidth();
    1125 }
    1126 
    1127 LayoutUnit RenderBox::overrideContentLogicalWidth() const
    1128 {
    1129     ASSERT(hasOverrideContentLogicalWidth());
    1130     return gOverrideContentLogicalWidthMap->get(this);
    1131 }
    1132 
    1133 LayoutUnit RenderBox::overrideContentLogicalHeight() const
    1134 {
    1135     ASSERT(hasOverrideContentLogicalHeight());
    1136     return gOverrideContentLogicalHeightMap->get(this);
     1121    clearOverrideLogicalHeight();
     1122    clearOverrideLogicalWidth();
     1123}
     1124
     1125LayoutUnit RenderBox::overrideLogicalWidth() const
     1126{
     1127    ASSERT(hasOverrideLogicalWidth());
     1128    return gOverrideLogicalWidthMap->get(this);
     1129}
     1130
     1131LayoutUnit RenderBox::overrideLogicalHeight() const
     1132{
     1133    ASSERT(hasOverrideLogicalHeight());
     1134    return gOverrideLogicalHeightMap->get(this);
    11371135}
    11381136
    … …  
    20272025
    20282026    RenderBlock* cb = containingBlock();
    2029     if (cb->hasOverrideContentLogicalHeight())
     2027    if (cb->hasOverrideLogicalHeight())
    20302028        return cb->overrideContentLogicalHeight();
    20312029
    … …  
    24342432    // FIXME: Account for block-flow in flexible boxes.
    24352433    // https://bugs.webkit.org/show_bug.cgi?id=46418
    2436     if (hasOverrideContentLogicalWidth() && (isRubyRun() || style().borderFit() == BorderFit::Lines || (parent()->isFlexibleBoxIncludingDeprecated()))) {
    2437         computedValues.m_extent = overrideContentLogicalWidth() + borderAndPaddingLogicalWidth();
     2434    if (hasOverrideLogicalWidth() && (isRubyRun() || style().borderFit() == BorderFit::Lines || (parent()->isFlexibleBoxIncludingDeprecated()))) {
     2435        computedValues.m_extent = overrideLogicalWidth();
    24382436        return;
    24392437    }
    … …  
    27772775void RenderBox::cacheIntrinsicContentLogicalHeightForFlexItem(LayoutUnit height) const
    27782776{
    2779     // FIXME: it should be enough with checking hasOverrideContentLogicalHeight() as this logic could be shared
     2777    // FIXME: it should be enough with checking hasOverrideLogicalHeight() as this logic could be shared
    27802778    // by any layout system using overrides like grid or flex. However this causes a never ending sequence of calls
    27812779    // between layoutBlock() <-> relayoutToAvoidWidows().
    2782     if (isFloatingOrOutOfFlowPositioned() || !parent() || !parent()->isFlexibleBox() || hasOverrideContentLogicalHeight())
     2780    if (isFloatingOrOutOfFlowPositioned() || !parent() || !parent()->isFlexibleBox() || hasOverrideLogicalHeight())
    27832781        return;
    27842782    downcast<RenderFlexibleBox>(parent())->setCachedChildIntrinsicContentLogicalHeight(*this, height);
    … …  
    28412839        // FIXME: Account for block-flow in flexible boxes.
    28422840        // https://bugs.webkit.org/show_bug.cgi?id=46418
    2843         if (hasOverrideContentLogicalHeight() && (parent()->isFlexibleBoxIncludingDeprecated() || parent()->isRenderGrid())) {
    2844             h = Length(overrideContentLogicalHeight(), Fixed);
     2841        if (hasOverrideLogicalHeight() && (parent()->isFlexibleBoxIncludingDeprecated() || parent()->isRenderGrid())) {
     2842            h = Length(overrideLogicalHeight(), Fixed);
    28452843        } else if (treatAsReplaced)
    2846             h = Length(computeReplacedLogicalHeight(), Fixed);
     2844            h = Length(computeReplacedLogicalHeight() + borderAndPaddingLogicalHeight(), Fixed);
    28472845        else {
    28482846            h = style().logicalHeight();
    … …  
    28552853        if (h.isAuto() && is<RenderDeprecatedFlexibleBox>(*parent()) && parent()->style().boxOrient() == BoxOrient::Horizontal
    28562854                && downcast<RenderDeprecatedFlexibleBox>(*parent()).isStretchingChildren()) {
    2857             h = Length(parentBox()->contentLogicalHeight() - marginBefore() - marginAfter() - borderAndPaddingLogicalHeight(), Fixed);
     2855            h = Length(parentBox()->contentLogicalHeight() - marginBefore() - marginAfter(), Fixed);
    28582856            checkMinMaxHeight = false;
    28592857        }
    … …  
    28652863            heightResult = constrainLogicalHeightByMinMax(heightResult, intrinsicHeight);
    28662864        } else {
    2867             // The only times we don't check min/max height are when a fixed length has
    2868             // been given as an override.  Just use that.  The value has already been adjusted
    2869             // for box-sizing.
    28702865            ASSERT(h.isFixed());
    2871             heightResult = h.value() + borderAndPaddingLogicalHeight();
     2866            heightResult = h.value();
    28722867        }
    28732868
    … …  
    30363031            // don't care if the cell specified a height or not. We just always make ourselves
    30373032            // be a percentage of the cell's current content height.
    3038             if (!cb->hasOverrideContentLogicalHeight())
     3033            if (!cb->hasOverrideLogicalHeight())
    30393034                return tableCellShouldHaveZeroInitialSize(*cb, *this, scrollsOverflowY()) ? Optional<LayoutUnit>(0) : WTF::nullopt;
    30403035
    3041             availableHeight = cb->overrideContentLogicalHeight();
     3036            availableHeight = cb->overrideLogicalHeight() - cb->computedCSSPaddingBefore() - cb->computedCSSPaddingAfter() - cb->borderBefore() - cb->borderAfter();
    30423037        }
    30433038    } else
    … …  
    30493044    LayoutUnit result = valueForLength(height, availableHeight.value() - rootMarginBorderPaddingHeight + (isTable() && isOutOfFlowPositioned() ? cb->paddingBefore() + cb->paddingAfter() : 0_lu));
    30503045   
    3051     // |overrideContentLogicalHeight| is the maximum height made available by the
     3046    // |overrideLogicalHeight| is the maximum height made available by the
    30523047    // cell to its percent height children when we decide they can determine the
    30533048    // height of the cell. If the percent height child is box-sizing:content-box
    30543049    // then we must subtract the border and padding from the cell's
    3055     // |availableHeight| (given by |overrideContentLogicalHeight|) to arrive
     3050    // |availableHeight| (given by |overrideLogicalHeight|) to arrive
    30563051    // at the child's computed height.
    3057     bool subtractBorderAndPadding = isTable() || (is<RenderTableCell>(*cb) && !skippedAutoHeightContainingBlock && cb->hasOverrideContentLogicalHeight());
     3052    bool subtractBorderAndPadding = isTable() || (is<RenderTableCell>(*cb) && !skippedAutoHeightContainingBlock && cb->hasOverrideLogicalHeight());
    30583053    if (subtractBorderAndPadding) {
    30593054        result -= borderAndPaddingLogicalHeight();
    … …  
    31943189                if (block->isFlexItem())
    31953190                    stretchedHeight = downcast<RenderFlexibleBox>(block->parent())->childLogicalHeightForPercentageResolution(*block);
    3196                 else if (block->isGridItem() && block->hasOverrideContentLogicalHeight())
    3197                     stretchedHeight = block->overrideContentLogicalHeight();
     3191                else if (block->isGridItem() && block->hasOverrideLogicalHeight())
     3192                    stretchedHeight = block->overrideLogicalHeight() - block->borderAndPaddingLogicalHeight();
    31983193            }
    31993194
    … …  
    32603255    // height, and then when we lay out again we'll use the calculation below.
    32613256    if (isTableCell() && (h.isAuto() || h.isPercentOrCalculated())) {
    3262         if (hasOverrideContentLogicalHeight())
    3263             return overrideContentLogicalHeight();
     3257        if (hasOverrideLogicalHeight())
     3258            return overrideLogicalHeight() - computedCSSPaddingBefore() - computedCSSPaddingAfter() - borderBefore() - borderAfter();
    32643259        return logicalHeight() - borderAndPaddingLogicalHeight();
    32653260    }

  • trunk/Source/WebCore/rendering/RenderBox.h

    r261775 r268666  
    308308    LayoutUnit maxPreferredLogicalWidth() const override;
    309309
    310     // FIXME: We should rename these back to overrideLogicalHeight/Width and have them store
    311     // the border-box height/width like the regular height/width accessors on RenderBox.
    312     // Right now, these are different than contentHeight/contentWidth because they still
    313     // include the scrollbar height/width.
    314     LayoutUnit overrideContentLogicalWidth() const;
    315     LayoutUnit overrideContentLogicalHeight() const;
    316     bool hasOverrideContentLogicalHeight() const;
    317     bool hasOverrideContentLogicalWidth() const;
    318     void setOverrideContentLogicalHeight(LayoutUnit);
    319     void setOverrideContentLogicalWidth(LayoutUnit);
     310    LayoutUnit overrideLogicalWidth() const;
     311    LayoutUnit overrideLogicalHeight() const;
     312    bool hasOverrideLogicalHeight() const;
     313    bool hasOverrideLogicalWidth() const;
     314    void setOverrideLogicalHeight(LayoutUnit);
     315    void setOverrideLogicalWidth(LayoutUnit);
    320316    void clearOverrideContentSize();
    321     void clearOverrideContentLogicalHeight();
    322     void clearOverrideContentLogicalWidth();
     317    void clearOverrideLogicalHeight();
     318    void clearOverrideLogicalWidth();
     319
     320    LayoutUnit overrideContentLogicalWidth() const { return overrideLogicalWidth() - borderAndPaddingLogicalWidth() - scrollbarLogicalWidth(); }
     321    LayoutUnit overrideContentLogicalHeight() const { return overrideLogicalHeight() - borderAndPaddingLogicalHeight() - scrollbarLogicalHeight(); }
    323322
    324323    Optional<LayoutUnit> overrideContainingBlockContentWidth() const override;

  • trunk/Source/WebCore/rendering/RenderDeprecatedFlexibleBox.cpp

    r262892 r268666  
    152152}
    153153
     154static LayoutUnit widthForChild(RenderBox* child)
     155{
     156    if (child->hasOverrideLogicalWidth())
     157        return child->overrideLogicalWidth();
     158    return child->logicalWidth();
     159}
     160
     161static LayoutUnit heightForChild(RenderBox* child)
     162{
     163    if (child->hasOverrideLogicalHeight())
     164        return child->overrideLogicalHeight();
     165    return child->logicalHeight();
     166}
     167
    154168static LayoutUnit contentWidthForChild(RenderBox* child)
    155169{
    156     if (child->hasOverrideContentLogicalWidth())
    157         return child->overrideContentLogicalWidth();
    158     return child->logicalWidth() - child->borderAndPaddingLogicalWidth();
     170    return std::max<LayoutUnit>(0, widthForChild(child) - child->borderAndPaddingLogicalWidth());
    159171}
    160172
    161173static LayoutUnit contentHeightForChild(RenderBox* child)
    162174{
    163     if (child->hasOverrideContentLogicalHeight())
    164         return child->overrideContentLogicalHeight();
    165     return child->logicalHeight() - child->borderAndPaddingLogicalHeight();
     175    return std::max<LayoutUnit>(0, heightForChild(child) - child->borderAndPaddingLogicalHeight());
    166176}
    167177
    … …  
    586596                            LayoutUnit spaceAdd = LayoutUnit(spaceAvailableThisPass * (child->style().boxFlex() / totalFlex));
    587597                            if (spaceAdd) {
    588                                 child->setOverrideContentLogicalWidth(contentWidthForChild(child) + spaceAdd);
     598                                child->setOverrideLogicalWidth(widthForChild(child) + spaceAdd);
    589599                                flexingChildren = true;
    590600                                relayoutChildren = true;
    … …  
    603613                        for (RenderBox* child = iterator.first(); child && groupRemainingSpace; child = iterator.next()) {
    604614                            if (allowedChildFlex(child, expanding, i)) {
    605                                 child->setOverrideContentLogicalWidth(contentWidthForChild(child) + spaceAdd);
     615                                child->setOverrideLogicalWidth(widthForChild(child) + spaceAdd);
    606616                                flexingChildren = true;
    607617                                relayoutChildren = true;
    … …  
    843853                            LayoutUnit spaceAdd { spaceAvailableThisPass * (child->style().boxFlex() / totalFlex) };
    844854                            if (spaceAdd) {
    845                                 child->setOverrideContentLogicalHeight(contentHeightForChild(child) + spaceAdd);
     855                                child->setOverrideLogicalHeight(heightForChild(child) + spaceAdd);
    846856                                flexingChildren = true;
    847857                                relayoutChildren = true;
    … …  
    860870                        for (RenderBox* child = iterator.first(); child && groupRemainingSpace; child = iterator.next()) {
    861871                            if (allowedChildFlex(child, expanding, i)) {
    862                                 child->setOverrideContentLogicalHeight(contentHeightForChild(child) + spaceAdd);
     872                                child->setOverrideLogicalHeight(heightForChild(child) + spaceAdd);
    863873                                flexingChildren = true;
    864874                                relayoutChildren = true;
    … …  
    975985
    976986        child->setChildNeedsLayout(MarkOnlyThis);
    977         child->setOverrideContentLogicalHeight(newHeight - child->verticalBorderAndPaddingExtent());
     987        child->setOverrideLogicalHeight(newHeight);
    978988        child->layoutIfNeeded();
    979989

  • trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp

    r267829 r268666  
    481481
    482482    // Temporarily clear potential overrides to compute the logical width otherwise it'll return the override size.
    483     bool childHasOverrideWidth = child.hasOverrideContentLogicalWidth();
    484     auto overrideWidth = childHasOverrideWidth ? child.overrideContentLogicalWidth() : -1_lu;
     483    bool childHasOverrideWidth = child.hasOverrideLogicalWidth();
     484    auto overrideWidth = childHasOverrideWidth ? child.overrideLogicalWidth() : -1_lu;
    485485    if (childHasOverrideWidth)
    486         const_cast<RenderBox*>(&child)->clearOverrideContentLogicalWidth();
     486        const_cast<RenderBox*>(&child)->clearOverrideLogicalWidth();
    487487    LogicalExtentComputedValues values;
    488488    child.computeLogicalWidthInFragment(values);
    489489    if (childHasOverrideWidth)
    490         const_cast<RenderBox*>(&child)->setOverrideContentLogicalWidth(overrideWidth);
     490        const_cast<RenderBox*>(&child)->setOverrideLogicalWidth(overrideWidth);
    491491    return values.m_extent;
    492492}
    … …  
    11701170
    11711171    // Here we implement https://drafts.csswg.org/css-flexbox/#algo-stretch
    1172     if (child.hasOverrideContentLogicalHeight())
    1173         return child.overrideContentLogicalHeight() - child.scrollbarLogicalHeight();
    1174    
     1172    if (child.hasOverrideLogicalHeight())
     1173        return child.overrideContentLogicalHeight();
     1174
    11751175    // We don't currently implement the optimization from
    11761176    // https://drafts.csswg.org/css-flexbox/#definite-sizes case 1. While that
    … …  
    11911191        return WTF::nullopt;
    11921192
    1193     return child.hasOverrideContentLogicalHeight() ? Optional<LayoutUnit>(child.overrideContentLogicalHeight() - child.scrollbarLogicalHeight()) : WTF::nullopt;
     1193    return child.hasOverrideLogicalHeight() ? Optional<LayoutUnit>(child.overrideContentLogicalHeight()) : WTF::nullopt;
    11941194}
    11951195
    … …  
    14251425{
    14261426    if (hasOrthogonalFlow(child))
    1427         child.setOverrideContentLogicalHeight(childPreferredSize);
     1427        child.setOverrideLogicalHeight(childPreferredSize + child.borderAndPaddingLogicalHeight());
    14281428    else
    1429         child.setOverrideContentLogicalWidth(childPreferredSize);
     1429        child.setOverrideLogicalWidth(childPreferredSize + child.borderAndPaddingLogicalWidth());
    14301430}
    14311431
    … …  
    18841884            childNeedsRelayout = true;
    18851885        }
    1886         if (childNeedsRelayout || !child.hasOverrideContentLogicalHeight())
    1887             child.setOverrideContentLogicalHeight(desiredLogicalHeight - child.borderAndPaddingLogicalHeight());
     1886        if (childNeedsRelayout || !child.hasOverrideLogicalHeight())
     1887            child.setOverrideLogicalHeight(desiredLogicalHeight);
    18881888        if (childNeedsRelayout) {
    18891889            SetForScope<bool> resetChildLogicalHeight(m_shouldResetChildLogicalHeightBeforeLayout, true);
    … …  
    19061906       
    19071907        if (childWidth != child.logicalWidth()) {
    1908             child.setOverrideContentLogicalWidth(childWidth - child.borderAndPaddingLogicalWidth());
     1908            child.setOverrideLogicalWidth(childWidth);
    19091909            child.setChildNeedsLayout(MarkOnlyThis);
    19101910            child.layoutIfNeeded();

  • trunk/Source/WebCore/rendering/RenderGrid.cpp

    r266173 r268666  
    194194        // FIXME: We should use RenderBlock::hasDefiniteLogicalHeight() but it does not work for positioned stuff.
    195195        // FIXME: Consider caching the hasDefiniteLogicalHeight value throughout the layout.
    196         bool hasDefiniteLogicalHeight = hasOverrideContentLogicalHeight() || computeContentLogicalHeight(MainOrPreferredSize, style().logicalHeight(), WTF::nullopt);
     196        bool hasDefiniteLogicalHeight = hasOverrideLogicalHeight() || computeContentLogicalHeight(MainOrPreferredSize, style().logicalHeight(), WTF::nullopt);
    197197
    198198        m_hasAnyOrthogonalItem = false;
    … …  
    203203            // clear any override height set previously, so it doesn't interfere in current layout
    204204            // execution. Grid never uses the override width, that's why we don't need to clear  it.
    205             child->clearOverrideContentLogicalHeight();
     205            child->clearOverrideLogicalHeight();
    206206
    207207            // We may need to repeat the track sizing in case of any grid item was orthogonal.
    … …  
    11301130    // We clear height override values because we will decide now whether it's allowed or
    11311131    // not, evaluating the conditions which might have changed since the old values were set.
    1132     child.clearOverrideContentLogicalHeight();
     1132    child.clearOverrideLogicalHeight();
    11331133
    11341134    GridTrackSizingDirection childBlockDirection = GridLayoutFunctions::flowAwareDirectionForChild(*this, child, ForRows);
    … …  
    11381138        LayoutUnit stretchedLogicalHeight = availableAlignmentSpaceForChildBeforeStretching(GridLayoutFunctions::overrideContainingBlockContentSizeForChild(child, childBlockDirection).value(), child);
    11391139        LayoutUnit desiredLogicalHeight = child.constrainLogicalHeightByMinMax(stretchedLogicalHeight, -1_lu);
    1140         child.setOverrideContentLogicalHeight(desiredLogicalHeight - child.borderAndPaddingLogicalHeight());
     1140        child.setOverrideLogicalHeight(desiredLogicalHeight);
    11411141        if (desiredLogicalHeight != child.logicalHeight()) {
    11421142            // FIXME: Can avoid laying out here in some cases. See https://webkit.org/b/87905.

  • trunk/Source/WebCore/rendering/RenderRubyBase.cpp

    r248517 r268666  
    6868void RenderRubyBase::adjustInlineDirectionLineBounds(int expansionOpportunityCount, float& logicalLeft, float& logicalWidth) const
    6969{
    70     if (rubyRun()->hasOverrideContentLogicalWidth() && firstRootBox() && !firstRootBox()->nextRootBox()) {
     70    if (rubyRun()->hasOverrideLogicalWidth() && firstRootBox() && !firstRootBox()->nextRootBox()) {
    7171        logicalLeft += m_initialOffset;
    7272        logicalWidth -= 2 * m_initialOffset;
    … …  
    7474    }
    7575
    76     LayoutUnit maxPreferredLogicalWidth = rubyRun() && rubyRun()->hasOverrideContentLogicalWidth() ? rubyRun()->overrideContentLogicalWidth() : this->maxPreferredLogicalWidth();
     76    LayoutUnit maxPreferredLogicalWidth = rubyRun() && rubyRun()->hasOverrideLogicalWidth() ? rubyRun()->overrideLogicalWidth() : this->maxPreferredLogicalWidth();
    7777    if (maxPreferredLogicalWidth >= logicalWidth)
    7878        return;

  • trunk/Source/WebCore/rendering/RenderTable.cpp

    r265746 r268666  
    283283    // Our parent might have set an override content logical width on us, so we must respect it. This
    284284    // is how flexbox containers flex or stretch us.
    285     if (hasOverrideContentLogicalWidth())
    286         setLogicalWidth(std::max(logicalWidth(), overrideContentLogicalWidth()));
     285    if (hasOverrideLogicalWidth())
     286        setLogicalWidth(std::max(logicalWidth(), overrideLogicalWidth()));
    287287
    288288    // Ensure we aren't bigger than our max-width style.

  • trunk/Source/WebCore/rendering/RenderTableCell.cpp

    r266691 r268666  
    331331}
    332332
    333 void RenderTableCell::setOverrideContentLogicalHeightFromRowHeight(LayoutUnit rowHeight)
     333void RenderTableCell::setOverrideLogicalHeightFromRowHeight(LayoutUnit rowHeight)
    334334{
    335335    clearIntrinsicPadding();
    336     setOverrideContentLogicalHeight(std::max<LayoutUnit>(0, rowHeight - borderAndPaddingLogicalHeight()));
     336    setOverrideLogicalHeight(rowHeight);
    337337}
    338338

  • trunk/Source/WebCore/rendering/RenderTableCell.h

    r260415 r268666  
    103103    LayoutUnit paddingAfter() const override;
    104104
    105     void setOverrideContentLogicalHeightFromRowHeight(LayoutUnit);
     105    void setOverrideLogicalHeightFromRowHeight(LayoutUnit);
    106106
    107107    void scrollbarsChanged(bool horizontalScrollbarChanged, bool verticalScrollbarChanged) override;

  • trunk/Source/WebCore/rendering/RenderTableSection.cpp

    r259575 r268666  
    284284                unsigned cellStartRow = cell->rowIndex();
    285285
    286                 if (cell->hasOverrideContentLogicalHeight()) {
     286                if (cell->hasOverrideLogicalHeight()) {
    287287                    cell->clearIntrinsicPadding();
    288288                    cell->clearOverrideContentSize();
    … …  
    523523    // height, which becomes irrelevant once the cell has
    524524    // been resized based off its percentage.
    525     cell.setOverrideContentLogicalHeightFromRowHeight(rowHeight);
     525    cell.setOverrideLogicalHeightFromRowHeight(rowHeight);
    526526    cell.layoutIfNeeded();
    527527   
Note: See TracChangeset for help on using the changeset viewer.