Attachment 353585 Details for Bug 90342 – Patch

[patch] Patch

bug-90342-20181101082046.patch (text/plain), 189.20 KB, created by Simon Fraser (smfr) on 2018-11-01 00:20:49 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Simon Fraser (smfr)

Created: 2018-11-01 00:20:49 PDT

Size: 189.20 KB

patch

obsolete

>Subversion Revision: 237312
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 02462ef8e72af81c7a78490915cab542b735441c..3b51fe7b872b0c31aba79d180f66fd2e5601f585 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,103 @@
>+2018-10-21  Simon Fraser  <simon.fraser@apple.com>
>+
>+        Do incremental compositing updates when possible
>+        https://bugs.webkit.org/show_bug.cgi?id=90342
>+
>+        Reviewed by NOBODY (OOPS!).
>+        
>+        Make compositing updates incremental, with dirty bits on RenderLayers.
>+
>+        * page/FrameView.cpp:
>+        (WebCore::FrameView::setViewportConstrainedObjectsNeedLayout):
>+        * platform/graphics/ca/GraphicsLayerCA.cpp:
>+        (WebCore::GraphicsLayerCA::updateBackdropFilters):
>+        * rendering/RenderLayer.cpp:
>+        (WebCore::RenderLayer::RenderLayer):
>+        (WebCore::RenderLayer::~RenderLayer):
>+        (WebCore::RenderLayer::dirtyPaintOrderListsOnChildChange):
>+        (WebCore::RenderLayer::shouldBeStackingContext const):
>+        (WebCore::RenderLayer::stackingContext const):
>+        (WebCore::RenderLayer::dirtyZOrderLists):
>+        (WebCore::RenderLayer::dirtyNormalFlowList):
>+        (WebCore::RenderLayer::updateNormalFlowList):
>+        (WebCore::RenderLayer::rebuildZOrderLists):
>+        (WebCore::RenderLayer::setAncestorsHaveCompositingDirtyFlag):
>+        (WebCore::RenderLayer::contentChanged):
>+        (WebCore::RenderLayer::updateLayerPositions):
>+        (WebCore::RenderLayer::updateTransform):
>+        (WebCore::RenderLayer::updateLayerPosition):
>+        (WebCore::RenderLayer::updateCompositingLayersAfterScroll):
>+        (WebCore::RenderLayer::updateScrollInfoAfterLayout):
>+        (WebCore::RenderLayer::paintLayerContents):
>+        (WebCore::RenderLayer::hitTest):
>+        (WebCore::RenderLayer::hitTestLayer):
>+        (WebCore::RenderLayer::calculateClipRects const):
>+        (WebCore::outputPaintOrderTreeLegend):
>+        (WebCore::outputPaintOrderTreeRecursive):
>+        * rendering/RenderLayer.h:
>+        (WebCore::RenderLayer::clearZOrderLists):
>+        (WebCore::RenderLayer::paintOrderParent const):
>+        * rendering/RenderLayerBacking.cpp:
>+        (WebCore::RenderLayerBacking::updateCompositedBounds):
>+        (WebCore::RenderLayerBacking::updateAfterWidgetResize):
>+        (WebCore::RenderLayerBacking::updateAfterLayout):
>+        (WebCore::RenderLayerBacking::updateConfigurationAfterStyleChange):
>+        (WebCore::RenderLayerBacking::updateConfiguration):
>+        (WebCore::RenderLayerBacking::updateGeometry):
>+        (WebCore::RenderLayerBacking::setRequiresBackgroundLayer):
>+        (WebCore::RenderLayerBacking::contentChanged):
>+        (WebCore::RenderLayerBacking::setContentsNeedDisplay):
>+        (WebCore::RenderLayerBacking::setContentsNeedDisplayInRect):
>+        (WebCore::RenderLayerBacking::setCompositedBounds):
>+        * rendering/RenderLayerBacking.h:
>+        * rendering/RenderLayerCompositor.cpp:
>+        (WebCore::RenderLayerCompositor::CompositingState::CompositingState):
>+        (WebCore::RenderLayerCompositor::enableCompositingMode):
>+        (WebCore::RenderLayerCompositor::cacheAcceleratedCompositingFlags):
>+        (WebCore::RenderLayerCompositor::cacheAcceleratedCompositingFlagsAfterLayout):
>+        (WebCore::RenderLayerCompositor::willRecalcStyle):
>+        (WebCore::RenderLayerCompositor::didRecalcStyleWithNoPendingLayout):
>+        (WebCore::RenderLayerCompositor::updateCompositingLayers):
>+        (WebCore::RenderLayerCompositor::computeCompositingRequirements):
>+        (WebCore::RenderLayerCompositor::traverseUnchangedSubtree):
>+        (WebCore::RenderLayerCompositor::updateBackingAndHierarchy):
>+        (WebCore::RenderLayerCompositor::appendDocumentOverlayLayers):
>+        (WebCore::RenderLayerCompositor::layerBecameNonComposited):
>+        (WebCore::RenderLayerCompositor::logLayerInfo):
>+        (WebCore::clippingChanged):
>+        (WebCore::checkIfDescendantClippingContextNeedsUpdate):
>+        (WebCore::isScrollableOverflow):
>+        (WebCore::styleHasTouchScrolling):
>+        (WebCore::styleChangeRequiresLayerRebuild):
>+        (WebCore::RenderLayerCompositor::layerStyleChanged):
>+        (WebCore::RenderLayerCompositor::needsCompositingUpdateForStyleChangeOnNonCompositedLayer const):
>+        (WebCore::RenderLayerCompositor::updateBacking):
>+        (WebCore::RenderLayerCompositor::updateLayerCompositingState):
>+        (WebCore::RenderLayerCompositor::layerWasAdded):
>+        (WebCore::RenderLayerCompositor::layerWillBeRemoved):
>+        (WebCore::RenderLayerCompositor::rootFixedBackgroundsChanged):
>+        (WebCore::RenderLayerCompositor::updateLayerTreeGeometry):
>+        (WebCore::RenderLayerCompositor::updateRootLayerPosition):
>+        (WebCore::RenderLayerCompositor::needsToBeComposited const):
>+        (WebCore::RenderLayerCompositor::requiresCompositingLayer const):
>+        (WebCore::RenderLayerCompositor::requiresOwnBackingStore const):
>+        (WebCore::RenderLayerCompositor::reasonsForCompositing const):
>+        (WebCore::RenderLayerCompositor::clippedByAncestor const):
>+        (WebCore::RenderLayerCompositor::requiresCompositingForAnimation const):
>+        (WebCore::RenderLayerCompositor::requiresCompositingForTransform const):
>+        (WebCore::RenderLayerCompositor::requiresCompositingForVideo const):
>+        (WebCore::RenderLayerCompositor::requiresCompositingForFilters const):
>+        (WebCore::RenderLayerCompositor::requiresCompositingForWillChange const):
>+        (WebCore::RenderLayerCompositor::requiresCompositingForPlugin const):
>+        (WebCore::RenderLayerCompositor::requiresCompositingForFrame const):
>+        (WebCore::RenderLayerCompositor::requiresCompositingForScrollableFrame const):
>+        (WebCore::RenderLayerCompositor::requiresCompositingForPosition const):
>+        (WebCore::RenderLayerCompositor::requiresCompositingForOverflowScrolling const):
>+        (WebCore::RenderLayerCompositor::styleChangeMayAffectIndirectCompositingReasons):
>+        (WebCore::operator<<):
>+        (WebCore::RenderLayerCompositor::rebuildCompositingLayerTree): Deleted.
>+        * rendering/RenderLayerCompositor.h:
>+
> 2018-10-20  YUHAN WU  <yuhan_wu@apple.com>
> 
>         MediaRecorder should fire a stop event when all tracks are ended
>diff --git a/Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp b/Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp
>index f18a8fbd090fb954c8dfdc59274781fcb3be9e1f..cfb3ad4811b787bb4f7f20282794f52aa93d9693 100644
>--- a/Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp
>+++ b/Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp
>@@ -923,7 +923,7 @@ void WebGLRenderingContextBase::markContextChanged()
>     if (isAccelerated() && renderBox && renderBox->hasAcceleratedCompositing()) {
>         m_markedCanvasDirty = true;
>         htmlCanvas()->clearCopiedImage();
>-        renderBox->contentChanged(CanvasChanged);
>+        renderBox->contentChanged(CanvasPixelsChanged);
>     } else {
>         if (!m_markedCanvasDirty) {
>             m_markedCanvasDirty = true;
>diff --git a/Source/WebCore/page/FrameView.cpp b/Source/WebCore/page/FrameView.cpp
>index fde6d759270242f3fcef4c2eab281f800f2ce9f2..00341759c961e5dd11c2ed9394e57351bb775d5e 100644
>--- a/Source/WebCore/page/FrameView.cpp
>+++ b/Source/WebCore/page/FrameView.cpp
>@@ -2393,8 +2393,13 @@ void FrameView::setViewportConstrainedObjectsNeedLayout()
>     if (!hasViewportConstrainedObjects())
>         return;
> 
>-    for (auto& renderer : *m_viewportConstrainedObjects)
>+    for (auto& renderer : *m_viewportConstrainedObjects) {
>         renderer->setNeedsLayout();
>+        if (renderer->hasLayer()) {
>+            auto* layer = downcast<RenderBoxModelObject>(*renderer).layer();
>+            layer->setNeedsCompositingGeometryUpdate();
>+        }
>+    }
> }
> 
> void FrameView::didChangeScrollOffset()
>diff --git a/Source/WebCore/page/Page.cpp b/Source/WebCore/page/Page.cpp
>index 4ce5f4295d9fafd4eccbb10b6623bfbed862208d..8dbb4dd1bfa9a9ef910f3bc54af74896830d7290 100644
>--- a/Source/WebCore/page/Page.cpp
>+++ b/Source/WebCore/page/Page.cpp
>@@ -879,8 +879,11 @@ void Page::setPageScaleFactor(float scale, const IntPoint& origin, bool inStable
>     m_pageScaleFactor = scale;
> 
>     if (!m_settings->delegatesPageScaling()) {
>-        if (document->renderView())
>-            document->renderView()->setNeedsLayout();
>+        if (auto* renderView = document->renderView()) {
>+            renderView->setNeedsLayout();
>+            if (renderView->hasLayer() && renderView->layer()->isComposited())
>+                renderView->layer()->setNeedsCompositingGeometryUpdate();
>+        }
> 
>         document->resolveStyle(Document::ResolveStyleType::Rebuild);
> 
>diff --git a/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp b/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp
>index d3b530cc9837afb0b598a05d6173133467e2d5f9..2be81dae078652e83fb7fa7a42a592e48e932ee2 100644
>--- a/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp
>+++ b/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp
>@@ -2156,8 +2156,10 @@ void GraphicsLayerCA::updateBackdropFilters(CommitState& commitState)
>         }
>     }
> 
>-    if (madeLayer)
>+    if (madeLayer) {
>         updateBackdropFiltersRect();
>+        noteSublayersChanged(DontScheduleFlush);
>+    }
> }
> 
> void GraphicsLayerCA::updateBackdropFiltersRect()
>diff --git a/Source/WebCore/platform/graphics/ca/TileController.cpp b/Source/WebCore/platform/graphics/ca/TileController.cpp
>index 621be17b3a392bebdbd9a12e38b5d296e9e07117..80cfc4fac345c92ecd61737fc9254dcd8b755bf8 100644
>--- a/Source/WebCore/platform/graphics/ca/TileController.cpp
>+++ b/Source/WebCore/platform/graphics/ca/TileController.cpp
>@@ -527,6 +527,11 @@ void TileController::tileSizeChangeTimerFired()
> }
> 
> IntSize TileController::tileSize() const
>+{
>+    return tileGrid().tileSize();
>+}
>+
>+IntSize TileController::computeTileSize()
> {
>     if (m_inLiveResize || m_tileSizeLocked)
>         return tileGrid().tileSize();
>diff --git a/Source/WebCore/platform/graphics/ca/TileController.h b/Source/WebCore/platform/graphics/ca/TileController.h
>index cdc066baeca60d00eb4469870a26f02ee147775d..ae19b8c5171fd5741a5515f76a69886662faf07c 100644
>--- a/Source/WebCore/platform/graphics/ca/TileController.h
>+++ b/Source/WebCore/platform/graphics/ca/TileController.h
>@@ -123,6 +123,8 @@ public:
>     void adjustTileCoverageRect(FloatRect& coverageRect, const FloatSize& newSize, const FloatRect& previousVisibleRect, const FloatRect& currentVisibleRect, float contentsScale) const override;
>     bool scrollingPerformanceLoggingEnabled() const override { return m_scrollingPerformanceLoggingEnabled; }
> 
>+    IntSize computeTileSize();
>+
>     IntRect boundsAtLastRevalidate() const { return m_boundsAtLastRevalidate; }
>     IntRect boundsAtLastRevalidateWithoutMargin() const;
>     void didRevalidateTiles();
>@@ -229,7 +231,7 @@ private:
>     bool m_tilesAreOpaque { false };
>     bool m_hasTilesWithTemporaryScaleFactor { false }; // Used to make low-res tiles when zooming.
>     bool m_inLiveResize { false };
>-    mutable bool m_tileSizeLocked { false };
>+    bool m_tileSizeLocked { false };
>     bool m_isTileSizeUpdateDelayDisabledForTesting { false };
> 
>     Color m_tileDebugBorderColor;
>diff --git a/Source/WebCore/platform/graphics/ca/TileGrid.cpp b/Source/WebCore/platform/graphics/ca/TileGrid.cpp
>index 1163d144d637298162efc33711c5173b382ec428..6851cc3b19bdbe533921aa48bef761d906d92379 100644
>--- a/Source/WebCore/platform/graphics/ca/TileGrid.cpp
>+++ b/Source/WebCore/platform/graphics/ca/TileGrid.cpp
>@@ -368,7 +368,7 @@ void TileGrid::revalidateTiles(TileValidationPolicy validationPolicy)
>     Seconds minimumRevalidationTimerDuration = Seconds::infinity();
>     bool needsTileRevalidation = false;
>     
>-    auto tileSize = m_controller.tileSize();
>+    auto tileSize = m_controller.computeTileSize();
>     if (tileSize != m_tileSize) {
>         removeAllTiles();
>         m_tileSize = tileSize;
>diff --git a/Source/WebCore/rendering/RenderBox.cpp b/Source/WebCore/rendering/RenderBox.cpp
>index ca6e7c145fbfe27e074cb11fce38a22836003060..167ef1030524da0d6ebeaefeb8b0c9ef3cc2c945 100644
>--- a/Source/WebCore/rendering/RenderBox.cpp
>+++ b/Source/WebCore/rendering/RenderBox.cpp
>@@ -261,7 +261,7 @@ void RenderBox::styleWillChange(StyleDifference diff, const RenderStyle& newStyl
>         if (diff >= StyleDifference::Repaint && (isDocumentElementRenderer() || isBody())) {
>             view().repaintRootContents();
>             if (oldStyle->hasEntirelyFixedBackground() != newStyle.hasEntirelyFixedBackground())
>-                view().compositor().rootFixedBackgroundsChanged();
>+                view().compositor().rootLayerConfigurationChanged();
>         }
>         
>         // When a layout hint happens and an object's position style changes, we have to do a layout
>diff --git a/Source/WebCore/rendering/RenderLayer.cpp b/Source/WebCore/rendering/RenderLayer.cpp
>index 7f58ac07e4a44361b1967c5e4a7e4531b8957d0c..de9a8a914932983d109ca6f37d5ef64a0b490418 100644
>--- a/Source/WebCore/rendering/RenderLayer.cpp
>+++ b/Source/WebCore/rendering/RenderLayer.cpp
>@@ -273,6 +273,7 @@ RenderLayer::RenderLayer(RenderLayerModelObject& rendererLayerModelObject)
>     , m_forcedStackingContext(rendererLayerModelObject.isMedia())
>     , m_zOrderListsDirty(false)
>     , m_normalFlowListDirty(true)
>+    , m_hadNegativeZOrderList(false)
>     , m_inResizeMode(false)
>     , m_scrollDimensionsDirty(true)
>     , m_hasSelfPaintingLayerDescendant(false)
>@@ -371,8 +372,8 @@ RenderLayer::~RenderLayer()
>     clearBacking(true);
> 
>     // Layer and all its children should be removed from the tree before destruction.
>-    RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(renderer().renderTreeBeingDestroyed() || !m_parent);
>-    RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(renderer().renderTreeBeingDestroyed() || !m_first);
>+    RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(renderer().renderTreeBeingDestroyed() || !parent());
>+    RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(renderer().renderTreeBeingDestroyed() || !firstChild());
> }
> 
> void RenderLayer::addChild(RenderLayer& child, RenderLayer* beforeChild)
>@@ -403,6 +404,15 @@ void RenderLayer::addChild(RenderLayer& child, RenderLayer* beforeChild)
>     if (child.isSelfPaintingLayer() || child.hasSelfPaintingLayerDescendant())
>         setAncestorChainHasSelfPaintingLayerDescendant();
> 
>+    if (compositor().inCompositingMode())
>+        setDescendantsNeedCompositingRequirementsTraversal();
>+
>+    if (child.hasDescendantNeedingCompositingRequirementsTraversal() || child.needsCompositingRequirementsTraversal())
>+        setAncestorsHaveCompositingDirtyFlag(HasDescendantNeedingCompositingRequirementsTraversal);
>+
>+    if (child.hasDescendantNeedingUpdateBackingOrHierachyTraversal() || child.needsUpdateBackingOrHierachyTraversal())
>+        setAncestorsHaveCompositingDirtyFlag(HasDescendantNeedingUpdateBackingOrHierachyTraversal);
>+
> #if ENABLE(CSS_COMPOSITING)
>     if (child.hasBlendMode() || (child.hasNotIsolatedBlendingDescendants() && !child.isolatesBlending()))
>         updateAncestorChainHasBlendingDescendants(); // Why not just dirty?
>@@ -440,6 +450,9 @@ void RenderLayer::removeChild(RenderLayer& oldChild)
>     if (oldChild.isSelfPaintingLayer() || oldChild.hasSelfPaintingLayerDescendant())
>         dirtyAncestorChainHasSelfPaintingLayerDescendantStatus();
> 
>+    if (compositor().inCompositingMode())
>+        setDescendantsNeedCompositingRequirementsTraversal();
>+
> #if ENABLE(CSS_COMPOSITING)
>     if (oldChild.hasBlendMode() || (oldChild.hasNotIsolatedBlendingDescendants() && !oldChild.isolatesBlending()))
>         dirtyAncestorChainHasBlendingDescendants();
>@@ -551,8 +564,6 @@ bool RenderLayer::shouldBeNormalFlowOnly() const
> 
> bool RenderLayer::shouldBeStackingContext() const
> {
>-    // Non-auto z-index always implies stacking context here, because StyleResolver::adjustRenderStyle already adjusts z-index
>-    // based on positioning and other criteria.
>     return !renderer().style().hasAutoZIndex() || isRenderViewLayer() || isForcedStackingContext();
> }
> 
>@@ -599,9 +610,19 @@ void RenderLayer::setParent(RenderLayer* parent)
>         compositor().layerWasAdded(*m_parent, *this);
> }
> 
>+RenderLayer* RenderLayer::stackingContext() const
>+{
>+    RenderLayer* layer = parent();
>+    while (layer && !layer->isStackingContext())
>+        layer = layer->parent();
>+
>+    ASSERT(!layer || layer->isStackingContext());
>+    return layer;
>+}
>+
> void RenderLayer::dirtyZOrderLists()
> {
>-    ASSERT(m_layerListMutationAllowed);
>+    ASSERT(layerListMutationAllowed());
>     ASSERT(isStackingContext());
> 
>     if (m_posZOrderList)
>@@ -610,8 +631,9 @@ void RenderLayer::dirtyZOrderLists()
>         m_negZOrderList->clear();
>     m_zOrderListsDirty = true;
> 
>-    if (!renderer().renderTreeBeingDestroyed())
>-        compositor().setCompositingLayersNeedRebuild();
>+    // FIXME: Ideally, we'd only dirty if the lists changed.
>+    if (hasCompositingDescendant())
>+        setNeedsCompositingPaintOrderChildrenUpdate();
> }
> 
> void RenderLayer::dirtyStackingContextZOrderLists()
>@@ -622,14 +644,14 @@ void RenderLayer::dirtyStackingContextZOrderLists()
> 
> void RenderLayer::dirtyNormalFlowList()
> {
>-    ASSERT(m_layerListMutationAllowed);
>+    ASSERT(layerListMutationAllowed());
> 
>     if (m_normalFlowList)
>         m_normalFlowList->clear();
>     m_normalFlowListDirty = true;
> 
>-    if (!renderer().renderTreeBeingDestroyed())
>-        compositor().setCompositingLayersNeedRebuild();
>+    if (hasCompositingDescendant())
>+        setNeedsCompositingPaintOrderChildrenUpdate();
> }
> 
> void RenderLayer::updateNormalFlowList()
>@@ -637,7 +659,7 @@ void RenderLayer::updateNormalFlowList()
>     if (!m_normalFlowListDirty)
>         return;
> 
>-    ASSERT(m_layerListMutationAllowed);
>+    ASSERT(layerListMutationAllowed());
> 
>     for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {
>         // Ignore non-overflow layers and reflections.
>@@ -653,10 +675,19 @@ void RenderLayer::updateNormalFlowList()
> 
> void RenderLayer::rebuildZOrderLists()
> {
>-    ASSERT(m_layerListMutationAllowed);
>+    ASSERT(layerListMutationAllowed());
>     ASSERT(isDirtyStackingContext());
>     rebuildZOrderLists(m_posZOrderList, m_negZOrderList);
>     m_zOrderListsDirty = false;
>+    
>+    bool hasNegativeZOrderList = m_negZOrderList && m_negZOrderList->size();
>+    // Having negative z-order lists affect whether a compositing layer needs a foreground layer.
>+    // Ideally we'd only trigger this when having z-order children changes, but we blow away the old z-order
>+    // lists on dirtying so we don't know the old state.
>+    if (hasNegativeZOrderList != m_hadNegativeZOrderList) {
>+        m_hadNegativeZOrderList = hasNegativeZOrderList;
>+        setNeedsCompositingConfigurationUpdate();
>+    }
> }
> 
> void RenderLayer::rebuildZOrderLists(std::unique_ptr<Vector<RenderLayer*>>& posZOrderList, std::unique_ptr<Vector<RenderLayer*>>& negZOrderList)
>@@ -704,6 +735,15 @@ void RenderLayer::collectLayers(bool includeHiddenLayers, std::unique_ptr<Vector
>     }
> }
> 
>+void RenderLayer::setAncestorsHaveCompositingDirtyFlag(CompositingStateFlag flag)
>+{
>+    for (auto* layer = paintOrderParent(); layer; layer = layer->paintOrderParent()) {
>+        if (layer->m_compositingDirtyBits.contains(flag))
>+            break;
>+        layer->m_compositingDirtyBits.add(flag);
>+    }
>+}
>+
> void RenderLayer::updateLayerListsIfNeeded()
> {
>     updateZOrderLists();
>@@ -765,8 +805,10 @@ RenderLayerCompositor& RenderLayer::compositor() const
> 
> void RenderLayer::contentChanged(ContentChangeType changeType)
> {
>-    if ((changeType == CanvasChanged || changeType == VideoChanged || changeType == FullScreenChanged || changeType == ImageChanged) && compositor().updateLayerCompositingState(*this))
>-        compositor().setCompositingLayersNeedRebuild();
>+    if (changeType == CanvasChanged || changeType == VideoChanged || changeType == FullScreenChanged || changeType == ImageChanged) {
>+        setNeedsPostLayoutCompositingUpdate();
>+        setNeedsCompositingConfigurationUpdate();
>+    }
> 
>     if (m_backing)
>         m_backing->contentChanged(changeType);
>@@ -879,11 +921,6 @@ void RenderLayer::updateLayerPositions(RenderGeometryMap* geometryMap, OptionSet
>     if (m_reflection)
>         m_reflection->layout();
> 
>-    // Clear the IsCompositingUpdateRoot flag once we've found the first compositing layer in this update.
>-    bool isUpdateRoot = flags.contains(IsCompositingUpdateRoot);
>-    if (isComposited())
>-        flags.remove(IsCompositingUpdateRoot);
>-
>     if (renderer().isInFlowRenderFragmentedFlow()) {
>         updatePagination();
>         flags.add(UpdatePagination);
>@@ -898,15 +935,6 @@ void RenderLayer::updateLayerPositions(RenderGeometryMap* geometryMap, OptionSet
>     for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
>         child->updateLayerPositions(geometryMap, flags);
> 
>-    if ((flags & UpdateCompositingLayers) && isComposited()) {
>-        OptionSet<RenderLayerBacking::UpdateAfterLayoutFlags> updateFlags;
>-        if (flags & NeedsFullRepaintInBacking)
>-            updateFlags.add(RenderLayerBacking::UpdateAfterLayoutFlags::NeedsFullRepaint);
>-        if (isUpdateRoot)
>-            updateFlags.add(RenderLayerBacking::UpdateAfterLayoutFlags::IsUpdateRoot);
>-        backing()->updateAfterLayout(updateFlags);
>-    }
>-        
>     // With all our children positioned, now update our marquee if we need to.
>     if (m_marquee) {
>         // FIXME: would like to use SetForScope<> but it doesn't work with bitfields.
>@@ -915,6 +943,9 @@ void RenderLayer::updateLayerPositions(RenderGeometryMap* geometryMap, OptionSet
>         m_marquee->updateMarqueePosition();
>         m_updatingMarqueePosition = oldUpdatingMarqueePosition;
>     }
>+    
>+    if (isComposited())
>+        backing()->updateAfterLayout(flags.contains(NeedsFullRepaintInBacking));
> 
>     if (geometryMap)
>         geometryMap->popMappingsToAncestor(parent());
>@@ -1139,8 +1170,11 @@ void RenderLayer::updateTransform()
>         makeMatrixRenderable(*m_transform, canRender3DTransforms());
>     }
> 
>-    if (had3DTransform != has3DTransform())
>+    if (had3DTransform != has3DTransform()) {
>         dirty3DTransformedDescendantStatus();
>+        // Having a 3D transform affects whether enclosing perspective and preserve-3d layers composite, so trigger an update.
>+        setNeedsPostLayoutCompositingUpdateOnAncestors();
>+    }
> }
> 
> TransformationMatrix RenderLayer::currentTransform(RenderStyle::ApplyTransformOrigin applyOrigin) const
>@@ -1522,6 +1556,16 @@ bool RenderLayer::updateLayerPosition()
>     
>     positionOrOffsetChanged |= location() != localPoint;
>     setLocation(localPoint);
>+    
>+    if (positionOrOffsetChanged && compositor().inCompositingMode()) {
>+        if (isComposited())
>+            setNeedsCompositingGeometryUpdate();
>+        // This layer's position can affect the location of a composited descendant (which may be a sibling in z-order),
>+        // so trigger a descendant walk from the paint-order parent.
>+        if (auto* paintParent = paintOrderParent())
>+            paintParent->setDescendantsNeedUpdateBackingAndHierarchyTraversal();
>+    }
>+
>     return positionOrOffsetChanged;
> }
> 
>@@ -1568,16 +1612,6 @@ FloatPoint RenderLayer::perspectiveOrigin() const
>                       floatValueForLength(style.perspectiveOriginY(), borderBox.height()));
> }
> 
>-RenderLayer* RenderLayer::stackingContext() const
>-{
>-    RenderLayer* layer = parent();
>-    while (layer && !layer->isStackingContext())
>-        layer = layer->parent();
>-
>-    ASSERT(!layer || layer->isStackingContext());
>-    return layer;
>-}
>-
> static inline bool isContainerForPositioned(RenderLayer& layer, PositionType position)
> {
>     switch (position) {
>@@ -1660,11 +1694,6 @@ RenderLayer* RenderLayer::enclosingTransformedAncestor() const
>     return curr;
> }
> 
>-static inline const RenderLayer* compositingContainer(const RenderLayer& layer)
>-{
>-    return layer.isNormalFlowOnly() ? layer.parent() : layer.stackingContext();
>-}
>-
> inline bool RenderLayer::shouldRepaintAfterLayout() const
> {
>     if (m_repaintStatus == NeedsNormalRepaint)
>@@ -1686,7 +1715,7 @@ RenderLayer* RenderLayer::enclosingCompositingLayer(IncludeSelfOrNot includeSelf
>     if (includeSelf == IncludeSelf && isComposited())
>         return const_cast<RenderLayer*>(this);
> 
>-    for (const RenderLayer* curr = compositingContainer(*this); curr; curr = compositingContainer(*curr)) {
>+    for (const RenderLayer* curr = paintOrderParent(); curr; curr = curr->paintOrderParent()) {
>         if (curr->isComposited())
>             return const_cast<RenderLayer*>(curr);
>     }
>@@ -1699,7 +1728,7 @@ RenderLayer* RenderLayer::enclosingCompositingLayerForRepaint(IncludeSelfOrNot i
>     if (includeSelf == IncludeSelf && compositedWithOwnBackingStore(*this))
>         return const_cast<RenderLayer*>(this);
> 
>-    for (const RenderLayer* curr = compositingContainer(*this); curr; curr = compositingContainer(*curr)) {
>+    for (const RenderLayer* curr = paintOrderParent(); curr; curr = curr->paintOrderParent()) {
>         if (compositedWithOwnBackingStore(*curr))
>             return const_cast<RenderLayer*>(curr);
>     }
>@@ -1788,7 +1817,7 @@ RenderLayer* RenderLayer::clippingRootForPainting() const
>         if (current->isRenderViewLayer())
>             return const_cast<RenderLayer*>(current);
> 
>-        current = compositingContainer(*current);
>+        current = current->paintOrderParent();
>         ASSERT(current);
>         if (current->transform() || compositedWithOwnBackingStore(*current))
>             return const_cast<RenderLayer*>(current);
>@@ -2326,8 +2355,10 @@ void RenderLayer::scrollTo(const ScrollPosition& position)
>     
>     if (m_scrollPosition == newPosition) {
> #if PLATFORM(IOS_FAMILY)
>-        if (m_requiresScrollBoundsOriginUpdate)
>+        if (m_requiresScrollBoundsOriginUpdate) {
>+            setNeedsCompositingGeometryUpdate();
>             updateCompositingLayersAfterScroll();
>+        }
> #endif
>         return;
>     }
>@@ -2352,6 +2383,11 @@ void RenderLayer::scrollTo(const ScrollPosition& position)
>             // positions. Updating layer positions requires a full walk of up-to-date RenderLayers, and
>             // in this case we're still updating their positions; we'll update compositing layers later
>             // when that completes.
>+            if (usesCompositedScrolling()) {
>+                setNeedsCompositingGeometryUpdate();
>+                setDescendantsNeedUpdateBackingAndHierarchyTraversal();
>+            }
>+
>             updateCompositingLayersAfterScroll();
>         }
> 
>@@ -2374,8 +2410,11 @@ void RenderLayer::scrollTo(const ScrollPosition& position)
>     frame.eventHandler().dispatchFakeMouseMoveEventSoonInQuad(quadForFakeMouseMoveEvent);
> 
>     bool requiresRepaint = true;
>-    if (compositor().inCompositingMode() && usesCompositedScrolling())
>+    if (compositor().inCompositingMode() && usesCompositedScrolling()) {
>+        setNeedsCompositingGeometryUpdate();
>+        setDescendantsNeedUpdateBackingAndHierarchyTraversal();
>         requiresRepaint = false;
>+    }
> 
>     // Just schedule a full repaint of our object.
>     if (requiresRepaint)
>@@ -2527,8 +2566,11 @@ void RenderLayer::updateCompositingLayersAfterScroll()
>         if (RenderLayer* compositingAncestor = stackingContext()->enclosingCompositingLayer()) {
>             if (usesCompositedScrolling())
>                 compositor().updateCompositingLayers(CompositingUpdateType::OnCompositedScroll, compositingAncestor);
>-            else
>+            else {
>+                // FIXME: would be nice to only dirty layers whose positions were affected by scrolling.
>+                compositingAncestor->setDescendantsNeedUpdateBackingAndHierarchyTraversal();
>                 compositor().updateCompositingLayers(CompositingUpdateType::OnScroll, compositingAncestor);
>+            }
>         }
>     }
> }
>@@ -3517,10 +3559,7 @@ void RenderLayer::updateScrollInfoAfterLayout()
>     if (originalScrollOffset != scrollOffset())
>         scrollToOffsetWithoutAnimation(IntPoint(scrollOffset()));
> 
>-    // Composited scrolling may need to be enabled or disabled if the amount of overflow changed.
>-    // FIXME: this should just dirty the layer and updateLayerPositions should do stuff.
>-    if (compositor().updateLayerCompositingState(*this))
>-        compositor().setCompositingLayersNeedRebuild();
>+    setNeedsCompositingGeometryUpdate(); // FIXME: probably need something more specific to scrolling.
> 
>     updateScrollSnapState();
> }
>@@ -4198,7 +4237,6 @@ void RenderLayer::paintLayerContents(GraphicsContext& context, const LayerPainti
>     if (localPaintFlags & PaintLayerPaintingRootBackgroundOnly && !renderer().isRenderView() && !renderer().isDocumentElementRenderer())
>         return;
> 
>-    // Ensure our lists are up-to-date.
>     updateLayerListsIfNeeded();
> 
>     LayoutSize offsetFromRoot = offsetFromAncestor(paintingInfo.rootLayer);
>@@ -4791,8 +4829,6 @@ bool RenderLayer::hitTest(const HitTestRequest& request, const HitTestLocation&
>     ASSERT(isSelfPaintingLayer() || hasSelfPaintingLayerDescendant());
>     ASSERT(!renderer().view().needsLayout());
>     
>-    updateLayerListsIfNeeded();
>-
>     ASSERT(!isRenderFragmentedFlow());
>     LayoutRect hitTestArea = renderer().view().documentRect();
>     if (!request.ignoreClipping()) {
>@@ -4935,6 +4971,8 @@ RenderLayer* RenderLayer::hitTestLayer(RenderLayer* rootLayer, RenderLayer* cont
>                                        const LayoutRect& hitTestRect, const HitTestLocation& hitTestLocation, bool appliedTransform,
>                                        const HitTestingTransformState* transformState, double* zOffset)
> {
>+    updateLayerListsIfNeeded();
>+
>     if (!isSelfPaintingLayer() && !hasSelfPaintingLayerDescendant())
>         return nullptr;
> 
>@@ -4958,7 +4996,6 @@ RenderLayer* RenderLayer::hitTestLayer(RenderLayer* rootLayer, RenderLayer* cont
>     }
> 
>     // Ensure our lists and 3d status are up-to-date.
>-    updateCompositingAndLayerListsIfNeeded();
>     update3DTransformedDescendantStatus();
> 
>     RefPtr<HitTestingTransformState> localTransformState;
>@@ -5956,7 +5993,7 @@ bool RenderLayer::backgroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect)
>     // FIXME: Remove this check.
>     // This function should not be called when layer-lists are dirty.
>     // It is somehow getting triggered during style update.
>-    if (m_zOrderListsDirty || m_normalFlowListDirty)
>+    if (zOrderListsDirty() || normalFlowListDirty())
>         return false;
> 
>     // Table painting is special; a table paints its sections.
>@@ -6000,17 +6037,6 @@ bool RenderLayer::listBackgroundIsKnownToBeOpaqueInRect(const LayerList& list, c
>     return false;
> }
> 
>-void RenderLayer::updateCompositingAndLayerListsIfNeeded()
>-{
>-    if (compositor().inCompositingMode()) {
>-        if (isDirtyStackingContext() || m_normalFlowListDirty)
>-            compositor().updateCompositingLayers(CompositingUpdateType::OnHitTest, this);
>-        return;
>-    }
>-
>-    updateLayerListsIfNeeded();
>-}
>-
> void RenderLayer::repaintIncludingDescendants()
> {
>     renderer().repaint();
>@@ -6583,8 +6609,11 @@ void showLayerTree(const WebCore::RenderObject* renderer)
> static void outputPaintOrderTreeLegend(TextStream& stream)
> {
>     stream.nextLine();
>-    stream << "(S)tacking Context, (N)ormal flow only, (O)verflow clip, (A)lpha (opacity or mask), (T)ransform-ish, (F)ilter, Fi(X)ed position, (C)omposited\n"
>-        "Dirty (z)-lists, Dirty (n)ormal flow lists";
>+    stream << "(S)tacking Context, (N)ormal flow only, (O)verflow clip, (A)lpha (opacity or mask), has (B)lend mode, (I)solates blending, (T)ransform-ish, (F)ilter, Fi(X)ed position, (C)omposited\n"
>+        "Dirty (z)-lists, Dirty (n)ormal flow lists\n"
>+        "Descendant needs overlap (t)raversal, Descendant needs (b)acking or hierarchy update, All descendants need (r)equirements traversal, All descendants need (h)ierarchy traversal\n"
>+        "(d)irect compositing changed, Needs compositing paint (o)rder children update, "
>+        "Needs post-(l)ayout update, Needs compositing (g)eometry update, (k)ids need geometry update, Needs compositing (c)onfig update, Needs compositing layer conne(x)ion update";
>     stream.nextLine();
> }
> 
>@@ -6601,6 +6630,8 @@ static void outputPaintOrderTreeRecursive(TextStream& stream, const WebCore::Ren
>     stream << (layer.isNormalFlowOnly() ? "N" : "-");
>     stream << (layer.renderer().hasOverflowClip() ? "O" : "-");
>     stream << (layer.isTransparent() ? "A" : "-");
>+    stream << (layer.hasBlendMode() ? "B" : "-");
>+    stream << (layer.isolatesBlending() ? "I" : "-");
>     stream << (layer.renderer().hasTransformRelatedProperty() ? "T" : "-");
>     stream << (layer.hasFilter() ? "F" : "-");
>     stream << (layer.renderer().isFixedPositioned() ? "X" : "-");
>@@ -6611,6 +6642,25 @@ static void outputPaintOrderTreeRecursive(TextStream& stream, const WebCore::Ren
>     stream << (layer.zOrderListsDirty() ? "z" : "-");
>     stream << (layer.normalFlowListDirty() ? "n" : "-");
> 
>+    stream << " ";
>+
>+    stream << (layer.hasDescendantNeedingCompositingRequirementsTraversal() ? "t" : "-");
>+    stream << (layer.hasDescendantNeedingUpdateBackingOrHierachyTraversal() ? "b" : "-");
>+    stream << (layer.descendantsNeedCompositingRequirementsTraversal() ? "r" : "-");
>+    stream << (layer.descendantsNeedUpdateBackingAndHierarchyTraversal() ? "h" : "-");
>+
>+    stream << " ";
>+
>+    stream << (layer.directCompositingStateChanged() ? "d" : "-");
>+    stream << (layer.needsCompositingPaintOrderChildrenUpdate() ? "o" : "-");
>+    stream << (layer.needsPostLayoutCompositingUpdate() ? "l" : "-");
>+    stream << (layer.needsCompositingGeometryUpdate() ? "g" : "-");
>+    stream << (layer.childrenNeedCompositingGeometryUpdate() ? "k" : "-");
>+    stream << (layer.needsCompositingConfigurationUpdate() ? "c" : "-");
>+    stream << (layer.needsCompositingLayerConnection() ? "x" : "-");
>+
>+    stream << " ";
>+
>     outputIdent(stream, depth);
> 
>     stream << prefix;
>diff --git a/Source/WebCore/rendering/RenderLayer.h b/Source/WebCore/rendering/RenderLayer.h
>index e35aeba6cdbb6aed2612c0815f49984154bcbcec..9f35970c0b88327b8a7c78599e41a25a4da8dfd4 100644
>--- a/Source/WebCore/rendering/RenderLayer.h
>+++ b/Source/WebCore/rendering/RenderLayer.h
>@@ -178,6 +178,8 @@ public:
>     // itself, if it is a stacking container.
>     RenderLayer* enclosingStackingContext() { return isStackingContext() ? this : stackingContext(); }
> 
>+    RenderLayer* paintOrderParent() const;
>+
>     void dirtyNormalFlowList();
>     void dirtyZOrderLists();
>     void dirtyStackingContextZOrderLists();
>@@ -185,6 +187,148 @@ public:
>     bool normalFlowListDirty() const { return m_normalFlowListDirty; }
>     bool zOrderListsDirty() const { return m_zOrderListsDirty; }
> 
>+#if !ASSERT_DISABLED
>+    bool layerListMutationAllowed() const { return m_layerListMutationAllowed; }
>+    void setLayerListMutationAllowed(bool flag) { m_layerListMutationAllowed = flag; }
>+#endif
>+
>+private:
>+    // These flags propagate in paint order (z-order tree).
>+    enum CompositingStateFlag {
>+        HasDescendantNeedingCompositingRequirementsTraversal    = 1 << 0, // Need to do the overlap-testing tree walk because hierarchy or geometry changed.
>+        HasDescendantNeedingUpdateBackingOrHierachyTraversal    = 1 << 1, // Need to hook up GraphicsLayers for some descendant.
>+
>+        // Things that trigger HasDescendantNeedingCompositingRequirementsTraversal
>+        DirectCompositingStateChanged                           = 1 << 2, // Compositing on this layer changed for direct reaons.
>+        NeedsCompositingPaintOrderChildrenUpdate                = 1 << 3, // The paint order children of this layer changed (gained/lost child, order change).
>+        NeedsPostLayoutCompositingUpdate                        = 1 << 4, // Needs compositing to be re-evaluated after layout (it depends on geometry).
>+        DescendantsNeedCompositingRequirementsTraversal         = 1 << 5, // Something changed that forces us to traverse all descendant layers in computeCompositingRequirements.
>+
>+        // Things that trigger HasDescendantNeedingUpdateBackingOrHierachyTraversal
>+        NeedsCompositingGeometryUpdate                          = 1 << 6, // This layer needs a geometry update.
>+        NeedsCompositingConfigurationUpdate                     = 1 << 7, // This layer needs a configuration update (updating its internal compositing hierarchy).
>+        NeedsCompositingLayerConnection                         = 1 << 8, // This layer needs hookup with its parents or children.
>+        ChildrenNeedCompositingGeometryUpdate                   = 1 << 9, // This layer's composited children needs a geometry update.
>+        DescendantsNeedUpdateBackingAndHierarchyTraversal       = 1 << 10, // Something changed that forces us to traverse all descendant layers in updateBackingAndHierarchy.
>+    };
>+
>+    static constexpr OptionSet<CompositingStateFlag> computeCompositingRequirementsFlags()
>+    {
>+        return {
>+            DirectCompositingStateChanged,
>+            NeedsCompositingPaintOrderChildrenUpdate,
>+            NeedsPostLayoutCompositingUpdate,
>+            DescendantsNeedCompositingRequirementsTraversal,
>+        };
>+    }
>+
>+    static constexpr OptionSet<CompositingStateFlag> updateBackingOrHierachyFlags()
>+    {
>+        return {
>+            NeedsCompositingLayerConnection,
>+            NeedsCompositingGeometryUpdate,
>+            NeedsCompositingConfigurationUpdate,
>+            ChildrenNeedCompositingGeometryUpdate,
>+            DescendantsNeedUpdateBackingAndHierarchyTraversal,
>+        };
>+    }
>+
>+    void setAncestorsHaveCompositingDirtyFlag(CompositingStateFlag);
>+
>+public:
>+    bool hasDescendantNeedingCompositingRequirementsTraversal() const { return m_compositingDirtyBits.contains(HasDescendantNeedingCompositingRequirementsTraversal); }
>+    bool hasDescendantNeedingUpdateBackingOrHierachyTraversal() const { return m_compositingDirtyBits.contains(HasDescendantNeedingUpdateBackingOrHierachyTraversal); }
>+
>+    bool directCompositingStateChanged() const { return m_compositingDirtyBits.contains(DirectCompositingStateChanged); }
>+    void setDirectCompositingStateChanged()
>+    {
>+        m_compositingDirtyBits.add(DirectCompositingStateChanged);
>+        setAncestorsHaveCompositingDirtyFlag(HasDescendantNeedingCompositingRequirementsTraversal);
>+    }
>+
>+    bool needsCompositingPaintOrderChildrenUpdate() const { return m_compositingDirtyBits.contains(NeedsCompositingPaintOrderChildrenUpdate); }
>+    void setNeedsCompositingPaintOrderChildrenUpdate()
>+    {
>+        m_compositingDirtyBits.add(NeedsCompositingPaintOrderChildrenUpdate);
>+        setAncestorsHaveCompositingDirtyFlag(HasDescendantNeedingCompositingRequirementsTraversal);
>+    }
>+
>+    bool needsPostLayoutCompositingUpdate() const { return m_compositingDirtyBits.contains(NeedsPostLayoutCompositingUpdate); }
>+    void setNeedsPostLayoutCompositingUpdate()
>+    {
>+        m_compositingDirtyBits.add(NeedsPostLayoutCompositingUpdate);
>+        setAncestorsHaveCompositingDirtyFlag(HasDescendantNeedingCompositingRequirementsTraversal);
>+    }
>+
>+    void setNeedsPostLayoutCompositingUpdateOnAncestors()
>+    {
>+        setAncestorsHaveCompositingDirtyFlag(NeedsPostLayoutCompositingUpdate);
>+    }
>+
>+    bool descendantsNeedCompositingRequirementsTraversal() const { return m_compositingDirtyBits.contains(DescendantsNeedCompositingRequirementsTraversal); }
>+    void setDescendantsNeedCompositingRequirementsTraversal()
>+    {
>+        m_compositingDirtyBits.add(DescendantsNeedCompositingRequirementsTraversal);
>+        setAncestorsHaveCompositingDirtyFlag(HasDescendantNeedingCompositingRequirementsTraversal);
>+    }
>+
>+    bool needsCompositingGeometryUpdate() const { return m_compositingDirtyBits.contains(NeedsCompositingGeometryUpdate); }
>+    void setNeedsCompositingGeometryUpdate()
>+    {
>+        m_compositingDirtyBits.add(NeedsCompositingGeometryUpdate);
>+        setAncestorsHaveCompositingDirtyFlag(HasDescendantNeedingUpdateBackingOrHierachyTraversal);
>+    }
>+
>+    bool childrenNeedCompositingGeometryUpdate() const { return m_compositingDirtyBits.contains(ChildrenNeedCompositingGeometryUpdate); }
>+    void setChildrenNeedCompositingGeometryUpdate()
>+    {
>+        m_compositingDirtyBits.add(ChildrenNeedCompositingGeometryUpdate);
>+        setAncestorsHaveCompositingDirtyFlag(HasDescendantNeedingUpdateBackingOrHierachyTraversal);
>+    }
>+
>+    void setNeedsCompositingGeometryUpdateOnAncestors()
>+    {
>+        setAncestorsHaveCompositingDirtyFlag(NeedsCompositingGeometryUpdate);
>+    }
>+
>+    bool needsCompositingConfigurationUpdate() const { return m_compositingDirtyBits.contains(NeedsCompositingConfigurationUpdate); }
>+    void setNeedsCompositingConfigurationUpdate()
>+    {
>+        m_compositingDirtyBits.add(NeedsCompositingConfigurationUpdate);
>+        setAncestorsHaveCompositingDirtyFlag(HasDescendantNeedingUpdateBackingOrHierachyTraversal);
>+    }
>+
>+    bool needsCompositingLayerConnection() const { return m_compositingDirtyBits.contains(NeedsCompositingLayerConnection); }
>+    void setNeedsCompositingLayerConnection()
>+    {
>+        m_compositingDirtyBits.add(NeedsCompositingLayerConnection);
>+        setAncestorsHaveCompositingDirtyFlag(HasDescendantNeedingUpdateBackingOrHierachyTraversal);
>+    }
>+
>+    bool descendantsNeedUpdateBackingAndHierarchyTraversal() const { return m_compositingDirtyBits.contains(DescendantsNeedUpdateBackingAndHierarchyTraversal); }
>+    void setDescendantsNeedUpdateBackingAndHierarchyTraversal()
>+    {
>+        m_compositingDirtyBits.add(DescendantsNeedUpdateBackingAndHierarchyTraversal);
>+        setAncestorsHaveCompositingDirtyFlag(HasDescendantNeedingUpdateBackingOrHierachyTraversal);
>+    }
>+
>+    bool needsCompositingRequirementsTraversal() const { return m_compositingDirtyBits.containsAny(computeCompositingRequirementsFlags()); }
>+    void clearCompositingRequirementsTraversalState()
>+    {
>+        m_compositingDirtyBits.remove(HasDescendantNeedingCompositingRequirementsTraversal);
>+        m_compositingDirtyBits.remove(computeCompositingRequirementsFlags());
>+    }
>+
>+    bool needsUpdateBackingOrHierachyTraversal() const { return m_compositingDirtyBits.containsAny(updateBackingOrHierachyFlags()); }
>+    void clearUpdateBackingOrHierachyTraversalState()
>+    {
>+        m_compositingDirtyBits.remove(HasDescendantNeedingUpdateBackingOrHierachyTraversal);
>+        m_compositingDirtyBits.remove(updateBackingOrHierachyFlags());
>+    }
>+
>+    bool needsAnyCompositingTraversal() const { return !m_compositingDirtyBits.isEmpty(); }
>+    void clearCompositingPaintOrderState() { m_compositingDirtyBits = { }; }
>+
>     class LayerList {
>         friend class RenderLayer;
>     public:
>@@ -243,6 +387,7 @@ public:
> 
>     // Update our normal and z-index lists.
>     void updateLayerListsIfNeeded();
>+    void updateDescendantDependentFlags();
> 
>     void repaintIncludingDescendants();
> 
>@@ -274,7 +419,7 @@ public:
>     void setLocation(const LayoutPoint& p) { m_topLeft = p; }
> 
>     const IntSize& size() const { return m_layerSize; }
>-    void setSize(const IntSize& size) { m_layerSize = size; }
>+    void setSize(const IntSize& size) { m_layerSize = size; } // Only public for RenderTreeAsText.
> 
>     LayoutRect rect() const { return LayoutRect(location(), size()); }
> 
>@@ -384,13 +529,11 @@ public:
>     enum UpdateLayerPositionsFlag {
>         CheckForRepaint                 = 1 << 0,
>         NeedsFullRepaintInBacking       = 1 << 1,
>-        IsCompositingUpdateRoot         = 1 << 2,
>-        UpdateCompositingLayers         = 1 << 3,
>-        UpdatePagination                = 1 << 4,
>-        SeenTransformedLayer            = 1 << 5,
>-        Seen3DTransformedLayer          = 1 << 6,
>+        UpdatePagination                = 1 << 2,
>+        SeenTransformedLayer            = 1 << 3,
>+        Seen3DTransformedLayer          = 1 << 4,
>     };
>-    static constexpr OptionSet<UpdateLayerPositionsFlag> updateLayerPositionsDefaultFlags() { return { CheckForRepaint, IsCompositingUpdateRoot, UpdateCompositingLayers }; }
>+    static constexpr OptionSet<UpdateLayerPositionsFlag> updateLayerPositionsDefaultFlags() { return { CheckForRepaint }; }
> 
>     void updateLayerPositionsAfterLayout(const RenderLayer* rootLayer, OptionSet<UpdateLayerPositionsFlag>);
> 
>@@ -708,11 +851,6 @@ public:
>     bool paintsWithFilters() const;
>     bool requiresFullLayerImageForFilters() const;
> 
>-#if !ASSERT_DISABLED
>-    bool layerListMutationAllowed() const { return m_layerListMutationAllowed; }
>-    void setLayerListMutationAllowed(bool flag) { m_layerListMutationAllowed = flag; }
>-#endif
>-
>     Element* enclosingElement() const;
> 
>     enum ViewportConstrainedNotCompositedReason {
>@@ -731,7 +869,7 @@ public:
>     bool isDirtyRenderFragmentedFlow() const
>     {
>         ASSERT(isRenderFragmentedFlow());
>-        return m_zOrderListsDirty || m_normalFlowListDirty;
>+        return zOrderListsDirty() || normalFlowListDirty();
>     }
> 
>     RenderLayer* enclosingFragmentedFlowAncestor() const;
>@@ -796,7 +934,6 @@ private:
>     void calculateClipRects(const ClipRectsContext&, ClipRects&) const;
>     ClipRects* clipRects(const ClipRectsContext&) const;
> 
>-
>     void setAncestorChainHasSelfPaintingLayerDescendant();
>     void dirtyAncestorChainHasSelfPaintingLayerDescendantStatus();
> 
>@@ -835,8 +972,6 @@ private:
> 
>     LayoutPoint renderBoxLocation() const { return is<RenderBox>(renderer()) ? downcast<RenderBox>(renderer()).location() : LayoutPoint(); }
> 
>-    void updateCompositingAndLayerListsIfNeeded();
>-
>     bool setupFontSubpixelQuantization(GraphicsContext&, bool& didQuantizeFonts);
> 
>     Path computeClipPath(const LayoutSize& offsetFromRoot, LayoutRect& rootRelativeBounds, WindRule&) const;
>@@ -957,8 +1092,6 @@ private:
>     void dirtyAncestorChainVisibleDescendantStatus();
>     void setAncestorChainHasVisibleDescendant();
> 
>-    void updateDescendantDependentFlags();
>-
>     bool has3DTransformedDescendant() const { return m_has3DTransformedDescendant; }
> 
>     bool hasTransformedAncestor() const { return m_hasTransformedAncestor; }
>@@ -1036,7 +1169,7 @@ private:
> 
>     bool overflowControlsIntersectRect(const IntRect& localRect) const;
> 
>-    // The bitfields are up here so they will fall into the padding from ScrollableArea on 64-bit.
>+    OptionSet<CompositingStateFlag> m_compositingDirtyBits;
> 
>     const bool m_isRenderViewLayer : 1;
>     const bool m_forcedStackingContext : 1;
>@@ -1046,6 +1179,7 @@ private:
> 
>     bool m_zOrderListsDirty : 1;
>     bool m_normalFlowListDirty: 1;
>+    bool m_hadNegativeZOrderList : 1;
> 
>     // Keeps track of whether the layer is currently resizing, so events can cause resizing to start and stop.
>     bool m_inResizeMode : 1;
>@@ -1175,7 +1309,7 @@ private:
> inline void RenderLayer::clearZOrderLists()
> {
>     ASSERT(!isStackingContext());
>-    ASSERT(m_layerListMutationAllowed);
>+    ASSERT(layerListMutationAllowed());
> 
>     m_posZOrderList = nullptr;
>     m_negZOrderList = nullptr;
>@@ -1195,6 +1329,11 @@ inline void RenderLayer::updateZOrderLists()
>     rebuildZOrderLists();
> }
> 
>+inline RenderLayer* RenderLayer::paintOrderParent() const
>+{
>+    return m_isNormalFlowOnly ? m_parent : stackingContext();
>+}
>+
> #if !ASSERT_DISABLED
> class LayerListMutationDetector {
> public:
>diff --git a/Source/WebCore/rendering/RenderLayerBacking.cpp b/Source/WebCore/rendering/RenderLayerBacking.cpp
>index 88d6e01dd6efc6e2f7a9bc24339d4844adf2ad7a..869be04cf2072cf94245fc2ab16008f128327b48 100644
>--- a/Source/WebCore/rendering/RenderLayerBacking.cpp
>+++ b/Source/WebCore/rendering/RenderLayerBacking.cpp
>@@ -591,7 +591,7 @@ static bool hasNonZeroTransformOrigin(const RenderObject& renderer)
>         || (style.transformOriginY().type() == Fixed && style.transformOriginY().value());
> }
> 
>-void RenderLayerBacking::updateCompositedBounds()
>+bool RenderLayerBacking::updateCompositedBounds()
> {
>     LayoutRect layerBounds = m_owningLayer.calculateLayerBounds(&m_owningLayer, LayoutSize(), RenderLayer::defaultCalculateLayerBoundsFlags() | RenderLayer::ExcludeHiddenDescendants | RenderLayer::DontConstrainForMask);
>     // Clip to the size of the document or enclosing overflow-scroll layer.
>@@ -626,82 +626,99 @@ void RenderLayerBacking::updateCompositedBounds()
>     } else
>         m_artificiallyInflatedBounds = false;
> 
>-    setCompositedBounds(layerBounds);
>+    return setCompositedBounds(layerBounds);
> }
> 
> void RenderLayerBacking::updateAfterWidgetResize()
> {
>     if (!is<RenderWidget>(renderer()))
>         return;
>+
>     if (auto* innerCompositor = RenderLayerCompositor::frameContentsCompositor(&downcast<RenderWidget>(renderer()))) {
>         innerCompositor->frameViewDidChangeSize();
>         innerCompositor->frameViewDidChangeLocation(flooredIntPoint(contentsBox().location()));
>     }
> }
> 
>-void RenderLayerBacking::updateAfterLayout(OptionSet<UpdateAfterLayoutFlags> flags)
>+void RenderLayerBacking::updateAfterLayout(bool needsFullRepaint)
> {
>     LOG(Compositing, "RenderLayerBacking %p updateAfterLayout (layer %p)", this, &m_owningLayer);
> 
>-    if (!compositor().compositingLayersNeedRebuild()) {
>-        // Calling updateGeometry() here gives incorrect results, because the
>-        // position of this layer's GraphicsLayer depends on the position of our compositing
>-        // ancestor's GraphicsLayer. That cannot be determined until all the descendant 
>-        // RenderLayers of that ancestor have been processed via updateLayerPositions().
>-        //
>-        // The solution is to update compositing children of this layer here,
>-        // via updateCompositingChildrenGeometry().
>-        updateCompositedBounds();
>-        compositor().updateCompositingDescendantGeometry(m_owningLayer, m_owningLayer);
>-        
>-        if (flags.contains(UpdateAfterLayoutFlags::IsUpdateRoot)) {
>-            updateGeometry();
>-            updateAfterDescendants();
>-            compositor().updateRootLayerPosition();
>-            auto* stackingContext = m_owningLayer.enclosingStackingContext();
>-            if (!compositor().compositingLayersNeedRebuild() && stackingContext && (stackingContext != &m_owningLayer))
>-                compositor().updateCompositingDescendantGeometry(*stackingContext, *stackingContext);
>-        }
>+    // This is the main trigger for layout changing layer geometry, but we have to do the work again in updateBackingAndHierarchy()
>+    // when we know the final compositing hierarchy. We can't just set dirty bits from RenderLayer::setSize() because that doesn't
>+    // take overflow into account.
>+    if (updateCompositedBounds()) {
>+        m_owningLayer.setNeedsCompositingGeometryUpdate();
>+        // This layer's geometry affects those of its children (FIXME: an we make this go only one level deep?).
>+        m_owningLayer.setDescendantsNeedUpdateBackingAndHierarchyTraversal();
>     }
>     
>-    if (flags.contains(UpdateAfterLayoutFlags::NeedsFullRepaint) && canIssueSetNeedsDisplay())
>+    if (needsFullRepaint && canIssueSetNeedsDisplay())
>         setContentsNeedDisplay();
> }
> 
>+// This can only update things that don't require up-to-date layout.
>+void RenderLayerBacking::updateConfigurationAfterStyleChange()
>+{
>+    updateMaskingLayer(renderer().hasMask(), renderer().hasClipPath());
>+
>+    if (m_owningLayer.hasReflection()) {
>+        if (m_owningLayer.reflectionLayer()->backing()) {
>+            auto* reflectionLayer = m_owningLayer.reflectionLayer()->backing()->graphicsLayer();
>+            m_graphicsLayer->setReplicatedByLayer(reflectionLayer);
>+        }
>+    } else
>+        m_graphicsLayer->setReplicatedByLayer(nullptr);
>+
>+    // FIXME: do we care if opacity is animating?
>+    auto& style = renderer().style();
>+    updateOpacity(style);
>+    updateFilters(style);
>+
>+#if ENABLE(FILTERS_LEVEL_2)
>+    updateBackdropFilters(style);
>+#endif
>+#if ENABLE(CSS_COMPOSITING)
>+    updateBlendMode(style);
>+#endif
>+    updateCustomAppearance(style);
>+}
>+
> bool RenderLayerBacking::updateConfiguration()
> {
>-    m_owningLayer.updateDescendantDependentFlags();
>-    m_owningLayer.updateZOrderLists();
>+    ASSERT(!m_owningLayer.normalFlowListDirty());
>+    ASSERT(!m_owningLayer.zOrderListsDirty());
>+    ASSERT(!renderer().view().needsLayout());
> 
>     bool layerConfigChanged = false;
>+
>     setBackgroundLayerPaintsFixedRootBackground(compositor().needsFixedRootBackgroundLayer(m_owningLayer));
>-    
>-    // The background layer is currently only used for fixed root backgrounds.
>+
>     if (updateBackgroundLayer(m_backgroundLayerPaintsFixedRootBackground || m_requiresBackgroundLayer))
>         layerConfigChanged = true;
> 
>     if (updateForegroundLayer(compositor().needsContentsCompositingLayer(m_owningLayer)))
>         layerConfigChanged = true;
>     
>+    // This requires descendants to have been updated.
>     bool needsDescendantsClippingLayer = compositor().clipsCompositingDescendants(m_owningLayer);
>+    bool usesCompositedScrolling = m_owningLayer.hasTouchScrollableOverflow();
> 
>-    if (!renderer().view().needsLayout()) {
>-        bool usesCompositedScrolling = m_owningLayer.hasTouchScrollableOverflow();
>-
>-        // Our scrolling layer will clip.
>-        if (usesCompositedScrolling)
>-            needsDescendantsClippingLayer = false;
>+    // Our scrolling layer will clip.
>+    if (usesCompositedScrolling)
>+        needsDescendantsClippingLayer = false;
> 
>-        if (updateScrollingLayers(usesCompositedScrolling))
>-            layerConfigChanged = true;
>+    if (updateScrollingLayers(usesCompositedScrolling))
>+        layerConfigChanged = true;
> 
>-        if (updateDescendantClippingLayer(needsDescendantsClippingLayer))
>-            layerConfigChanged = true;
>-    }
>+    if (updateDescendantClippingLayer(needsDescendantsClippingLayer))
>+        layerConfigChanged = true;
> 
>+    // clippedByAncestor() does a tree walk.
>     if (updateAncestorClippingLayer(compositor().clippedByAncestor(m_owningLayer)))
>         layerConfigChanged = true;
> 
>+    // Requires layout.
>     if (updateOverflowControlsLayers(requiresHorizontalScrollbarLayer(), requiresVerticalScrollbarLayer(), requiresScrollCornerLayer()))
>         layerConfigChanged = true;
> 
>@@ -727,12 +744,14 @@ bool RenderLayerBacking::updateConfiguration()
> 
>     PaintedContentsInfo contentsInfo(*this);
> 
>+    // Requires layout.
>     if (!m_owningLayer.isRenderViewLayer()) {
>         bool didUpdateContentsRect = false;
>         updateDirectlyCompositedBoxDecorations(contentsInfo, didUpdateContentsRect);
>     } else
>         updateRootLayerConfiguration();
>     
>+    // Requires layout.
>     if (contentsInfo.isDirectlyCompositedImage())
>         updateImageContents(contentsInfo);
> 
>@@ -752,6 +771,7 @@ bool RenderLayerBacking::updateConfiguration()
>     else if (is<RenderVideo>(renderer()) && downcast<RenderVideo>(renderer()).shouldDisplayVideo()) {
>         auto* mediaElement = downcast<HTMLMediaElement>(renderer().element());
>         m_graphicsLayer->setContentsToPlatformLayer(mediaElement->platformLayer(), GraphicsLayer::ContentsLayerPurpose::Media);
>+        // Requires layout.
>         resetContentsRect();
>     }
> #endif
>@@ -760,11 +780,14 @@ bool RenderLayerBacking::updateConfiguration()
>         const HTMLCanvasElement* canvas = downcast<HTMLCanvasElement>(renderer().element());
>         if (auto* context = canvas->renderingContext())
>             m_graphicsLayer->setContentsToPlatformLayer(context->platformLayer(), GraphicsLayer::ContentsLayerPurpose::Canvas);
>+
>         layerConfigChanged = true;
>     }
> #endif
>-    if (is<RenderWidget>(renderer()))
>-        layerConfigChanged = RenderLayerCompositor::parentFrameContentLayers(&downcast<RenderWidget>(renderer()));
>+    if (is<RenderWidget>(renderer()) && RenderLayerCompositor::parentFrameContentLayers(&downcast<RenderWidget>(renderer()))) {
>+        m_owningLayer.setNeedsCompositingGeometryUpdate();
>+        layerConfigChanged = true;
>+    }
> 
>     return layerConfigChanged;
> }
>@@ -894,6 +917,7 @@ LayoutRect RenderLayerBacking::computePrimaryGraphicsLayerRect(const LayoutRect&
>         deviceScaleFactor()));
> }
> 
>+// FIXME: don't need this is updateGeometry() is always called in post-order traversal. Or do we?
> LayoutRect RenderLayerBacking::computeParentGraphicsLayerRect(RenderLayer* compositedAncestor, LayoutSize& ancestorClippingLayerOffset) const
> {
>     if (!compositedAncestor || !compositedAncestor->backing())
>@@ -945,7 +969,8 @@ LayoutRect RenderLayerBacking::computeParentGraphicsLayerRect(RenderLayer* compo
> void RenderLayerBacking::updateGeometry()
> {
>     // If we haven't built z-order lists yet, wait until later.
>-    if (m_owningLayer.isStackingContext() && m_owningLayer.m_zOrderListsDirty)
>+    // FIXME: this should never happen.
>+    if (m_owningLayer.isStackingContext() && m_owningLayer.zOrderListsDirty())
>         return;
> 
>     const RenderStyle& style = renderer().style();
>@@ -978,7 +1003,7 @@ void RenderLayerBacking::updateGeometry()
> #if ENABLE(CSS_COMPOSITING)
>     updateBlendMode(style);
> #endif
>-    m_owningLayer.updateDescendantDependentFlags();
>+    m_owningLayer.updateDescendantDependentFlags(); // FIXME: should be removable.
> 
>     // FIXME: reflections should force transform-style to be flat in the style: https://bugs.webkit.org/show_bug.cgi?id=106959
>     bool preserves3D = style.transformStyle3D() == TransformStyle3D::Preserve3D && !renderer().hasReflection();
>@@ -1019,7 +1044,7 @@ void RenderLayerBacking::updateGeometry()
>         m_contentsContainmentLayer->setSize(primaryGraphicsLayerRect.size());
>     }
> 
>-    // Compute renderer offset from primary graphics layer. Note that primaryGraphicsLayerRect is in parentGraphicsLayer's coordidate system which is not necessarily
>+    // Compute renderer offset from primary graphics layer. Note that primaryGraphicsLayerRect is in parentGraphicsLayer's coordinate system which is not necessarily
>     // the same as the ancestor graphics layer.
>     OffsetFromRenderer primaryGraphicsLayerOffsetFromRenderer;
>     LayoutSize oldSubpixelOffsetFromRenderer = m_subpixelOffsetFromRenderer;
>@@ -1441,7 +1466,11 @@ void RenderLayerBacking::setBackgroundLayerPaintsFixedRootBackground(bool backgr
> 
> void RenderLayerBacking::setRequiresBackgroundLayer(bool requiresBackgroundLayer)
> {
>+    if (requiresBackgroundLayer == m_requiresBackgroundLayer)
>+        return;
>+
>     m_requiresBackgroundLayer = requiresBackgroundLayer;
>+    m_owningLayer.setNeedsCompositingConfigurationUpdate();
> }
> 
> bool RenderLayerBacking::requiresHorizontalScrollbarLayer() const
>@@ -1654,6 +1683,8 @@ void RenderLayerBacking::updateMaskingLayer(bool hasMask, bool hasClipPath)
>             m_maskLayer->setPaintingPhase(maskPhases);
>             layerChanged = true;
>             m_graphicsLayer->setMaskLayer(m_maskLayer.copyRef());
>+            // We need a geometry update to size the new mask layer.
>+            m_owningLayer.setNeedsCompositingGeometryUpdate();
>         }
>     } else if (m_maskLayer) {
>         m_graphicsLayer->setMaskLayer(nullptr);
>@@ -2216,13 +2247,10 @@ void RenderLayerBacking::contentChanged(ContentChangeType changeType)
>     }
> 
>     if ((changeType == BackgroundImageChanged) && canDirectlyCompositeBackgroundBackgroundImage(renderer().style()))
>-        updateGeometry();
>+        m_owningLayer.setNeedsCompositingConfigurationUpdate();
> 
>-    if ((changeType == MaskImageChanged) && m_maskLayer) {
>-        // The composited layer bounds relies on box->maskClipRect(), which changes
>-        // when the mask image becomes available.
>-        updateAfterLayout(UpdateAfterLayoutFlags::IsUpdateRoot);
>-    }
>+    if ((changeType == MaskImageChanged) && m_maskLayer)
>+        m_owningLayer.setNeedsCompositingConfigurationUpdate();
> 
> #if ENABLE(WEBGL) || ENABLE(ACCELERATED_2D_CANVAS)
>     if ((changeType == CanvasChanged || changeType == CanvasPixelsChanged) && renderer().isCanvas() && canvasCompositingStrategy(renderer()) == CanvasAsLayerContents) {
>@@ -2393,6 +2421,10 @@ void RenderLayerBacking::setContentsNeedDisplay(GraphicsLayer::ShouldClipToLayer
> {
>     ASSERT(!paintsIntoCompositedAncestor());
> 
>+    // Use the repaint as a trigger to re-evaluate direct compositing (which is never used on the root layer).
>+    if (!m_owningLayer.isRenderViewLayer())
>+        m_owningLayer.setNeedsCompositingConfigurationUpdate();
>+
>     auto& frameView = renderer().view().frameView();
>     if (m_isMainFrameRenderViewLayer && frameView.isTrackingRepaints())
>         frameView.addTrackedRepaintRect(owningLayer().absoluteBoundingBoxForPainting());
>@@ -2426,6 +2458,10 @@ void RenderLayerBacking::setContentsNeedDisplay(GraphicsLayer::ShouldClipToLayer
> void RenderLayerBacking::setContentsNeedDisplayInRect(const LayoutRect& r, GraphicsLayer::ShouldClipToLayer shouldClip)
> {
>     ASSERT(!paintsIntoCompositedAncestor());
>+    
>+    // Use the repaint as a trigger to re-evaluate direct compositing (which is never used on the root layer).
>+    if (!m_owningLayer.isRenderViewLayer())
>+        m_owningLayer.setNeedsCompositingConfigurationUpdate();
> 
>     FloatRect pixelSnappedRectForPainting = snapRectToDevicePixels(r, deviceScaleFactor());
>     auto& frameView = renderer().view().frameView();
>@@ -2771,6 +2807,9 @@ bool RenderLayerBacking::startAnimation(double timeOffset, const Animation* anim
>         didAnimate = true;
> #endif
> 
>+    if (didAnimate)
>+        m_owningLayer.setNeedsPostLayoutCompositingUpdate();
>+
>     return didAnimate;
> }
> 
>@@ -2787,6 +2826,7 @@ void RenderLayerBacking::animationSeeked(double timeOffset, const String& animat
> void RenderLayerBacking::animationFinished(const String& animationName)
> {
>     m_graphicsLayer->removeAnimation(animationName);
>+    m_owningLayer.setNeedsPostLayoutCompositingUpdate();
> }
> 
> bool RenderLayerBacking::startTransition(double timeOffset, CSSPropertyID property, const RenderStyle* fromStyle, const RenderStyle* toStyle)
>@@ -2854,6 +2894,9 @@ bool RenderLayerBacking::startTransition(double timeOffset, CSSPropertyID proper
>     }
> #endif
> 
>+    if (didAnimate)
>+        m_owningLayer.setNeedsPostLayoutCompositingUpdate();
>+
>     return didAnimate;
> }
> 
>@@ -2867,8 +2910,10 @@ void RenderLayerBacking::transitionPaused(double timeOffset, CSSPropertyID prope
> void RenderLayerBacking::transitionFinished(CSSPropertyID property)
> {
>     AnimatedPropertyID animatedProperty = cssToGraphicsLayerProperty(property);
>-    if (animatedProperty != AnimatedPropertyInvalid)
>+    if (animatedProperty != AnimatedPropertyInvalid) {
>         m_graphicsLayer->removeAnimation(GraphicsLayer::animationNameForTransition(animatedProperty));
>+        m_owningLayer.setNeedsPostLayoutCompositingUpdate();
>+    }
> }
> 
> void RenderLayerBacking::notifyAnimationStarted(const GraphicsLayer*, const String&, MonotonicTime time)
>@@ -2904,9 +2949,13 @@ LayoutRect RenderLayerBacking::compositedBounds() const
>     return m_compositedBounds;
> }
> 
>-void RenderLayerBacking::setCompositedBounds(const LayoutRect& bounds)
>+bool RenderLayerBacking::setCompositedBounds(const LayoutRect& bounds)
> {
>+    if (bounds == m_compositedBounds)
>+        return false;
>+
>     m_compositedBounds = bounds;
>+    return true;
> }
> 
> LayoutRect RenderLayerBacking::compositedBoundsIncludingMargin() const
>diff --git a/Source/WebCore/rendering/RenderLayerBacking.h b/Source/WebCore/rendering/RenderLayerBacking.h
>index 02f9d2bcc319e1f37e03b6bcd6260455b8821981..dd235040c9dd9c26684476279856e76a9a61b76a 100644
>--- a/Source/WebCore/rendering/RenderLayerBacking.h
>+++ b/Source/WebCore/rendering/RenderLayerBacking.h
>@@ -65,12 +65,8 @@ public:
> 
>     RenderLayer& owningLayer() const { return m_owningLayer; }
> 
>-    enum class UpdateAfterLayoutFlags {
>-        NeedsFullRepaint    = 1 << 0,
>-        IsUpdateRoot        = 1 << 1
>-    };
>-    void updateAfterLayout(OptionSet<UpdateAfterLayoutFlags>);
>-    
>+    void updateConfigurationAfterStyleChange();
>+
>     // Returns true if layer configuration changed.
>     bool updateConfiguration();
> 
>@@ -83,6 +79,8 @@ public:
>     // Update contents and clipping structure.
>     void updateDrawsContent();
>     
>+    void updateAfterLayout(bool needsFullRepaint);
>+    
>     GraphicsLayer* graphicsLayer() const { return m_graphicsLayer.get(); }
> 
>     // Layer to clip children
>@@ -177,8 +175,10 @@ public:
>     void resumeAnimations();
> 
>     LayoutRect compositedBounds() const;
>-    void setCompositedBounds(const LayoutRect&);
>-    void updateCompositedBounds();
>+    // Returns true if changed.
>+    bool setCompositedBounds(const LayoutRect&);
>+    // Returns true if changed.
>+    bool updateCompositedBounds();
>     
>     void updateAfterWidgetResize();
>     void positionOverflowControlsLayers();
>diff --git a/Source/WebCore/rendering/RenderLayerCompositor.cpp b/Source/WebCore/rendering/RenderLayerCompositor.cpp
>index b655ff25c9a958060648bb7bedf209f9c500b3c8..d59cf31d14940987a4579d467089d3bca5e3b1f3 100644
>--- a/Source/WebCore/rendering/RenderLayerCompositor.cpp
>+++ b/Source/WebCore/rendering/RenderLayerCompositor.cpp
>@@ -222,6 +222,8 @@ struct RenderLayerCompositor::CompositingState {
>         : compositingAncestor(compAncestor)
>         , subtreeIsCompositing(false)
>         , testingOverlap(testOverlap)
>+        , fullPaintOrderTraversalRequired(false)
>+        , descendantsRequireCompositingUpdate(false)
>         , ancestorHasTransformAnimation(false)
> #if ENABLE(CSS_COMPOSITING)
>         , hasNotIsolatedCompositedBlendingDescendants(false)
>@@ -236,6 +238,8 @@ struct RenderLayerCompositor::CompositingState {
>         : compositingAncestor(other.compositingAncestor)
>         , subtreeIsCompositing(other.subtreeIsCompositing)
>         , testingOverlap(other.testingOverlap)
>+        , fullPaintOrderTraversalRequired(other.fullPaintOrderTraversalRequired)
>+        , descendantsRequireCompositingUpdate(other.descendantsRequireCompositingUpdate)
>         , ancestorHasTransformAnimation(other.ancestorHasTransformAnimation)
> #if ENABLE(CSS_COMPOSITING)
>         , hasNotIsolatedCompositedBlendingDescendants(other.hasNotIsolatedCompositedBlendingDescendants)
>@@ -249,6 +253,8 @@ struct RenderLayerCompositor::CompositingState {
>     RenderLayer* compositingAncestor;
>     bool subtreeIsCompositing;
>     bool testingOverlap;
>+    bool fullPaintOrderTraversalRequired;
>+    bool descendantsRequireCompositingUpdate;
>     bool ancestorHasTransformAnimation;
> #if ENABLE(CSS_COMPOSITING)
>     bool hasNotIsolatedCompositedBlendingDescendants;
>@@ -299,6 +305,9 @@ void RenderLayerCompositor::enableCompositingMode(bool enable /* = true */)
>             notifyIFramesOfCompositingChange();
>         } else
>             destroyRootLayer();
>+        
>+        
>+        m_renderView.layer()->setNeedsPostLayoutCompositingUpdate();
>     }
> }
> 
>@@ -325,8 +334,10 @@ void RenderLayerCompositor::cacheAcceleratedCompositingFlags()
>         forceCompositingMode = m_renderView.settings().forceCompositingMode() && hasAcceleratedCompositing; 
>     
>     if (hasAcceleratedCompositing != m_hasAcceleratedCompositing || showDebugBorders != m_showDebugBorders || showRepaintCounter != m_showRepaintCounter || forceCompositingMode != m_forceCompositingMode) {
>-        setCompositingLayersNeedRebuild();
>-        m_layerNeedsCompositingUpdate = true;
>+        if (auto* rootLayer = m_renderView.layer()) {
>+            rootLayer->setNeedsCompositingConfigurationUpdate();
>+            rootLayer->setDescendantsNeedUpdateBackingAndHierarchyTraversal();
>+        }
>     }
> 
>     bool debugBordersChanged = m_showDebugBorders != showDebugBorders;
>@@ -349,7 +360,7 @@ void RenderLayerCompositor::cacheAcceleratedCompositingFlags()
>     }
>     
>     if (updateCompositingPolicy())
>-        setCompositingLayersNeedRebuild();
>+        rootRenderLayer().setDescendantsNeedCompositingRequirementsTraversal();
> }
> 
> void RenderLayerCompositor::cacheAcceleratedCompositingFlagsAfterLayout()
>@@ -359,10 +370,11 @@ void RenderLayerCompositor::cacheAcceleratedCompositingFlagsAfterLayout()
>     if (isMainFrameCompositor())
>         return;
> 
>-    bool forceCompositingMode = m_hasAcceleratedCompositing && m_renderView.settings().forceCompositingMode() && requiresCompositingForScrollableFrame();
>+    CompositingQueryData queryData;
>+    bool forceCompositingMode = m_hasAcceleratedCompositing && m_renderView.settings().forceCompositingMode() && requiresCompositingForScrollableFrame(queryData);
>     if (forceCompositingMode != m_forceCompositingMode) {
>         m_forceCompositingMode = forceCompositingMode;
>-        setCompositingLayersNeedRebuild();
>+        rootRenderLayer().setDescendantsNeedCompositingRequirementsTraversal();
>     }
> }
> 
>@@ -387,23 +399,13 @@ bool RenderLayerCompositor::canRender3DTransforms() const
>     return hasAcceleratedCompositing() && (m_compositingTriggers & ChromeClient::ThreeDTransformTrigger);
> }
> 
>-void RenderLayerCompositor::setCompositingLayersNeedRebuild(bool needRebuild)
>-{
>-    if (inCompositingMode())
>-        m_compositingLayersNeedRebuild = needRebuild;
>-}
>-
> void RenderLayerCompositor::willRecalcStyle()
> {
>-    m_layerNeedsCompositingUpdate = false;
>     cacheAcceleratedCompositingFlags();
> }
> 
> bool RenderLayerCompositor::didRecalcStyleWithNoPendingLayout()
> {
>-    if (!m_layerNeedsCompositingUpdate)
>-        return false;
>-    
>     return updateCompositingLayers(CompositingUpdateType::AfterStyleChange);
> }
> 
>@@ -651,9 +653,17 @@ void RenderLayerCompositor::cancelCompositingLayerUpdate()
>     m_updateCompositingLayersTimer.stop();
> }
> 
>+// Returns true on a successful update.
> bool RenderLayerCompositor::updateCompositingLayers(CompositingUpdateType updateType, RenderLayer* updateRoot)
> {
>     LOG_WITH_STREAM(Compositing, stream << "RenderLayerCompositor " << this << " updateCompositingLayers " << updateType << " root " << updateRoot);
>+    UNUSED_PARAM(updateType);
>+    UNUSED_PARAM(updateRoot);
>+
>+#if !LOG_DISABLED
>+    if (compositingLogEnabled())
>+        showPaintOrderTree(m_renderView.layer());
>+#endif
> 
>     if (updateType == CompositingUpdateType::AfterStyleChange || updateType == CompositingUpdateType::AfterLayout)
>         cacheAcceleratedCompositingFlagsAfterLayout(); // Some flags (e.g. forceCompositingMode) depend on layout.
>@@ -667,53 +677,36 @@ bool RenderLayerCompositor::updateCompositingLayers(CompositingUpdateType update
>         return false;
> 
>     // Avoid updating the layers with old values. Compositing layers will be updated after the layout is finished.
>+    // This happens when m_updateCompositingLayersTimer fires before layout is updated.
>     if (m_renderView.needsLayout())
>         return false;
> 
>     if (!m_compositing && (m_forceCompositingMode || (isMainFrameCompositor() && page().pageOverlayController().overlayCount())))
>         enableCompositingMode(true);
> 
>-    if (!m_reevaluateCompositingAfterLayout && !m_compositing)
>-        return false;
>-
>-    ++m_compositingUpdateCount;
>-
>-    AnimationUpdateBlock animationUpdateBlock(&m_renderView.frameView().frame().animation());
>-
>-    SetForScope<bool> postLayoutChange(m_inPostLayoutUpdate, true);
>-    
>-    bool checkForHierarchyUpdate = m_reevaluateCompositingAfterLayout;
>-    bool needGeometryUpdate = false;
>-    bool needRootLayerConfigurationUpdate = m_rootLayerConfigurationNeedsUpdate;
>+    updateRoot = &rootRenderLayer();
> 
>-    switch (updateType) {
>-    case CompositingUpdateType::AfterStyleChange:
>-    case CompositingUpdateType::AfterLayout:
>-    case CompositingUpdateType::OnHitTest:
>-        checkForHierarchyUpdate = true;
>-        break;
>-    case CompositingUpdateType::OnScroll:
>-    case CompositingUpdateType::OnCompositedScroll:
>-        checkForHierarchyUpdate = true; // Overlap can change with scrolling, so need to check for hierarchy updates.
>-        needGeometryUpdate = true;
>-        break;
>+    if (updateType == CompositingUpdateType::OnScroll || updateType == CompositingUpdateType::OnCompositedScroll) {
>+        // Scrolling can affect overlap. FIXME: avoid for page scrolling.
>+        updateRoot->setDescendantsNeedCompositingRequirementsTraversal();
>     }
> 
>-    if (!checkForHierarchyUpdate && !needGeometryUpdate && !needRootLayerConfigurationUpdate)
>+    if (!updateRoot->hasDescendantNeedingCompositingRequirementsTraversal() && !m_compositing) {
>+        LOG_WITH_STREAM(Compositing, stream << " no compositing work to do");
>         return false;
>+    }
> 
>-    bool needHierarchyUpdate = m_compositingLayersNeedRebuild;
>-    bool isFullUpdate = !updateRoot;
>+    if (!updateRoot->needsAnyCompositingTraversal()) {
>+        LOG_WITH_STREAM(Compositing, stream << " updateRoot has no dirty child and doesn't need update");
>+        return true;
>+    }
> 
>-    // Only clear the flag if we're updating the entire hierarchy.
>-    m_compositingLayersNeedRebuild = false;
>-    m_rootLayerConfigurationNeedsUpdate = false;
>-    updateRoot = &rootRenderLayer();
>+    bool isFullUpdate = true;
>+    ++m_compositingUpdateCount;
> 
>-    if (isFullUpdate && updateType == CompositingUpdateType::AfterLayout)
>-        m_reevaluateCompositingAfterLayout = false;
>+    AnimationUpdateBlock animationUpdateBlock(&m_renderView.frameView().frame().animation());
> 
>-    LOG(Compositing, " checkForHierarchyUpdate %d, needGeometryUpdate %d", checkForHierarchyUpdate, needHierarchyUpdate);
>+    SetForScope<bool> postLayoutChange(m_inPostLayoutUpdate, true);
> 
> #if !LOG_DISABLED
>     MonotonicTime startTime;
>@@ -721,21 +714,8 @@ bool RenderLayerCompositor::updateCompositingLayers(CompositingUpdateType update
>         ++m_rootLayerUpdateCount;
>         startTime = MonotonicTime::now();
>     }
>-#endif
>-
>-    if (checkForHierarchyUpdate) {
>-        // Go through the layers in presentation order, so that we can compute which RenderLayers need compositing layers.
>-        // FIXME: we could maybe do this and the hierarchy udpate in one pass, but the parenting logic would be more complex.
>-        CompositingState compState(updateRoot);
>-        bool layersChanged = false;
>-        bool saw3DTransform = false;
>-        OverlapMap overlapTestRequestMap;
>-        computeCompositingRequirements(nullptr, *updateRoot, overlapTestRequestMap, compState, layersChanged, saw3DTransform);
>-        needHierarchyUpdate |= layersChanged;
>-    }
> 
>-#if !LOG_DISABLED
>-    if (compositingLogEnabled() && isFullUpdate && (needHierarchyUpdate || needGeometryUpdate)) {
>+    if (compositingLogEnabled()) {
>         m_obligateCompositedLayerCount = 0;
>         m_secondaryCompositedLayerCount = 0;
>         m_obligatoryBackingStoreBytes = 0;
>@@ -747,10 +727,26 @@ bool RenderLayerCompositor::updateCompositingLayers(CompositingUpdateType update
>     }
> #endif
> 
>-    if (needHierarchyUpdate) {
>-        // Update the hierarchy of the compositing layers.
>+    // FIXME: optimize root-only update.
>+    if (updateRoot->hasDescendantNeedingCompositingRequirementsTraversal() || updateRoot->needsCompositingRequirementsTraversal()) {
>+        CompositingState compositingState(updateRoot);
>+        OverlapMap overlapMap;
>+
>+        // FIXME: use updateRoot.
>+        bool layerChanged = false;
>+        bool descendantHas3DTransform = false;
>+        computeCompositingRequirements(nullptr, rootRenderLayer(), overlapMap, compositingState, layerChanged, descendantHas3DTransform);
>+    }
>+
>+    LOG(Compositing, "\nRenderLayerCompositor::updateCompositingLayers - mid");
>+#if !LOG_DISABLED
>+    if (compositingLogEnabled())
>+        showPaintOrderTree(m_renderView.layer());
>+#endif
>+
>+    if (updateRoot->hasDescendantNeedingUpdateBackingOrHierachyTraversal() || updateRoot->needsUpdateBackingOrHierachyTraversal()) {
>         Vector<Ref<GraphicsLayer>> childList;
>-        rebuildCompositingLayerTree(*updateRoot, childList, 0);
>+        updateBackingAndHierarchy(*updateRoot, childList);
> 
>         // Host the document layer in the RenderView's root layer.
>         if (isFullUpdate) {
>@@ -762,18 +758,12 @@ bool RenderLayerCompositor::updateCompositingLayers(CompositingUpdateType update
>             else if (m_rootContentLayer)
>                 m_rootContentLayer->setChildren(WTFMove(childList));
>         }
>-        
>-        reattachSubframeScrollLayers();
>-    } else if (needGeometryUpdate) {
>-        // We just need to do a geometry update. This is only used for position:fixed scrolling;
>-        // most of the time, geometry is updated via RenderLayer::styleChanged().
>-        updateLayerTreeGeometry(*updateRoot, 0);
>-        ASSERT(!isFullUpdate || !m_subframeScrollLayersNeedReattach);
>-    } else if (needRootLayerConfigurationUpdate)
>-        m_renderView.layer()->backing()->updateConfiguration();
>     
>+        reattachSubframeScrollLayers();
>+    }
>+
> #if !LOG_DISABLED
>-    if (compositingLogEnabled() && isFullUpdate && (needHierarchyUpdate || needGeometryUpdate)) {
>+    if (compositingLogEnabled()) {
>         MonotonicTime endTime = MonotonicTime::now();
>         LOG(Compositing, "Total layers   primary   secondary   obligatory backing (KB)   secondary backing(KB)   total backing (KB)  update time (ms)\n");
> 
>@@ -782,197 +772,670 @@ bool RenderLayerCompositor::updateCompositingLayers(CompositingUpdateType update
>             m_secondaryCompositedLayerCount, m_obligatoryBackingStoreBytes / 1024, m_secondaryBackingStoreBytes / 1024, (m_obligatoryBackingStoreBytes + m_secondaryBackingStoreBytes) / 1024, (endTime - startTime).milliseconds());
>     }
> #endif
>-    ASSERT(updateRoot || !m_compositingLayersNeedRebuild);
> 
>-    if (!hasAcceleratedCompositing())
>-        enableCompositingMode(false);
>+    // FIXME: Only do if dirty.
>+    updateRootLayerPosition();
>+
>+#if !LOG_DISABLED
>+    if (compositingLogEnabled()) {
>+        LOG(Compositing, "RenderLayerCompositor::updateCompositingLayers - post");
>+        showPaintOrderTree(m_renderView.layer());
>+        LOG(Compositing, "RenderLayerCompositor::updateCompositingLayers - GraphicsLayers post");
>+        showGraphicsLayerTree(m_rootContentLayer.get());
>+    }
>+#endif
> 
>-    // Inform the inspector that the layer tree has changed.
>     InspectorInstrumentation::layerTreeDidChange(&page());
> 
>     return true;
> }
> 
>-void RenderLayerCompositor::appendDocumentOverlayLayers(Vector<Ref<GraphicsLayer>>& childList)
>+void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestorLayer, RenderLayer& layer, OverlapMap& overlapMap, CompositingState& compositingState, bool& layersChanged, bool& descendantHas3DTransform)
> {
>-    if (!isMainFrameCompositor() || !m_compositing)
>+    if (!layer.hasDescendantNeedingCompositingRequirementsTraversal() && !layer.needsCompositingRequirementsTraversal() && !compositingState.fullPaintOrderTraversalRequired && !compositingState.descendantsRequireCompositingUpdate) {
>+        traverseUnchangedSubtree(ancestorLayer, layer, overlapMap, compositingState, descendantHas3DTransform);
>         return;
>+    }
> 
>-    Ref<GraphicsLayer> overlayHost = page().pageOverlayController().layerWithDocumentOverlays();
>-    childList.append(WTFMove(overlayHost));
>-}
>+    LOG(Compositing, "%*p computeCompositingRequirements", 12 + compositingState.depth * 2, &layer);
> 
>-void RenderLayerCompositor::layerBecameNonComposited(const RenderLayer& layer)
>-{
>-    // Inform the inspector that the given RenderLayer was destroyed.
>-    InspectorInstrumentation::renderLayerDestroyed(&page(), layer);
>+    // FIXME: consult needsCompositingPaintOrderChildrenUpdate()?
>+    compositingState.fullPaintOrderTraversalRequired |= layer.needsCompositingRequirementsTraversal();
>+    compositingState.descendantsRequireCompositingUpdate |= layer.descendantsNeedCompositingRequirementsTraversal();
> 
>-    ASSERT(m_compositedLayerCount > 0);
>-    --m_compositedLayerCount;
>-}
>+    // If none of the bits changed, the only thing that may have changed is overlap, so we just need to do overlap testing.
>+    // Avoid geometry updates when possible.
>+    
>+    layer.updateDescendantDependentFlags();
>+    layer.updateLayerListsIfNeeded();
> 
>-#if !LOG_DISABLED
>-void RenderLayerCompositor::logLayerInfo(const RenderLayer& layer, int depth)
>-{
>-    if (!compositingLogEnabled())
>-        return;
>+    layer.setHasCompositingDescendant(false);
> 
>-    auto* backing = layer.backing();
>-    if (requiresCompositingLayer(layer) || layer.isRenderViewLayer()) {
>-        ++m_obligateCompositedLayerCount;
>-        m_obligatoryBackingStoreBytes += backing->backingStoreMemoryEstimate();
>-    } else {
>-        ++m_secondaryCompositedLayerCount;
>-        m_secondaryBackingStoreBytes += backing->backingStoreMemoryEstimate();
>+    // We updated compositng for direct reasons in layerStyleChanged(). Here, check for compositing that can only be evaluated after layout.
>+    CompositingQueryData queryData;
>+    bool willBeComposited = layer.isComposited();
>+    if (layer.needsPostLayoutCompositingUpdate() || compositingState.fullPaintOrderTraversalRequired || compositingState.descendantsRequireCompositingUpdate) {
>+        layer.setIndirectCompositingReason(RenderLayer::IndirectCompositingReason::None);
>+        willBeComposited = needsToBeComposited(layer, queryData);
>     }
> 
>-    LayoutRect absoluteBounds = backing->compositedBounds();
>-    absoluteBounds.move(layer.offsetFromAncestor(m_renderView.layer()));
>-    
>-    StringBuilder logString;
>-    logString.append(String::format("%*p id %" PRIu64 " (%.3f,%.3f-%.3f,%.3f) %.2fKB", 12 + depth * 2, &layer, backing->graphicsLayer()->primaryLayerID(),
>-        absoluteBounds.x().toFloat(), absoluteBounds.y().toFloat(), absoluteBounds.maxX().toFloat(), absoluteBounds.maxY().toFloat(),
>-        backing->backingStoreMemoryEstimate() / 1024));
>-    
>-    if (!layer.renderer().style().hasAutoZIndex())
>-        logString.append(String::format(" z-index: %d", layer.renderer().style().zIndex())); 
>+    OverlapExtent layerExtent;
>+    // Use the fact that we're composited as a hint to check for an animating transform.
>+    // FIXME: Maybe needsToBeComposited() should return a bitmask of reasons, to avoid the need to recompute things.
>+    if (willBeComposited && !layer.isRenderViewLayer())
>+        layerExtent.hasTransformAnimation = isRunningTransformAnimation(layer.renderer());
> 
>-    logString.appendLiteral(" (");
>-    logString.append(logReasonsForCompositing(layer));
>-    logString.appendLiteral(") ");
>+    bool respectTransforms = !layerExtent.hasTransformAnimation;
>+    overlapMap.geometryMap().pushMappingsToAncestor(&layer, ancestorLayer, respectTransforms);
> 
>-    if (backing->graphicsLayer()->contentsOpaque() || backing->paintsIntoCompositedAncestor() || backing->foregroundLayer() || backing->backgroundLayer()) {
>-        logString.append('[');
>-        bool prependSpace = false;
>-        if (backing->graphicsLayer()->contentsOpaque()) {
>-            logString.appendLiteral("opaque");
>-            prependSpace = true;
>-        }
>+    RenderLayer::IndirectCompositingReason compositingReason = compositingState.subtreeIsCompositing ? RenderLayer::IndirectCompositingReason::Stacking : RenderLayer::IndirectCompositingReason::None;
> 
>-        if (backing->paintsIntoCompositedAncestor()) {
>-            if (prependSpace)
>-                logString.appendLiteral(", ");
>-            logString.appendLiteral("paints into ancestor");
>-            prependSpace = true;
>-        }
>+    // If we know for sure the layer is going to be composited, don't bother looking it up in the overlap map
>+    if (!willBeComposited && !overlapMap.isEmpty() && compositingState.testingOverlap) {
>+        computeExtent(overlapMap, layer, layerExtent);
>+        // If we're testing for overlap, we only need to composite if we overlap something that is already composited.
>+        compositingReason = overlapMap.overlapsLayers(layerExtent.bounds) ? RenderLayer::IndirectCompositingReason::Overlap : RenderLayer::IndirectCompositingReason::None;
>+    }
> 
>-        if (backing->foregroundLayer() || backing->backgroundLayer()) {
>-            if (prependSpace)
>-                logString.appendLiteral(", ");
>-            if (backing->foregroundLayer() && backing->backgroundLayer()) {
>-                logString.appendLiteral("+foreground+background");
>-                prependSpace = true;
>-            } else if (backing->foregroundLayer()) {
>-                logString.appendLiteral("+foreground");
>-                prependSpace = true;
>-            } else {
>-                logString.appendLiteral("+background");
>-                prependSpace = true;
>-            }
>-        }
>-        
>-        if (backing->paintsSubpixelAntialiasedText()) {
>-            if (prependSpace)
>-                logString.appendLiteral(", ");
>-            logString.appendLiteral("texty");
>-        }
>+#if ENABLE(VIDEO)
>+    // Video is special. It's the only RenderLayer type that can both have
>+    // RenderLayer children and whose children can't use its backing to render
>+    // into. These children (the controls) always need to be promoted into their
>+    // own layers to draw on top of the accelerated video.
>+    if (compositingState.compositingAncestor && compositingState.compositingAncestor->renderer().isVideo())
>+        compositingReason = RenderLayer::IndirectCompositingReason::Overlap;
>+#endif
> 
>-        logString.appendLiteral("] ");
>-    }
>+    if (compositingReason != RenderLayer::IndirectCompositingReason::None)
>+        layer.setIndirectCompositingReason(compositingReason);
> 
>-    logString.append(layer.name());
>+    // Check if the computed indirect reason will force the layer to become composited.
>+    if (!willBeComposited && layer.mustCompositeForIndirectReasons() && canBeComposited(layer))
>+        willBeComposited = true;
> 
>-    LOG(Compositing, "%s", logString.toString().utf8().data());
>-}
>+    // The children of this layer don't need to composite, unless there is
>+    // a compositing layer among them, so start by inheriting the compositing
>+    // ancestor with subtreeIsCompositing set to false.
>+    CompositingState childState(compositingState);
>+    childState.subtreeIsCompositing = false;
>+#if ENABLE(CSS_COMPOSITING)
>+    childState.hasNotIsolatedCompositedBlendingDescendants = false;
> #endif
> 
>-static bool checkIfDescendantClippingContextNeedsUpdate(const RenderLayer& layer, bool isClipping)
>-{
>-    for (auto* child = layer.firstChild(); child; child = child->nextSibling()) {
>-        auto* backing = child->backing();
>-        if (backing && (isClipping || backing->hasAncestorClippingLayer()))
>-            return true;
>+    if (willBeComposited) {
>+        // Tell the parent it has compositing descendants.
>+        compositingState.subtreeIsCompositing = true;
>+        // This layer now acts as the ancestor for kids.
>+        childState.compositingAncestor = &layer;
> 
>-        if (checkIfDescendantClippingContextNeedsUpdate(*child, isClipping))
>-            return true;
>-    }
>-    return false;
>-}
>+        overlapMap.pushCompositingContainer();
>+        // This layer is going to be composited, so children can safely ignore the fact that there's an
>+        // animation running behind this layer, meaning they can rely on the overlap map testing again.
>+        childState.testingOverlap = true;
> 
>-#if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)
>-static bool isScrollableOverflow(Overflow overflow)
>-{
>-    return overflow == Overflow::Scroll || overflow == Overflow::Auto;
>-}
>+        computeExtent(overlapMap, layer, layerExtent);
>+        childState.ancestorHasTransformAnimation |= layerExtent.hasTransformAnimation;
>+        // Too hard to compute animated bounds if both us and some ancestor is animating transform.
>+        layerExtent.animationCausesExtentUncertainty |= layerExtent.hasTransformAnimation && compositingState.ancestorHasTransformAnimation;
>+    }
> 
>-static bool styleHasTouchScrolling(const RenderStyle& style)
>-{
>-    return style.useTouchOverflowScrolling() && (isScrollableOverflow(style.overflowX()) || isScrollableOverflow(style.overflowY()));
>-}
>+#if !ASSERT_DISABLED
>+    LayerListMutationDetector mutationChecker(layer);
> #endif
> 
>-static bool styleChangeRequiresLayerRebuild(const RenderLayer& layer, const RenderStyle& oldStyle, const RenderStyle& newStyle)
>-{
>-    // Clip can affect ancestor compositing bounds, so we need recompute overlap when it changes on a non-composited layer.
>-    // FIXME: we should avoid doing this for all clip changes.
>-    if (oldStyle.clip() != newStyle.clip() || oldStyle.hasClip() != newStyle.hasClip())
>-        return true;
>+    bool anyDescendantHas3DTransform = false;
> 
>-    // FIXME: need to check everything that we consult to avoid backing store here: webkit.org/b/138383
>-    if (!oldStyle.opacity() != !newStyle.opacity()) {
>-        auto* repaintContainer = layer.renderer().containerForRepaint();
>-        if (auto* ancestorBacking = repaintContainer ? repaintContainer->layer()->backing() : nullptr) {
>-            if (static_cast<bool>(newStyle.opacity()) != ancestorBacking->graphicsLayer()->drawsContent())
>-                return true;
>+    for (auto* childLayer : layer.negativeZOrderLayers()) {
>+        computeCompositingRequirements(&layer, *childLayer, overlapMap, childState, layersChanged, anyDescendantHas3DTransform);
>+
>+        // If we have to make a layer for this child, make one now so we can have a contents layer
>+        // (since we need to ensure that the -ve z-order child renders underneath our contents).
>+        if (!willBeComposited && childState.subtreeIsCompositing) {
>+            // make layer compositing
>+            layer.setIndirectCompositingReason(RenderLayer::IndirectCompositingReason::BackgroundLayer);
>+            childState.compositingAncestor = &layer;
>+            overlapMap.pushCompositingContainer();
>+            // This layer is going to be composited, so children can safely ignore the fact that there's an
>+            // animation running behind this layer, meaning they can rely on the overlap map testing again
>+            childState.testingOverlap = true;
>+            willBeComposited = true;
>         }
>     }
>-
>-    // When overflow changes, composited layers may need to update their ancestorClipping layers.
>-    if (!layer.isComposited() && (oldStyle.overflowX() != newStyle.overflowX() || oldStyle.overflowY() != newStyle.overflowY()) && layer.stackingContext()->hasCompositingDescendant())
>-        return true;
>     
>-#if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)
>-    if (styleHasTouchScrolling(oldStyle) != styleHasTouchScrolling(newStyle))
>-        return true;
>-#endif
>-
>-    // Compositing layers keep track of whether they are clipped by any of the ancestors.
>-    // When the current layer's clipping behaviour changes, we need to propagate it to the descendants.
>-    bool wasClipping = oldStyle.hasClip() || oldStyle.overflowX() != Overflow::Visible || oldStyle.overflowY() != Overflow::Visible;
>-    bool isClipping = newStyle.hasClip() || newStyle.overflowX() != Overflow::Visible || newStyle.overflowY() != Overflow::Visible;
>-    if (isClipping != wasClipping) {
>-        if (checkIfDescendantClippingContextNeedsUpdate(layer, isClipping))
>-            return true;
>-    }
>+    for (auto* childLayer : layer.normalFlowLayers())
>+        computeCompositingRequirements(&layer, *childLayer, overlapMap, childState, layersChanged, anyDescendantHas3DTransform);
> 
>-    return false;
>-}
>-
>-void RenderLayerCompositor::layerStyleChanged(StyleDifference diff, RenderLayer& layer, const RenderStyle* oldStyle)
>-{
>-    if (diff == StyleDifference::Equal)
>-        return;
>+    for (auto* childLayer : layer.positiveZOrderLayers())
>+        computeCompositingRequirements(&layer, *childLayer, overlapMap, childState, layersChanged, anyDescendantHas3DTransform);
> 
>-    const RenderStyle& newStyle = layer.renderer().style();
>-    if (updateLayerCompositingState(layer) || (oldStyle && styleChangeRequiresLayerRebuild(layer, *oldStyle, newStyle))) {
>-        setCompositingLayersNeedRebuild();
>-        m_layerNeedsCompositingUpdate = true;
>-        return;
>+    // If we just entered compositing mode, the root will have become composited (as long as accelerated compositing is enabled).
>+    if (layer.isRenderViewLayer()) {
>+        if (inCompositingMode() && m_hasAcceleratedCompositing)
>+            willBeComposited = true;
>     }
>+    
>+    // All layers (even ones that aren't being composited) need to get added to
>+    // the overlap map. Layers that do not composite will draw into their
>+    // compositing ancestor's backing, and so are still considered for overlap.
>+    // FIXME: When layerExtent has taken animation bounds into account, we also know that the bounds
>+    // include descendants, so we don't need to add them all to the overlap map.
>+    if (childState.compositingAncestor && !childState.compositingAncestor->isRenderViewLayer())
>+        addToOverlapMap(overlapMap, layer, layerExtent);
> 
>-    if (layer.isComposited()) {
>-        // FIXME: updating geometry here is potentially harmful, because layout is not up-to-date.
>-        layer.backing()->updateGeometry();
>-        layer.backing()->updateAfterDescendants();
>-        m_layerNeedsCompositingUpdate = true;
>-        return;
>+#if ENABLE(CSS_COMPOSITING)
>+    layer.setHasNotIsolatedCompositedBlendingDescendants(childState.hasNotIsolatedCompositedBlendingDescendants);
>+    ASSERT(!layer.hasNotIsolatedCompositedBlendingDescendants() || layer.hasNotIsolatedBlendingDescendants());
>+#endif
>+    // Now check for reasons to become composited that depend on the state of descendant layers.
>+    RenderLayer::IndirectCompositingReason indirectCompositingReason;
>+    if (!willBeComposited && canBeComposited(layer)
>+        && requiresCompositingForIndirectReason(layer.renderer(), childState.subtreeIsCompositing, anyDescendantHas3DTransform, indirectCompositingReason)) {
>+        layer.setIndirectCompositingReason(indirectCompositingReason);
>+        childState.compositingAncestor = &layer;
>+        overlapMap.pushCompositingContainer();
>+        addToOverlapMapRecursive(overlapMap, layer);
>+        willBeComposited = true;
>+    }
>+    
>+    if (layer.reflectionLayer()) {
>+        // FIXME: Shouldn't we call computeCompositingRequirements to handle a reflection overlapping with another renderer?
>+        layer.reflectionLayer()->setIndirectCompositingReason(willBeComposited ? RenderLayer::IndirectCompositingReason::Stacking : RenderLayer::IndirectCompositingReason::None);
>     }
> 
>-    if (needsCompositingUpdateForStyleChangeOnNonCompositedLayer(layer, oldStyle))
>-        m_layerNeedsCompositingUpdate = true;
>-}
>+    // Subsequent layers in the parent stacking context also need to composite.
>+    compositingState.subtreeIsCompositing |= childState.subtreeIsCompositing;
>+    compositingState.fullPaintOrderTraversalRequired |= childState.fullPaintOrderTraversalRequired;
> 
>-bool RenderLayerCompositor::needsCompositingUpdateForStyleChangeOnNonCompositedLayer(RenderLayer& layer, const RenderStyle* oldStyle) const
>+    // Set the flag to say that this layer has compositing children.
>+    layer.setHasCompositingDescendant(childState.subtreeIsCompositing);
>+
>+    // setHasCompositingDescendant() may have changed the answer to needsToBeComposited() when clipping, so test that again.
>+    bool isCompositedClippingLayer = canBeComposited(layer) && clipsCompositingDescendants(layer);
>+
>+    // Turn overlap testing off for later layers if it's already off, or if we have an animating transform.
>+    // Note that if the layer clips its descendants, there's no reason to propagate the child animation to the parent layers. That's because
>+    // we know for sure the animation is contained inside the clipping rectangle, which is already added to the overlap map.
>+    if ((!childState.testingOverlap && !isCompositedClippingLayer) || layerExtent.knownToBeHaveExtentUncertainty())
>+        compositingState.testingOverlap = false;
>+    
>+    if (isCompositedClippingLayer) {
>+        if (!willBeComposited) {
>+            childState.compositingAncestor = &layer;
>+            overlapMap.pushCompositingContainer();
>+            addToOverlapMapRecursive(overlapMap, layer);
>+            willBeComposited = true;
>+        }
>+    }
>+
>+#if ENABLE(CSS_COMPOSITING)
>+    if ((willBeComposited && layer.hasBlendMode())
>+        || (layer.hasNotIsolatedCompositedBlendingDescendants() && !layer.isolatesCompositedBlending()))
>+        compositingState.hasNotIsolatedCompositedBlendingDescendants = true;
>+#endif
>+
>+    if (childState.compositingAncestor == &layer && !layer.isRenderViewLayer())
>+        overlapMap.popCompositingContainer();
>+
>+    // If we're back at the root, and no other layers need to be composited, and the root layer itself doesn't need
>+    // to be composited, then we can drop out of compositing mode altogether. However, don't drop out of compositing mode
>+    // if there are composited layers that we didn't hit in our traversal (e.g. because of visibility:hidden).
>+    CompositingQueryData rootLayerQueryData;
>+    if (layer.isRenderViewLayer() && !childState.subtreeIsCompositing && !requiresCompositingLayer(layer, rootLayerQueryData) && !m_forceCompositingMode && !hasAnyAdditionalCompositedLayers(layer)) {
>+        // Don't drop out of compositing on iOS, because we may flash. See <rdar://problem/8348337>.
>+#if !PLATFORM(IOS_FAMILY)
>+        enableCompositingMode(false);
>+        willBeComposited = false;
>+#endif
>+    }
>+    
>+    ASSERT(willBeComposited == needsToBeComposited(layer, queryData));
>+
>+    // Create or destroy backing here. However, we can't update geometry because layers above us may become composited
>+    // during post-order traversal (e.g. for clipping).
>+    if (updateBacking(layer, queryData, CompositingChangeRepaintNow, willBeComposited ? BackingRequired::Yes : BackingRequired::No)) {
>+        layer.setNeedsCompositingLayerConnection();
>+        // Child layers need to get a geometry update to recompute their position. FIXME: Ideally we'd only dirty direct children.
>+        layer.setDescendantsNeedUpdateBackingAndHierarchyTraversal();
>+        // The composited bounds of enclosing layers depends on which descendants are composited, so they need a geometry update.
>+        layer.setNeedsCompositingGeometryUpdateOnAncestors();
>+        layersChanged = true;
>+    }
>+
>+    // This is the only caller of updateLayerCompositingState.
>+    if (layer.reflectionLayer() && updateLayerCompositingState(*layer.reflectionLayer(), queryData, CompositingChangeRepaintNow)) {
>+        // FIXME: check bit propagation for reflection layers.
>+        layer.setNeedsCompositingLayerConnection();
>+        layersChanged = true; // FIXME: layersChanged is unused.
>+    }
>+
>+    descendantHas3DTransform |= anyDescendantHas3DTransform || layer.has3DTransform();
>+    
>+    // FIXME: clarify needsCompositingPaintOrderChildrenUpdate. If a composited layer gets a new ancestor, it needs geometry computations.
>+    if (layer.needsCompositingPaintOrderChildrenUpdate()) {
>+        layer.setChildrenNeedCompositingGeometryUpdate();
>+        layer.setNeedsCompositingLayerConnection();
>+    }
>+
>+    LOG(Compositing, "%*p computeCompositingRequirements - willBeComposited %d", 12 + compositingState.depth * 2, &layer, willBeComposited);
>+
>+    layer.clearCompositingRequirementsTraversalState();
>+    
>+    overlapMap.geometryMap().popMappingsToAncestor(ancestorLayer);
>+}
>+
>+
>+// We have to traverse unchanged layers to fill in the overlap map.
>+void RenderLayerCompositor::traverseUnchangedSubtree(RenderLayer* ancestorLayer, RenderLayer& layer, OverlapMap& overlapMap, CompositingState& compositingState, bool& descendantHas3DTransform)
>+{
>+    ASSERT(!compositingState.fullPaintOrderTraversalRequired);
>+    ASSERT(!layer.hasDescendantNeedingCompositingRequirementsTraversal());
>+    ASSERT(!layer.needsCompositingRequirementsTraversal());
>+
>+    LOG(Compositing, "%*p traverseUnchangedSubtree", 12 + compositingState.depth * 2, &layer);
>+
>+    layer.updateDescendantDependentFlags();
>+    layer.updateLayerListsIfNeeded();
>+
>+    bool layerIsComposited = layer.isComposited();
>+
>+    OverlapExtent layerExtent;
>+    if (layerIsComposited && !layer.isRenderViewLayer())
>+        layerExtent.hasTransformAnimation = isRunningTransformAnimation(layer.renderer());
>+
>+    bool respectTransforms = !layerExtent.hasTransformAnimation;
>+    overlapMap.geometryMap().pushMappingsToAncestor(&layer, ancestorLayer, respectTransforms);
>+
>+    // If we know for sure the layer is going to be composited, don't bother looking it up in the overlap map
>+    if (!layerIsComposited && !overlapMap.isEmpty() && compositingState.testingOverlap)
>+        computeExtent(overlapMap, layer, layerExtent);
>+
>+    CompositingState childState(compositingState);
>+    childState.subtreeIsCompositing = false;
>+#if ENABLE(CSS_COMPOSITING)
>+    childState.hasNotIsolatedCompositedBlendingDescendants = false;
>+#endif
>+
>+    if (layerIsComposited) {
>+        // Tell the parent it has compositing descendants.
>+        compositingState.subtreeIsCompositing = true;
>+        // This layer now acts as the ancestor for kids.
>+        childState.compositingAncestor = &layer;
>+
>+        overlapMap.pushCompositingContainer();
>+        // This layer is going to be composited, so children can safely ignore the fact that there's an
>+        // animation running behind this layer, meaning they can rely on the overlap map testing again.
>+        childState.testingOverlap = true;
>+
>+        computeExtent(overlapMap, layer, layerExtent);
>+        childState.ancestorHasTransformAnimation |= layerExtent.hasTransformAnimation;
>+        // Too hard to compute animated bounds if both us and some ancestor is animating transform.
>+        layerExtent.animationCausesExtentUncertainty |= layerExtent.hasTransformAnimation && compositingState.ancestorHasTransformAnimation;
>+    }
>+
>+#if !ASSERT_DISABLED
>+    LayerListMutationDetector mutationChecker(layer);
>+#endif
>+
>+    bool anyDescendantHas3DTransform = false;
>+
>+    for (auto* childLayer : layer.negativeZOrderLayers()) {
>+        traverseUnchangedSubtree(&layer, *childLayer, overlapMap, childState, anyDescendantHas3DTransform);
>+        if (childState.subtreeIsCompositing)
>+            ASSERT(layerIsComposited);
>+    }
>+    
>+    for (auto* childLayer : layer.normalFlowLayers())
>+        traverseUnchangedSubtree(&layer, *childLayer, overlapMap, childState, anyDescendantHas3DTransform);
>+
>+    for (auto* childLayer : layer.positiveZOrderLayers())
>+        traverseUnchangedSubtree(&layer, *childLayer, overlapMap, childState, anyDescendantHas3DTransform);
>+
>+    // All layers (even ones that aren't being composited) need to get added to
>+    // the overlap map. Layers that do not composite will draw into their
>+    // compositing ancestor's backing, and so are still considered for overlap.
>+    // FIXME: When layerExtent has taken animation bounds into account, we also know that the bounds
>+    // include descendants, so we don't need to add them all to the overlap map.
>+    if (childState.compositingAncestor && !childState.compositingAncestor->isRenderViewLayer())
>+        addToOverlapMap(overlapMap, layer, layerExtent);
>+
>+    // Subsequent layers in the parent stacking context also need to composite.
>+    if (childState.subtreeIsCompositing)
>+        compositingState.subtreeIsCompositing = true;
>+
>+    // Set the flag to say that this layer has compositing children.
>+    ASSERT(layer.hasCompositingDescendant() == childState.subtreeIsCompositing);
>+
>+    // setHasCompositingDescendant() may have changed the answer to needsToBeComposited() when clipping, so test that again.
>+    bool isCompositedClippingLayer = canBeComposited(layer) && clipsCompositingDescendants(layer);
>+
>+    // Turn overlap testing off for later layers if it's already off, or if we have an animating transform.
>+    // Note that if the layer clips its descendants, there's no reason to propagate the child animation to the parent layers. That's because
>+    // we know for sure the animation is contained inside the clipping rectangle, which is already added to the overlap map.
>+    if ((!childState.testingOverlap && !isCompositedClippingLayer) || layerExtent.knownToBeHaveExtentUncertainty())
>+        compositingState.testingOverlap = false;
>+    
>+    if (isCompositedClippingLayer)
>+        ASSERT(layerIsComposited);
>+
>+#if ENABLE(CSS_COMPOSITING)
>+    if ((layerIsComposited && layer.hasBlendMode())
>+        || (layer.hasNotIsolatedCompositedBlendingDescendants() && !layer.isolatesCompositedBlending()))
>+        compositingState.hasNotIsolatedCompositedBlendingDescendants = true;
>+#endif
>+
>+    if (childState.compositingAncestor == &layer && !layer.isRenderViewLayer())
>+        overlapMap.popCompositingContainer();
>+
>+    descendantHas3DTransform |= anyDescendantHas3DTransform || layer.has3DTransform();
>+
>+    ASSERT(!layer.needsCompositingRequirementsTraversal());
>+
>+    overlapMap.geometryMap().popMappingsToAncestor(ancestorLayer);
>+}
>+
>+void RenderLayerCompositor::updateBackingAndHierarchy(RenderLayer& layer, Vector<Ref<GraphicsLayer>>& childLayersOfEnclosingLayer, OptionSet<UpdateLevel> updateLevel, int depth)
>+{
>+    layer.updateDescendantDependentFlags();
>+    layer.updateLayerListsIfNeeded();
>+
>+    bool layerNeedsUpdate = !updateLevel.isEmpty();
>+    if (layer.descendantsNeedUpdateBackingAndHierarchyTraversal())
>+        updateLevel.add(UpdateLevel::AllDescendants);
>+
>+//    LOG(Compositing, "RenderLayerCompositor::updateBackingAndHierarchy layer %p, needs update %d", &layer, layerNeedsUpdate || layer.needsCompositingConfigurationUpdate());
>+
>+    auto* layerBacking = layer.backing();
>+    if (layerBacking) {
>+        updateLevel.remove(UpdateLevel::CompositedChildren);
>+
>+        // We updated the composited bounds in RenderLayerBacking::updateAfterLayout(), but it may have changed
>+        // based on which descendants are now composited.
>+        if (layerBacking->updateCompositedBounds()) {
>+            layer.setNeedsCompositingGeometryUpdate();
>+            // Our geometry can affect descendants.
>+            updateLevel.add(UpdateLevel::CompositedChildren);
>+        }
>+        
>+        if (layerNeedsUpdate || layer.needsCompositingConfigurationUpdate()) {
>+            if (layerBacking->updateConfiguration()) {
>+                layerNeedsUpdate = true; // We also need to update geometry.
>+                layer.setNeedsCompositingLayerConnection();
>+            }
>+
>+            layerBacking->updateDebugIndicators(m_showDebugBorders, m_showRepaintCounter);
>+        }
>+        
>+        if (layerNeedsUpdate || layer.needsCompositingGeometryUpdate())
>+            layerBacking->updateGeometry();
>+
>+        if (auto* reflection = layer.reflectionLayer()) {
>+            if (auto* reflectionBacking = reflection->backing()) {
>+                reflectionBacking->updateCompositedBounds();
>+                reflectionBacking->updateGeometry();
>+                reflectionBacking->updateAfterDescendants();
>+            }
>+        }
>+
>+        if (!layer.parent())
>+            updateRootLayerPosition();
>+
>+#if !LOG_DISABLED
>+        logLayerInfo(layer, "updateBackingAndHierarchy", depth);
>+#else
>+        UNUSED_PARAM(depth);
>+#endif
>+    }
>+
>+    if (layer.childrenNeedCompositingGeometryUpdate())
>+        updateLevel.add(UpdateLevel::CompositedChildren);
>+
>+    // If this layer has backing, then we are collecting its children, otherwise appending
>+    // to the compositing child list of an enclosing layer.
>+    Vector<Ref<GraphicsLayer>> layerChildren;
>+    auto& childList = layerBacking ? layerChildren : childLayersOfEnclosingLayer;
>+    // FIXME: why the !layerBacking check?
>+    bool requireDescendantTraversal = !layerBacking || layer.needsCompositingLayerConnection() || layer.hasDescendantNeedingUpdateBackingOrHierachyTraversal() || !updateLevel.isEmpty();
>+
>+#if !ASSERT_DISABLED
>+    LayerListMutationDetector mutationChecker(layer);
>+#endif
>+    
>+    if (requireDescendantTraversal) {
>+        for (auto* renderLayer : layer.negativeZOrderLayers())
>+            updateBackingAndHierarchy(*renderLayer, childList, updateLevel, depth + 1);
>+
>+            // If a negative z-order child is compositing, we get a foreground layer which needs to get parented.
>+        if (layer.negativeZOrderLayers().size()) {
>+            if (layerBacking && layerBacking->foregroundLayer())
>+                childList.append(*layerBacking->foregroundLayer());
>+        }
>+
>+        for (auto* renderLayer : layer.normalFlowLayers())
>+            updateBackingAndHierarchy(*renderLayer, childList, updateLevel, depth + 1);
>+        
>+        for (auto* renderLayer : layer.positiveZOrderLayers())
>+            updateBackingAndHierarchy(*renderLayer, childList, updateLevel, depth + 1);
>+    }
>+
>+    if (layerBacking) {
>+        if (requireDescendantTraversal) {
>+            bool parented = false;
>+            if (is<RenderWidget>(layer.renderer()))
>+                parented = parentFrameContentLayers(&downcast<RenderWidget>(layer.renderer()));
>+
>+            if (!parented)
>+                layerBacking->parentForSublayers()->setChildren(WTFMove(layerChildren));
>+
>+            // If the layer has a clipping layer the overflow controls layers will be siblings of the clipping layer.
>+            // Otherwise, the overflow control layers are normal children.
>+            if (!layerBacking->hasClippingLayer() && !layerBacking->hasScrollingLayer()) {
>+                if (auto* overflowControlLayer = layerBacking->layerForHorizontalScrollbar())
>+                    layerBacking->parentForSublayers()->addChild(*overflowControlLayer);
>+
>+                if (auto* overflowControlLayer = layerBacking->layerForVerticalScrollbar())
>+                    layerBacking->parentForSublayers()->addChild(*overflowControlLayer);
>+
>+                if (auto* overflowControlLayer = layerBacking->layerForScrollCorner())
>+                    layerBacking->parentForSublayers()->addChild(*overflowControlLayer);
>+            }
>+        }
>+
>+        childLayersOfEnclosingLayer.append(*layerBacking->childForSuperlayers());
>+
>+        layerBacking->updateAfterDescendants(); // FIXME: validate.
>+    }
>+    
>+    layer.clearUpdateBackingOrHierachyTraversalState();
>+}
>+
>+void RenderLayerCompositor::appendDocumentOverlayLayers(Vector<Ref<GraphicsLayer>>& childList)
>+{
>+    if (!isMainFrameCompositor() || !m_compositing)
>+        return;
>+
>+    Ref<GraphicsLayer> overlayHost = page().pageOverlayController().layerWithDocumentOverlays();
>+    childList.append(WTFMove(overlayHost));
>+}
>+
>+void RenderLayerCompositor::layerBecameNonComposited(const RenderLayer& layer)
>+{
>+    // Inform the inspector that the given RenderLayer was destroyed.
>+    InspectorInstrumentation::renderLayerDestroyed(&page(), layer);
>+
>+    ASSERT(m_compositedLayerCount > 0);
>+    --m_compositedLayerCount;
>+}
>+
>+#if !LOG_DISABLED
>+void RenderLayerCompositor::logLayerInfo(const RenderLayer& layer, const char* phase, int depth)
>+{
>+    if (!compositingLogEnabled())
>+        return;
>+
>+    auto* backing = layer.backing();
>+    CompositingQueryData queryData;
>+    if (requiresCompositingLayer(layer, queryData) || layer.isRenderViewLayer()) {
>+        ++m_obligateCompositedLayerCount;
>+        m_obligatoryBackingStoreBytes += backing->backingStoreMemoryEstimate();
>+    } else {
>+        ++m_secondaryCompositedLayerCount;
>+        m_secondaryBackingStoreBytes += backing->backingStoreMemoryEstimate();
>+    }
>+
>+    LayoutRect absoluteBounds = backing->compositedBounds();
>+    absoluteBounds.move(layer.offsetFromAncestor(m_renderView.layer()));
>+    
>+    StringBuilder logString;
>+    logString.append(String::format("%*p id %" PRIu64 " (%.3f,%.3f-%.3f,%.3f) %.2fKB", 12 + depth * 2, &layer, backing->graphicsLayer()->primaryLayerID(),
>+        absoluteBounds.x().toFloat(), absoluteBounds.y().toFloat(), absoluteBounds.maxX().toFloat(), absoluteBounds.maxY().toFloat(),
>+        backing->backingStoreMemoryEstimate() / 1024));
>+    
>+    if (!layer.renderer().style().hasAutoZIndex())
>+        logString.append(String::format(" z-index: %d", layer.renderer().style().zIndex())); 
>+
>+    logString.appendLiteral(" (");
>+    logString.append(logReasonsForCompositing(layer));
>+    logString.appendLiteral(") ");
>+
>+    if (backing->graphicsLayer()->contentsOpaque() || backing->paintsIntoCompositedAncestor() || backing->foregroundLayer() || backing->backgroundLayer()) {
>+        logString.append('[');
>+        bool prependSpace = false;
>+        if (backing->graphicsLayer()->contentsOpaque()) {
>+            logString.appendLiteral("opaque");
>+            prependSpace = true;
>+        }
>+
>+        if (backing->paintsIntoCompositedAncestor()) {
>+            if (prependSpace)
>+                logString.appendLiteral(", ");
>+            logString.appendLiteral("paints into ancestor");
>+            prependSpace = true;
>+        }
>+
>+        if (backing->foregroundLayer() || backing->backgroundLayer()) {
>+            if (prependSpace)
>+                logString.appendLiteral(", ");
>+            if (backing->foregroundLayer() && backing->backgroundLayer()) {
>+                logString.appendLiteral("+foreground+background");
>+                prependSpace = true;
>+            } else if (backing->foregroundLayer()) {
>+                logString.appendLiteral("+foreground");
>+                prependSpace = true;
>+            } else {
>+                logString.appendLiteral("+background");
>+                prependSpace = true;
>+            }
>+        }
>+        
>+        if (backing->paintsSubpixelAntialiasedText()) {
>+            if (prependSpace)
>+                logString.appendLiteral(", ");
>+            logString.appendLiteral("texty");
>+        }
>+
>+        logString.appendLiteral("] ");
>+    }
>+
>+    logString.append(layer.name());
>+
>+    logString.appendLiteral(" - ");
>+    logString.append(phase);
>+
>+    LOG(Compositing, "%s", logString.toString().utf8().data());
>+}
>+#endif
>+
>+static bool clippingChanged(const RenderStyle& oldStyle, const RenderStyle& newStyle)
>+{
>+    return oldStyle.overflowX() != newStyle.overflowX() || oldStyle.overflowY() != newStyle.overflowY()
>+        || oldStyle.hasClip() != newStyle.hasClip() || oldStyle.clip() != newStyle.clip();
>+}
>+
>+static bool styleAffectsLayerGeometry(const RenderStyle& style)
>+{
>+    return style.hasClip() || style.clipPath() || style.hasBorderRadius();
>+}
>+
>+void RenderLayerCompositor::layerStyleChanged(StyleDifference diff, RenderLayer& layer, const RenderStyle* oldStyle)
>+{
>+    if (diff == StyleDifference::Equal)
>+        return;
>+
>+    // Create or destroy backing here so that code that runs during layout can reliably use isComposited() (though this
>+    // is only true for layers composited for direct reasons).
>+    // Also, it allows us to avoid a tree walk in updateCompositingLayers() when no layer changed its compositing state.
>+    CompositingQueryData queryData;
>+    queryData.layoutUpToDate = LayoutUpToDate::No;
>+    
>+    bool layerChanged = updateBacking(layer, queryData, CompositingChangeRepaintNow);
>+    if (layerChanged) {
>+        layer.setNeedsCompositingLayerConnection();
>+        layer.setDirectCompositingStateChanged();
>+        // Ancestor layers that composited for indirect reasons (things listed in styleChangeMayAffectIndirectCompositingReasons()) need to get updated.
>+        // This could be optimized by only setting this flag on layers with the relevant styles.
>+        layer.setNeedsPostLayoutCompositingUpdateOnAncestors();
>+    }
>+    
>+    if (queryData.reevaluateAfterLayout)
>+        layer.setNeedsPostLayoutCompositingUpdate();
>+
>+    // See if we need content or clipping layers. Methods called here should assume
>+    // that the compositing state of descendant layers has not been updated yet.
>+    if (auto* backing = layer.backing())
>+        backing->updateConfigurationAfterStyleChange();
>+
>+    const auto& newStyle = layer.renderer().style();
>+
>+    if (diff >= StyleDifference::Repaint) {
>+        // Visibility change may affect geometry of the enclosing composited layer.
>+        if (oldStyle && oldStyle->visibility() != newStyle.visibility())
>+            layer.setNeedsCompositingGeometryUpdate();
>+        
>+        // We'll get a diff of Repaint when things like clip-path change; these might affect layer or inner-layer geometry.
>+        if (layer.isComposited() && oldStyle) {
>+            if (styleAffectsLayerGeometry(*oldStyle) || styleAffectsLayerGeometry(newStyle))
>+                layer.setNeedsCompositingGeometryUpdate();
>+        }
>+    }
>+
>+    if (diff == StyleDifference::RecompositeLayer && oldStyle) {
>+        if (oldStyle->transform() != newStyle.transform()) {
>+            // FIXME: transform changes really need to trigger layout. See RenderElement::adjustStyleDifference().
>+            layer.setNeedsPostLayoutCompositingUpdate();
>+            layer.setNeedsCompositingGeometryUpdate();
>+        }
>+    }
>+
>+    if (diff >= StyleDifference::LayoutPositionedMovementOnly) {
>+        layer.setNeedsPostLayoutCompositingUpdate();
>+        layer.setNeedsCompositingGeometryUpdate();
>+    }
>+    
>+    if (diff >= StyleDifference::Layout) {
>+        // FIXME: only set flags here if we know we have a composited descendant, but we might not know at this point.
>+        if (oldStyle && clippingChanged(*oldStyle, newStyle)) {
>+            if (layer.isStackingContext()) {
>+                layer.setNeedsPostLayoutCompositingUpdate(); // Layer needs to become composited if it has composited descendants.
>+                layer.setNeedsCompositingConfigurationUpdate(); // If already composited, layer needs to create/destroy clipping layer.
>+            } else {
>+                // Descendant (in containing block order) compositing layers need to re-evaluate their clipping,
>+                // but they might be siblings in z-order so go up to our stacking context.
>+                if (auto* stackingContext = layer.stackingContext())
>+                    stackingContext->setDescendantsNeedUpdateBackingAndHierarchyTraversal();
>+            }
>+        }
>+
>+        // These properties trigger compositing if some descendant is composited.
>+        if (oldStyle && styleChangeMayAffectIndirectCompositingReasons(*oldStyle, newStyle))
>+            layer.setNeedsPostLayoutCompositingUpdate();
>+
>+        layer.setNeedsCompositingGeometryUpdate();
>+    }
>+
>+    // FIXME: handle styleChangeRequiresLayerRebuild and needsCompositingUpdateForStyleChangeOnNonCompositedLayer
>+}
>+
>+bool RenderLayerCompositor::needsCompositingUpdateForStyleChangeOnNonCompositedLayer(RenderLayer& layer, const RenderStyle* oldStyle) const
> {
>     // Needed for scroll bars.
>     if (layer.isRenderViewLayer())
>@@ -987,7 +1450,7 @@ bool RenderLayerCompositor::needsCompositingUpdateForStyleChangeOnNonCompositedL
>         return true;
> 
>     // We don't have any direct reasons for this style change to affect layer composition. Test if it might affect things indirectly.
>-    if (styleChangeMayAffectIndirectCompositingReasons(layer.renderer(), *oldStyle))
>+    if (styleChangeMayAffectIndirectCompositingReasons(*oldStyle, newStyle))
>         return true;
> 
>     return false;
>@@ -1005,6 +1468,7 @@ bool RenderLayerCompositor::canCompositeClipPath(const RenderLayer& layer)
>     return (clipPath.type() != ClipPathOperation::Shape || clipPath.type() == ClipPathOperation::Shape) && GraphicsLayer::supportsLayerType(GraphicsLayer::Type::Shape);
> }
> 
>+// FIXME: remove and never ask questions about reflection layers.
> static RenderLayerModelObject& rendererForCompositingTests(const RenderLayer& layer)
> {
>     auto* renderer = &layer.renderer();
>@@ -1021,16 +1485,14 @@ void RenderLayerCompositor::updateRootContentLayerClipping()
>     m_rootContentLayer->setMasksToBounds(!m_renderView.settings().backgroundShouldExtendBeyondPage());
> }
> 
>-bool RenderLayerCompositor::updateBacking(RenderLayer& layer, CompositingChangeRepaint shouldRepaint, BackingRequired backingRequired)
>+bool RenderLayerCompositor::updateBacking(RenderLayer& layer, CompositingQueryData& queryData, CompositingChangeRepaint shouldRepaint, BackingRequired backingRequired)
> {
>     bool layerChanged = false;
>-    RenderLayer::ViewportConstrainedNotCompositedReason viewportConstrainedNotCompositedReason = RenderLayer::NoNotCompositedReason;
>-
>     if (backingRequired == BackingRequired::Unknown)
>-        backingRequired = needsToBeComposited(layer, &viewportConstrainedNotCompositedReason) ? BackingRequired::Yes : BackingRequired::No;
>+        backingRequired = needsToBeComposited(layer, queryData) ? BackingRequired::Yes : BackingRequired::No;
>     else {
>         // Need to fetch viewportConstrainedNotCompositedReason, but without doing all the work that needsToBeComposited does.
>-        requiresCompositingForPosition(rendererForCompositingTests(layer), layer, &viewportConstrainedNotCompositedReason);
>+        requiresCompositingForPosition(rendererForCompositingTests(layer), layer, queryData);
>     }
> 
>     if (backingRequired == BackingRequired::Yes) {
>@@ -1061,6 +1523,10 @@ bool RenderLayerCompositor::updateBacking(RenderLayer& layer, CompositingChangeR
>             // the repaint container, so change when compositing changes; we need to update them here.
>             if (layer.parent())
>                 layer.computeRepaintRectsIncludingDescendants();
>+            
>+            layer.setNeedsCompositingGeometryUpdate();
>+            layer.setNeedsCompositingConfigurationUpdate();
>+            layer.setNeedsCompositingPaintOrderChildrenUpdate(); // FIXME: right?
> 
>             layerChanged = true;
>         }
>@@ -1111,8 +1577,8 @@ bool RenderLayerCompositor::updateBacking(RenderLayer& layer, CompositingChangeR
>     // If a fixed position layer gained/lost a backing or the reason not compositing it changed,
>     // the scrolling coordinator needs to recalculate whether it can do fast scrolling.
>     if (layer.renderer().isFixedPositioned()) {
>-        if (layer.viewportConstrainedNotCompositedReason() != viewportConstrainedNotCompositedReason) {
>-            layer.setViewportConstrainedNotCompositedReason(viewportConstrainedNotCompositedReason);
>+        if (layer.viewportConstrainedNotCompositedReason() != queryData.nonCompositedForPositionReason) {
>+            layer.setViewportConstrainedNotCompositedReason(queryData.nonCompositedForPositionReason);
>             layerChanged = true;
>         }
>         if (layerChanged) {
>@@ -1128,9 +1594,9 @@ bool RenderLayerCompositor::updateBacking(RenderLayer& layer, CompositingChangeR
>     return layerChanged;
> }
> 
>-bool RenderLayerCompositor::updateLayerCompositingState(RenderLayer& layer, CompositingChangeRepaint shouldRepaint)
>+bool RenderLayerCompositor::updateLayerCompositingState(RenderLayer& layer, CompositingQueryData& queryData, CompositingChangeRepaint shouldRepaint)
> {
>-    bool layerChanged = updateBacking(layer, shouldRepaint);
>+    bool layerChanged = updateBacking(layer, queryData, shouldRepaint);
> 
>     // See if we need content or clipping layers. Methods called here should assume
>     // that the compositing state of descendant layers has not been updated yet.
>@@ -1177,9 +1643,9 @@ void RenderLayerCompositor::repaintInCompositedAncestor(RenderLayer& layer, cons
>         m_renderView.frameView().setNeedsOneShotDrawingSynchronization();
> }
> 
>+// FIXME: remove.
> void RenderLayerCompositor::layerWasAdded(RenderLayer&, RenderLayer&)
> {
>-    setCompositingLayersNeedRebuild();
> }
> 
> void RenderLayerCompositor::layerWillBeRemoved(RenderLayer& parent, RenderLayer& child)
>@@ -1188,303 +1654,97 @@ void RenderLayerCompositor::layerWillBeRemoved(RenderLayer& parent, RenderLayer&
>         return;
> 
>     removeFromScrollCoordinatedLayers(child);
>-    repaintInCompositedAncestor(child, child.backing()->compositedBounds());
>+    repaintInCompositedAncestor(child, child.backing()->compositedBounds()); // FIXME: do via dirty bits?
> 
>     setCompositingParent(child, nullptr);
>-    setCompositingLayersNeedRebuild();
>-}
>-
>-RenderLayer* RenderLayerCompositor::enclosingNonStackingClippingLayer(const RenderLayer& layer) const
>-{
>-    for (auto* parent = layer.parent(); parent; parent = parent->parent()) {
>-        if (parent->isStackingContext())
>-            return nullptr;
>-        if (parent->renderer().hasClipOrOverflowClip())
>-            return parent;
>-    }
>-    return nullptr;
>-}
>-
>-void RenderLayerCompositor::computeExtent(const OverlapMap& overlapMap, const RenderLayer& layer, OverlapExtent& extent) const
>-{
>-    if (extent.extentComputed)
>-        return;
>-
>-    LayoutRect layerBounds;
>-    if (extent.hasTransformAnimation)
>-        extent.animationCausesExtentUncertainty = !layer.getOverlapBoundsIncludingChildrenAccountingForTransformAnimations(layerBounds);
>-    else
>-        layerBounds = layer.overlapBounds();
>-    
>-    // In the animating transform case, we avoid double-accounting for the transform because
>-    // we told pushMappingsToAncestor() to ignore transforms earlier.
>-    extent.bounds = enclosingLayoutRect(overlapMap.geometryMap().absoluteRect(layerBounds));
>-
>-    // Empty rects never intersect, but we need them to for the purposes of overlap testing.
>-    if (extent.bounds.isEmpty())
>-        extent.bounds.setSize(LayoutSize(1, 1));
>-
>-
>-    RenderLayerModelObject& renderer = layer.renderer();
>-    if (renderer.isFixedPositioned() && renderer.container() == &m_renderView) {
>-        // Because fixed elements get moved around without re-computing overlap, we have to compute an overlap
>-        // rect that covers all the locations that the fixed element could move to.
>-        // FIXME: need to handle sticky too.
>-        extent.bounds = m_renderView.frameView().fixedScrollableAreaBoundsInflatedForScrolling(extent.bounds);
>-    }
>-
>-    extent.extentComputed = true;
>-}
>-
>-void RenderLayerCompositor::addToOverlapMap(OverlapMap& overlapMap, const RenderLayer& layer, OverlapExtent& extent)
>-{
>-    if (layer.isRenderViewLayer())
>-        return;
>-
>-    computeExtent(overlapMap, layer, extent);
>-
>-    LayoutRect clipRect = layer.backgroundClipRect(RenderLayer::ClipRectsContext(&rootRenderLayer(), AbsoluteClipRects)).rect(); // FIXME: Incorrect for CSS regions.
>-
>-    // On iOS, pageScaleFactor() is not applied by RenderView, so we should not scale here.
>-    if (!m_renderView.settings().delegatesPageScaling())
>-        clipRect.scale(pageScaleFactor());
>-    clipRect.intersect(extent.bounds);
>-    overlapMap.add(clipRect);
>-}
>-
>-void RenderLayerCompositor::addToOverlapMapRecursive(OverlapMap& overlapMap, const RenderLayer& layer, const RenderLayer* ancestorLayer)
>-{
>-    if (!canBeComposited(layer))
>-        return;
>-
>-    // A null ancestorLayer is an indication that 'layer' has already been pushed.
>-    if (ancestorLayer)
>-        overlapMap.geometryMap().pushMappingsToAncestor(&layer, ancestorLayer);
>-    
>-    OverlapExtent layerExtent;
>-    addToOverlapMap(overlapMap, layer, layerExtent);
>-
>-#if !ASSERT_DISABLED
>-    LayerListMutationDetector mutationChecker(const_cast<RenderLayer&>(layer));
>-#endif
>-
>-    for (auto* renderLayer : layer.negativeZOrderLayers())
>-        addToOverlapMapRecursive(overlapMap, *renderLayer, &layer);
>-
>-    for (auto* renderLayer : layer.normalFlowLayers())
>-        addToOverlapMapRecursive(overlapMap, *renderLayer, &layer);
>-
>-    for (auto* renderLayer : layer.positiveZOrderLayers())
>-        addToOverlapMapRecursive(overlapMap, *renderLayer, &layer);
>-    
>-    if (ancestorLayer)
>-        overlapMap.geometryMap().popMappingsToAncestor(ancestorLayer);
>-}
>-
>-//  Recurse through the layers in z-index and overflow order (which is equivalent to painting order)
>-//  For the z-order children of a compositing layer:
>-//      If a child layers has a compositing layer, then all subsequent layers must
>-//      be compositing in order to render above that layer.
>-//
>-//      If a child in the negative z-order list is compositing, then the layer itself
>-//      must be compositing so that its contents render over that child.
>-//      This implies that its positive z-index children must also be compositing.
>-//
>-void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestorLayer, RenderLayer& layer, OverlapMap& overlapMap, CompositingState& compositingState, bool& layersChanged, bool& descendantHas3DTransform)
>-{
>-    layer.updateDescendantDependentFlags();
>-    layer.updateLayerListsIfNeeded();
>-
>-    // Clear the flag
>-    layer.setHasCompositingDescendant(false);
>-    layer.setIndirectCompositingReason(RenderLayer::IndirectCompositingReason::None);
>-
>-    // Check if the layer needs to be composited for direct reasons (e.g. 3D transform).
>-    bool willBeComposited = needsToBeComposited(layer);
>-
>-    OverlapExtent layerExtent;
>-    // Use the fact that we're composited as a hint to check for an animating transform.
>-    // FIXME: Maybe needsToBeComposited() should return a bitmask of reasons, to avoid the need to recompute things.
>-    if (willBeComposited && !layer.isRenderViewLayer())
>-        layerExtent.hasTransformAnimation = isRunningTransformAnimation(layer.renderer());
>-
>-    bool respectTransforms = !layerExtent.hasTransformAnimation;
>-    overlapMap.geometryMap().pushMappingsToAncestor(&layer, ancestorLayer, respectTransforms);
>-
>-    RenderLayer::IndirectCompositingReason compositingReason = compositingState.subtreeIsCompositing ? RenderLayer::IndirectCompositingReason::Stacking : RenderLayer::IndirectCompositingReason::None;
>-
>-    // If we know for sure the layer is going to be composited, don't bother looking it up in the overlap map
>-    if (!willBeComposited && !overlapMap.isEmpty() && compositingState.testingOverlap) {
>-        computeExtent(overlapMap, layer, layerExtent);
>-        // If we're testing for overlap, we only need to composite if we overlap something that is already composited.
>-        compositingReason = overlapMap.overlapsLayers(layerExtent.bounds) ? RenderLayer::IndirectCompositingReason::Overlap : RenderLayer::IndirectCompositingReason::None;
>-    }
>-
>-#if ENABLE(VIDEO)
>-    // Video is special. It's the only RenderLayer type that can both have
>-    // RenderLayer children and whose children can't use its backing to render
>-    // into. These children (the controls) always need to be promoted into their
>-    // own layers to draw on top of the accelerated video.
>-    if (compositingState.compositingAncestor && compositingState.compositingAncestor->renderer().isVideo())
>-        compositingReason = RenderLayer::IndirectCompositingReason::Overlap;
>-#endif
>-
>-    layer.setIndirectCompositingReason(compositingReason);
>-
>-    // Check if the computed indirect reason will force the layer to become composited.
>-    if (!willBeComposited && layer.mustCompositeForIndirectReasons() && canBeComposited(layer))
>-        willBeComposited = true;
>-    ASSERT(willBeComposited == needsToBeComposited(layer));
>-
>-    // The children of this layer don't need to composite, unless there is
>-    // a compositing layer among them, so start by inheriting the compositing
>-    // ancestor with subtreeIsCompositing set to false.
>-    CompositingState childState(compositingState);
>-    childState.subtreeIsCompositing = false;
>-#if ENABLE(CSS_COMPOSITING)
>-    childState.hasNotIsolatedCompositedBlendingDescendants = false;
>-#endif
>-
>-    if (willBeComposited) {
>-        // Tell the parent it has compositing descendants.
>-        compositingState.subtreeIsCompositing = true;
>-        // This layer now acts as the ancestor for kids.
>-        childState.compositingAncestor = &layer;
>-
>-        overlapMap.pushCompositingContainer();
>-        // This layer is going to be composited, so children can safely ignore the fact that there's an 
>-        // animation running behind this layer, meaning they can rely on the overlap map testing again.
>-        childState.testingOverlap = true;
>-
>-        computeExtent(overlapMap, layer, layerExtent);
>-        childState.ancestorHasTransformAnimation |= layerExtent.hasTransformAnimation;
>-        // Too hard to compute animated bounds if both us and some ancestor is animating transform.
>-        layerExtent.animationCausesExtentUncertainty |= layerExtent.hasTransformAnimation && compositingState.ancestorHasTransformAnimation;
>-    }
>-
>-#if !ASSERT_DISABLED
>-    LayerListMutationDetector mutationChecker(layer);
>-#endif
>-
>-    bool anyDescendantHas3DTransform = false;
>-
>-    for (auto* renderLayer : layer.negativeZOrderLayers()) {
>-        computeCompositingRequirements(&layer, *renderLayer, overlapMap, childState, layersChanged, anyDescendantHas3DTransform);
>+    child.setNeedsCompositingLayerConnection();
>+}
> 
>-        // If we have to make a layer for this child, make one now so we can have a contents layer
>-        // (since we need to ensure that the -ve z-order child renders underneath our contents).
>-        if (!willBeComposited && childState.subtreeIsCompositing) {
>-            // make layer compositing
>-            layer.setIndirectCompositingReason(RenderLayer::IndirectCompositingReason::BackgroundLayer);
>-            childState.compositingAncestor = &layer;
>-            overlapMap.pushCompositingContainer();
>-            // This layer is going to be composited, so children can safely ignore the fact that there's an
>-            // animation running behind this layer, meaning they can rely on the overlap map testing again
>-            childState.testingOverlap = true;
>-            willBeComposited = true;
>-        }
>+RenderLayer* RenderLayerCompositor::enclosingNonStackingClippingLayer(const RenderLayer& layer) const
>+{
>+    for (auto* parent = layer.parent(); parent; parent = parent->parent()) {
>+        if (parent->isStackingContext())
>+            return nullptr;
>+        if (parent->renderer().hasClipOrOverflowClip())
>+            return parent;
>     }
>-    
>-    for (auto* renderLayer : layer.normalFlowLayers())
>-        computeCompositingRequirements(&layer, *renderLayer, overlapMap, childState, layersChanged, anyDescendantHas3DTransform);
>+    return nullptr;
>+}
> 
>-    for (auto* renderLayer : layer.positiveZOrderLayers())
>-        computeCompositingRequirements(&layer, *renderLayer, overlapMap, childState, layersChanged, anyDescendantHas3DTransform);
>+void RenderLayerCompositor::computeExtent(const OverlapMap& overlapMap, const RenderLayer& layer, OverlapExtent& extent) const
>+{
>+    if (extent.extentComputed)
>+        return;
> 
>-    // If we just entered compositing mode, the root will have become composited (as long as accelerated compositing is enabled).
>-    if (layer.isRenderViewLayer()) {
>-        if (inCompositingMode() && m_hasAcceleratedCompositing)
>-            willBeComposited = true;
>-    }
>+    LayoutRect layerBounds;
>+    if (extent.hasTransformAnimation)
>+        extent.animationCausesExtentUncertainty = !layer.getOverlapBoundsIncludingChildrenAccountingForTransformAnimations(layerBounds);
>+    else
>+        layerBounds = layer.overlapBounds();
>     
>-    ASSERT(willBeComposited == needsToBeComposited(layer));
>+    // In the animating transform case, we avoid double-accounting for the transform because
>+    // we told pushMappingsToAncestor() to ignore transforms earlier.
>+    extent.bounds = enclosingLayoutRect(overlapMap.geometryMap().absoluteRect(layerBounds));
> 
>-    // All layers (even ones that aren't being composited) need to get added to
>-    // the overlap map. Layers that do not composite will draw into their
>-    // compositing ancestor's backing, and so are still considered for overlap.
>-    // FIXME: When layerExtent has taken animation bounds into account, we also know that the bounds
>-    // include descendants, so we don't need to add them all to the overlap map.
>-    if (childState.compositingAncestor && !childState.compositingAncestor->isRenderViewLayer())
>-        addToOverlapMap(overlapMap, layer, layerExtent);
>+    // Empty rects never intersect, but we need them to for the purposes of overlap testing.
>+    if (extent.bounds.isEmpty())
>+        extent.bounds.setSize(LayoutSize(1, 1));
> 
>-#if ENABLE(CSS_COMPOSITING)
>-    layer.setHasNotIsolatedCompositedBlendingDescendants(childState.hasNotIsolatedCompositedBlendingDescendants);
>-    ASSERT(!layer.hasNotIsolatedCompositedBlendingDescendants() || layer.hasNotIsolatedBlendingDescendants());
>-#endif
>-    // Now check for reasons to become composited that depend on the state of descendant layers.
>-    RenderLayer::IndirectCompositingReason indirectCompositingReason;
>-    if (!willBeComposited && canBeComposited(layer)
>-        && requiresCompositingForIndirectReason(layer.renderer(), childState.subtreeIsCompositing, anyDescendantHas3DTransform, indirectCompositingReason)) {
>-        layer.setIndirectCompositingReason(indirectCompositingReason);
>-        childState.compositingAncestor = &layer;
>-        overlapMap.pushCompositingContainer();
>-        addToOverlapMapRecursive(overlapMap, layer);
>-        willBeComposited = true;
>-    }
>-    
>-    ASSERT(willBeComposited == needsToBeComposited(layer));
>-    if (layer.reflectionLayer()) {
>-        // FIXME: Shouldn't we call computeCompositingRequirements to handle a reflection overlapping with another renderer?
>-        layer.reflectionLayer()->setIndirectCompositingReason(willBeComposited ? RenderLayer::IndirectCompositingReason::Stacking : RenderLayer::IndirectCompositingReason::None);
>+
>+    RenderLayerModelObject& renderer = layer.renderer();
>+    if (renderer.isFixedPositioned() && renderer.container() == &m_renderView) {
>+        // Because fixed elements get moved around without re-computing overlap, we have to compute an overlap
>+        // rect that covers all the locations that the fixed element could move to.
>+        // FIXME: need to handle sticky too.
>+        extent.bounds = m_renderView.frameView().fixedScrollableAreaBoundsInflatedForScrolling(extent.bounds);
>     }
> 
>-    // Subsequent layers in the parent stacking context also need to composite.
>-    if (childState.subtreeIsCompositing)
>-        compositingState.subtreeIsCompositing = true;
>+    extent.extentComputed = true;
>+}
> 
>-    // Set the flag to say that this layer has compositing children.
>-    layer.setHasCompositingDescendant(childState.subtreeIsCompositing);
>+void RenderLayerCompositor::addToOverlapMap(OverlapMap& overlapMap, const RenderLayer& layer, OverlapExtent& extent)
>+{
>+    if (layer.isRenderViewLayer())
>+        return;
> 
>-    // setHasCompositingDescendant() may have changed the answer to needsToBeComposited() when clipping, so test that again.
>-    bool isCompositedClippingLayer = canBeComposited(layer) && clipsCompositingDescendants(layer);
>+    computeExtent(overlapMap, layer, extent);
> 
>-    // Turn overlap testing off for later layers if it's already off, or if we have an animating transform.
>-    // Note that if the layer clips its descendants, there's no reason to propagate the child animation to the parent layers. That's because
>-    // we know for sure the animation is contained inside the clipping rectangle, which is already added to the overlap map.
>-    if ((!childState.testingOverlap && !isCompositedClippingLayer) || layerExtent.knownToBeHaveExtentUncertainty())
>-        compositingState.testingOverlap = false;
>-    
>-    if (isCompositedClippingLayer) {
>-        if (!willBeComposited) {
>-            childState.compositingAncestor = &layer;
>-            overlapMap.pushCompositingContainer();
>-            addToOverlapMapRecursive(overlapMap, layer);
>-            willBeComposited = true;
>-         }
>-    }
>+    LayoutRect clipRect = layer.backgroundClipRect(RenderLayer::ClipRectsContext(&rootRenderLayer(), AbsoluteClipRects)).rect(); // FIXME: Incorrect for CSS regions.
> 
>-#if ENABLE(CSS_COMPOSITING)
>-    if ((willBeComposited && layer.hasBlendMode())
>-        || (layer.hasNotIsolatedCompositedBlendingDescendants() && !layer.isolatesCompositedBlending()))
>-        compositingState.hasNotIsolatedCompositedBlendingDescendants = true;
>-#endif
>+    // On iOS, pageScaleFactor() is not applied by RenderView, so we should not scale here.
>+    if (!m_renderView.settings().delegatesPageScaling())
>+        clipRect.scale(pageScaleFactor());
>+    clipRect.intersect(extent.bounds);
>+    overlapMap.add(clipRect);
>+}
> 
>-    if (childState.compositingAncestor == &layer && !layer.isRenderViewLayer())
>-        overlapMap.popCompositingContainer();
>+void RenderLayerCompositor::addToOverlapMapRecursive(OverlapMap& overlapMap, const RenderLayer& layer, const RenderLayer* ancestorLayer)
>+{
>+    if (!canBeComposited(layer))
>+        return;
> 
>-    // If we're back at the root, and no other layers need to be composited, and the root layer itself doesn't need
>-    // to be composited, then we can drop out of compositing mode altogether. However, don't drop out of compositing mode
>-    // if there are composited layers that we didn't hit in our traversal (e.g. because of visibility:hidden).
>-    if (layer.isRenderViewLayer() && !childState.subtreeIsCompositing && !requiresCompositingLayer(layer) && !m_forceCompositingMode && !hasAnyAdditionalCompositedLayers(layer)) {
>-        // Don't drop out of compositing on iOS, because we may flash. See <rdar://problem/8348337>.
>-#if !PLATFORM(IOS_FAMILY)
>-        enableCompositingMode(false);
>-        willBeComposited = false;
>-#endif
>-    }
>+    // A null ancestorLayer is an indication that 'layer' has already been pushed.
>+    if (ancestorLayer)
>+        overlapMap.geometryMap().pushMappingsToAncestor(&layer, ancestorLayer);
>     
>-    ASSERT(willBeComposited == needsToBeComposited(layer));
>+    OverlapExtent layerExtent;
>+    addToOverlapMap(overlapMap, layer, layerExtent);
> 
>-    // Update backing now, so that we can use isComposited() reliably during tree traversal in rebuildCompositingLayerTree().
>-    if (updateBacking(layer, CompositingChangeRepaintNow, willBeComposited ? BackingRequired::Yes : BackingRequired::No))
>-        layersChanged = true;
>+#if !ASSERT_DISABLED
>+    LayerListMutationDetector mutationChecker(const_cast<RenderLayer&>(layer));
>+#endif
> 
>-    if (layer.reflectionLayer() && updateLayerCompositingState(*layer.reflectionLayer(), CompositingChangeRepaintNow))
>-        layersChanged = true;
>+    for (auto* renderLayer : layer.negativeZOrderLayers())
>+        addToOverlapMapRecursive(overlapMap, *renderLayer, &layer);
> 
>-    descendantHas3DTransform |= anyDescendantHas3DTransform || layer.has3DTransform();
>+    for (auto* renderLayer : layer.normalFlowLayers())
>+        addToOverlapMapRecursive(overlapMap, *renderLayer, &layer);
> 
>-    overlapMap.geometryMap().popMappingsToAncestor(ancestorLayer);
>+    for (auto* renderLayer : layer.positiveZOrderLayers())
>+        addToOverlapMapRecursive(overlapMap, *renderLayer, &layer);
>+    
>+    if (ancestorLayer)
>+        overlapMap.geometryMap().popMappingsToAncestor(ancestorLayer);
> }
> 
> void RenderLayerCompositor::setCompositingParent(RenderLayer& childLayer, RenderLayer* parentLayer)
>@@ -1524,90 +1784,6 @@ bool RenderLayerCompositor::canAccelerateVideoRendering(RenderVideo& video) cons
> }
> #endif
> 
>-void RenderLayerCompositor::rebuildCompositingLayerTree(RenderLayer& layer, Vector<Ref<GraphicsLayer>>& childLayersOfEnclosingLayer, int depth)
>-{
>-    // Make the layer compositing if necessary, and set up clipping and content layers.
>-    // Note that we can only do work here that is independent of whether the descendant layers
>-    // have been processed. computeCompositingRequirements() will already have done the repaint if necessary.
>-
>-    auto* layerBacking = layer.backing();
>-    if (layerBacking) {
>-        // The compositing state of all our children has been updated already, so now
>-        // we can compute and cache the composited bounds for this layer.
>-        layerBacking->updateCompositedBounds();
>-
>-        if (auto* reflection = layer.reflectionLayer()) {
>-            if (reflection->backing())
>-                reflection->backing()->updateCompositedBounds();
>-        }
>-
>-        if (layerBacking->updateConfiguration())
>-            layerBacking->updateDebugIndicators(m_showDebugBorders, m_showRepaintCounter);
>-        
>-        layerBacking->updateGeometry();
>-
>-        if (!layer.parent())
>-            updateRootLayerPosition();
>-
>-#if !LOG_DISABLED
>-        logLayerInfo(layer, depth);
>-#else
>-        UNUSED_PARAM(depth);
>-#endif
>-    }
>-
>-    // If this layer has backing, then we are collecting its children, otherwise appending
>-    // to the compositing child list of an enclosing layer.
>-    Vector<Ref<GraphicsLayer>> layerChildren;
>-    auto& childList = layerBacking ? layerChildren : childLayersOfEnclosingLayer;
>-
>-#if !ASSERT_DISABLED
>-    LayerListMutationDetector mutationChecker(layer);
>-#endif
>-
>-    for (auto* renderLayer : layer.negativeZOrderLayers())
>-        rebuildCompositingLayerTree(*renderLayer, childList, depth + 1);
>-
>-    // If a negative z-order child is compositing, we get a foreground layer which needs to get parented.
>-    if (layer.negativeZOrderLayers().size()) {
>-        if (layerBacking && layerBacking->foregroundLayer())
>-            childList.append(*layerBacking->foregroundLayer());
>-    }
>-    
>-    for (auto* renderLayer : layer.normalFlowLayers())
>-        rebuildCompositingLayerTree(*renderLayer, childList, depth + 1);
>-    
>-    for (auto* renderLayer : layer.positiveZOrderLayers())
>-        rebuildCompositingLayerTree(*renderLayer, childList, depth + 1);
>-
>-    if (layerBacking) {
>-        bool parented = false;
>-        if (is<RenderWidget>(layer.renderer()))
>-            parented = parentFrameContentLayers(&downcast<RenderWidget>(layer.renderer()));
>-
>-        if (!parented)
>-            layerBacking->parentForSublayers()->setChildren(WTFMove(layerChildren));
>-
>-        // If the layer has a clipping layer the overflow controls layers will be siblings of the clipping layer.
>-        // Otherwise, the overflow control layers are normal children.
>-        if (!layerBacking->hasClippingLayer() && !layerBacking->hasScrollingLayer()) {
>-            if (auto* overflowControlLayer = layerBacking->layerForHorizontalScrollbar())
>-                layerBacking->parentForSublayers()->addChild(*overflowControlLayer);
>-
>-            if (auto* overflowControlLayer = layerBacking->layerForVerticalScrollbar())
>-                layerBacking->parentForSublayers()->addChild(*overflowControlLayer);
>-
>-            if (auto* overflowControlLayer = layerBacking->layerForScrollCorner())
>-                layerBacking->parentForSublayers()->addChild(*overflowControlLayer);
>-        }
>-
>-        childLayersOfEnclosingLayer.append(*layerBacking->childForSuperlayers());
>-    }
>-    
>-    if (auto* layerBacking = layer.backing())
>-        layerBacking->updateAfterDescendants();
>-}
>-
> void RenderLayerCompositor::frameViewDidChangeLocation(const IntPoint& contentsOffset)
> {
>     if (m_overflowControlsHostLayer)
>@@ -1688,11 +1864,13 @@ void RenderLayerCompositor::frameViewDidLayout()
>         renderViewBacking->adjustTiledBackingCoverage();
> }
> 
>-void RenderLayerCompositor::rootFixedBackgroundsChanged()
>+void RenderLayerCompositor::rootLayerConfigurationChanged()
> {
>     auto* renderViewBacking = m_renderView.layer()->backing();
>-    if (renderViewBacking && renderViewBacking->isFrameLayerWithTiledBacking())
>-        setCompositingLayersNeedRebuild();
>+    if (renderViewBacking && renderViewBacking->isFrameLayerWithTiledBacking()) {
>+        m_renderView.layer()->setNeedsCompositingConfigurationUpdate();
>+        scheduleCompositingLayerUpdate();
>+    }
> }
> 
> void RenderLayerCompositor::scrollingLayerDidChange(RenderLayer& layer)
>@@ -1763,6 +1941,7 @@ RenderLayerCompositor* RenderLayerCompositor::frameContentsCompositor(RenderWidg
>     return nullptr;
> }
> 
>+// FIXME: rename.
> bool RenderLayerCompositor::parentFrameContentLayers(RenderWidget* renderer)
> {
>     auto* innerCompositor = frameContentsCompositor(renderer);
>@@ -1780,6 +1959,7 @@ bool RenderLayerCompositor::parentFrameContentLayers(RenderWidget* renderer)
>         hostingLayer->removeAllChildren();
>         hostingLayer->addChild(*rootLayer);
>     }
>+    // FIXME: Why always return true and not just when the layers changed?
>     return true;
> }
> 
>@@ -1803,7 +1983,7 @@ void RenderLayerCompositor::updateLayerTreeGeometry(RenderLayer& layer, int dept
>             updateRootLayerPosition();
> 
> #if !LOG_DISABLED
>-        logLayerInfo(layer, depth);
>+        logLayerInfo(layer, "updateLayerTreeGeometry", depth);
> #else
>         UNUSED_PARAM(depth);
> #endif
>@@ -1826,49 +2006,6 @@ void RenderLayerCompositor::updateLayerTreeGeometry(RenderLayer& layer, int dept
>         layerBacking->updateAfterDescendants();
> }
> 
>-// Recurs down the RenderLayer tree until its finds the compositing descendants of compositingAncestor and updates their geometry.
>-void RenderLayerCompositor::updateCompositingDescendantGeometry(RenderLayer& compositingAncestor, RenderLayer& layer)
>-{
>-    if (&layer != &compositingAncestor) {
>-        if (auto* layerBacking = layer.backing()) {
>-            layerBacking->updateCompositedBounds();
>-
>-            if (auto* reflection = layer.reflectionLayer()) {
>-                if (reflection->backing())
>-                    reflection->backing()->updateCompositedBounds();
>-            }
>-
>-            layerBacking->updateGeometry();
>-            layerBacking->updateAfterDescendants();
>-            return;
>-        }
>-    }
>-
>-    if (layer.reflectionLayer())
>-        updateCompositingDescendantGeometry(compositingAncestor, *layer.reflectionLayer());
>-
>-    if (!layer.hasCompositingDescendant())
>-        return;
>-
>-#if !ASSERT_DISABLED
>-    LayerListMutationDetector mutationChecker(layer);
>-#endif
>-    
>-    for (auto* renderLayer : layer.negativeZOrderLayers())
>-        updateCompositingDescendantGeometry(compositingAncestor, *renderLayer);
>-
>-    for (auto* renderLayer : layer.normalFlowLayers())
>-        updateCompositingDescendantGeometry(compositingAncestor, *renderLayer);
>-    
>-    for (auto* renderLayer : layer.positiveZOrderLayers())
>-        updateCompositingDescendantGeometry(compositingAncestor, *renderLayer);
>-    
>-    if (&layer != &compositingAncestor) {
>-        if (auto* layerBacking = layer.backing())
>-            layerBacking->updateAfterDescendants();
>-    }
>-}
>-
> void RenderLayerCompositor::repaintCompositedLayers()
> {
>     recursiveRepaintLayer(rootRenderLayer());
>@@ -1972,7 +2109,7 @@ void RenderLayerCompositor::updateRootLayerPosition()
>     }
> 
> #if ENABLE(RUBBER_BANDING)
>-    if (m_contentShadowLayer) {
>+    if (m_contentShadowLayer && m_rootContentLayer) {
>         m_contentShadowLayer->setPosition(m_rootContentLayer->position());
>         m_contentShadowLayer->setSize(m_rootContentLayer->size());
>     }
>@@ -1989,18 +2126,18 @@ bool RenderLayerCompositor::has3DContent() const
>     return layerHas3DContent(rootRenderLayer());
> }
> 
>-bool RenderLayerCompositor::needsToBeComposited(const RenderLayer& layer, RenderLayer::ViewportConstrainedNotCompositedReason* viewportConstrainedNotCompositedReason) const
>+bool RenderLayerCompositor::needsToBeComposited(const RenderLayer& layer, CompositingQueryData& queryData) const
> {
>     if (!canBeComposited(layer))
>         return false;
> 
>-    return requiresCompositingLayer(layer, viewportConstrainedNotCompositedReason) || layer.mustCompositeForIndirectReasons() || (inCompositingMode() && layer.isRenderViewLayer());
>+    return requiresCompositingLayer(layer, queryData) || layer.mustCompositeForIndirectReasons() || (inCompositingMode() && layer.isRenderViewLayer());
> }
> 
> // Note: this specifies whether the RL needs a compositing layer for intrinsic reasons.
> // Use needsToBeComposited() to determine if a RL actually needs a compositing layer.
>-// static
>-bool RenderLayerCompositor::requiresCompositingLayer(const RenderLayer& layer, RenderLayer::ViewportConstrainedNotCompositedReason* viewportConstrainedNotCompositedReason) const
>+// FIXME: is clipsCompositingDescendants() an intrinsic reason?
>+bool RenderLayerCompositor::requiresCompositingLayer(const RenderLayer& layer, CompositingQueryData& queryData) const
> {
>     auto& renderer = rendererForCompositingTests(layer);
> 
>@@ -2008,15 +2145,15 @@ bool RenderLayerCompositor::requiresCompositingLayer(const RenderLayer& layer, R
>     return requiresCompositingForTransform(renderer)
>         || requiresCompositingForAnimation(renderer)
>         || clipsCompositingDescendants(*renderer.layer())
>-        || requiresCompositingForPosition(renderer, *renderer.layer(), viewportConstrainedNotCompositedReason)
>+        || requiresCompositingForPosition(renderer, *renderer.layer(), queryData)
>         || requiresCompositingForCanvas(renderer)
>         || requiresCompositingForFilters(renderer)
>         || requiresCompositingForWillChange(renderer)
>         || requiresCompositingForBackfaceVisibility(renderer)
>         || requiresCompositingForVideo(renderer)
>-        || requiresCompositingForFrame(renderer)
>-        || requiresCompositingForPlugin(renderer)
>-        || requiresCompositingForOverflowScrolling(*renderer.layer());
>+        || requiresCompositingForFrame(renderer, queryData)
>+        || requiresCompositingForPlugin(renderer, queryData)
>+        || requiresCompositingForOverflowScrolling(*renderer.layer(), queryData);
> }
> 
> bool RenderLayerCompositor::canBeComposited(const RenderLayer& layer) const
>@@ -2064,18 +2201,19 @@ bool RenderLayerCompositor::requiresOwnBackingStore(const RenderLayer& layer, co
>             || compositingAncestorLayer->backing()->paintsIntoCompositedAncestor()))
>         return true;
> 
>+    CompositingQueryData queryData;
>     if (layer.isRenderViewLayer()
>         || layer.transform() // note: excludes perspective and transformStyle3D.
>         || requiresCompositingForAnimation(renderer)
>-        || requiresCompositingForPosition(renderer, layer)
>+        || requiresCompositingForPosition(renderer, layer, queryData)
>         || requiresCompositingForCanvas(renderer)
>         || requiresCompositingForFilters(renderer)
>         || requiresCompositingForWillChange(renderer)
>         || requiresCompositingForBackfaceVisibility(renderer)
>         || requiresCompositingForVideo(renderer)
>-        || requiresCompositingForFrame(renderer)
>-        || requiresCompositingForPlugin(renderer)
>-        || requiresCompositingForOverflowScrolling(layer)
>+        || requiresCompositingForFrame(renderer, queryData)
>+        || requiresCompositingForPlugin(renderer, queryData)
>+        || requiresCompositingForOverflowScrolling(layer, queryData)
>         || renderer.isTransparent()
>         || renderer.hasMask()
>         || renderer.hasReflection()
>@@ -2105,6 +2243,8 @@ OptionSet<CompositingReason> RenderLayerCompositor::reasonsForCompositing(const
>     if (!layer.isComposited())
>         return reasons;
> 
>+    CompositingQueryData queryData;
>+
>     auto& renderer = rendererForCompositingTests(layer);
> 
>     if (requiresCompositingForTransform(renderer))
>@@ -2114,9 +2254,9 @@ OptionSet<CompositingReason> RenderLayerCompositor::reasonsForCompositing(const
>         reasons.add(CompositingReason::Video);
>     else if (requiresCompositingForCanvas(renderer))
>         reasons.add(CompositingReason::Canvas);
>-    else if (requiresCompositingForPlugin(renderer))
>+    else if (requiresCompositingForPlugin(renderer, queryData))
>         reasons.add(CompositingReason::Plugin);
>-    else if (requiresCompositingForFrame(renderer))
>+    else if (requiresCompositingForFrame(renderer, queryData))
>         reasons.add(CompositingReason::IFrame);
> 
>     if ((canRender3DTransforms() && renderer.style().backfaceVisibility() == BackfaceVisibility::Hidden))
>@@ -2134,10 +2274,10 @@ OptionSet<CompositingReason> RenderLayerCompositor::reasonsForCompositing(const
>     if (requiresCompositingForWillChange(renderer))
>         reasons.add(CompositingReason::WillChange);
> 
>-    if (requiresCompositingForPosition(renderer, *renderer.layer()))
>+    if (requiresCompositingForPosition(renderer, *renderer.layer(), queryData))
>         reasons.add(renderer.isFixedPositioned() ? CompositingReason::PositionFixed : CompositingReason::PositionSticky);
> 
>-    if (requiresCompositingForOverflowScrolling(*renderer.layer()))
>+    if (requiresCompositingForOverflowScrolling(*renderer.layer(), queryData))
>         reasons.add(CompositingReason::OverflowScrollingTouch);
> 
>     switch (renderer.layer()->indirectCompositingReason()) {
>@@ -2281,11 +2421,14 @@ const char* RenderLayerCompositor::logReasonsForCompositing(const RenderLayer& l
> // according to the z-order hierarchy, yet clipping goes down the renderer hierarchy.
> // Thus, a RenderLayer can be clipped by a RenderLayer that is an ancestor in the renderer hierarchy,
> // but a sibling in the z-order hierarchy.
>+// FIXME: can we do this without a tree walk?
> bool RenderLayerCompositor::clippedByAncestor(RenderLayer& layer) const
> {
>-    if (!layer.isComposited() || !layer.parent())
>+    ASSERT(layer.isComposited());
>+    if (!layer.parent())
>         return false;
> 
>+    // On first pass in WK1, the root may not have become composited yet.
>     auto* compositingAncestor = layer.ancestorCompositingLayer();
>     if (!compositingAncestor)
>         return false;
>@@ -2323,22 +2466,30 @@ bool RenderLayerCompositor::clipsCompositingDescendants(const RenderLayer& layer
>     return layer.hasCompositingDescendant() && layer.renderer().hasClipOrOverflowClip() && !layer.isolatesCompositedBlending();
> }
> 
>-bool RenderLayerCompositor::requiresCompositingForScrollableFrame() const
>+bool RenderLayerCompositor::requiresCompositingForAnimation(RenderLayerModelObject& renderer) const
> {
>-    if (isMainFrameCompositor())
>+    if (!(m_compositingTriggers & ChromeClient::AnimationTrigger))
>         return false;
> 
>-#if PLATFORM(MAC) || PLATFORM(IOS_FAMILY)
>-    if (!m_renderView.settings().asyncFrameScrollingEnabled())
>-        return false;
>-#endif
>+    if (auto* element = renderer.element()) {
>+        if (auto* timeline = element->document().existingTimeline()) {
>+            if (timeline->runningAnimationsForElementAreAllAccelerated(*element))
>+                return true;
>+        }
>+    }
> 
>-    if (!(m_compositingTriggers & ChromeClient::ScrollableNonMainFrameTrigger))
>+    if (RuntimeEnabledFeatures::sharedFeatures().webAnimationsCSSIntegrationEnabled())
>         return false;
> 
>-    // Need this done first to determine overflow.
>-    ASSERT(!m_renderView.needsLayout());
>-    return m_renderView.frameView().isScrollable();
>+    const AnimationBase::RunningState activeAnimationState = AnimationBase::Running | AnimationBase::Paused;
>+    auto& animController = renderer.animation();
>+    return (animController.isRunningAnimationOnRenderer(renderer, CSSPropertyOpacity, activeAnimationState)
>+        && (inCompositingMode() || (m_compositingTriggers & ChromeClient::AnimatedOpacityTrigger)))
>+        || animController.isRunningAnimationOnRenderer(renderer, CSSPropertyFilter, activeAnimationState)
>+#if ENABLE(FILTERS_LEVEL_2)
>+        || animController.isRunningAnimationOnRenderer(renderer, CSSPropertyWebkitBackdropFilter, activeAnimationState)
>+#endif
>+        || animController.isRunningAnimationOnRenderer(renderer, CSSPropertyTransform, activeAnimationState);
> }
> 
> bool RenderLayerCompositor::requiresCompositingForTransform(RenderLayerModelObject& renderer) const
>@@ -2358,7 +2509,7 @@ bool RenderLayerCompositor::requiresCompositingForTransform(RenderLayerModelObje
>         // Continue to allow pages to avoid the very slow software filter path.
>         if (renderer.style().transform().has3DOperation() && renderer.hasFilter())
>             return true;
>-        return !renderer.style().transform().isRepresentableIn2D();
>+        return renderer.style().transform().isRepresentableIn2D() ? false : true;
>     }
>     return false;
> }
>@@ -2392,11 +2543,12 @@ bool RenderLayerCompositor::requiresCompositingForVideo(RenderLayerModelObject&
>         return false;
> 
>     auto& video = downcast<RenderVideo>(renderer);
>-    return (video.requiresImmediateCompositing() || video.shouldDisplayVideo()) && canAccelerateVideoRendering(video);
>+    if ((video.requiresImmediateCompositing() || video.shouldDisplayVideo()) && canAccelerateVideoRendering(video))
>+        return true;
> #else
>     UNUSED_PARAM(renderer);
>-    return false;
> #endif
>+    return false;
> }
> 
> bool RenderLayerCompositor::requiresCompositingForCanvas(RenderLayerModelObject& renderer) const
>@@ -2424,7 +2576,40 @@ bool RenderLayerCompositor::requiresCompositingForCanvas(RenderLayerModelObject&
>     return false;
> }
> 
>-bool RenderLayerCompositor::requiresCompositingForPlugin(RenderLayerModelObject& renderer) const
>+bool RenderLayerCompositor::requiresCompositingForFilters(RenderLayerModelObject& renderer) const
>+{
>+#if ENABLE(FILTERS_LEVEL_2)
>+    if (renderer.hasBackdropFilter())
>+        return true;
>+#endif
>+
>+    if (!(m_compositingTriggers & ChromeClient::FilterTrigger))
>+        return false;
>+
>+    return renderer.hasFilter();
>+}
>+
>+bool RenderLayerCompositor::requiresCompositingForWillChange(RenderLayerModelObject& renderer) const
>+{
>+    if (!renderer.style().willChange() || !renderer.style().willChange()->canTriggerCompositing())
>+        return false;
>+
>+#if ENABLE(FULLSCREEN_API)
>+    // FIXME: does this require layout?
>+    if (renderer.layer() && isDescendantOfFullScreenLayer(*renderer.layer()) == FullScreenDescendant::No)
>+        return false;
>+#endif
>+
>+    if (m_compositingPolicy == CompositingPolicy::Conservative)
>+        return false;
>+
>+    if (is<RenderBox>(renderer))
>+        return true;
>+
>+    return renderer.style().willChange()->canTriggerCompositingOnInline();
>+}
>+
>+bool RenderLayerCompositor::requiresCompositingForPlugin(RenderLayerModelObject& renderer, CompositingQueryData& queryData) const
> {
>     if (!(m_compositingTriggers & ChromeClient::PluginTrigger))
>         return false;
>@@ -2433,22 +2618,22 @@ bool RenderLayerCompositor::requiresCompositingForPlugin(RenderLayerModelObject&
>     if (!isCompositedPlugin)
>         return false;
> 
>-    m_reevaluateCompositingAfterLayout = true;
>-    
>     auto& pluginRenderer = downcast<RenderWidget>(renderer);
>     if (pluginRenderer.style().visibility() != Visibility::Visible)
>         return false;
> 
>     // If we can't reliably know the size of the plugin yet, don't change compositing state.
>-    if (pluginRenderer.needsLayout())
>+    if (queryData.layoutUpToDate == LayoutUpToDate::No) {
>+        queryData.reevaluateAfterLayout = true;
>         return pluginRenderer.isComposited();
>+    }
> 
>     // Don't go into compositing mode if height or width are zero, or size is 1x1.
>     IntRect contentBox = snappedIntRect(pluginRenderer.contentBoxRect());
>-    return contentBox.height() * contentBox.width() > 1;
>+    return (contentBox.height() * contentBox.width() > 1);
> }
> 
>-bool RenderLayerCompositor::requiresCompositingForFrame(RenderLayerModelObject& renderer) const
>+bool RenderLayerCompositor::requiresCompositingForFrame(RenderLayerModelObject& renderer, CompositingQueryData& queryData) const
> {
>     if (!is<RenderWidget>(renderer))
>         return false;
>@@ -2460,42 +2645,127 @@ bool RenderLayerCompositor::requiresCompositingForFrame(RenderLayerModelObject&
>     if (!frameRenderer.requiresAcceleratedCompositing())
>         return false;
> 
>-    m_reevaluateCompositingAfterLayout = true;
>-
>-    // If we can't reliably know the size of the iframe yet, don't change compositing state.
>-    if (!frameRenderer.parent() || frameRenderer.needsLayout())
>+    if (queryData.layoutUpToDate == LayoutUpToDate::No) {
>+        queryData.reevaluateAfterLayout = true;
>         return frameRenderer.isComposited();
>-    
>+    }
>+
>     // Don't go into compositing mode if height or width are zero.
>     return !snappedIntRect(frameRenderer.contentBoxRect()).isEmpty();
> }
> 
>-bool RenderLayerCompositor::requiresCompositingForAnimation(RenderLayerModelObject& renderer) const
>+bool RenderLayerCompositor::requiresCompositingForScrollableFrame(CompositingQueryData& queryData) const
> {
>-    if (!(m_compositingTriggers & ChromeClient::AnimationTrigger))
>+    if (isMainFrameCompositor())
>         return false;
> 
>-    if (auto* element = renderer.element()) {
>-        if (auto* timeline = element->document().existingTimeline()) {
>-            if (timeline->runningAnimationsForElementAreAllAccelerated(*element))
>-                return true;
>-        }
>+#if PLATFORM(MAC) || PLATFORM(IOS_FAMILY)
>+    if (!m_renderView.settings().asyncFrameScrollingEnabled())
>+        return false;
>+#endif
>+
>+    if (!(m_compositingTriggers & ChromeClient::ScrollableNonMainFrameTrigger))
>+        return false;
>+
>+    if (queryData.layoutUpToDate == LayoutUpToDate::No) {
>+        queryData.reevaluateAfterLayout = true;
>+        return m_renderView.isComposited();
>     }
> 
>-    if (RuntimeEnabledFeatures::sharedFeatures().webAnimationsCSSIntegrationEnabled())
>+    return m_renderView.frameView().isScrollable();
>+}
>+
>+bool RenderLayerCompositor::requiresCompositingForPosition(RenderLayerModelObject& renderer, const RenderLayer& layer, CompositingQueryData& queryData) const
>+{
>+    // position:fixed elements that create their own stacking context (e.g. have an explicit z-index,
>+    // opacity, transform) can get their own composited layer. A stacking context is required otherwise
>+    // z-index and clipping will be broken.
>+    if (!renderer.isPositioned())
>+        return false;
>+    
>+#if ENABLE(FULLSCREEN_API)
>+    if (isDescendantOfFullScreenLayer(layer) == FullScreenDescendant::No)
>         return false;
>+#endif
> 
>-    const AnimationBase::RunningState activeAnimationState = AnimationBase::Running | AnimationBase::Paused;
>-    auto& animController = renderer.animation();
>-    return (animController.isRunningAnimationOnRenderer(renderer, CSSPropertyOpacity, activeAnimationState)
>-            && (inCompositingMode() || (m_compositingTriggers & ChromeClient::AnimatedOpacityTrigger)))
>-            || animController.isRunningAnimationOnRenderer(renderer, CSSPropertyFilter, activeAnimationState)
>-#if ENABLE(FILTERS_LEVEL_2)
>-            || animController.isRunningAnimationOnRenderer(renderer, CSSPropertyWebkitBackdropFilter, activeAnimationState)
>+    auto position = renderer.style().position();
>+    bool isFixed = renderer.isOutOfFlowPositioned() && position == PositionType::Fixed;
>+    if (isFixed && !layer.isStackingContext())
>+        return false;
>+    
>+    bool isSticky = renderer.isInFlowPositioned() && position == PositionType::Sticky;
>+    if (!isFixed && !isSticky)
>+        return false;
>+
>+    // FIXME: acceleratedCompositingForFixedPositionEnabled should probably be renamed acceleratedCompositingForViewportConstrainedPositionEnabled().
>+    if (!m_renderView.settings().acceleratedCompositingForFixedPositionEnabled())
>+        return false;
>+
>+    if (isSticky)
>+        return isAsyncScrollableStickyLayer(layer);
>+
>+    if (queryData.layoutUpToDate == LayoutUpToDate::No) {
>+        queryData.reevaluateAfterLayout = true;
>+        return layer.isComposited();
>+    }
>+
>+    auto container = renderer.container();
>+    ASSERT(container);
>+
>+    // Don't promote fixed position elements that are descendants of a non-view container, e.g. transformed elements.
>+    // They will stay fixed wrt the container rather than the enclosing frame.j
>+    if (container != &m_renderView) {
>+        queryData.nonCompositedForPositionReason = RenderLayer::NotCompositedForNonViewContainer;
>+        return false;
>+    }
>+
>+    bool paintsContent = layer.isVisuallyNonEmpty() || layer.hasVisibleDescendant();
>+    if (!paintsContent) {
>+        queryData.nonCompositedForPositionReason = RenderLayer::NotCompositedForNoVisibleContent;
>+        return false;
>+    }
>+
>+    // Fixed position elements that are invisible in the current view don't get their own layer.
>+    // FIXME: We shouldn't have to check useFixedLayout() here; one of the viewport rects needs to give the correct answer.
>+    LayoutRect viewBounds;
>+    if (m_renderView.frameView().useFixedLayout())
>+        viewBounds = m_renderView.unscaledDocumentRect();
>+    else
>+        viewBounds = m_renderView.frameView().rectForFixedPositionLayout();
>+
>+    LayoutRect layerBounds = layer.calculateLayerBounds(&layer, LayoutSize(), { RenderLayer::UseLocalClipRectIfPossible, RenderLayer::IncludeLayerFilterOutsets, RenderLayer::UseFragmentBoxesExcludingCompositing,
>+        RenderLayer::ExcludeHiddenDescendants, RenderLayer::DontConstrainForMask, RenderLayer::IncludeCompositedDescendants });
>+    // Map to m_renderView to ignore page scale.
>+    FloatRect absoluteBounds = layer.renderer().localToContainerQuad(FloatRect(layerBounds), &m_renderView).boundingBox();
>+    if (!viewBounds.intersects(enclosingIntRect(absoluteBounds))) {
>+        queryData.nonCompositedForPositionReason = RenderLayer::NotCompositedForBoundsOutOfView;
>+        LOG_WITH_STREAM(Compositing, stream << "Layer " << &layer << " bounds " << absoluteBounds << " outside visible rect " << viewBounds);
>+        return false;
>+    }
>+    
>+    return true;
>+}
>+
>+bool RenderLayerCompositor::requiresCompositingForOverflowScrolling(const RenderLayer& layer, CompositingQueryData& queryData) const
>+{
>+#if PLATFORM(IOS_FAMILY)
>+    if (!layer.canUseAcceleratedTouchScrolling())
>+        return false;
>+
>+    if (queryData.layoutUpToDate == LayoutUpToDate::No) {
>+        queryData.reevaluateAfterLayout = true;
>+        return layer.isComposited();
>+    }
>+
>+    return layer.hasTouchScrollableOverflow();
>+#else
>+    UNUSED_PARAM(layer);
>+    UNUSED_PARAM(queryData);
>+    return false;
> #endif
>-            || animController.isRunningAnimationOnRenderer(renderer, CSSPropertyTransform, activeAnimationState);
> }
> 
>+// FIXME: why doesn't this handle the clipping cases?
> bool RenderLayerCompositor::requiresCompositingForIndirectReason(RenderLayerModelObject& renderer, bool hasCompositedDescendants, bool has3DTransformedDescendants, RenderLayer::IndirectCompositingReason& reason) const
> {
>     auto& layer = *downcast<RenderBoxModelObject>(renderer).layer();
>@@ -2525,57 +2795,24 @@ bool RenderLayerCompositor::requiresCompositingForIndirectReason(RenderLayerMode
>     return false;
> }
> 
>-bool RenderLayerCompositor::styleChangeMayAffectIndirectCompositingReasons(const RenderLayerModelObject& renderer, const RenderStyle& oldStyle)
>+bool RenderLayerCompositor::styleChangeMayAffectIndirectCompositingReasons(const RenderStyle& oldStyle, const RenderStyle& newStyle)
> {
>-    auto& style = renderer.style();
>-    if (RenderElement::createsGroupForStyle(style) != RenderElement::createsGroupForStyle(oldStyle))
>+    if (RenderElement::createsGroupForStyle(newStyle) != RenderElement::createsGroupForStyle(oldStyle))
>         return true;
>-    if (style.isolation() != oldStyle.isolation())
>+    if (newStyle.isolation() != oldStyle.isolation())
>         return true;
>-    if (style.hasTransform() != oldStyle.hasTransform())
>+    if (newStyle.hasTransform() != oldStyle.hasTransform())
>         return true;
>-    if (style.boxReflect() != oldStyle.boxReflect())
>+    if (newStyle.boxReflect() != oldStyle.boxReflect())
>         return true;
>-    if (style.transformStyle3D() != oldStyle.transformStyle3D())
>+    if (newStyle.transformStyle3D() != oldStyle.transformStyle3D())
>         return true;
>-    if (style.hasPerspective() != oldStyle.hasPerspective())
>+    if (newStyle.hasPerspective() != oldStyle.hasPerspective())
>         return true;
> 
>     return false;
> }
> 
>-bool RenderLayerCompositor::requiresCompositingForFilters(RenderLayerModelObject& renderer) const
>-{
>-#if ENABLE(FILTERS_LEVEL_2)
>-    if (renderer.hasBackdropFilter())
>-        return true;
>-#endif
>-
>-    if (!(m_compositingTriggers & ChromeClient::FilterTrigger))
>-        return false;
>-
>-    return renderer.hasFilter();
>-}
>-
>-bool RenderLayerCompositor::requiresCompositingForWillChange(RenderLayerModelObject& renderer) const
>-{
>-    if (!renderer.style().willChange() || !renderer.style().willChange()->canTriggerCompositing())
>-        return false;
>-
>-#if ENABLE(FULLSCREEN_API)
>-    if (renderer.layer() && isDescendantOfFullScreenLayer(*renderer.layer()) == FullScreenDescendant::No)
>-        return false;
>-#endif
>-
>-    if (m_compositingPolicy == CompositingPolicy::Conservative)
>-        return false;
>-
>-    if (is<RenderBox>(renderer))
>-        return true;
>-
>-    return renderer.style().willChange()->canTriggerCompositingOnInline();
>-}
>-
> bool RenderLayerCompositor::isAsyncScrollableStickyLayer(const RenderLayer& layer, const RenderLayer** enclosingAcceleratedOverflowLayer) const
> {
>     ASSERT(layer.renderer().isStickilyPositioned());
>@@ -2632,103 +2869,6 @@ bool RenderLayerCompositor::useCoordinatedScrollingForLayer(const RenderLayer& l
>     return layer.hasTouchScrollableOverflow();
> }
> 
>-bool RenderLayerCompositor::requiresCompositingForPosition(RenderLayerModelObject& renderer, const RenderLayer& layer, RenderLayer::ViewportConstrainedNotCompositedReason* viewportConstrainedNotCompositedReason) const
>-{
>-    // position:fixed elements that create their own stacking context (e.g. have an explicit z-index,
>-    // opacity, transform) can get their own composited layer. A stacking context is required otherwise
>-    // z-index and clipping will be broken.
>-    if (!renderer.isPositioned())
>-        return false;
>-    
>-#if ENABLE(FULLSCREEN_API)
>-    if (isDescendantOfFullScreenLayer(layer) == FullScreenDescendant::No)
>-        return false;
>-#endif
>-
>-    auto position = renderer.style().position();
>-    bool isFixed = renderer.isOutOfFlowPositioned() && position == PositionType::Fixed;
>-    if (isFixed && !layer.isStackingContext())
>-        return false;
>-    
>-    bool isSticky = renderer.isInFlowPositioned() && position == PositionType::Sticky;
>-    if (!isFixed && !isSticky)
>-        return false;
>-
>-    // FIXME: acceleratedCompositingForFixedPositionEnabled should probably be renamed acceleratedCompositingForViewportConstrainedPositionEnabled().
>-    if (!m_renderView.settings().acceleratedCompositingForFixedPositionEnabled())
>-        return false;
>-
>-    if (isSticky)
>-        return isAsyncScrollableStickyLayer(layer);
>-
>-    auto container = renderer.container();
>-    // If the renderer is not hooked up yet then we have to wait until it is.
>-    if (!container) {
>-        m_reevaluateCompositingAfterLayout = true;
>-        return false;
>-    }
>-
>-    // Don't promote fixed position elements that are descendants of a non-view container, e.g. transformed elements.
>-    // They will stay fixed wrt the container rather than the enclosing frame.
>-    if (container != &m_renderView) {
>-        if (viewportConstrainedNotCompositedReason)
>-            *viewportConstrainedNotCompositedReason = RenderLayer::NotCompositedForNonViewContainer;
>-        return false;
>-    }
>-    
>-    // Subsequent tests depend on layout. If we can't tell now, just keep things the way they are until layout is done.
>-    if (!m_inPostLayoutUpdate) {
>-        m_reevaluateCompositingAfterLayout = true;
>-        return layer.isComposited();
>-    }
>-
>-    bool paintsContent = layer.isVisuallyNonEmpty() || layer.hasVisibleDescendant();
>-    if (!paintsContent) {
>-        if (viewportConstrainedNotCompositedReason)
>-            *viewportConstrainedNotCompositedReason = RenderLayer::NotCompositedForNoVisibleContent;
>-        return false;
>-    }
>-
>-    // Fixed position elements that are invisible in the current view don't get their own layer.
>-    // FIXME: We shouldn't have to check useFixedLayout() here; one of the viewport rects needs to give the correct answer.
>-    LayoutRect viewBounds;
>-    if (m_renderView.frameView().useFixedLayout())
>-        viewBounds = m_renderView.unscaledDocumentRect();
>-    else
>-        viewBounds = m_renderView.frameView().rectForFixedPositionLayout();
>-
>-    LayoutRect layerBounds = layer.calculateLayerBounds(&layer, LayoutSize(), { RenderLayer::UseLocalClipRectIfPossible, RenderLayer::IncludeLayerFilterOutsets, RenderLayer::UseFragmentBoxesExcludingCompositing,
>-        RenderLayer::ExcludeHiddenDescendants, RenderLayer::DontConstrainForMask, RenderLayer::IncludeCompositedDescendants });
>-    // Map to m_renderView to ignore page scale.
>-    FloatRect absoluteBounds = layer.renderer().localToContainerQuad(FloatRect(layerBounds), &m_renderView).boundingBox();
>-    if (!viewBounds.intersects(enclosingIntRect(absoluteBounds))) {
>-        if (viewportConstrainedNotCompositedReason)
>-            *viewportConstrainedNotCompositedReason = RenderLayer::NotCompositedForBoundsOutOfView;
>-        LOG_WITH_STREAM(Compositing, stream << "Layer " << &layer << " bounds " << absoluteBounds << " outside visible rect " << viewBounds);
>-        return false;
>-    }
>-    
>-    return true;
>-}
>-
>-bool RenderLayerCompositor::requiresCompositingForOverflowScrolling(const RenderLayer& layer) const
>-{
>-#if PLATFORM(IOS_FAMILY)
>-    if (!layer.canUseAcceleratedTouchScrolling())
>-        return false;
>-
>-    if (!m_inPostLayoutUpdate) {
>-        m_reevaluateCompositingAfterLayout = true;
>-        return layer.isComposited();
>-    }
>-
>-    return layer.hasTouchScrollableOverflow();
>-#else
>-    UNUSED_PARAM(layer);
>-    return false;
>-#endif
>-}
>-
> bool RenderLayerCompositor::isRunningTransformAnimation(RenderLayerModelObject& renderer) const
> {
>     if (!(m_compositingTriggers & ChromeClient::AnimationTrigger))
>@@ -3118,10 +3258,8 @@ void RenderLayerCompositor::rootOrBodyStyleChanged(RenderElement& renderer, cons
>         rootBackgroundColorOrTransparencyChanged();
> 
>     bool hadFixedBackground = oldStyle && oldStyle->hasEntirelyFixedBackground();
>-    if (hadFixedBackground != renderer.style().hasEntirelyFixedBackground()) {
>-        setCompositingLayersNeedRebuild();
>-        scheduleCompositingLayerUpdate();
>-    }
>+    if (hadFixedBackground != renderer.style().hasEntirelyFixedBackground())
>+        rootLayerConfigurationChanged();
> }
> 
> void RenderLayerCompositor::rootBackgroundColorOrTransparencyChanged()
>@@ -3138,10 +3276,11 @@ void RenderLayerCompositor::rootBackgroundColorOrTransparencyChanged()
>     bool backgroundColorChanged = m_viewBackgroundColor != backgroundColor;
>     bool extendedBackgroundColorChanged = m_rootExtendedBackgroundColor != extendedBackgroundColor;
> 
>-    LOG(Compositing, "RenderLayerCompositor %p rootBackgroundColorOrTransparencyChanged. isTransparent=%d, transparencyChanged=%d, backgroundColorChanged=%d, extendedBackgroundColorChanged=%d", this, isTransparent, transparencyChanged, backgroundColorChanged, extendedBackgroundColorChanged);
>     if (!transparencyChanged && !backgroundColorChanged && !extendedBackgroundColorChanged)
>         return;
> 
>+    LOG(Compositing, "RenderLayerCompositor %p rootBackgroundColorOrTransparencyChanged. isTransparent=%d", this, isTransparent);
>+
>     m_viewBackgroundIsTransparent = isTransparent;
>     m_viewBackgroundColor = backgroundColor;
>     m_rootExtendedBackgroundColor = extendedBackgroundColor;
>@@ -3160,8 +3299,7 @@ void RenderLayerCompositor::rootBackgroundColorOrTransparencyChanged()
> #endif
>     }
>     
>-    setRootLayerConfigurationNeedsUpdate();
>-    scheduleCompositingLayerUpdate();
>+    rootLayerConfigurationChanged();
> }
> 
> void RenderLayerCompositor::updateOverflowControlsLayers()
>@@ -4064,7 +4202,6 @@ TextStream& operator<<(TextStream& ts, CompositingUpdateType updateType)
>     switch (updateType) {
>     case CompositingUpdateType::AfterStyleChange: ts << "after style change"; break;
>     case CompositingUpdateType::AfterLayout: ts << "after layout"; break;
>-    case CompositingUpdateType::OnHitTest: ts << "on hit test"; break;
>     case CompositingUpdateType::OnScroll: ts << "on scroll"; break;
>     case CompositingUpdateType::OnCompositedScroll: ts << "on composited scroll"; break;
>     }
>diff --git a/Source/WebCore/rendering/RenderLayerCompositor.h b/Source/WebCore/rendering/RenderLayerCompositor.h
>index 8875fff7b2367fe6ab817e7d241073e78a8748ee..5b881df931f36491bbe60eb1d47c49b9bf39bbb8 100644
>--- a/Source/WebCore/rendering/RenderLayerCompositor.h
>+++ b/Source/WebCore/rendering/RenderLayerCompositor.h
>@@ -49,7 +49,6 @@ typedef unsigned LayerTreeFlags;
> enum class CompositingUpdateType {
>     AfterStyleChange,
>     AfterLayout,
>-    OnHitTest,
>     OnScroll,
>     OnCompositedScroll
> };
>@@ -110,11 +109,6 @@ public:
> 
>     bool canRender3DTransforms() const;
> 
>-    // Called when the layer hierarchy needs to be updated (compositing layers have been
>-    // created, destroyed or re-parented).
>-    void setCompositingLayersNeedRebuild(bool needRebuild = true);
>-    bool compositingLayersNeedRebuild() const { return m_compositingLayersNeedRebuild; }
>-    
>     void willRecalcStyle();
> 
>     // Returns true if the composited layers were actually updated.
>@@ -141,11 +135,18 @@ public:
> 
>     // Update the compositing state of the given layer. Returns true if that state changed.
>     enum CompositingChangeRepaint { CompositingChangeRepaintNow, CompositingChangeWillRepaintLater };
>-    bool updateLayerCompositingState(RenderLayer&, CompositingChangeRepaint = CompositingChangeRepaintNow);
>+    enum class LayoutUpToDate {
>+        Yes, No
>+    };
>+
>+    struct CompositingQueryData {
>+        LayoutUpToDate layoutUpToDate { LayoutUpToDate::Yes };
>+        RenderLayer::ViewportConstrainedNotCompositedReason nonCompositedForPositionReason { RenderLayer::NoNotCompositedReason };
>+        bool reevaluateAfterLayout { false };
>+    };
>+
>+    bool updateLayerCompositingState(RenderLayer&, CompositingQueryData&, CompositingChangeRepaint = CompositingChangeRepaintNow);
> 
>-    // Update the geometry for compositing children of compositingAncestor.
>-    void updateCompositingDescendantGeometry(RenderLayer& compositingAncestor, RenderLayer&);
>-    
>     // Whether layer's backing needs a graphics layer to do clipping by an ancestor (non-stacking-context parent with overflow).
>     bool clippedByAncestor(RenderLayer&) const;
>     // Whether layer's backing needs a graphics layer to clip z-order children of the given layer.
>@@ -234,7 +235,7 @@ public:
>     void frameViewDidScroll();
>     void frameViewDidAddOrRemoveScrollbars();
>     void frameViewDidLayout();
>-    void rootFixedBackgroundsChanged();
>+    void rootLayerConfigurationChanged();
> 
>     void scrollingLayerDidChange(RenderLayer&);
>     void fixedRootBackgroundLayerChanged();
>@@ -295,9 +296,6 @@ public:
>     void resetTrackedRepaintRects();
>     void setTracksRepaints(bool tracksRepaints) { m_isTrackingRepaints = tracksRepaints; }
> 
>-
>-    void setShouldReevaluateCompositingAfterLayout() { m_reevaluateCompositingAfterLayout = true; }
>-
>     bool viewHasTransparentBackground(Color* backgroundColor = nullptr) const;
> 
>     bool hasNonMainLayersWithTiledBacking() const { return m_layersWithTiledBackingCount; }
>@@ -346,16 +344,16 @@ private:
>     void cacheAcceleratedCompositingFlagsAfterLayout();
> 
>     // Whether the given RL needs a compositing layer.
>-    bool needsToBeComposited(const RenderLayer&, RenderLayer::ViewportConstrainedNotCompositedReason* = nullptr) const;
>+    bool needsToBeComposited(const RenderLayer&, CompositingQueryData&) const;
>     // Whether the layer has an intrinsic need for compositing layer.
>-    bool requiresCompositingLayer(const RenderLayer&, RenderLayer::ViewportConstrainedNotCompositedReason* = nullptr) const;
>+    bool requiresCompositingLayer(const RenderLayer&, CompositingQueryData&) const;
>     // Whether the layer could ever be composited.
>     bool canBeComposited(const RenderLayer&) const;
>     bool needsCompositingUpdateForStyleChangeOnNonCompositedLayer(RenderLayer&, const RenderStyle* oldStyle) const;
> 
>     // Make or destroy the backing for this layer; returns true if backing changed.
>     enum class BackingRequired { No, Yes, Unknown };
>-    bool updateBacking(RenderLayer&, CompositingChangeRepaint shouldRepaint, BackingRequired = BackingRequired::Unknown);
>+    bool updateBacking(RenderLayer&, CompositingQueryData&, CompositingChangeRepaint shouldRepaint, BackingRequired = BackingRequired::Unknown);
> 
>     void clearBackingForLayerIncludingDescendants(RenderLayer&);
> 
>@@ -368,11 +366,15 @@ private:
> 
>     void updateCompositingLayersTimerFired();
> 
>-    // Returns true if any layer's compositing changed
>     void computeCompositingRequirements(RenderLayer* ancestorLayer, RenderLayer&, OverlapMap&, CompositingState&, bool& layersChanged, bool& descendantHas3DTransform);
>+    void traverseUnchangedSubtree(RenderLayer* ancestorLayer, RenderLayer&, OverlapMap&, CompositingState&, bool& descendantHas3DTransform);
> 
>+    enum class UpdateLevel {
>+        AllDescendants          = 1 << 0,
>+        CompositedChildren      = 1 << 1,
>+    };
>     // Recurses down the tree, parenting descendant compositing layers and collecting an array of child layers for the current compositing layer.
>-    void rebuildCompositingLayerTree(RenderLayer&, Vector<Ref<GraphicsLayer>>& childGraphicsLayersOfEnclosingLayer, int depth);
>+    void updateBackingAndHierarchy(RenderLayer&, Vector<Ref<GraphicsLayer>>& childGraphicsLayersOfEnclosingLayer, OptionSet<UpdateLevel> = { }, int depth = 0);
> 
>     // Recurses down the tree, updating layer geometry only.
>     void updateLayerTreeGeometry(RenderLayer&, int depth);
>@@ -417,20 +419,25 @@ private:
>     RefPtr<DisplayRefreshMonitor> createDisplayRefreshMonitor(PlatformDisplayID) const override;
> #endif
> 
>+    // Non layout-dependent
>     bool requiresCompositingForAnimation(RenderLayerModelObject&) const;
>     bool requiresCompositingForTransform(RenderLayerModelObject&) const;
>     bool requiresCompositingForBackfaceVisibility(RenderLayerModelObject&) const;
>     bool requiresCompositingForVideo(RenderLayerModelObject&) const;
>     bool requiresCompositingForCanvas(RenderLayerModelObject&) const;
>-    bool requiresCompositingForPlugin(RenderLayerModelObject&) const;
>-    bool requiresCompositingForFrame(RenderLayerModelObject&) const;
>     bool requiresCompositingForFilters(RenderLayerModelObject&) const;
>     bool requiresCompositingForWillChange(RenderLayerModelObject&) const;
>-    bool requiresCompositingForScrollableFrame() const;
>-    bool requiresCompositingForPosition(RenderLayerModelObject&, const RenderLayer&, RenderLayer::ViewportConstrainedNotCompositedReason* = nullptr) const;
>-    bool requiresCompositingForOverflowScrolling(const RenderLayer&) const;
>+
>+    // Layout-dependent
>+    bool requiresCompositingForPlugin(RenderLayerModelObject&, CompositingQueryData&) const;
>+    bool requiresCompositingForFrame(RenderLayerModelObject&, CompositingQueryData&) const;
>+    bool requiresCompositingForScrollableFrame(CompositingQueryData&) const;
>+    bool requiresCompositingForPosition(RenderLayerModelObject&, const RenderLayer&, CompositingQueryData&) const;
>+    bool requiresCompositingForOverflowScrolling(const RenderLayer&, CompositingQueryData&) const;
>+
>     bool requiresCompositingForIndirectReason(RenderLayerModelObject&, bool hasCompositedDescendants, bool has3DTransformedDescendants, RenderLayer::IndirectCompositingReason&) const;
>-    static bool styleChangeMayAffectIndirectCompositingReasons(const RenderLayerModelObject& renderer, const RenderStyle& oldStyle);
>+
>+    static bool styleChangeMayAffectIndirectCompositingReasons(const RenderStyle& oldStyle, const RenderStyle& newStyle);
> 
>     void updateCustomLayersAfterFlush();
> 
>@@ -469,14 +476,12 @@ private:
> 
> #if !LOG_DISABLED
>     const char* logReasonsForCompositing(const RenderLayer&);
>-    void logLayerInfo(const RenderLayer&, int depth);
>+    void logLayerInfo(const RenderLayer&, const char*, int depth);
> #endif
> 
>     bool documentUsesTiledBacking() const;
>     bool isMainFrameCompositor() const;
>     
>-    void setRootLayerConfigurationNeedsUpdate() { m_rootLayerConfigurationNeedsUpdate = true; }
>-
> private:
>     RenderView& m_renderView;
>     RefPtr<GraphicsLayer> m_rootContentLayer;
>@@ -492,13 +497,7 @@ private:
>     bool m_acceleratedDrawingEnabled { false };
>     bool m_displayListDrawingEnabled { false };
> 
>-    // When true, we have to wait until layout has happened before we can decide whether to enter compositing mode,
>-    // because only then do we know the final size of plugins and iframes.
>-    mutable bool m_reevaluateCompositingAfterLayout { false };
>-
>     bool m_compositing { false };
>-    bool m_compositingLayersNeedRebuild { false };
>-    bool m_rootLayerConfigurationNeedsUpdate { false };
>     bool m_flushingLayers { false };
>     bool m_shouldFlushOnReattach { false };
>     bool m_forceCompositingMode { false };
>@@ -548,7 +547,6 @@ private:
>     bool m_layerFlushThrottlingEnabled { false };
>     bool m_layerFlushThrottlingTemporarilyDisabledForInteraction { false };
>     bool m_hasPendingLayerFlush { false };
>-    bool m_layerNeedsCompositingUpdate { false };
>     bool m_viewBackgroundIsTransparent { false };
> 
> #if !LOG_DISABLED
>diff --git a/Source/WebCore/rendering/RenderTreeAsText.cpp b/Source/WebCore/rendering/RenderTreeAsText.cpp
>index 234236a072c3ae95bf82b9f36fb5cba1e38c4f6e..1e8664be0d54400b52ade4732f5d67f99cf5d629 100644
>--- a/Source/WebCore/rendering/RenderTreeAsText.cpp
>+++ b/Source/WebCore/rendering/RenderTreeAsText.cpp
>@@ -704,6 +704,7 @@ static void writeLayers(TextStream& ts, const RenderLayer& rootLayer, RenderLaye
> 
>     // Ensure our lists are up-to-date.
>     layer.updateLayerListsIfNeeded();
>+    layer.updateDescendantDependentFlags();
> 
>     bool shouldPaint = (behavior & RenderAsTextShowAllLayers) ? true : layer.intersectsDamageRect(layerBounds, damageRect.rect(), &rootLayer, layer.offsetFromAncestor(&rootLayer));
>     auto negativeZOrderLayers = layer.negativeZOrderLayers();
>diff --git a/LayoutTests/compositing/geometry/stacking-context-change-layer-reparent-expected.html b/LayoutTests/compositing/geometry/stacking-context-change-layer-reparent-expected.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..83478f43fda18aa05e2aacde07f0e0c7c5017a2c
>--- /dev/null
>+++ b/LayoutTests/compositing/geometry/stacking-context-change-layer-reparent-expected.html
>@@ -0,0 +1,36 @@
>+<!DOCTYPE html>
>+<style>
>+    #container {
>+        height: 250px;
>+        width: 250px;
>+        border: 1px solid black;
>+        transform: translateZ(0);
>+    }
>+
>+    #parent {
>+        position: absolute;
>+        left: 320px;
>+        width: 250px;
>+        height: 250px;
>+        background-color: green;
>+        z-index: auto;
>+    }
>+  
>+    #child {
>+        position: absolute;
>+        left: 25px;
>+        top: 25px;
>+        width: 200px;
>+        height: 200px;
>+        z-index: -2;
>+        background-color: red;
>+        transform: translateZ(0);
>+    }
>+</style>
>+<body>
>+    <div id="container">
>+        <div id="parent">
>+            <div id="child"></div>
>+        </div>
>+    </div>
>+</body>
>diff --git a/LayoutTests/compositing/geometry/stacking-context-change-layer-reparent.html b/LayoutTests/compositing/geometry/stacking-context-change-layer-reparent.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..d997751429bb74641c4143ddf23313e3cd2808fe
>--- /dev/null
>+++ b/LayoutTests/compositing/geometry/stacking-context-change-layer-reparent.html
>@@ -0,0 +1,52 @@
>+<!DOCTYPE html>
>+<style>
>+    #container {
>+        height: 250px;
>+        width: 250px;
>+        border: 1px solid black;
>+        transform: translateZ(0);
>+    }
>+
>+    #parent {
>+        position: absolute;
>+        left: 320px;
>+        width: 250px;
>+        height: 250px;
>+        background-color: green;
>+        z-index: 0;
>+    }
>+  
>+    #parent.changed {
>+        z-index: auto;
>+    }
>+  
>+    #child {
>+        position: absolute;
>+        left: 25px;
>+        top: 25px;
>+        width: 200px;
>+        height: 200px;
>+        z-index: -2;
>+        background-color: red;
>+        transform: translateZ(0);
>+    }
>+</style>
>+<script>
>+    if (window.testRunner)
>+        testRunner.waitUntilDone();
>+
>+    window.addEventListener('load', function() {
>+        setTimeout(function() {
>+            document.getElementById('parent').classList.add('changed');
>+            if (window.testRunner)
>+                testRunner.notifyDone();
>+        }, 0);
>+    }, false);
>+</script>
>+<body>
>+    <div id="container">
>+        <div id="parent">
>+            <div id="child"></div>
>+        </div>
>+    </div>
>+</body>
>diff --git a/LayoutTests/platform/mac-wk1/TestExpectations b/LayoutTests/platform/mac-wk1/TestExpectations
>index ff287e1a2041568f9525a9c7b98e076c03a2fcf9..8bd9e20169d6ef5a8eccbd2472c8985228e4afd5 100644
>--- a/LayoutTests/platform/mac-wk1/TestExpectations
>+++ b/LayoutTests/platform/mac-wk1/TestExpectations
>@@ -625,6 +625,9 @@ webkit.org/b/188357 legacy-animation-engine/compositing/backing/transform-transi
> webkit.org/b/188357 legacy-animation-engine/compositing/geometry/limit-layer-bounds-opacity-transition.html [ Pass Failure ]
> webkit.org/b/188357 legacy-animation-engine/compositing/layer-creation/animation-overlap-with-children.html [ Pass Failure ]
> 
>+webkit.org/b/190648 compositing/layer-creation/fixed-overlap-extent.html [ Pass Failure ]
>+webkit.org/b/190627 compositing/repaint/iframes/compositing-iframe-scroll-repaint.html [ Pass Failure ]
>+
> # <rdar://problem/42904780>
> [ Mojave+ Release ] imported/w3c/web-platform-tests/WebCryptoAPI/derive_bits_keys/hkdf.https.worker.html [ Failure ]
>

Actions: View | Formatted Diff | Diff

Attachments on bug 90342: 150323 | 352389 | 352400 | 352403 | 352409 | 352413 | 352419 | 352423 | 352427 | 352430 | 352431 | 352439 | 352440 | 352441 | 352442 | 352443 | 352444 | 352477 | 352489 | 352501 | 352505 | 352531 | 352572 | 352579 | 352586 | 352595 | 352665 | 352711 | 352716 | 352718 | 352722 | 352724 | 352869 | 352870 | 352871 | 352872 | 353585 | 353586 | 353587 | 354091 | 354105 | 354109 | 354390 | 354396 | 354400 | 354406 | 354421 | 354456 | 354475 | 354491 | 354508 | 354510