Changeset 245502 in webkit


Ignore:
Timestamp:
May 19, 2019 7:01:15 AM (5 years ago)
Author:
Simon Fraser
Message:

Layers painting into shared backing need to contribute to overlap
​https://bugs.webkit.org/show_bug.cgi?id=198021

Reviewed by Zalan Bujtas.
Source/WebCore:

Layers that paint into a composited (non-root) layer get added to the overlap map so
that later layers correct overlap them; this is done via the test against currentState.compositingAncestor.

We need the same logic for layers that paint into shared backing; they need to behave
the same way in terms of how they contribute to overlap. We already had currentState.backingSharingAncestor
which was unused, but now use it for this, and correctly null it out when a layer composites.

Bug was noticed during testing, and not known to affect any websites (though it probably does).

Also move the overlap container popping into updateOverlapMap() so the two callers can
share the code, and more explicitly track whether a container was pushed.

Test: compositing/shared-backing/sharing-child-contributes-to-overlap.html

  • rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::computeCompositingRequirements):
(WebCore::RenderLayerCompositor::traverseUnchangedSubtree):
(WebCore::RenderLayerCompositor::updateOverlapMap const):

  • rendering/RenderLayerCompositor.h:

LayoutTests:

  • compositing/shared-backing/sharing-child-contributes-to-overlap-expected.html: Added.
  • compositing/shared-backing/sharing-child-contributes-to-overlap.html: Added.
Location:
trunk
Files:
2 added
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r245500 r245502  
     12019-05-19  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Layers painting into shared backing need to contribute to overlap
     4        https://bugs.webkit.org/show_bug.cgi?id=198021
     5
     6        Reviewed by Zalan Bujtas.
     7
     8        * compositing/shared-backing/sharing-child-contributes-to-overlap-expected.html: Added.
     9        * compositing/shared-backing/sharing-child-contributes-to-overlap.html: Added.
     10
    1112019-05-18  Jiewen Tan  <jiewen_tan@apple.com>
    212

  • trunk/Source/WebCore/ChangeLog

    r245494 r245502  
     12019-05-19  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Layers painting into shared backing need to contribute to overlap
     4        https://bugs.webkit.org/show_bug.cgi?id=198021
     5
     6        Reviewed by Zalan Bujtas.
     7       
     8        Layers that paint into a composited (non-root) layer get added to the overlap map so
     9        that later layers correct overlap them; this is done via the test against currentState.compositingAncestor.
     10
     11        We need the same logic for layers that paint into shared backing; they need to behave
     12        the same way in terms of how they contribute to overlap. We already had currentState.backingSharingAncestor
     13        which was unused, but now use it for this, and correctly null it out when a layer composites.
     14
     15        Bug was noticed during testing, and not known to affect any websites (though it probably does).
     16       
     17        Also move the overlap container popping into updateOverlapMap() so the two callers can
     18        share the code, and more explicitly track whether a container was pushed.
     19
     20        Test: compositing/shared-backing/sharing-child-contributes-to-overlap.html
     21
     22        * rendering/RenderLayerCompositor.cpp:
     23        (WebCore::RenderLayerCompositor::computeCompositingRequirements):
     24        (WebCore::RenderLayerCompositor::traverseUnchangedSubtree):
     25        (WebCore::RenderLayerCompositor::updateOverlapMap const):
     26        * rendering/RenderLayerCompositor.h:
     27
    1282019-05-17  Joonghun Park  <pjh0718@gmail.com>
    229

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

    r245490 r245502  
    880880    IndirectCompositingReason compositingReason = compositingState.subtreeIsCompositing ? IndirectCompositingReason::Stacking : IndirectCompositingReason::None;
    881881    bool layerPaintsIntoProvidedBacking = false;
     882    bool didPushOverlapContainer = false;
    882883
    883884    // If we know for sure the layer is going to be composited, don't bother looking it up in the overlap map
    … …  
    928929        // This layer now acts as the ancestor for kids.
    929930        currentState.compositingAncestor = &layer;
    930        
     931        // Compositing turns off backing sharing.
     932        currentState.backingSharingAncestor = nullptr;
     933
    931934        if (layerPaintsIntoProvidedBacking) {
    932935            layerPaintsIntoProvidedBacking = false;
    … …  
    934937            // no longer share, put this this indirect reason back on the layer so that requiresOwnBackingStore() sees it.
    935938            layer.setIndirectCompositingReason(IndirectCompositingReason::Overlap);
    936             LOG_WITH_STREAM(CompositingOverlap, stream << "layer " << &layer << " was sharing now will composite");
     939            LOG_WITH_STREAM(Compositing, stream << "layer " << &layer << " was sharing now will composite");
    937940        } else {
    938941            overlapMap.pushCompositingContainer();
     942            didPushOverlapContainer = true;
    939943            LOG_WITH_STREAM(CompositingOverlap, stream << "layer " << &layer << " will composite, pushed container " << overlapMap);
    940944        }
    … …  
    959963        currentState.backingSharingAncestor = &layer;
    960964        overlapMap.pushCompositingContainer();
     965        didPushOverlapContainer = true;
    961966        LOG_WITH_STREAM(CompositingOverlap, stream << "layer " << &layer << " will share, pushed container " << overlapMap);
    962967    }
    … …  
    10651070    descendantHas3DTransform |= anyDescendantHas3DTransform || layer.has3DTransform();
    10661071    compositingState.updateWithDescendantStateAndLayer(currentState, layer, layerExtent);
    1067 
    1068     bool layerContributesToOverlap = currentState.compositingAncestor && !currentState.compositingAncestor->isRenderViewLayer();
    1069     updateOverlapMap(overlapMap, layer, layerExtent, layerContributesToOverlap, becameCompositedAfterDescendantTraversal && !descendantsAddedToOverlap);
    1070 
    1071     // Pop backing/overlap sharing state.
    1072     if ((willBeComposited && !layer.isRenderViewLayer()) || currentState.backingSharingAncestor == &layer) {
    1073         overlapMap.popCompositingContainer();
    1074         LOG_WITH_STREAM(CompositingOverlap, stream << "layer " << &layer << " is composited, popped container " << overlapMap);
    1075     }
    1076 
    10771072    backingSharingState.updateAfterDescendantTraversal(layer, compositingState.stackingContextAncestor);
     1073
     1074    bool layerContributesToOverlap = (currentState.compositingAncestor && !currentState.compositingAncestor->isRenderViewLayer()) || currentState.backingSharingAncestor;
     1075    updateOverlapMap(overlapMap, layer, layerExtent, didPushOverlapContainer, layerContributesToOverlap, becameCompositedAfterDescendantTraversal && !descendantsAddedToOverlap);
     1076
    10781077    overlapMap.geometryMap().popMappingsToAncestor(ancestorLayer);
    10791078
    … …  
    10941093
    10951094    bool layerIsComposited = layer.isComposited();
     1095    bool layerPaintsIntoProvidedBacking = false;
     1096    bool didPushOverlapContainer = false;
    10961097
    10971098    OverlapExtent layerExtent;
    … …  
    11101111        ASSERT(backingProviderLayerCanIncludeLayer(*backingSharingState.backingProviderCandidate(), layer));
    11111112        backingSharingState.appendSharingLayer(layer);
     1113        layerPaintsIntoProvidedBacking = true;
    11121114    }
    11131115
    … …  
    11201122        // This layer now acts as the ancestor for kids.
    11211123        currentState.compositingAncestor = &layer;
     1124        currentState.backingSharingAncestor = nullptr;
    11221125        overlapMap.pushCompositingContainer();
     1126        didPushOverlapContainer = true;
    11231127        LOG_WITH_STREAM(CompositingOverlap, stream << "unchangedSubtree: layer " << &layer << " will composite, pushed container " << overlapMap);
    11241128
    … …  
    11271131        // Too hard to compute animated bounds if both us and some ancestor is animating transform.
    11281132        layerExtent.animationCausesExtentUncertainty |= layerExtent.hasTransformAnimation && compositingState.ancestorHasTransformAnimation;
     1133    } else if (layerPaintsIntoProvidedBacking) {
     1134        overlapMap.pushCompositingContainer();
     1135        currentState.backingSharingAncestor = &layer;
     1136        didPushOverlapContainer = true;
     1137        LOG_WITH_STREAM(CompositingOverlap, stream << "unchangedSubtree: layer " << &layer << " will share, pushed container " << overlapMap);
    11291138    }
    11301139
    … …  
    11571166    ASSERT(!currentState.fullPaintOrderTraversalRequired);
    11581167    compositingState.updateWithDescendantStateAndLayer(currentState, layer, layerExtent, true);
    1159 
    1160     bool layerContributesToOverlap = currentState.compositingAncestor && !currentState.compositingAncestor->isRenderViewLayer();
    1161     updateOverlapMap(overlapMap, layer, layerExtent, layerContributesToOverlap);
    1162 
    1163     if ((layerIsComposited && !layer.isRenderViewLayer()) || currentState.backingSharingAncestor == &layer) {
    1164         overlapMap.popCompositingContainer();
    1165         LOG_WITH_STREAM(CompositingOverlap, stream << "unchangedSubtree: layer " << &layer << " is composited, popped container " << overlapMap);
    1166     }
    1167 
    11681168    backingSharingState.updateAfterDescendantTraversal(layer, compositingState.stackingContextAncestor);
     1169
     1170    bool layerContributesToOverlap = (currentState.compositingAncestor && !currentState.compositingAncestor->isRenderViewLayer()) || currentState.backingSharingAncestor;
     1171    updateOverlapMap(overlapMap, layer, layerExtent, didPushOverlapContainer, layerContributesToOverlap);
     1172
    11691173    overlapMap.geometryMap().popMappingsToAncestor(ancestorLayer);
    11701174
    … …  
    18411845}
    18421846
    1843 void RenderLayerCompositor::updateOverlapMap(LayerOverlapMap& overlapMap, const RenderLayer& layer, OverlapExtent& layerExtent, bool layerContributesToOverlap, bool addDescendantsToOverlap) const
    1844 {
    1845     ASSERT_IMPLIES(addDescendantsToOverlap, layerContributesToOverlap);
    1846 
    1847     // All layers (even ones that aren't being composited) need to get added to
    1848     // the overlap map. Layers that do not composite will draw into their
    1849     // compositing ancestor's backing, and so are still considered for overlap.
    1850     // FIXME: When layerExtent has taken animation bounds into account, we also know that the bounds
    1851     // include descendants, so we don't need to add them all to the overlap map.
    1852     if (layerContributesToOverlap) {
     1847void RenderLayerCompositor::updateOverlapMap(LayerOverlapMap& overlapMap, const RenderLayer& layer, OverlapExtent& layerExtent, bool didPushContainer, bool addLayerToOverlap, bool addDescendantsToOverlap) const
     1848{
     1849    if (addLayerToOverlap) {
    18531850        addToOverlapMap(overlapMap, layer, layerExtent);
    18541851        LOG_WITH_STREAM(CompositingOverlap, stream << "layer " << &layer << " contributes to overlap, added to map " << overlapMap);
    … …  
    18591856        addDescendantsToOverlapMapRecursive(overlapMap, layer);
    18601857        LOG_WITH_STREAM(CompositingOverlap, stream << "layer " << &layer << " composited post descendant traversal, added recursive " << overlapMap);
     1858    }
     1859
     1860    if (didPushContainer) {
     1861        overlapMap.popCompositingContainer();
     1862        LOG_WITH_STREAM(CompositingOverlap, stream << "layer " << &layer << " is composited or shared, popped container " << overlapMap);
    18611863    }
    18621864}

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

    r245490 r245502  
    409409    void addToOverlapMap(LayerOverlapMap&, const RenderLayer&, OverlapExtent&) const;
    410410    void addDescendantsToOverlapMapRecursive(LayerOverlapMap&, const RenderLayer&, const RenderLayer* ancestorLayer = nullptr) const;
    411     void updateOverlapMap(LayerOverlapMap&, const RenderLayer&, OverlapExtent&, bool layerContributesToOverlap, bool addDescendantsToOverlap = false) const;
     411    void updateOverlapMap(LayerOverlapMap&, const RenderLayer&, OverlapExtent&, bool didPushContainer, bool addLayerToOverlap, bool addDescendantsToOverlap = false) const;
    412412
    413413    void updateCompositingLayersTimerFired();
Note: See TracChangeset for help on using the changeset viewer.