<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[279918] trunk/Source</title>
</head>
<body>

<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt;  }
#msg dl a { font-weight: bold}
#msg dl a:link    { color:#fc3; }
#msg dl a:active  { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff  {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/279918">279918</a></dd>
<dt>Author</dt> <dd>commit-queue@webkit.org</dd>
<dt>Date</dt> <dd>2021-07-14 13:40:50 -0700 (Wed, 14 Jul 2021)</dd>
</dl>

<h3>Log Message</h3>
<pre>Rename hasOverflowClip() to prepare for the real overflow:clip
https://bugs.webkit.org/show_bug.cgi?id=227899

Patch by Rob Buis <rbuis@igalia.com> on 2021-07-14
Reviewed by Simon Fraser.

Rename hasOverflowClip() to prepare for the real overflow:clip.

Source/WebCore:

No new tests since no change in behavior.

* dom/Document.cpp:
(WebCore::Document::isBodyPotentiallyScrollable):
(WebCore::computeIntersectionState):
* dom/Element.cpp:
(WebCore::Element::scrollTo):
(WebCore::Element::scrollByUnits):
* editing/TextIterator.cpp:
(WebCore::fullyClipsContents):
* layout/integration/LayoutIntegrationInlineContentBuilder.cpp:
(WebCore::LayoutIntegration::lineOverflowWidth):
* layout/integration/LayoutIntegrationLineLayout.cpp:
(WebCore::LayoutIntegration::LineLayout::collectOverflow):
* page/ios/FrameIOS.mm:
(WebCore::Frame::nodeRespondingToScrollWheelEvents):
* rendering/LegacyLineLayout.cpp:
(WebCore::LegacyLineLayout::layoutLineBoxes):
(WebCore::LegacyLineLayout::addOverflowFromInlineChildren):
* rendering/RenderBlock.cpp:
(WebCore::OverflowEventDispatcher::OverflowEventDispatcher):
(WebCore::RenderBlock::endAndCommitUpdateScrollInfoAfterLayoutTransaction):
(WebCore::RenderBlock::updateScrollInfoAfterLayout):
(WebCore::RenderBlock::computeOverflow):
(WebCore::RenderBlock::paint):
(WebCore::RenderBlock::isSelectionRoot const):
(WebCore::RenderBlock::nodeAtPoint):
(WebCore::RenderBlock::addFocusRingRects):
* rendering/RenderBlockFlow.cpp:
(WebCore::RenderBlockFlow::layoutBlock):
(WebCore::RenderBlockFlow::adjustForBorderFit const):
* rendering/RenderBlockFlow.h:
(WebCore::RenderBlockFlow::endPaddingWidthForCaret const):
* rendering/RenderBox.cpp:
(WebCore::RenderBox::styleWillChange):
(WebCore::RenderBox::styleDidChange):
(WebCore::RenderBox::updateFromStyle):
(WebCore::RenderBox::scrollWidth const):
(WebCore::RenderBox::scrollHeight const):
(WebCore::RenderBox::scrollLeft const):
(WebCore::RenderBox::scrollTop const):
(WebCore::RenderBox::setScrollLeft):
(WebCore::RenderBox::setScrollTop):
(WebCore::RenderBox::setScrollPosition):
(WebCore::RenderBox::includeVerticalScrollbarSize const):
(WebCore::RenderBox::includeHorizontalScrollbarSize const):
(WebCore::RenderBox::intrinsicScrollbarLogicalWidth const):
(WebCore::RenderBox::requiresLayerWithScrollableArea const):
(WebCore::RenderBox::canBeProgramaticallyScrolled const):
(WebCore::RenderBox::usesCompositedScrolling const):
(WebCore::RenderBox::hasAutoScrollbar const):
(WebCore::RenderBox::hasAlwaysPresentScrollbar const):
(WebCore::RenderBox::scrollPosition const):
(WebCore::RenderBox::cachedSizeForOverflowClip const):
(WebCore::RenderBox::backgroundHasOpaqueTopLayer const):
(WebCore::RenderBox::pushContentsClip):
(WebCore::RenderBox::popContentsClip):
(WebCore::RenderBox::computeVisibleRectInContainer const):
(WebCore::RenderBox::createsNewFormattingContext const):
(WebCore::RenderBox::addOverflowFromChild):
(WebCore::RenderBox::addLayoutOverflow):
(WebCore::RenderBox::layoutOverflowRectForPropagation const):
* rendering/RenderBox.h:
(WebCore::RenderBox::scrollsOverflowX const):
(WebCore::RenderBox::scrollsOverflowY const):
* rendering/RenderBoxModelObject.cpp:
(WebCore::RenderBoxModelObject::paintFillLayerExtended):
(WebCore::RenderBoxModelObject::boxShadowShouldBeAppliedToBackground const):
* rendering/RenderElement.cpp:
(WebCore::RenderElement::styleWillChange):
(WebCore::RenderElement::mayCauseRepaintInsideViewport const):
* rendering/RenderElement.h:
(WebCore::RenderElement::hasClipOrNonVisibleOverflow const):
(WebCore::RenderElement::hasClipOrOverflowClip const): Deleted.
* rendering/RenderFlexibleBox.cpp:
(WebCore::RenderFlexibleBox::hitTestChildren):
* rendering/RenderFragmentContainer.cpp:
(WebCore::RenderFragmentContainer::shouldClipFragmentedFlowContent const):
(WebCore::RenderFragmentContainer::layoutOverflowRectForBoxForPropagation):
* rendering/RenderFragmentedFlow.cpp:
(WebCore::RenderFragmentedFlow::addFragmentsOverflowFromChild):
* rendering/RenderInline.cpp:
(WebCore::RenderInline::clippedOverflowRect const):
(WebCore::RenderInline::computeVisibleRectInContainer const):
* rendering/RenderLayer.cpp:
(WebCore::RenderLayer::shouldBeNormalFlowOnly const):
(WebCore::RenderLayer::updateLayerPositionsAfterScroll):
(WebCore::RenderLayer::enclosingOverflowClipLayer const):
(WebCore::RenderLayer::updateLayerPosition):
(WebCore::RenderLayer::allowsCurrentScroll const):
(WebCore::RenderLayer::canResize const):
(WebCore::RenderLayer::clipToRect):
(WebCore::RenderLayer::setupFontSubpixelQuantization):
(WebCore::RenderLayer::paintLayerContents):
(WebCore::RenderLayer::calculateClipRects const):
(WebCore::outputPaintOrderTreeRecursive):
* rendering/RenderLayerBacking.cpp:
(WebCore::clippingLayerBox):
(WebCore::RenderLayerBacking::updateCompositedBounds):
* rendering/RenderLayerCompositor.cpp:
(WebCore::RenderLayerCompositor::enclosingNonStackingClippingLayer const):
(WebCore::RenderLayerCompositor::computeAncestorClippingStack const):
(WebCore::RenderLayerCompositor::clipsCompositingDescendants):
* rendering/RenderLayerScrollableArea.cpp:
(WebCore::RenderLayerScrollableArea::paintOverflowControls):
(WebCore::RenderLayerScrollableArea::updateScrollCornerStyle):
(WebCore::RenderLayerScrollableArea::updateResizerStyle):
(WebCore::RenderLayerScrollableArea::scrollByRecursively):
* rendering/RenderLayoutState.cpp:
(WebCore::RenderLayoutState::RenderLayoutState):
(WebCore::RenderLayoutState::computeOffsets):
(WebCore::RenderLayoutState::computeClipRect):
* rendering/RenderListItem.cpp:
(WebCore::RenderListItem::paint):
* rendering/RenderListMarker.cpp:
(WebCore::RenderListMarker::addOverflowFromListMarker):
* rendering/RenderMultiColumnSet.cpp:
(WebCore::RenderMultiColumnSet::addOverflowFromChildren):
* rendering/RenderObject.cpp:
(WebCore::RenderObject::enclosingScrollableContainerForSnapping const):
(WebCore::objectIsRelayoutBoundary):
(WebCore::RenderObject::computeVisibleRectInContainer const):
(WebCore::RenderObject::outputRenderObject const):
* rendering/RenderObject.h:
(WebCore::RenderObject::hasNonVisibleOverflow const):
(WebCore::RenderObject::setHasNonVisibleOverflow):
(WebCore::RenderObject::RenderObjectBitfields::RenderObjectBitfields):
(WebCore::RenderObject::hasOverflowClip const): Deleted.
(WebCore::RenderObject::setHasOverflowClip): Deleted.
* rendering/RenderScrollbarPart.cpp:
(WebCore::RenderScrollbarPart::styleDidChange):
* rendering/RenderTable.cpp:
(WebCore::RenderTable::nodeAtPoint):
* rendering/RenderTableRow.h:
* rendering/RenderTableSection.cpp:
(WebCore::RenderTableSection::nodeAtPoint):
* rendering/RenderTextControl.cpp:
(WebCore::RenderTextControl::canScroll const):
* rendering/RenderTextControlSingleLine.cpp:
(WebCore::RenderTextControlSingleLine::styleDidChange):
* rendering/RenderTreeAsText.cpp:
* rendering/svg/RenderSVGBlock.cpp:
(WebCore::RenderSVGBlock::updateFromStyle):

Source/WebKitLegacy/mac:

* DOM/DOMHTML.mm:
(-[DOMHTMLElement scrollXOffset]):
(-[DOMHTMLElement scrollYOffset]):
(-[DOMHTMLElement setScrollXOffset:scrollYOffset:adjustForIOSCaret:]):</pre>

<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCoredomDocumentcpp">trunk/Source/WebCore/dom/Document.cpp</a></li>
<li><a href="#trunkSourceWebCoredomElementcpp">trunk/Source/WebCore/dom/Element.cpp</a></li>
<li><a href="#trunkSourceWebCoreeditingTextIteratorcpp">trunk/Source/WebCore/editing/TextIterator.cpp</a></li>
<li><a href="#trunkSourceWebCorelayoutintegrationLayoutIntegrationInlineContentBuildercpp">trunk/Source/WebCore/layout/integration/LayoutIntegrationInlineContentBuilder.cpp</a></li>
<li><a href="#trunkSourceWebCorelayoutintegrationLayoutIntegrationLineLayoutcpp">trunk/Source/WebCore/layout/integration/LayoutIntegrationLineLayout.cpp</a></li>
<li><a href="#trunkSourceWebCorepageiosFrameIOSmm">trunk/Source/WebCore/page/ios/FrameIOS.mm</a></li>
<li><a href="#trunkSourceWebCorerenderingLegacyLineLayoutcpp">trunk/Source/WebCore/rendering/LegacyLineLayout.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBlockcpp">trunk/Source/WebCore/rendering/RenderBlock.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBlockFlowcpp">trunk/Source/WebCore/rendering/RenderBlockFlow.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBlockFlowh">trunk/Source/WebCore/rendering/RenderBlockFlow.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBoxcpp">trunk/Source/WebCore/rendering/RenderBox.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBoxh">trunk/Source/WebCore/rendering/RenderBox.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBoxModelObjectcpp">trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderElementcpp">trunk/Source/WebCore/rendering/RenderElement.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderElementh">trunk/Source/WebCore/rendering/RenderElement.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderFlexibleBoxcpp">trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderFragmentContainercpp">trunk/Source/WebCore/rendering/RenderFragmentContainer.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderFragmentedFlowcpp">trunk/Source/WebCore/rendering/RenderFragmentedFlow.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderInlinecpp">trunk/Source/WebCore/rendering/RenderInline.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderLayercpp">trunk/Source/WebCore/rendering/RenderLayer.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderLayerBackingcpp">trunk/Source/WebCore/rendering/RenderLayerBacking.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderLayerCompositorcpp">trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderLayerScrollableAreacpp">trunk/Source/WebCore/rendering/RenderLayerScrollableArea.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderLayoutStatecpp">trunk/Source/WebCore/rendering/RenderLayoutState.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderListItemcpp">trunk/Source/WebCore/rendering/RenderListItem.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderListMarkercpp">trunk/Source/WebCore/rendering/RenderListMarker.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderMultiColumnSetcpp">trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderObjectcpp">trunk/Source/WebCore/rendering/RenderObject.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderObjecth">trunk/Source/WebCore/rendering/RenderObject.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderScrollbarPartcpp">trunk/Source/WebCore/rendering/RenderScrollbarPart.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderTablecpp">trunk/Source/WebCore/rendering/RenderTable.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderTableRowh">trunk/Source/WebCore/rendering/RenderTableRow.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderTableSectioncpp">trunk/Source/WebCore/rendering/RenderTableSection.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderTextControlcpp">trunk/Source/WebCore/rendering/RenderTextControl.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderTextControlSingleLinecpp">trunk/Source/WebCore/rendering/RenderTextControlSingleLine.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderTreeAsTextcpp">trunk/Source/WebCore/rendering/RenderTreeAsText.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingsvgRenderSVGBlockcpp">trunk/Source/WebCore/rendering/svg/RenderSVGBlock.cpp</a></li>
<li><a href="#trunkSourceWebKitLegacymacChangeLog">trunk/Source/WebKitLegacy/mac/ChangeLog</a></li>
<li><a href="#trunkSourceWebKitLegacymacDOMDOMHTMLmm">trunk/Source/WebKitLegacy/mac/DOM/DOMHTML.mm</a></li>
</ul>

</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog   2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/ChangeLog      2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -1,3 +1,156 @@
</span><ins>+2021-07-14  Rob Buis  <rbuis@igalia.com>
+
+        Rename hasOverflowClip() to prepare for the real overflow:clip
+        https://bugs.webkit.org/show_bug.cgi?id=227899
+
+        Reviewed by Simon Fraser.
+
+        Rename hasOverflowClip() to prepare for the real overflow:clip.
+
+        No new tests since no change in behavior.
+
+        * dom/Document.cpp:
+        (WebCore::Document::isBodyPotentiallyScrollable):
+        (WebCore::computeIntersectionState):
+        * dom/Element.cpp:
+        (WebCore::Element::scrollTo):
+        (WebCore::Element::scrollByUnits):
+        * editing/TextIterator.cpp:
+        (WebCore::fullyClipsContents):
+        * layout/integration/LayoutIntegrationInlineContentBuilder.cpp:
+        (WebCore::LayoutIntegration::lineOverflowWidth):
+        * layout/integration/LayoutIntegrationLineLayout.cpp:
+        (WebCore::LayoutIntegration::LineLayout::collectOverflow):
+        * page/ios/FrameIOS.mm:
+        (WebCore::Frame::nodeRespondingToScrollWheelEvents):
+        * rendering/LegacyLineLayout.cpp:
+        (WebCore::LegacyLineLayout::layoutLineBoxes):
+        (WebCore::LegacyLineLayout::addOverflowFromInlineChildren):
+        * rendering/RenderBlock.cpp:
+        (WebCore::OverflowEventDispatcher::OverflowEventDispatcher):
+        (WebCore::RenderBlock::endAndCommitUpdateScrollInfoAfterLayoutTransaction):
+        (WebCore::RenderBlock::updateScrollInfoAfterLayout):
+        (WebCore::RenderBlock::computeOverflow):
+        (WebCore::RenderBlock::paint):
+        (WebCore::RenderBlock::isSelectionRoot const):
+        (WebCore::RenderBlock::nodeAtPoint):
+        (WebCore::RenderBlock::addFocusRingRects):
+        * rendering/RenderBlockFlow.cpp:
+        (WebCore::RenderBlockFlow::layoutBlock):
+        (WebCore::RenderBlockFlow::adjustForBorderFit const):
+        * rendering/RenderBlockFlow.h:
+        (WebCore::RenderBlockFlow::endPaddingWidthForCaret const):
+        * rendering/RenderBox.cpp:
+        (WebCore::RenderBox::styleWillChange):
+        (WebCore::RenderBox::styleDidChange):
+        (WebCore::RenderBox::updateFromStyle):
+        (WebCore::RenderBox::scrollWidth const):
+        (WebCore::RenderBox::scrollHeight const):
+        (WebCore::RenderBox::scrollLeft const):
+        (WebCore::RenderBox::scrollTop const):
+        (WebCore::RenderBox::setScrollLeft):
+        (WebCore::RenderBox::setScrollTop):
+        (WebCore::RenderBox::setScrollPosition):
+        (WebCore::RenderBox::includeVerticalScrollbarSize const):
+        (WebCore::RenderBox::includeHorizontalScrollbarSize const):
+        (WebCore::RenderBox::intrinsicScrollbarLogicalWidth const):
+        (WebCore::RenderBox::requiresLayerWithScrollableArea const):
+        (WebCore::RenderBox::canBeProgramaticallyScrolled const):
+        (WebCore::RenderBox::usesCompositedScrolling const):
+        (WebCore::RenderBox::hasAutoScrollbar const):
+        (WebCore::RenderBox::hasAlwaysPresentScrollbar const):
+        (WebCore::RenderBox::scrollPosition const):
+        (WebCore::RenderBox::cachedSizeForOverflowClip const):
+        (WebCore::RenderBox::backgroundHasOpaqueTopLayer const):
+        (WebCore::RenderBox::pushContentsClip):
+        (WebCore::RenderBox::popContentsClip):
+        (WebCore::RenderBox::computeVisibleRectInContainer const):
+        (WebCore::RenderBox::createsNewFormattingContext const):
+        (WebCore::RenderBox::addOverflowFromChild):
+        (WebCore::RenderBox::addLayoutOverflow):
+        (WebCore::RenderBox::layoutOverflowRectForPropagation const):
+        * rendering/RenderBox.h:
+        (WebCore::RenderBox::scrollsOverflowX const):
+        (WebCore::RenderBox::scrollsOverflowY const):
+        * rendering/RenderBoxModelObject.cpp:
+        (WebCore::RenderBoxModelObject::paintFillLayerExtended):
+        (WebCore::RenderBoxModelObject::boxShadowShouldBeAppliedToBackground const):
+        * rendering/RenderElement.cpp:
+        (WebCore::RenderElement::styleWillChange):
+        (WebCore::RenderElement::mayCauseRepaintInsideViewport const):
+        * rendering/RenderElement.h:
+        (WebCore::RenderElement::hasClipOrNonVisibleOverflow const):
+        (WebCore::RenderElement::hasClipOrOverflowClip const): Deleted.
+        * rendering/RenderFlexibleBox.cpp:
+        (WebCore::RenderFlexibleBox::hitTestChildren):
+        * rendering/RenderFragmentContainer.cpp:
+        (WebCore::RenderFragmentContainer::shouldClipFragmentedFlowContent const):
+        (WebCore::RenderFragmentContainer::layoutOverflowRectForBoxForPropagation):
+        * rendering/RenderFragmentedFlow.cpp:
+        (WebCore::RenderFragmentedFlow::addFragmentsOverflowFromChild):
+        * rendering/RenderInline.cpp:
+        (WebCore::RenderInline::clippedOverflowRect const):
+        (WebCore::RenderInline::computeVisibleRectInContainer const):
+        * rendering/RenderLayer.cpp:
+        (WebCore::RenderLayer::shouldBeNormalFlowOnly const):
+        (WebCore::RenderLayer::updateLayerPositionsAfterScroll):
+        (WebCore::RenderLayer::enclosingOverflowClipLayer const):
+        (WebCore::RenderLayer::updateLayerPosition):
+        (WebCore::RenderLayer::allowsCurrentScroll const):
+        (WebCore::RenderLayer::canResize const):
+        (WebCore::RenderLayer::clipToRect):
+        (WebCore::RenderLayer::setupFontSubpixelQuantization):
+        (WebCore::RenderLayer::paintLayerContents):
+        (WebCore::RenderLayer::calculateClipRects const):
+        (WebCore::outputPaintOrderTreeRecursive):
+        * rendering/RenderLayerBacking.cpp:
+        (WebCore::clippingLayerBox):
+        (WebCore::RenderLayerBacking::updateCompositedBounds):
+        * rendering/RenderLayerCompositor.cpp:
+        (WebCore::RenderLayerCompositor::enclosingNonStackingClippingLayer const):
+        (WebCore::RenderLayerCompositor::computeAncestorClippingStack const):
+        (WebCore::RenderLayerCompositor::clipsCompositingDescendants):
+        * rendering/RenderLayerScrollableArea.cpp:
+        (WebCore::RenderLayerScrollableArea::paintOverflowControls):
+        (WebCore::RenderLayerScrollableArea::updateScrollCornerStyle):
+        (WebCore::RenderLayerScrollableArea::updateResizerStyle):
+        (WebCore::RenderLayerScrollableArea::scrollByRecursively):
+        * rendering/RenderLayoutState.cpp:
+        (WebCore::RenderLayoutState::RenderLayoutState):
+        (WebCore::RenderLayoutState::computeOffsets):
+        (WebCore::RenderLayoutState::computeClipRect):
+        * rendering/RenderListItem.cpp:
+        (WebCore::RenderListItem::paint):
+        * rendering/RenderListMarker.cpp:
+        (WebCore::RenderListMarker::addOverflowFromListMarker):
+        * rendering/RenderMultiColumnSet.cpp:
+        (WebCore::RenderMultiColumnSet::addOverflowFromChildren):
+        * rendering/RenderObject.cpp:
+        (WebCore::RenderObject::enclosingScrollableContainerForSnapping const):
+        (WebCore::objectIsRelayoutBoundary):
+        (WebCore::RenderObject::computeVisibleRectInContainer const):
+        (WebCore::RenderObject::outputRenderObject const):
+        * rendering/RenderObject.h:
+        (WebCore::RenderObject::hasNonVisibleOverflow const):
+        (WebCore::RenderObject::setHasNonVisibleOverflow):
+        (WebCore::RenderObject::RenderObjectBitfields::RenderObjectBitfields):
+        (WebCore::RenderObject::hasOverflowClip const): Deleted.
+        (WebCore::RenderObject::setHasOverflowClip): Deleted.
+        * rendering/RenderScrollbarPart.cpp:
+        (WebCore::RenderScrollbarPart::styleDidChange):
+        * rendering/RenderTable.cpp:
+        (WebCore::RenderTable::nodeAtPoint):
+        * rendering/RenderTableRow.h:
+        * rendering/RenderTableSection.cpp:
+        (WebCore::RenderTableSection::nodeAtPoint):
+        * rendering/RenderTextControl.cpp:
+        (WebCore::RenderTextControl::canScroll const):
+        * rendering/RenderTextControlSingleLine.cpp:
+        (WebCore::RenderTextControlSingleLine::styleDidChange):
+        * rendering/RenderTreeAsText.cpp:
+        * rendering/svg/RenderSVGBlock.cpp:
+        (WebCore::RenderSVGBlock::updateFromStyle):
+
</ins><span class="cx"> 2021-07-14  Chris Dumez  <cdumez@apple.com>
</span><span class="cx"> 
</span><span class="cx">         Fix type of exceptions thrown in the WebAudio API
</span></span></pre></div>
<a id="trunkSourceWebCoredomDocumentcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/dom/Document.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/dom/Document.cpp    2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/dom/Document.cpp       2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -1630,7 +1630,7 @@
</span><span class="cx">     //   overflow-x or overflow-y properties is not visible.
</span><span class="cx">     // - The element's used value of the overflow-x or overflow-y properties is not visible.
</span><span class="cx">     //
</span><del>-    // FIXME: We should use RenderObject::hasOverflowClip() instead of Element::computedStyle() but
</del><ins>+    // FIXME: We should use RenderObject::hasNonVisibleOverflow() instead of Element::computedStyle() but
</ins><span class="cx">     // the used values are currently not correctly updated. See https://webkit.org/b/182292.
</span><span class="cx">     return body.renderer()
</span><span class="cx">         && documentElement()->computedStyle()
</span><span class="lines">@@ -7843,7 +7843,7 @@
</span><span class="cx"> 
</span><span class="cx">         if (observer.root() == &target.document())
</span><span class="cx">             localRootBounds = frameView.layoutViewportRect();
</span><del>-        else if (rootRenderer->hasOverflowClip())
</del><ins>+        else if (rootRenderer->hasNonVisibleOverflow())
</ins><span class="cx">             localRootBounds = rootRenderer->contentBoxRect();
</span><span class="cx">         else
</span><span class="cx">             localRootBounds = { FloatPoint(), rootRenderer->size() };
</span></span></pre></div>
<a id="trunkSourceWebCoredomElementcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/dom/Element.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/dom/Element.cpp     2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/dom/Element.cpp        2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -1028,7 +1028,7 @@
</span><span class="cx">     // If the element does not have any associated CSS layout box, the element has no associated scrolling box,
</span><span class="cx">     // or the element has no overflow, terminate these steps.
</span><span class="cx">     RenderBox* renderer = renderBox();
</span><del>-    if (!renderer || !renderer->hasOverflowClip())
</del><ins>+    if (!renderer || !renderer->hasNonVisibleOverflow())
</ins><span class="cx">         return;
</span><span class="cx"> 
</span><span class="cx">     auto scrollToOptions = normalizeNonFiniteCoordinatesOrFallBackTo(options,
</span><span class="lines">@@ -1058,7 +1058,7 @@
</span><span class="cx">     if (!renderer)
</span><span class="cx">         return;
</span><span class="cx"> 
</span><del>-    if (!renderer->hasOverflowClip())
</del><ins>+    if (!renderer->hasNonVisibleOverflow())
</ins><span class="cx">         return;
</span><span class="cx"> 
</span><span class="cx">     ScrollDirection direction = ScrollDown;
</span></span></pre></div>
<a id="trunkSourceWebCoreeditingTextIteratorcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/editing/TextIterator.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/editing/TextIterator.cpp    2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/editing/TextIterator.cpp       2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -201,7 +201,7 @@
</span><span class="cx">     if (!is<RenderBox>(*renderer))
</span><span class="cx">         return false;
</span><span class="cx">     auto& box = downcast<RenderBox>(*renderer);
</span><del>-    if (!box.hasOverflowClip())
</del><ins>+    if (!box.hasNonVisibleOverflow())
</ins><span class="cx">         return false;
</span><span class="cx"> 
</span><span class="cx">     // Quirk to keep copy/paste in the CodeMirror editor version used in Jenkins working.
</span></span></pre></div>
<a id="trunkSourceWebCorelayoutintegrationLayoutIntegrationInlineContentBuildercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/layout/integration/LayoutIntegrationInlineContentBuilder.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/layout/integration/LayoutIntegrationInlineContentBuilder.cpp        2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/layout/integration/LayoutIntegrationInlineContentBuilder.cpp   2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -60,10 +60,10 @@
</span><span class="cx"> inline static float lineOverflowWidth(const RenderBlockFlow& flow, InlineLayoutUnit lineBoxLogicalWidth, InlineLayoutUnit lineContentLogicalWidth)
</span><span class="cx"> {
</span><span class="cx">     // FIXME: It's the copy of the lets-adjust-overflow-for-the-caret behavior from LegacyLineLayout::addOverflowFromInlineChildren.
</span><del>-    auto endPadding = flow.hasOverflowClip() ? flow.paddingEnd() : 0_lu;
</del><ins>+    auto endPadding = flow.hasNonVisibleOverflow() ? flow.paddingEnd() : 0_lu;
</ins><span class="cx">     if (!endPadding)
</span><span class="cx">         endPadding = flow.endPaddingWidthForCaret();
</span><del>-    if (flow.hasOverflowClip() && !endPadding && flow.element() && flow.element()->isRootEditableElement())
</del><ins>+    if (flow.hasNonVisibleOverflow() && !endPadding && flow.element() && flow.element()->isRootEditableElement())
</ins><span class="cx">         endPadding = 1;
</span><span class="cx">     lineContentLogicalWidth += endPadding;
</span><span class="cx">     return std::max(lineBoxLogicalWidth, lineContentLogicalWidth);
</span></span></pre></div>
<a id="trunkSourceWebCorelayoutintegrationLayoutIntegrationLineLayoutcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/layout/integration/LayoutIntegrationLineLayout.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/layout/integration/LayoutIntegrationLineLayout.cpp  2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/layout/integration/LayoutIntegrationLineLayout.cpp     2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -346,7 +346,7 @@
</span><span class="cx"> {
</span><span class="cx">     for (auto& line : inlineContent()->lines) {
</span><span class="cx">         flow().addLayoutOverflow(Layout::toLayoutRect(line.scrollableOverflow()));
</span><del>-        if (!flow().hasOverflowClip())
</del><ins>+        if (!flow().hasNonVisibleOverflow())
</ins><span class="cx">             flow().addVisualOverflow(Layout::toLayoutRect(line.inkOverflow()));
</span><span class="cx">     }
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorepageiosFrameIOSmm"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/page/ios/FrameIOS.mm (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/page/ios/FrameIOS.mm        2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/page/ios/FrameIOS.mm   2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -560,7 +560,7 @@
</span><span class="cx"> 
</span><span class="cx">             auto& style = renderer->style();
</span><span class="cx"> 
</span><del>-            if (renderer->hasOverflowClip()
</del><ins>+            if (renderer->hasNonVisibleOverflow()
</ins><span class="cx">                 && (style.overflowY() == Overflow::Auto || style.overflowY() == Overflow::Scroll
</span><span class="cx">                 || style.overflowX() == Overflow::Auto || style.overflowX() == Overflow::Scroll)) {
</span><span class="cx">                 scrollingAncestor = node;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingLegacyLineLayoutcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/LegacyLineLayout.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/LegacyLineLayout.cpp      2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/LegacyLineLayout.cpp 2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -1718,8 +1718,8 @@
</span><span class="cx">     // difficult to figure out in general (especially in the middle of doing layout), so we only handle the
</span><span class="cx">     // simple case of an anonymous block truncating when it's parent is clipped.
</span><span class="cx">     auto* parent = m_flow.parent();
</span><del>-    bool hasTextOverflow = (style().textOverflow() == TextOverflow::Ellipsis && m_flow.hasOverflowClip())
-        || (m_flow.isAnonymousBlock() && parent && parent->isRenderBlock() && parent->style().textOverflow() == TextOverflow::Ellipsis && parent->hasOverflowClip());
</del><ins>+    bool hasTextOverflow = (style().textOverflow() == TextOverflow::Ellipsis && m_flow.hasNonVisibleOverflow())
+        || (m_flow.isAnonymousBlock() && parent && parent->isRenderBlock() && parent->style().textOverflow() == TextOverflow::Ellipsis && parent->hasNonVisibleOverflow());
</ins><span class="cx"> 
</span><span class="cx">     // Walk all the lines and delete our ellipsis line boxes if they exist.
</span><span class="cx">     if (hasTextOverflow)
</span><span class="lines">@@ -2123,11 +2123,11 @@
</span><span class="cx"> 
</span><span class="cx"> void LegacyLineLayout::addOverflowFromInlineChildren()
</span><span class="cx"> {
</span><del>-    LayoutUnit endPadding = m_flow.hasOverflowClip() ? m_flow.paddingEnd() : 0_lu;
</del><ins>+    LayoutUnit endPadding = m_flow.hasNonVisibleOverflow() ? m_flow.paddingEnd() : 0_lu;
</ins><span class="cx">     // FIXME: Need to find another way to do this, since scrollbars could show when we don't want them to.
</span><span class="cx">     if (!endPadding)
</span><span class="cx">         endPadding = m_flow.endPaddingWidthForCaret();
</span><del>-    if (m_flow.hasOverflowClip() && !endPadding && m_flow.element() && m_flow.element()->isRootEditableElement() && style().isLeftToRightDirection())
</del><ins>+    if (m_flow.hasNonVisibleOverflow() && !endPadding && m_flow.element() && m_flow.element()->isRootEditableElement() && style().isLeftToRightDirection())
</ins><span class="cx">         endPadding = 1;
</span><span class="cx">     for (auto* curr = firstRootBox(); curr; curr = curr->nextRootBox()) {
</span><span class="cx">         m_flow.addLayoutOverflow(curr->paddedLayoutOverflowRect(endPadding));
</span><span class="lines">@@ -2134,7 +2134,7 @@
</span><span class="cx">         RenderFragmentContainer* fragment = m_flow.enclosingFragmentedFlow() ? curr->containingFragment() : nullptr;
</span><span class="cx">         if (fragment)
</span><span class="cx">             fragment->addLayoutOverflowForBox(&m_flow, curr->paddedLayoutOverflowRect(endPadding));
</span><del>-        if (!m_flow.hasOverflowClip()) {
</del><ins>+        if (!m_flow.hasNonVisibleOverflow()) {
</ins><span class="cx">             LayoutRect childVisualOverflowRect = curr->visualOverflowRect(curr->lineTop(), curr->lineBottom());
</span><span class="cx">             m_flow.addVisualOverflow(childVisualOverflowRect);
</span><span class="cx">             if (fragment)
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBlockcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBlock.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBlock.cpp   2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderBlock.cpp      2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -275,7 +275,7 @@
</span><span class="cx">         , m_hadHorizontalLayoutOverflow(false)
</span><span class="cx">         , m_hadVerticalLayoutOverflow(false)
</span><span class="cx">     {
</span><del>-        m_shouldDispatchEvent = !m_block->isAnonymous() && m_block->hasOverflowClip() && m_block->document().hasListenerType(Document::OVERFLOWCHANGED_LISTENER);
</del><ins>+        m_shouldDispatchEvent = !m_block->isAnonymous() && m_block->hasNonVisibleOverflow() && m_block->document().hasListenerType(Document::OVERFLOWCHANGED_LISTENER);
</ins><span class="cx">         if (m_shouldDispatchEvent) {
</span><span class="cx">             m_hadHorizontalLayoutOverflow = m_block->hasHorizontalLayoutOverflow();
</span><span class="cx">             m_hadVerticalLayoutOverflow = m_block->hasVerticalLayoutOverflow();
</span><span class="lines">@@ -551,7 +551,7 @@
</span><span class="cx">         updateScrollInfoAfterLayoutTransactionStack() = nullptr;
</span><span class="cx"> 
</span><span class="cx">     for (auto* block : blocksToUpdate) {
</span><del>-        ASSERT(block->hasOverflowClip());
</del><ins>+        ASSERT(block->hasNonVisibleOverflow());
</ins><span class="cx">         block->layer()->updateScrollInfoAfterLayout();
</span><span class="cx">     }
</span><span class="cx"> }
</span><span class="lines">@@ -568,7 +568,7 @@
</span><span class="cx"> 
</span><span class="cx"> void RenderBlock::updateScrollInfoAfterLayout()
</span><span class="cx"> {
</span><del>-    if (!hasOverflowClip())
</del><ins>+    if (!hasNonVisibleOverflow())
</ins><span class="cx">         return;
</span><span class="cx">     
</span><span class="cx">     // FIXME: https://bugs.webkit.org/show_bug.cgi?id=97937
</span><span class="lines">@@ -691,7 +691,7 @@
</span><span class="cx"> 
</span><span class="cx">     addOverflowFromPositionedObjects();
</span><span class="cx"> 
</span><del>-    if (hasOverflowClip()) {
</del><ins>+    if (hasNonVisibleOverflow()) {
</ins><span class="cx">         // When we have overflow clip, propagate the original spillout since it will include collapsed bottom margins
</span><span class="cx">         // and bottom padding.  Set the axis we don't care about to be 1, since we want this overflow to always
</span><span class="cx">         // be considered reachable.
</span><span class="lines">@@ -1134,7 +1134,7 @@
</span><span class="cx">     // Our scrollbar widgets paint exactly when we tell them to, so that they work properly with
</span><span class="cx">     // z-index. We paint after we painted the background/border, so that the scrollbars will
</span><span class="cx">     // sit above the background/border.
</span><del>-    if ((phase == PaintPhase::BlockBackground || phase == PaintPhase::ChildBlockBackground) && hasOverflowClip() && layer()
</del><ins>+    if ((phase == PaintPhase::BlockBackground || phase == PaintPhase::ChildBlockBackground) && hasNonVisibleOverflow() && layer()
</ins><span class="cx">         && layer()->scrollableArea() && style().visibility() == Visibility::Visible && paintInfo.shouldPaintWithinRoot(*this) && !paintInfo.paintRootBackgroundOnly())
</span><span class="cx">         layer()->scrollableArea()->paintOverflowControls(paintInfo.context(), roundedIntPoint(adjustedPaintOffset), snappedIntRect(paintInfo.rect));
</span><span class="cx"> }
</span><span class="lines">@@ -1451,7 +1451,7 @@
</span><span class="cx">     if (isTable())
</span><span class="cx">         return false;
</span><span class="cx">         
</span><del>-    if (isBody() || isDocumentElementRenderer() || hasOverflowClip()
</del><ins>+    if (isBody() || isDocumentElementRenderer() || hasNonVisibleOverflow()
</ins><span class="cx">         || isPositioned() || isFloating()
</span><span class="cx">         || isTableCell() || isInlineBlockOrInlineTable()
</span><span class="cx">         || hasTransform() || hasReflection() || hasMask() || isWritingModeRoot()
</span><span class="lines">@@ -2076,7 +2076,7 @@
</span><span class="cx">         return false;
</span><span class="cx"> 
</span><span class="cx">     // If we have clipping, then we can't have any spillout.
</span><del>-    bool useClip = (hasControlClip() || hasOverflowClip());
</del><ins>+    bool useClip = (hasControlClip() || hasNonVisibleOverflow());
</ins><span class="cx">     bool checkChildren = !useClip || (hasControlClip() ? locationInContainer.intersects(controlClipRect(adjustedLocation)) : locationInContainer.intersects(overflowClipRect(adjustedLocation, nullptr, IncludeOverlayScrollbarSize)));
</span><span class="cx">     if (checkChildren && hitTestChildren(request, result, locationInContainer, adjustedLocation, hitTestAction))
</span><span class="cx">         return true;
</span><span class="lines">@@ -2853,7 +2853,7 @@
</span><span class="cx">     } else if (width() && height())
</span><span class="cx">         rects.append(LayoutRect(additionalOffset, size()));
</span><span class="cx"> 
</span><del>-    if (!hasOverflowClip() && !hasControlClip()) {
</del><ins>+    if (!hasNonVisibleOverflow() && !hasControlClip()) {
</ins><span class="cx">         if (childrenInline())
</span><span class="cx">             addFocusRingRectsForInlineChildren(rects, additionalOffset, paintContainer);
</span><span class="cx">     
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBlockFlowcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBlockFlow.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBlockFlow.cpp       2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderBlockFlow.cpp  2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -589,12 +589,12 @@
</span><span class="cx">     bool didFullRepaint = repainter.repaintAfterLayout();
</span><span class="cx">     if (!didFullRepaint && repaintLogicalTop != repaintLogicalBottom && (styleToUse.visibility() == Visibility::Visible || enclosingLayer()->hasVisibleContent())) {
</span><span class="cx">         // FIXME: We could tighten up the left and right invalidation points if we let layoutInlineChildren fill them in based off the particular lines
</span><del>-        // it had to lay out. We wouldn't need the hasOverflowClip() hack in that case either.
</del><ins>+        // it had to lay out. We wouldn't need the hasNonVisibleOverflow() hack in that case either.
</ins><span class="cx">         LayoutUnit repaintLogicalLeft = logicalLeftVisualOverflow();
</span><span class="cx">         LayoutUnit repaintLogicalRight = logicalRightVisualOverflow();
</span><del>-        if (hasOverflowClip()) {
</del><ins>+        if (hasNonVisibleOverflow()) {
</ins><span class="cx">             // If we have clipped overflow, we should use layout overflow as well, since visual overflow from lines didn't propagate to our block's overflow.
</span><del>-            // Note the old code did this as well but even for overflow:visible. The addition of hasOverflowClip() at least tightens up the hack a bit.
</del><ins>+            // Note the old code did this as well but even for overflow:visible. The addition of hasNonVisibleOverflow() at least tightens up the hack a bit.
</ins><span class="cx">             // layoutInlineChildren should be patched to compute the entire repaint rect.
</span><span class="cx">             repaintLogicalLeft = std::min(repaintLogicalLeft, logicalLeftLayoutOverflow());
</span><span class="cx">             repaintLogicalRight = std::max(repaintLogicalRight, logicalRightLayoutOverflow());
</span><span class="lines">@@ -606,7 +606,7 @@
</span><span class="cx">         else
</span><span class="cx">             repaintRect = LayoutRect(repaintLogicalTop, repaintLogicalLeft, repaintLogicalBottom - repaintLogicalTop, repaintLogicalRight - repaintLogicalLeft);
</span><span class="cx"> 
</span><del>-        if (hasOverflowClip()) {
</del><ins>+        if (hasNonVisibleOverflow()) {
</ins><span class="cx">             // Adjust repaint rect for scroll offset
</span><span class="cx">             repaintRect.moveBy(-scrollPosition());
</span><span class="cx"> 
</span><span class="lines">@@ -3052,7 +3052,7 @@
</span><span class="cx">     } else {
</span><span class="cx">         for (RenderBox* obj = firstChildBox(); obj; obj = obj->nextSiblingBox()) {
</span><span class="cx">             if (!obj->isFloatingOrOutOfFlowPositioned()) {
</span><del>-                if (is<RenderBlockFlow>(*obj) && !obj->hasOverflowClip())
</del><ins>+                if (is<RenderBlockFlow>(*obj) && !obj->hasNonVisibleOverflow())
</ins><span class="cx">                     downcast<RenderBlockFlow>(*obj).adjustForBorderFit(x + obj->x(), left, right);
</span><span class="cx">                 else if (obj->style().visibility() == Visibility::Visible) {
</span><span class="cx">                     // We are a replaced element or some kind of non-block-flow object.
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBlockFlowh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBlockFlow.h (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBlockFlow.h 2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderBlockFlow.h    2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -637,7 +637,7 @@
</span><span class="cx"> 
</span><span class="cx"> inline LayoutUnit RenderBlockFlow::endPaddingWidthForCaret() const
</span><span class="cx"> {
</span><del>-    if (element() && element()->isRootEditableElement() && hasOverflowClip() && style().isLeftToRightDirection() && !paddingEnd())
</del><ins>+    if (element() && element()->isRootEditableElement() && hasNonVisibleOverflow() && style().isLeftToRightDirection() && !paddingEnd())
</ins><span class="cx">         return caretWidth;
</span><span class="cx">     return { };
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBoxcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBox.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBox.cpp     2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderBox.cpp        2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -132,7 +132,7 @@
</span><span class="cx">     controlStatesRendererMap().remove(&renderer);
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-bool RenderBox::s_hadOverflowClip = false;
</del><ins>+bool RenderBox::s_hadNonVisibleOverflow = false;
</ins><span class="cx"> 
</span><span class="cx"> RenderBox::RenderBox(Element& element, RenderStyle&& style, BaseTypeFlags baseTypeFlags)
</span><span class="cx">     : RenderBoxModelObject(element, WTFMove(style), baseTypeFlags)
</span><span class="lines">@@ -254,7 +254,7 @@
</span><span class="cx"> 
</span><span class="cx"> void RenderBox::styleWillChange(StyleDifference diff, const RenderStyle& newStyle)
</span><span class="cx"> {
</span><del>-    s_hadOverflowClip = hasOverflowClip();
</del><ins>+    s_hadNonVisibleOverflow = hasNonVisibleOverflow();
</ins><span class="cx"> 
</span><span class="cx">     const RenderStyle* oldStyle = hasInitializedStyle() ? &style() : nullptr;
</span><span class="cx">     if (oldStyle) {
</span><span class="lines">@@ -316,7 +316,7 @@
</span><span class="cx"> 
</span><span class="cx">     // If our zoom factor changes and we have a defined scrollLeft/Top, we need to adjust that value into the
</span><span class="cx">     // new zoomed coordinate space.
</span><del>-    if (hasOverflowClip() && layer() && oldStyle && oldStyle->effectiveZoom() != newStyle.effectiveZoom()) {
</del><ins>+    if (hasNonVisibleOverflow() && layer() && oldStyle && oldStyle->effectiveZoom() != newStyle.effectiveZoom()) {
</ins><span class="cx">         if (auto* scrollableArea = layer()->scrollableArea()) {
</span><span class="cx">             ScrollPosition scrollPosition = scrollableArea->scrollPosition();
</span><span class="cx">             float zoomScaleFactor = newStyle.effectiveZoom() / oldStyle->effectiveZoom();
</span><span class="lines">@@ -483,7 +483,7 @@
</span><span class="cx"> 
</span><span class="cx">     // We also handle <body> and <html>, whose overflow applies to the viewport.
</span><span class="cx">     if (styleToUse.overflowX() != Overflow::Visible && !isDocElementRenderer && isRenderBlock()) {
</span><del>-        bool boxHasOverflowClip = true;
</del><ins>+        bool boxHasNonVisibleOverflow = true;
</ins><span class="cx">         if (isBody()) {
</span><span class="cx">             // Overflow on the body can propagate to the viewport under the following conditions.
</span><span class="cx">             // (1) The root element is <html>.
</span><span class="lines">@@ -492,13 +492,13 @@
</span><span class="cx">             if (is<HTMLHtmlElement>(*document().documentElement())
</span><span class="cx">                 && document().body() == element()
</span><span class="cx">                 && document().documentElement()->renderer()->style().overflowX() == Overflow::Visible) {
</span><del>-                boxHasOverflowClip = false;
</del><ins>+                boxHasNonVisibleOverflow = false;
</ins><span class="cx">             }
</span><span class="cx">         }
</span><span class="cx">         // Check for overflow clip.
</span><span class="cx">         // It's sufficient to just check one direction, since it's illegal to have visible on only one overflow value.
</span><del>-        if (boxHasOverflowClip) {
-            if (!s_hadOverflowClip && hasRenderOverflow()) {
</del><ins>+        if (boxHasNonVisibleOverflow) {
+            if (!s_hadNonVisibleOverflow && hasRenderOverflow()) {
</ins><span class="cx">                 // Erase the overflow.
</span><span class="cx">                 // Overflow changes have to result in immediate repaints of the entire layout overflow area because
</span><span class="cx">                 // repaints issued by removal of descendants get clipped using the updated style when they shouldn't.
</span><span class="lines">@@ -505,7 +505,7 @@
</span><span class="cx">                 repaintRectangle(visualOverflowRect());
</span><span class="cx">                 repaintRectangle(layoutOverflowRect());
</span><span class="cx">             }
</span><del>-            setHasOverflowClip();
</del><ins>+            setHasNonVisibleOverflow();
</ins><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx">     setHasTransformRelatedProperty(styleToUse.hasTransformRelatedProperty());
</span><span class="lines">@@ -548,7 +548,7 @@
</span><span class="cx"> 
</span><span class="cx"> int RenderBox::scrollWidth() const
</span><span class="cx"> {
</span><del>-    if (hasOverflowClip() && layer())
</del><ins>+    if (hasNonVisibleOverflow() && layer())
</ins><span class="cx">         return layer()->scrollWidth();
</span><span class="cx">     // For objects with visible overflow, this matches IE.
</span><span class="cx">     // FIXME: Need to work right with writing modes.
</span><span class="lines">@@ -561,7 +561,7 @@
</span><span class="cx"> 
</span><span class="cx"> int RenderBox::scrollHeight() const
</span><span class="cx"> {
</span><del>-    if (hasOverflowClip() && layer())
</del><ins>+    if (hasNonVisibleOverflow() && layer())
</ins><span class="cx">         return layer()->scrollHeight();
</span><span class="cx">     // For objects with visible overflow, this matches IE.
</span><span class="cx">     // FIXME: Need to work right with writing modes.
</span><span class="lines">@@ -572,13 +572,13 @@
</span><span class="cx"> int RenderBox::scrollLeft() const
</span><span class="cx"> {
</span><span class="cx">     auto* scrollableArea = layer() ? layer()->scrollableArea() : nullptr;
</span><del>-    return (hasOverflowClip() && scrollableArea) ? scrollableArea->scrollPosition().x() : 0;
</del><ins>+    return (hasNonVisibleOverflow() && scrollableArea) ? scrollableArea->scrollPosition().x() : 0;
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> int RenderBox::scrollTop() const
</span><span class="cx"> {
</span><span class="cx">     auto* scrollableArea = layer() ? layer()->scrollableArea() : nullptr;
</span><del>-    return (hasOverflowClip() && scrollableArea) ? scrollableArea->scrollPosition().y() : 0;
</del><ins>+    return (hasNonVisibleOverflow() && scrollableArea) ? scrollableArea->scrollPosition().y() : 0;
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void RenderBox::resetLogicalHeightBeforeLayoutIfNeeded()
</span><span class="lines">@@ -597,7 +597,7 @@
</span><span class="cx"> 
</span><span class="cx"> void RenderBox::setScrollLeft(int newLeft, const ScrollPositionChangeOptions& options)
</span><span class="cx"> {
</span><del>-    if (!hasOverflowClip() || !layer())
</del><ins>+    if (!hasNonVisibleOverflow() || !layer())
</ins><span class="cx">         return;
</span><span class="cx">     auto* scrollableArea = layer()->scrollableArea();
</span><span class="cx">     ASSERT(scrollableArea);
</span><span class="lines">@@ -607,7 +607,7 @@
</span><span class="cx"> 
</span><span class="cx"> void RenderBox::setScrollTop(int newTop, const ScrollPositionChangeOptions& options)
</span><span class="cx"> {
</span><del>-    if (!hasOverflowClip() || !layer())
</del><ins>+    if (!hasNonVisibleOverflow() || !layer())
</ins><span class="cx">         return;
</span><span class="cx">     auto* scrollableArea = layer()->scrollableArea();
</span><span class="cx">     ASSERT(scrollableArea);
</span><span class="lines">@@ -617,7 +617,7 @@
</span><span class="cx"> 
</span><span class="cx"> void RenderBox::setScrollPosition(const ScrollPosition& position, const ScrollPositionChangeOptions& options)
</span><span class="cx"> {
</span><del>-    if (!hasOverflowClip() || !layer())
</del><ins>+    if (!hasNonVisibleOverflow() || !layer())
</ins><span class="cx">         return;
</span><span class="cx">     auto* scrollableArea = layer()->scrollableArea();
</span><span class="cx">     ASSERT(scrollableArea);
</span><span class="lines">@@ -841,13 +841,13 @@
</span><span class="cx"> 
</span><span class="cx"> bool RenderBox::includeVerticalScrollbarSize() const
</span><span class="cx"> {
</span><del>-    return hasOverflowClip() && layer() && !layer()->hasOverlayScrollbars()
</del><ins>+    return hasNonVisibleOverflow() && layer() && !layer()->hasOverlayScrollbars()
</ins><span class="cx">         && (style().overflowY() == Overflow::Scroll || style().overflowY() == Overflow::Auto);
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> bool RenderBox::includeHorizontalScrollbarSize() const
</span><span class="cx"> {
</span><del>-    return hasOverflowClip() && layer() && !layer()->hasOverlayScrollbars()
</del><ins>+    return hasNonVisibleOverflow() && layer() && !layer()->hasOverlayScrollbars()
</ins><span class="cx">         && (style().overflowX() == Overflow::Scroll || style().overflowX() == Overflow::Auto);
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="lines">@@ -869,7 +869,7 @@
</span><span class="cx"> 
</span><span class="cx"> int RenderBox::intrinsicScrollbarLogicalWidth() const
</span><span class="cx"> {
</span><del>-    if (!hasOverflowClip())
</del><ins>+    if (!hasNonVisibleOverflow())
</ins><span class="cx">         return 0;
</span><span class="cx"> 
</span><span class="cx">     if (isHorizontalWritingMode() && (style().overflowY() == Overflow::Scroll && !canUseOverlayScrollbars())) {
</span><span class="lines">@@ -959,7 +959,7 @@
</span><span class="cx">     if (isRenderView() || isDocumentElementRenderer())
</span><span class="cx">         return true;
</span><span class="cx"> 
</span><del>-    if (hasOverflowClip())
</del><ins>+    if (hasNonVisibleOverflow())
</ins><span class="cx">         return true;
</span><span class="cx"> 
</span><span class="cx">     if (style().resize() != Resize::None)
</span><span class="lines">@@ -977,7 +977,7 @@
</span><span class="cx">     if (isRenderView())
</span><span class="cx">         return true;
</span><span class="cx"> 
</span><del>-    if (!hasOverflowClip())
</del><ins>+    if (!hasNonVisibleOverflow())
</ins><span class="cx">         return false;
</span><span class="cx"> 
</span><span class="cx">     if (hasScrollableOverflowX() || hasScrollableOverflowY())
</span><span class="lines">@@ -988,7 +988,7 @@
</span><span class="cx"> 
</span><span class="cx"> bool RenderBox::usesCompositedScrolling() const
</span><span class="cx"> {
</span><del>-    return hasOverflowClip() && hasLayer() && layer()->usesCompositedScrolling();
</del><ins>+    return hasNonVisibleOverflow() && hasLayer() && layer()->usesCompositedScrolling();
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void RenderBox::autoscroll(const IntPoint& position)
</span><span class="lines">@@ -1058,7 +1058,7 @@
</span><span class="cx"> 
</span><span class="cx"> bool RenderBox::hasAutoScrollbar(ScrollbarOrientation orientation) const
</span><span class="cx"> {
</span><del>-    if (!hasOverflowClip())
</del><ins>+    if (!hasNonVisibleOverflow())
</ins><span class="cx">         return false;
</span><span class="cx"> 
</span><span class="cx">     auto isAutoOrScrollWithOverlayScrollbar = [&](Overflow overflow) {
</span><span class="lines">@@ -1076,7 +1076,7 @@
</span><span class="cx"> 
</span><span class="cx"> bool RenderBox::hasAlwaysPresentScrollbar(ScrollbarOrientation orientation) const
</span><span class="cx"> {
</span><del>-    if (!hasOverflowClip())
</del><ins>+    if (!hasNonVisibleOverflow())
</ins><span class="cx">         return false;
</span><span class="cx"> 
</span><span class="cx">     auto isAlwaysVisibleScrollbar = [&](Overflow overflow) {
</span><span class="lines">@@ -1099,7 +1099,7 @@
</span><span class="cx"> 
</span><span class="cx"> ScrollPosition RenderBox::scrollPosition() const
</span><span class="cx"> {
</span><del>-    if (!hasOverflowClip())
</del><ins>+    if (!hasNonVisibleOverflow())
</ins><span class="cx">         return { 0, 0 };
</span><span class="cx"> 
</span><span class="cx">     ASSERT(hasLayer());
</span><span class="lines">@@ -1112,7 +1112,7 @@
</span><span class="cx"> 
</span><span class="cx"> LayoutSize RenderBox::cachedSizeForOverflowClip() const
</span><span class="cx"> {
</span><del>-    ASSERT(hasOverflowClip());
</del><ins>+    ASSERT(hasNonVisibleOverflow());
</ins><span class="cx">     ASSERT(hasLayer());
</span><span class="cx">     return layer()->size();
</span><span class="cx"> }
</span><span class="lines">@@ -1744,7 +1744,7 @@
</span><span class="cx">         return false;
</span><span class="cx"> 
</span><span class="cx">     // Clipped with local scrolling
</span><del>-    if (hasOverflowClip() && fillLayer.attachment() == FillAttachment::LocalBackground)
</del><ins>+    if (hasNonVisibleOverflow() && fillLayer.attachment() == FillAttachment::LocalBackground)
</ins><span class="cx">         return false;
</span><span class="cx"> 
</span><span class="cx">     if (fillLayer.hasOpaqueImage(*this) && fillLayer.hasRepeatXY() && fillLayer.image()->canRender(this, style().effectiveZoom()))
</span><span class="lines">@@ -2000,7 +2000,7 @@
</span><span class="cx">         return false;
</span><span class="cx"> 
</span><span class="cx">     bool isControlClip = hasControlClip();
</span><del>-    bool isOverflowClip = hasOverflowClip() && !layer()->isSelfPaintingLayer();
</del><ins>+    bool isOverflowClip = hasNonVisibleOverflow() && !layer()->isSelfPaintingLayer();
</ins><span class="cx">     
</span><span class="cx">     if (!isControlClip && !isOverflowClip)
</span><span class="cx">         return false;
</span><span class="lines">@@ -2027,7 +2027,7 @@
</span><span class="cx"> 
</span><span class="cx"> void RenderBox::popContentsClip(PaintInfo& paintInfo, PaintPhase originalPhase, const LayoutPoint& accumulatedOffset)
</span><span class="cx"> {
</span><del>-    ASSERT(hasControlClip() || (hasOverflowClip() && !layer()->isSelfPaintingLayer()));
</del><ins>+    ASSERT(hasControlClip() || (hasNonVisibleOverflow() && !layer()->isSelfPaintingLayer()));
</ins><span class="cx"> 
</span><span class="cx">     if (paintInfo.phase == PaintPhase::EventRegion)
</span><span class="cx">         paintInfo.eventRegionContext->popClip();
</span><span class="lines">@@ -2515,7 +2515,7 @@
</span><span class="cx">     // FIXME: We ignore the lightweight clipping rect that controls use, since if |o| is in mid-layout,
</span><span class="cx">     // its controlClipRect will be wrong. For overflow clip we use the values cached by the layer.
</span><span class="cx">     adjustedRect.setLocation(topLeft);
</span><del>-    if (localContainer->hasOverflowClip()) {
</del><ins>+    if (localContainer->hasNonVisibleOverflow()) {
</ins><span class="cx">         RenderBox& containerBox = downcast<RenderBox>(*localContainer);
</span><span class="cx">         bool isEmpty = !containerBox.applyCachedClipAndScrollPosition(adjustedRect, container, context);
</span><span class="cx">         if (isEmpty) {
</span><span class="lines">@@ -4786,7 +4786,7 @@
</span><span class="cx"> 
</span><span class="cx"> bool RenderBox::createsNewFormattingContext() const
</span><span class="cx"> {
</span><del>-    return isInlineBlockOrInlineTable() || isFloatingOrOutOfFlowPositioned() || hasOverflowClip() || isFlexItemIncludingDeprecated()
</del><ins>+    return isInlineBlockOrInlineTable() || isFloatingOrOutOfFlowPositioned() || hasNonVisibleOverflow() || isFlexItemIncludingDeprecated()
</ins><span class="cx">         || isTableCell() || isTableCaption() || isFieldset() || isWritingModeRoot() || isDocumentElementRenderer() || isRenderFragmentedFlow() || isRenderFragmentContainer()
</span><span class="cx">         || style().containsLayout() || isGridItem() || style().specifiesColumns() || style().columnSpan() == ColumnSpan::All || style().display() == DisplayType::FlowRoot;
</span><span class="cx"> }
</span><span class="lines">@@ -4874,7 +4874,7 @@
</span><span class="cx">     // Add in visual overflow from the child.  Even if the child clips its overflow, it may still
</span><span class="cx">     // have visual overflow of its own set from box shadows or reflections. It is unnecessary to propagate this
</span><span class="cx">     // overflow if we are clipping our own overflow.
</span><del>-    if (child->hasSelfPaintingLayer() || hasOverflowClip())
</del><ins>+    if (child->hasSelfPaintingLayer() || hasNonVisibleOverflow())
</ins><span class="cx">         return;
</span><span class="cx">     LayoutRect childVisualOverflowRect = child->visualOverflowRectForPropagation(&style());
</span><span class="cx">     childVisualOverflowRect.move(delta);
</span><span class="lines">@@ -4889,7 +4889,7 @@
</span><span class="cx">     
</span><span class="cx">     // For overflow clip objects, we don't want to propagate overflow into unreachable areas.
</span><span class="cx">     LayoutRect overflowRect(rect);
</span><del>-    if (hasOverflowClip() || isRenderView()) {
</del><ins>+    if (hasNonVisibleOverflow() || isRenderView()) {
</ins><span class="cx">         // Overflow is in the block's coordinate space and thus is flipped for horizontal-bt and vertical-rl 
</span><span class="cx">         // writing modes. At this stage that is actually a simplification, since we can treat horizontal-tb/bt as the same
</span><span class="cx">         // and vertical-lr/rl as the same.
</span><span class="lines">@@ -5036,7 +5036,7 @@
</span><span class="cx"> {
</span><span class="cx">     // Only propagate interior layout overflow if we don't clip it.
</span><span class="cx">     LayoutRect rect = borderBoxRect();
</span><del>-    if (!shouldApplyLayoutContainment(*this) && !hasOverflowClip())
</del><ins>+    if (!shouldApplyLayoutContainment(*this) && !hasNonVisibleOverflow())
</ins><span class="cx">         rect.unite(layoutOverflowRect());
</span><span class="cx"> 
</span><span class="cx">     bool hasTransform = this->hasTransform();
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBoxh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBox.h (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBox.h       2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderBox.h  2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -52,7 +52,7 @@
</span><span class="cx">     // position:static elements that are not flex-items get their z-index coerced to auto.
</span><span class="cx">     bool requiresLayer() const override
</span><span class="cx">     {
</span><del>-        return isDocumentElementRenderer() || isPositioned() || createsGroup() || hasOverflowClip()
</del><ins>+        return isDocumentElementRenderer() || isPositioned() || createsGroup() || hasNonVisibleOverflow()
</ins><span class="cx">             || hasTransformRelatedProperty() || hasHiddenBackface() || hasReflection() || style().specifiesColumns()
</span><span class="cx">             || style().containsLayout() || !style().hasAutoUsedZIndex() || hasRunningAcceleratedAnimations();
</span><span class="cx">     }
</span><span class="lines">@@ -490,8 +490,8 @@
</span><span class="cx">     bool hasAlwaysPresentScrollbar(ScrollbarOrientation) const;
</span><span class="cx"> 
</span><span class="cx">     bool scrollsOverflow() const { return scrollsOverflowX() || scrollsOverflowY(); }
</span><del>-    bool scrollsOverflowX() const { return hasOverflowClip() && (style().overflowX() == Overflow::Scroll || style().overflowX() == Overflow::Auto); }
-    bool scrollsOverflowY() const { return hasOverflowClip() && (style().overflowY() == Overflow::Scroll || style().overflowY() == Overflow::Auto); }
</del><ins>+    bool scrollsOverflowX() const { return hasNonVisibleOverflow() && (style().overflowX() == Overflow::Scroll || style().overflowX() == Overflow::Auto); }
+    bool scrollsOverflowY() const { return hasNonVisibleOverflow() && (style().overflowY() == Overflow::Scroll || style().overflowY() == Overflow::Auto); }
</ins><span class="cx"> 
</span><span class="cx">     bool hasHorizontalOverflow() const { return scrollWidth() != roundToInt(paddingBoxWidth()); }
</span><span class="cx">     bool hasVerticalOverflow() const { return scrollHeight() != roundToInt(paddingBoxHeight()); }
</span><span class="lines">@@ -791,7 +791,7 @@
</span><span class="cx"> 
</span><span class="cx"> private:
</span><span class="cx">     // Used to store state between styleWillChange and styleDidChange
</span><del>-    static bool s_hadOverflowClip;
</del><ins>+    static bool s_hadNonVisibleOverflow;
</ins><span class="cx"> };
</span><span class="cx"> 
</span><span class="cx"> inline RenderBox* RenderBox::parentBox() const
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBoxModelObjectcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp  2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp     2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -727,7 +727,7 @@
</span><span class="cx">     bool includeRightEdge = box ? box->includeLogicalRightEdge() : true;
</span><span class="cx"> 
</span><span class="cx">     bool hasRoundedBorder = style().hasBorderRadius() && (includeLeftEdge || includeRightEdge);
</span><del>-    bool clippedWithLocalScrolling = hasOverflowClip() && bgLayer.attachment() == FillAttachment::LocalBackground;
</del><ins>+    bool clippedWithLocalScrolling = hasNonVisibleOverflow() && bgLayer.attachment() == FillAttachment::LocalBackground;
</ins><span class="cx">     bool isBorderFill = bgLayer.clip() == FillBox::Border;
</span><span class="cx">     bool isRoot = this->isDocumentElementRenderer();
</span><span class="cx"> 
</span><span class="lines">@@ -2360,7 +2360,7 @@
</span><span class="cx">     if (inlineFlowBox && !inlineFlowBox->boxShadowCanBeAppliedToBackground(*lastBackgroundLayer))
</span><span class="cx">         return false;
</span><span class="cx"> 
</span><del>-    if (hasOverflowClip() && lastBackgroundLayer->attachment() == FillAttachment::LocalBackground)
</del><ins>+    if (hasNonVisibleOverflow() && lastBackgroundLayer->attachment() == FillAttachment::LocalBackground)
</ins><span class="cx">         return false;
</span><span class="cx"> 
</span><span class="cx">     return true;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderElementcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderElement.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderElement.cpp 2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderElement.cpp    2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -893,7 +893,7 @@
</span><span class="cx"> 
</span><span class="cx">         setHorizontalWritingMode(true);
</span><span class="cx">         setHasVisibleBoxDecorations(false);
</span><del>-        setHasOverflowClip(false);
</del><ins>+        setHasNonVisibleOverflow(false);
</ins><span class="cx">         setHasTransformRelatedProperty(false);
</span><span class="cx">         setHasReflection(false);
</span><span class="cx">     }
</span><span class="lines">@@ -1340,7 +1340,7 @@
</span><span class="cx">     if (frameView.isOffscreen())
</span><span class="cx">         return false;
</span><span class="cx"> 
</span><del>-    if (!hasOverflowClip()) {
</del><ins>+    if (!hasNonVisibleOverflow()) {
</ins><span class="cx">         // FIXME: Computing the overflow rect is expensive if any descendant has
</span><span class="cx">         // its own self-painting layer. As a result, we prefer to abort early in
</span><span class="cx">         // this case and assume it may cause us to repaint inside the viewport.
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderElementh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderElement.h (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderElement.h   2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderElement.h      2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -164,7 +164,7 @@
</span><span class="cx">     bool hasBackground() const { return style().hasBackground(); }
</span><span class="cx">     bool hasMask() const { return style().hasMask(); }
</span><span class="cx">     bool hasClip() const { return isOutOfFlowPositioned() && style().hasClip(); }
</span><del>-    bool hasClipOrOverflowClip() const { return hasClip() || hasOverflowClip(); }
</del><ins>+    bool hasClipOrNonVisibleOverflow() const { return hasClip() || hasNonVisibleOverflow(); }
</ins><span class="cx">     bool hasClipPath() const { return style().clipPath(); }
</span><span class="cx">     bool hasHiddenBackface() const { return style().backfaceVisibility() == BackfaceVisibility::Hidden; }
</span><span class="cx">     bool hasOutlineAnnotation() const;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderFlexibleBoxcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp     2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp        2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -314,7 +314,7 @@
</span><span class="cx">     if (hitTestAction != HitTestForeground)
</span><span class="cx">         return false;
</span><span class="cx"> 
</span><del>-    LayoutPoint scrolledOffset = hasOverflowClip() ? adjustedLocation - toLayoutSize(scrollPosition()) : adjustedLocation;
</del><ins>+    LayoutPoint scrolledOffset = hasNonVisibleOverflow() ? adjustedLocation - toLayoutSize(scrollPosition()) : adjustedLocation;
</ins><span class="cx"> 
</span><span class="cx">     // If collecting the children in reverse order is bad for performance, this Vector could be determined at layout time.
</span><span class="cx">     Vector<RenderBox*> reversedOrderIteratorForHitTesting;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderFragmentContainercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderFragmentContainer.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderFragmentContainer.cpp       2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderFragmentContainer.cpp  2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -195,7 +195,7 @@
</span><span class="cx"> 
</span><span class="cx"> bool RenderFragmentContainer::shouldClipFragmentedFlowContent() const
</span><span class="cx"> {
</span><del>-    return hasOverflowClip();
</del><ins>+    return hasNonVisibleOverflow();
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void RenderFragmentContainer::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
</span><span class="lines">@@ -512,7 +512,7 @@
</span><span class="cx">     // Only propagate interior layout overflow if we don't clip it.
</span><span class="cx">     LayoutRect rect = box->borderBoxRectInFragment(this);
</span><span class="cx">     rect = rectFlowPortionForBox(box, rect);
</span><del>-    if (!box->hasOverflowClip())
</del><ins>+    if (!box->hasNonVisibleOverflow())
</ins><span class="cx">         rect.unite(layoutOverflowRectForBox(box));
</span><span class="cx"> 
</span><span class="cx">     bool hasTransform = box->hasTransform();
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderFragmentedFlowcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderFragmentedFlow.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderFragmentedFlow.cpp  2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderFragmentedFlow.cpp     2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -1058,7 +1058,7 @@
</span><span class="cx">         
</span><span class="cx">         fragment->addLayoutOverflowForBox(box, childLayoutOverflowRect);
</span><span class="cx"> 
</span><del>-        if (child->hasSelfPaintingLayer() || box->hasOverflowClip()) {
</del><ins>+        if (child->hasSelfPaintingLayer() || box->hasNonVisibleOverflow()) {
</ins><span class="cx">             if (fragment == endFragment)
</span><span class="cx">                 break;
</span><span class="cx">             continue;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderInlinecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderInline.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderInline.cpp  2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderInline.cpp     2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -891,7 +891,7 @@
</span><span class="cx">     if (hitRepaintContainer || !containingBlock)
</span><span class="cx">         return repaintRect;
</span><span class="cx"> 
</span><del>-    if (containingBlock->hasOverflowClip())
</del><ins>+    if (containingBlock->hasNonVisibleOverflow())
</ins><span class="cx">         containingBlock->applyCachedClipAndScrollPosition(repaintRect, repaintContainer, context);
</span><span class="cx"> 
</span><span class="cx">     repaintRect = containingBlock->computeRect(repaintRect, repaintContainer, context);
</span><span class="lines">@@ -957,7 +957,7 @@
</span><span class="cx">     // FIXME: We ignore the lightweight clipping rect that controls use, since if |o| is in mid-layout,
</span><span class="cx">     // its controlClipRect will be wrong. For overflow clip we use the values cached by the layer.
</span><span class="cx">     adjustedRect.setLocation(topLeft);
</span><del>-    if (localContainer->hasOverflowClip()) {
</del><ins>+    if (localContainer->hasNonVisibleOverflow()) {
</ins><span class="cx">         // FIXME: Respect the value of context.options.
</span><span class="cx">         SetForScope<OptionSet<VisibleRectContextOption>> change(context.options, context.options | VisibleRectContextOption::ApplyCompositedContainerScrolls);
</span><span class="cx">         bool isEmpty = !downcast<RenderBox>(*localContainer).applyCachedClipAndScrollPosition(adjustedRect, container, context);
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderLayercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderLayer.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderLayer.cpp   2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderLayer.cpp      2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -573,7 +573,7 @@
</span><span class="cx">     if (canCreateStackingContext(*this))
</span><span class="cx">         return false;
</span><span class="cx"> 
</span><del>-    return renderer().hasOverflowClip()
</del><ins>+    return renderer().hasNonVisibleOverflow()
</ins><span class="cx">         || renderer().isCanvas()
</span><span class="cx">         || renderer().isVideo()
</span><span class="cx">         || renderer().isEmbeddedObject()
</span><span class="lines">@@ -1123,7 +1123,7 @@
</span><span class="cx">     if (renderer().style().hasViewportConstrainedPosition())
</span><span class="cx">         flags.add(HasSeenViewportConstrainedAncestor);
</span><span class="cx"> 
</span><del>-    if (renderer().hasOverflowClip())
</del><ins>+    if (renderer().hasNonVisibleOverflow())
</ins><span class="cx">         flags.add(HasSeenAncestorWithOverflowClip);
</span><span class="cx">     
</span><span class="cx">     bool shouldComputeRepaintRects = (flags.contains(HasSeenViewportConstrainedAncestor) || flags.containsAll({ IsOverflowScroll, HasSeenAncestorWithOverflowClip })) && isSelfPaintingLayer();
</span><span class="lines">@@ -1331,7 +1331,7 @@
</span><span class="cx"> {
</span><span class="cx">     const RenderLayer* layer = (includeSelf == IncludeSelf) ? this : parent();
</span><span class="cx">     while (layer) {
</span><del>-        if (layer->renderer().hasOverflowClip())
</del><ins>+        if (layer->renderer().hasNonVisibleOverflow())
</ins><span class="cx">             return const_cast<RenderLayer*>(layer);
</span><span class="cx"> 
</span><span class="cx">         layer = layer->parent();
</span><span class="lines">@@ -1614,7 +1614,7 @@
</span><span class="cx">                 setNeedsPostLayoutCompositingUpdate();
</span><span class="cx">             }
</span><span class="cx"> 
</span><del>-            if (flags && renderer().hasOverflowClip())
</del><ins>+            if (flags && renderer().hasNonVisibleOverflow())
</ins><span class="cx">                 flags->add(ContainingClippingLayerChangedSize);
</span><span class="cx"> 
</span><span class="cx">             setSize(newSize);
</span><span class="lines">@@ -1645,7 +1645,7 @@
</span><span class="cx">     RenderLayer* positionedParent;
</span><span class="cx">     if (renderer().isOutOfFlowPositioned() && (positionedParent = enclosingAncestorForPosition(renderer().style().position()))) {
</span><span class="cx">         // For positioned layers, we subtract out the enclosing positioned layer's scroll offset.
</span><del>-        if (positionedParent->renderer().hasOverflowClip()) {
</del><ins>+        if (positionedParent->renderer().hasNonVisibleOverflow()) {
</ins><span class="cx">             if (auto* positionedParentScrollableArea = positionedParent->scrollableArea())
</span><span class="cx">                 localPoint -= toLayoutSize(positionedParentScrollableArea->scrollPosition());
</span><span class="cx">         }
</span><span class="lines">@@ -1658,7 +1658,7 @@
</span><span class="cx">         ASSERT(positionedParent->contentsScrollingScope());
</span><span class="cx">         m_boxScrollingScope = positionedParent->contentsScrollingScope();
</span><span class="cx">     } else if (auto* parentLayer = parent()) {
</span><del>-        if (parentLayer->renderer().hasOverflowClip()) {
</del><ins>+        if (parentLayer->renderer().hasNonVisibleOverflow()) {
</ins><span class="cx">             if (auto* parentLayerScrollableArea = parentLayer->scrollableArea())
</span><span class="cx">                 localPoint -= toLayoutSize(parentLayerScrollableArea->scrollPosition());
</span><span class="cx">         }
</span><span class="lines">@@ -2373,7 +2373,7 @@
</span><span class="cx"> 
</span><span class="cx"> bool RenderLayer::allowsCurrentScroll() const
</span><span class="cx"> {
</span><del>-    if (!renderer().hasOverflowClip())
</del><ins>+    if (!renderer().hasNonVisibleOverflow())
</ins><span class="cx">         return false;
</span><span class="cx"> 
</span><span class="cx">     // Don't scroll to reveal an overflow layer that is restricted by the -webkit-line-clamp property.
</span><span class="lines">@@ -2636,9 +2636,9 @@
</span><span class="cx"> bool RenderLayer::canResize() const
</span><span class="cx"> {
</span><span class="cx">     // We need a special case for <iframe> because they never have
</span><del>-    // hasOverflowClip(). However, they do "implicitly" clip their contents, so
</del><ins>+    // hasNonVisibleOverflow(). However, they do "implicitly" clip their contents, so
</ins><span class="cx">     // we want to allow resizing them also.
</span><del>-    return (renderer().hasOverflowClip() || renderer().isRenderIFrame()) && renderer().style().resize() != Resize::None;
</del><ins>+    return (renderer().hasNonVisibleOverflow() || renderer().isRenderIFrame()) && renderer().style().resize() != Resize::None;
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void RenderLayer::resize(const PlatformMouseEvent& evt, const LayoutSize& oldOffset)
</span><span class="lines">@@ -2886,7 +2886,7 @@
</span><span class="cx">             if (paintBehavior.contains(PaintBehavior::CompositedOverflowScrollContent) && layer->usesCompositedScrolling())
</span><span class="cx">                 break;
</span><span class="cx">         
</span><del>-            if (layer->renderer().hasOverflowClip() && layer->renderer().style().hasBorderRadius() && ancestorLayerIsInContainingBlockChain(*layer)) {
</del><ins>+            if (layer->renderer().hasNonVisibleOverflow() && layer->renderer().style().hasBorderRadius() && ancestorLayerIsInContainingBlockChain(*layer)) {
</ins><span class="cx">                 LayoutRect adjustedClipRect = LayoutRect(toLayoutPoint(layer->offsetFromAncestor(paintingInfo.rootLayer, AdjustForColumns)), layer->size());
</span><span class="cx">                 adjustedClipRect.move(paintingInfo.subpixelOffset);
</span><span class="cx">                 FloatRoundedRect roundedRect = layer->renderer().style().getRoundedInnerBorderFor(adjustedClipRect).pixelSnappedRoundedRectForPainting(deviceScaleFactor);
</span><span class="lines">@@ -3085,7 +3085,7 @@
</span><span class="cx"> 
</span><span class="cx">     // FIXME: We shouldn't have to disable subpixel quantization for overflow clips or subframes once we scroll those
</span><span class="cx">     // things on the scrolling thread.
</span><del>-    bool contentsScrollByPainting = (renderer().hasOverflowClip() && !usesCompositedScrolling()) || (renderer().frame().ownerElement());
</del><ins>+    bool contentsScrollByPainting = (renderer().hasNonVisibleOverflow() && !usesCompositedScrolling()) || (renderer().frame().ownerElement());
</ins><span class="cx">     bool isZooming = !page().chrome().client().hasStablePageScaleFactor();
</span><span class="cx">     if (scrollingOnMainThread || contentsScrollByPainting || isZooming) {
</span><span class="cx">         didQuantizeFonts = context.shouldSubpixelQuantizeFonts();
</span><span class="lines">@@ -3342,7 +3342,7 @@
</span><span class="cx">             // Collect the fragments. This will compute the clip rectangles and paint offsets for each layer fragment, as well as whether or not the content of each
</span><span class="cx">             // fragment should paint. If the parent's filter dictates full repaint to ensure proper filter effect,
</span><span class="cx">             // use the overflow clip as dirty rect, instead of no clipping. It maintains proper clipping for overflow::scroll.
</span><del>-            if (!localPaintingInfo.clipToDirtyRect && renderer().hasOverflowClip()) {
</del><ins>+            if (!localPaintingInfo.clipToDirtyRect && renderer().hasNonVisibleOverflow()) {
</ins><span class="cx">                 // We can turn clipping back by requesting full repaint for the overflow area.
</span><span class="cx">                 localPaintingInfo.clipToDirtyRect = true;
</span><span class="cx">                 paintDirtyRect = clipRectRelativeToAncestor(localPaintingInfo.rootLayer, offsetFromRoot, LayoutRect::infiniteRect());
</span><span class="lines">@@ -4452,9 +4452,9 @@
</span><span class="cx">     
</span><span class="cx">     // Update the clip rects that will be passed to child layers.
</span><span class="cx"> #if PLATFORM(IOS_FAMILY)
</span><del>-    if (renderer().hasClipOrOverflowClip() && (clipRectsContext.respectOverflowClip == RespectOverflowClip || this != clipRectsContext.rootLayer)) {
</del><ins>+    if (renderer().hasClipOrNonVisibleOverflow() && (clipRectsContext.respectOverflowClip == RespectOverflowClip || this != clipRectsContext.rootLayer)) {
</ins><span class="cx"> #else
</span><del>-    if ((renderer().hasOverflowClip() && (clipRectsContext.respectOverflowClip == RespectOverflowClip || this != clipRectsContext.rootLayer)) || renderer().hasClip()) {
</del><ins>+    if ((renderer().hasNonVisibleOverflow() && (clipRectsContext.respectOverflowClip == RespectOverflowClip || this != clipRectsContext.rootLayer)) || renderer().hasClip()) {
</ins><span class="cx"> #endif
</span><span class="cx">         // This layer establishes a clip of some kind.
</span><span class="cx">         LayoutPoint offset;
</span><span class="lines">@@ -4466,7 +4466,7 @@
</span><span class="cx">         if (clipRects.fixed() && &clipRectsContext.rootLayer->renderer() == &renderer().view())
</span><span class="cx">             offset -= toLayoutSize(renderer().view().frameView().scrollPositionForFixedPosition());
</span><span class="cx"> 
</span><del>-        if (renderer().hasOverflowClip()) {
</del><ins>+        if (renderer().hasNonVisibleOverflow()) {
</ins><span class="cx">             ClipRect newOverflowClip = downcast<RenderBox>(renderer()).overflowClipRectForChildLayers(offset, nullptr, clipRectsContext.overlayScrollbarSizeRelevancy);
</span><span class="cx">             newOverflowClip.setAffectedByRadius(renderer().style().hasBorderRadius());
</span><span class="cx">             clipRects.setOverflowClipRect(intersection(newOverflowClip, clipRects.overflowClipRect()));
</span><span class="lines">@@ -4479,7 +4479,7 @@
</span><span class="cx">             clipRects.setOverflowClipRect(intersection(newPosClip, clipRects.overflowClipRect()));
</span><span class="cx">             clipRects.setFixedClipRect(intersection(newPosClip, clipRects.fixedClipRect()));
</span><span class="cx">         }
</span><del>-    } else if (renderer().hasOverflowClip() && transform() && renderer().style().hasBorderRadius())
</del><ins>+    } else if (renderer().hasNonVisibleOverflow() && transform() && renderer().style().hasBorderRadius())
</ins><span class="cx">         clipRects.setOverflowClipRectAffectedByRadius();
</span><span class="cx"> 
</span><span class="cx">     LOG_WITH_STREAM(ClipRects, stream << "RenderLayer " << this << " calculateClipRects " << clipRectsContext << " computed " << clipRects);
</span><span class="lines">@@ -4548,9 +4548,9 @@
</span><span class="cx">     foregroundRect = backgroundRect;
</span><span class="cx"> 
</span><span class="cx">     // Update the clip rects that will be passed to child layers.
</span><del>-    if (renderer().hasClipOrOverflowClip()) {
</del><ins>+    if (renderer().hasClipOrNonVisibleOverflow()) {
</ins><span class="cx">         // This layer establishes a clip of some kind.
</span><del>-        if (renderer().hasOverflowClip()) {
</del><ins>+        if (renderer().hasNonVisibleOverflow()) {
</ins><span class="cx">             if (this != clipRectsContext.rootLayer || clipRectsContext.respectOverflowClip == RespectOverflowClip) {
</span><span class="cx">                 foregroundRect.intersect(downcast<RenderBox>(renderer()).overflowClipRect(toLayoutPoint(offsetFromRootLocal), nullptr, clipRectsContext.overlayScrollbarSizeRelevancy));
</span><span class="cx">                 foregroundRect.setAffectedByRadius(true);
</span><span class="lines">@@ -4668,7 +4668,7 @@
</span><span class="cx">     LayoutRect rect = m_blockSelectionGapsBounds;
</span><span class="cx">     if (m_scrollableArea)
</span><span class="cx">         rect.moveBy(-m_scrollableArea->scrollPosition());
</span><del>-    if (renderer().hasOverflowClip() && !usesCompositedScrolling())
</del><ins>+    if (renderer().hasNonVisibleOverflow() && !usesCompositedScrolling())
</ins><span class="cx">         rect.intersect(downcast<RenderBox>(renderer()).overflowClipRect(LayoutPoint(), nullptr)); // FIXME: Regions not accounted for.
</span><span class="cx">     if (renderer().hasClip())
</span><span class="cx">         rect.intersect(downcast<RenderBox>(renderer()).clipRect(LayoutPoint(), nullptr)); // FIXME: Regions not accounted for.
</span><span class="lines">@@ -5042,7 +5042,7 @@
</span><span class="cx">     
</span><span class="cx">     // We can't consult child layers if we clip, since they might cover
</span><span class="cx">     // parts of the rect that are clipped out.
</span><del>-    if (renderer().hasOverflowClip())
</del><ins>+    if (renderer().hasNonVisibleOverflow())
</ins><span class="cx">         return false;
</span><span class="cx">     
</span><span class="cx">     return listBackgroundIsKnownToBeOpaqueInRect(positiveZOrderLayers(), localRect)
</span><span class="lines">@@ -5727,7 +5727,7 @@
</span><span class="cx"> {
</span><span class="cx">     stream << (layer.isCSSStackingContext() ? "S" : (layer.isForcedStackingContext() ? "F" : (layer.isOpportunisticStackingContext() ? "P" : "-")));
</span><span class="cx">     stream << (layer.isNormalFlowOnly() ? "N" : "-");
</span><del>-    stream << (layer.renderer().hasOverflowClip() ? "O" : "-");
</del><ins>+    stream << (layer.renderer().hasNonVisibleOverflow() ? "O" : "-");
</ins><span class="cx">     stream << (layer.isTransparent() ? "A" : "-");
</span><span class="cx">     stream << (layer.hasBlendMode() ? "B" : "-");
</span><span class="cx">     stream << (layer.isolatesBlending() ? "I" : "-");
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderLayerBackingcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderLayerBacking.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderLayerBacking.cpp    2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderLayerBacking.cpp       2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -610,7 +610,7 @@
</span><span class="cx"> static LayoutRect clippingLayerBox(const RenderBox& renderBox)
</span><span class="cx"> {
</span><span class="cx">     LayoutRect result = LayoutRect::infiniteRect();
</span><del>-    if (renderBox.hasOverflowClip())
</del><ins>+    if (renderBox.hasNonVisibleOverflow())
</ins><span class="cx">         result = renderBox.overflowClipRect({ }, 0); // FIXME: Incorrect for CSS regions.
</span><span class="cx"> 
</span><span class="cx">     if (renderBox.hasClip())
</span><span class="lines">@@ -844,7 +844,7 @@
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     // If the backing provider has overflow:clip, we know all sharing layers are affected by the clip because they are containing-block descendants.
</span><del>-    if (!renderer().hasOverflowClip()) {
</del><ins>+    if (!renderer().hasNonVisibleOverflow()) {
</ins><span class="cx">         for (auto& layerWeakPtr : m_backingSharingLayers) {
</span><span class="cx">             auto* boundsRootLayer = &m_owningLayer;
</span><span class="cx">             ASSERT(layerWeakPtr->isDescendantOf(m_owningLayer));
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderLayerCompositorcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp 2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp    2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -1980,7 +1980,7 @@
</span><span class="cx">     for (auto* parent = layer.parent(); parent; parent = parent->parent()) {
</span><span class="cx">         if (parent->isStackingContext())
</span><span class="cx">             return nullptr;
</span><del>-        if (parent->renderer().hasClipOrOverflowClip())
</del><ins>+        if (parent->renderer().hasClipOrNonVisibleOverflow())
</ins><span class="cx">             return parent;
</span><span class="cx">     }
</span><span class="cx">     return nullptr;
</span><span class="lines">@@ -2930,7 +2930,7 @@
</span><span class="cx">             return AncestorTraversal::Stop;
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        if (isContainingBlockChain && ancestorLayer.renderer().hasClipOrOverflowClip()) {
</del><ins>+        if (isContainingBlockChain && ancestorLayer.renderer().hasClipOrNonVisibleOverflow()) {
</ins><span class="cx">             if (ancestorLayer.hasCompositedScrollableOverflow()) {
</span><span class="cx">                 if (haveNonScrollableClippingIntermediateLayer) {
</span><span class="cx">                     pushNonScrollableClip(*currentClippedLayer, ancestorLayer);
</span><span class="lines">@@ -2998,7 +2998,7 @@
</span><span class="cx"> // into the hierarchy between this layer and its children in the z-order hierarchy.
</span><span class="cx"> bool RenderLayerCompositor::clipsCompositingDescendants(const RenderLayer& layer)
</span><span class="cx"> {
</span><del>-    return layer.hasCompositingDescendant() && layer.renderer().hasClipOrOverflowClip() && !layer.isolatesCompositedBlending() && !layer.hasCompositedNonContainedDescendants();
</del><ins>+    return layer.hasCompositingDescendant() && layer.renderer().hasClipOrNonVisibleOverflow() && !layer.isolatesCompositedBlending() && !layer.hasCompositedNonContainedDescendants();
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> bool RenderLayerCompositor::requiresCompositingForAnimation(RenderLayerModelObject& renderer) const
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderLayerScrollableAreacpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderLayerScrollableArea.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderLayerScrollableArea.cpp     2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderLayerScrollableArea.cpp        2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -1293,7 +1293,7 @@
</span><span class="cx"> {
</span><span class="cx">     // Don't do anything if we have no overflow.
</span><span class="cx">     auto& renderer = m_layer.renderer();
</span><del>-    if (!renderer.hasOverflowClip())
</del><ins>+    if (!renderer.hasNonVisibleOverflow())
</ins><span class="cx">         return;
</span><span class="cx"> 
</span><span class="cx">     if (!showsOverflowControls())
</span><span class="lines">@@ -1636,7 +1636,7 @@
</span><span class="cx"> {
</span><span class="cx">     auto& renderer = m_layer.renderer();
</span><span class="cx">     RenderElement* actualRenderer = rendererForScrollbar(renderer);
</span><del>-    auto corner = renderer.hasOverflowClip() ? actualRenderer->getUncachedPseudoStyle({ PseudoId::ScrollbarCorner }, &actualRenderer->style()) : nullptr;
</del><ins>+    auto corner = renderer.hasNonVisibleOverflow() ? actualRenderer->getUncachedPseudoStyle({ PseudoId::ScrollbarCorner }, &actualRenderer->style()) : nullptr;
</ins><span class="cx"> 
</span><span class="cx">     if (!corner) {
</span><span class="cx">         clearScrollCorner();
</span><span class="lines">@@ -1664,7 +1664,7 @@
</span><span class="cx"> {
</span><span class="cx">     auto& renderer = m_layer.renderer();
</span><span class="cx">     RenderElement* actualRenderer = rendererForScrollbar(renderer);
</span><del>-    auto resizer = renderer.hasOverflowClip() ? actualRenderer->getUncachedPseudoStyle({ PseudoId::Resizer }, &actualRenderer->style()) : nullptr;
</del><ins>+    auto resizer = renderer.hasNonVisibleOverflow() ? actualRenderer->getUncachedPseudoStyle({ PseudoId::Resizer }, &actualRenderer->style()) : nullptr;
</ins><span class="cx"> 
</span><span class="cx">     if (!resizer) {
</span><span class="cx">         clearResizer();
</span><span class="lines">@@ -1776,7 +1776,7 @@
</span><span class="cx">     if (renderer.parent())
</span><span class="cx">         restrictedByLineClamp = !renderer.parent()->style().lineClamp().isNone();
</span><span class="cx"> 
</span><del>-    if (renderer.hasOverflowClip() && !restrictedByLineClamp) {
</del><ins>+    if (renderer.hasNonVisibleOverflow() && !restrictedByLineClamp) {
</ins><span class="cx">         ScrollOffset newScrollOffset = scrollOffset() + delta;
</span><span class="cx">         scrollToOffset(newScrollOffset);
</span><span class="cx">         if (scrolledArea)
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderLayoutStatecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderLayoutState.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderLayoutState.cpp     2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderLayoutState.cpp        2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -49,7 +49,7 @@
</span><span class="cx">         FloatPoint absContentPoint = container->localToAbsolute(FloatPoint(), UseTransforms);
</span><span class="cx">         m_paintOffset = LayoutSize(absContentPoint.x(), absContentPoint.y());
</span><span class="cx"> 
</span><del>-        if (container->hasOverflowClip()) {
</del><ins>+        if (container->hasNonVisibleOverflow()) {
</ins><span class="cx">             m_clipped = true;
</span><span class="cx">             auto& containerBox = downcast<RenderBox>(*container);
</span><span class="cx">             m_clipRect = LayoutRect(toLayoutPoint(m_paintOffset), containerBox.cachedSizeForOverflowClip());
</span><span class="lines">@@ -101,7 +101,7 @@
</span><span class="cx">     if (renderer.isInFlowPositioned() && renderer.hasLayer())
</span><span class="cx">         m_paintOffset += renderer.layer()->offsetForInFlowPosition();
</span><span class="cx"> 
</span><del>-    if (renderer.hasOverflowClip())
</del><ins>+    if (renderer.hasNonVisibleOverflow())
</ins><span class="cx">         m_paintOffset -= toLayoutSize(renderer.scrollPosition());
</span><span class="cx"> 
</span><span class="cx">     m_layoutDelta = ancestor.layoutDelta();
</span><span class="lines">@@ -116,7 +116,7 @@
</span><span class="cx">     m_clipped = !renderer.isFixedPositioned() && ancestor.isClipped();
</span><span class="cx">     if (m_clipped)
</span><span class="cx">         m_clipRect = ancestor.clipRect();
</span><del>-    if (!renderer.hasOverflowClip())
</del><ins>+    if (!renderer.hasNonVisibleOverflow())
</ins><span class="cx">         return;
</span><span class="cx"> 
</span><span class="cx">     auto paintOffsetForClipRect = toLayoutPoint(m_paintOffset + toLayoutSize(renderer.scrollPosition()));
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderListItemcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderListItem.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderListItem.cpp        2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderListItem.cpp   2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -270,7 +270,7 @@
</span><span class="cx"> 
</span><span class="cx"> void RenderListItem::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
</span><span class="cx"> {
</span><del>-    if (!logicalHeight() && hasOverflowClip())
</del><ins>+    if (!logicalHeight() && hasNonVisibleOverflow())
</ins><span class="cx">         return;
</span><span class="cx"> 
</span><span class="cx">     RenderBlockFlow::paint(paintInfo, paintOffset);
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderListMarkercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderListMarker.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderListMarker.cpp      2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderListMarker.cpp 2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -1745,7 +1745,7 @@
</span><span class="cx">         bool propagateLayoutOverflow = true;
</span><span class="cx">         do {
</span><span class="cx">             markerAncestor = parentBox(*markerAncestor);
</span><del>-            if (markerAncestor->hasOverflowClip())
</del><ins>+            if (markerAncestor->hasNonVisibleOverflow())
</ins><span class="cx">                 propagateVisualOverflow = false;
</span><span class="cx">             if (is<RenderBlock>(*markerAncestor)) {
</span><span class="cx">                 if (propagateVisualOverflow)
</span><span class="lines">@@ -1753,7 +1753,7 @@
</span><span class="cx">                 if (propagateLayoutOverflow)
</span><span class="cx">                     downcast<RenderBlock>(*markerAncestor).addLayoutOverflow(markerRect);
</span><span class="cx">             }
</span><del>-            if (markerAncestor->hasOverflowClip())
</del><ins>+            if (markerAncestor->hasNonVisibleOverflow())
</ins><span class="cx">                 propagateLayoutOverflow = false;
</span><span class="cx">             if (markerAncestor->hasSelfPaintingLayer())
</span><span class="cx">                 propagateVisualOverflow = false;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderMultiColumnSetcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp  2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp     2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -885,7 +885,7 @@
</span><span class="cx">     
</span><span class="cx">     LayoutRect lastRect = columnRectAt(colCount - 1);
</span><span class="cx">     addLayoutOverflow(lastRect);
</span><del>-    if (!hasOverflowClip())
</del><ins>+    if (!hasNonVisibleOverflow())
</ins><span class="cx">         addVisualOverflow(lastRect);
</span><span class="cx"> }
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderObjectcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderObject.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderObject.cpp  2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderObject.cpp     2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -480,7 +480,7 @@
</span><span class="cx">         // want to return this as our container. Instead we should use the root element.
</span><span class="cx">         if (candidate->isRenderView())
</span><span class="cx">             break;
</span><del>-        if (candidate->hasOverflowClip())
</del><ins>+        if (candidate->hasNonVisibleOverflow())
</ins><span class="cx">             return downcast<RenderBox>(candidate);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -508,7 +508,7 @@
</span><span class="cx">     if (object->isSVGRoot())
</span><span class="cx">         return true;
</span><span class="cx"> 
</span><del>-    if (!object->hasOverflowClip())
</del><ins>+    if (!object->hasNonVisibleOverflow())
</ins><span class="cx">         return false;
</span><span class="cx"> 
</span><span class="cx">     if (object->style().width().isIntrinsicOrAuto() || object->style().height().isIntrinsicOrAuto() || object->style().height().isPercentOrCalculated())
</span><span class="lines">@@ -1004,7 +1004,7 @@
</span><span class="cx">         return rect;
</span><span class="cx"> 
</span><span class="cx">     LayoutRect adjustedRect = rect;
</span><del>-    if (parent->hasOverflowClip()) {
</del><ins>+    if (parent->hasNonVisibleOverflow()) {
</ins><span class="cx">         bool isEmpty = !downcast<RenderBox>(*parent).applyCachedClipAndScrollPosition(adjustedRect, container, context);
</span><span class="cx">         if (isEmpty) {
</span><span class="cx">             if (context.options.contains(VisibleRectContextOption::UseEdgeInclusiveIntersection))
</span><span class="lines">@@ -1125,7 +1125,7 @@
</span><span class="cx">     else
</span><span class="cx">         stream << "-";
</span><span class="cx"> 
</span><del>-    if (hasOverflowClip())
</del><ins>+    if (hasNonVisibleOverflow())
</ins><span class="cx">         stream << "O";
</span><span class="cx">     else
</span><span class="cx">         stream << "-";
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderObjecth"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderObject.h (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderObject.h    2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderObject.h       2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -435,7 +435,7 @@
</span><span class="cx"> 
</span><span class="cx">     bool isSelectionBorder() const;
</span><span class="cx"> 
</span><del>-    bool hasOverflowClip() const { return m_bitfields.hasOverflowClip(); }
</del><ins>+    bool hasNonVisibleOverflow() const { return m_bitfields.hasNonVisibleOverflow(); }
</ins><span class="cx"> 
</span><span class="cx">     bool hasTransformRelatedProperty() const { return m_bitfields.hasTransformRelatedProperty(); } // Transform, perspective or transform-style: preserve-3d.
</span><span class="cx">     bool hasTransform() const { return hasTransformRelatedProperty() && (style().hasTransform() || style().translate() || style().scale() || style().rotate()); }
</span><span class="lines">@@ -493,7 +493,7 @@
</span><span class="cx">     void setIsRenderView() { ASSERT(isBox()); m_bitfields.setIsTextOrRenderView(true); }
</span><span class="cx">     void setReplaced(bool b = true) { m_bitfields.setIsReplaced(b); }
</span><span class="cx">     void setHorizontalWritingMode(bool b = true) { m_bitfields.setHorizontalWritingMode(b); }
</span><del>-    void setHasOverflowClip(bool b = true) { m_bitfields.setHasOverflowClip(b); }
</del><ins>+    void setHasNonVisibleOverflow(bool b = true) { m_bitfields.setHasNonVisibleOverflow(b); }
</ins><span class="cx">     void setHasLayer(bool b = true) { m_bitfields.setHasLayer(b); }
</span><span class="cx">     void setHasTransformRelatedProperty(bool b = true) { m_bitfields.setHasTransformRelatedProperty(b); }
</span><span class="cx"> 
</span><span class="lines">@@ -846,7 +846,7 @@
</span><span class="cx">             , m_isLineBreak(false)
</span><span class="cx">             , m_horizontalWritingMode(true)
</span><span class="cx">             , m_hasLayer(false)
</span><del>-            , m_hasOverflowClip(false)
</del><ins>+            , m_hasNonVisibleOverflow(false)
</ins><span class="cx">             , m_hasTransformRelatedProperty(false)
</span><span class="cx">             , m_everHadLayout(false)
</span><span class="cx">             , m_childrenInline(false)
</span><span class="lines">@@ -879,7 +879,7 @@
</span><span class="cx">         ADD_BOOLEAN_BITFIELD(horizontalWritingMode, HorizontalWritingMode);
</span><span class="cx"> 
</span><span class="cx">         ADD_BOOLEAN_BITFIELD(hasLayer, HasLayer);
</span><del>-        ADD_BOOLEAN_BITFIELD(hasOverflowClip, HasOverflowClip); // Set in the case of overflow:auto/scroll/hidden
</del><ins>+        ADD_BOOLEAN_BITFIELD(hasNonVisibleOverflow, HasNonVisibleOverflow); // Set in the case of overflow:auto/scroll/hidden
</ins><span class="cx">         ADD_BOOLEAN_BITFIELD(hasTransformRelatedProperty, HasTransformRelatedProperty);
</span><span class="cx"> 
</span><span class="cx">         ADD_BOOLEAN_BITFIELD(everHadLayout, EverHadLayout);
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderScrollbarPartcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderScrollbarPart.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderScrollbarPart.cpp   2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderScrollbarPart.cpp      2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -137,7 +137,7 @@
</span><span class="cx">     setInline(false);
</span><span class="cx">     clearPositionedState();
</span><span class="cx">     setFloating(false);
</span><del>-    setHasOverflowClip(false);
</del><ins>+    setHasNonVisibleOverflow(false);
</ins><span class="cx">     if (oldStyle && m_scrollbar && m_part != NoPart && diff >= StyleDifference::Repaint)
</span><span class="cx">         m_scrollbar->theme().invalidatePart(*m_scrollbar, m_part);
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderTablecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderTable.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderTable.cpp   2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderTable.cpp      2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -1561,7 +1561,7 @@
</span><span class="cx">     LayoutPoint adjustedLocation = accumulatedOffset + location();
</span><span class="cx"> 
</span><span class="cx">     // Check kids first.
</span><del>-    if (!hasOverflowClip() || locationInContainer.intersects(overflowClipRect(adjustedLocation, nullptr))) {
</del><ins>+    if (!hasNonVisibleOverflow() || locationInContainer.intersects(overflowClipRect(adjustedLocation, nullptr))) {
</ins><span class="cx">         for (RenderObject* child = lastChild(); child; child = child->previousSibling()) {
</span><span class="cx">             if (is<RenderBox>(*child) && !downcast<RenderBox>(*child).hasSelfPaintingLayer() && (child->isTableSection() || child->isTableCaption())) {
</span><span class="cx">                 LayoutPoint childPoint = flipForWritingModeForChild(downcast<RenderBox>(child), adjustedLocation);
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderTableRowh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderTableRow.h (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderTableRow.h  2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderTableRow.h     2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -76,7 +76,7 @@
</span><span class="cx">     void layout() override;
</span><span class="cx">     LayoutRect clippedOverflowRect(const RenderLayerModelObject* repaintContainer, VisibleRectContext) const override;
</span><span class="cx"> 
</span><del>-    bool requiresLayer() const override { return hasOverflowClip() || hasTransformRelatedProperty() || hasHiddenBackface() || hasClipPath() || createsGroup() || isStickilyPositioned(); }
</del><ins>+    bool requiresLayer() const override { return hasNonVisibleOverflow() || hasTransformRelatedProperty() || hasHiddenBackface() || hasClipPath() || createsGroup() || isStickilyPositioned(); }
</ins><span class="cx"> 
</span><span class="cx">     void paint(PaintInfo&, const LayoutPoint&) override;
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderTableSectioncpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderTableSection.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderTableSection.cpp    2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderTableSection.cpp       2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -1455,7 +1455,7 @@
</span><span class="cx">     // Just forward to our children always.
</span><span class="cx">     LayoutPoint adjustedLocation = accumulatedOffset + location();
</span><span class="cx"> 
</span><del>-    if (hasOverflowClip() && !locationInContainer.intersects(overflowClipRect(adjustedLocation, nullptr)))
</del><ins>+    if (hasNonVisibleOverflow() && !locationInContainer.intersects(overflowClipRect(adjustedLocation, nullptr)))
</ins><span class="cx">         return false;
</span><span class="cx"> 
</span><span class="cx">     if (hasOverflowingCell()) {
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderTextControlcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderTextControl.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderTextControl.cpp     2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderTextControl.cpp        2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -211,7 +211,7 @@
</span><span class="cx"> bool RenderTextControl::canScroll() const
</span><span class="cx"> {
</span><span class="cx">     auto innerText = innerTextElement();
</span><del>-    return innerText && innerText->renderer() && innerText->renderer()->hasOverflowClip();
</del><ins>+    return innerText && innerText->renderer() && innerText->renderer()->hasNonVisibleOverflow();
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> int RenderTextControl::innerLineHeight() const
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderTextControlSingleLinecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderTextControlSingleLine.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderTextControlSingleLine.cpp   2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderTextControlSingleLine.cpp      2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -272,7 +272,7 @@
</span><span class="cx">                 placeholder->renderer()->setNeedsLayout(MarkContainingBlockChain);
</span><span class="cx">         }
</span><span class="cx">     }
</span><del>-    setHasOverflowClip(false);
</del><ins>+    setHasNonVisibleOverflow(false);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> bool RenderTextControlSingleLine::hasControlClip() const
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderTreeAsTextcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderTreeAsText.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderTreeAsText.cpp      2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/RenderTreeAsText.cpp 2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -658,7 +658,7 @@
</span><span class="cx">             ts << " clip " << adjustedClipRect;
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    if (layer.renderer().hasOverflowClip()) {
</del><ins>+    if (layer.renderer().hasNonVisibleOverflow()) {
</ins><span class="cx">         if (auto* scrollableArea = layer.scrollableArea()) {
</span><span class="cx">             if (scrollableArea->scrollOffset().x())
</span><span class="cx">                 ts << " scrollX " << scrollableArea->scrollOffset().x();
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingsvgRenderSVGBlockcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/svg/RenderSVGBlock.cpp (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/svg/RenderSVGBlock.cpp    2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebCore/rendering/svg/RenderSVGBlock.cpp       2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -40,7 +40,7 @@
</span><span class="cx"> {
</span><span class="cx">     RenderBlockFlow::updateFromStyle();
</span><span class="cx"> 
</span><del>-    // RenderSVGlock, used by Render(SVGText|ForeignObject), is not allowed to call setHasOverflowClip(true).
</del><ins>+    // RenderSVGlock, used by Render(SVGText|ForeignObject), is not allowed to call setHasNonVisibleOverflow(true).
</ins><span class="cx">     // RenderBlock assumes a layer to be present when the overflow clip functionality is requested. Both
</span><span class="cx">     // Render(SVGText|ForeignObject) return 'false' on 'requiresLayer'. Fine for RenderSVGText.
</span><span class="cx">     //
</span><span class="lines">@@ -52,7 +52,7 @@
</span><span class="cx">     //
</span><span class="cx">     // Note: This does NOT affect overflow handling on outer/inner <svg> elements - this is handled
</span><span class="cx">     // manually by RenderSVGRoot - which owns the documents enclosing root layer and thus works fine.
</span><del>-    setHasOverflowClip(false);
</del><ins>+    setHasNonVisibleOverflow(false);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void RenderSVGBlock::absoluteRects(Vector<IntRect>&, const LayoutPoint&) const
</span></span></pre></div>
<a id="trunkSourceWebKitLegacymacChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKitLegacy/mac/ChangeLog (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKitLegacy/mac/ChangeLog  2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebKitLegacy/mac/ChangeLog     2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -1,3 +1,17 @@
</span><ins>+2021-07-14  Rob Buis  <rbuis@igalia.com>
+
+        Rename hasOverflowClip() to prepare for the real overflow:clip
+        https://bugs.webkit.org/show_bug.cgi?id=227899
+
+        Reviewed by Simon Fraser.
+
+        Rename hasOverflowClip() to prepare for the real overflow:clip.
+
+        * DOM/DOMHTML.mm:
+        (-[DOMHTMLElement scrollXOffset]):
+        (-[DOMHTMLElement scrollYOffset]):
+        (-[DOMHTMLElement setScrollXOffset:scrollYOffset:adjustForIOSCaret:]):
+
</ins><span class="cx"> 2021-06-25  Commit Queue  <commit-queue@webkit.org>
</span><span class="cx"> 
</span><span class="cx">         Unreviewed, reverting r279266.
</span></span></pre></div>
<a id="trunkSourceWebKitLegacymacDOMDOMHTMLmm"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKitLegacy/mac/DOM/DOMHTML.mm (279917 => 279918)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKitLegacy/mac/DOM/DOMHTML.mm     2021-07-14 20:39:39 UTC (rev 279917)
+++ trunk/Source/WebKitLegacy/mac/DOM/DOMHTML.mm        2021-07-14 20:40:50 UTC (rev 279918)
</span><span class="lines">@@ -75,7 +75,7 @@
</span><span class="cx">     if (!is<WebCore::RenderBlockFlow>(*renderer))
</span><span class="cx">         renderer = renderer->containingBlock();
</span><span class="cx"> 
</span><del>-    if (!is<WebCore::RenderBox>(*renderer) || !renderer->hasOverflowClip())
</del><ins>+    if (!is<WebCore::RenderBox>(*renderer) || !renderer->hasNonVisibleOverflow())
</ins><span class="cx">         return 0;
</span><span class="cx"> 
</span><span class="cx">     auto* layer = downcast<WebCore::RenderBox>(*renderer).layer();
</span><span class="lines">@@ -96,7 +96,7 @@
</span><span class="cx"> 
</span><span class="cx">     if (!is<WebCore::RenderBlockFlow>(*renderer))
</span><span class="cx">         renderer = renderer->containingBlock();
</span><del>-    if (!is<WebCore::RenderBox>(*renderer) || !renderer->hasOverflowClip())
</del><ins>+    if (!is<WebCore::RenderBox>(*renderer) || !renderer->hasNonVisibleOverflow())
</ins><span class="cx">         return 0;
</span><span class="cx"> 
</span><span class="cx">     auto* layer = downcast<WebCore::RenderBox>(*renderer).layer();
</span><span class="lines">@@ -122,7 +122,7 @@
</span><span class="cx"> 
</span><span class="cx">     if (!is<WebCore::RenderBlockFlow>(*renderer))
</span><span class="cx">         renderer = renderer->containingBlock();
</span><del>-    if (!renderer->hasOverflowClip() || !is<WebCore::RenderBox>(*renderer))
</del><ins>+    if (!renderer->hasNonVisibleOverflow() || !is<WebCore::RenderBox>(*renderer))
</ins><span class="cx">         return;
</span><span class="cx"> 
</span><span class="cx">     auto* layer = downcast<WebCore::RenderBox>(*renderer).layer();
</span></span></pre>
</div>
</div>

</body>
</html>