Changeset 245371 in webkit


Ignore:
Timestamp:
May 15, 2019 7:51:15 PM (5 years ago)
Author:
Simon Fraser
Message:

Clean up RenderLayerCompositor::computeCompositingRequirements() and traverseUnchangedSubtree()
​https://bugs.webkit.org/show_bug.cgi?id=197931

Reviewed by Zalan Bujtas.

These functions have grown and become hard to maintain, so try to undo some technical debt.

Rename "childState" to "currentState" since it's the state we pass to children, but also
is state we change when the current layer becomes composited.

Separate the layerWillComposite() lambda from layerWillCompositePostDescendants().

Group the chunks of code at end of the functions into:

  • updating bits on RenderLayer
  • updating compositingState with changes from children and our state
  • doing post-traversal work on overlapMap and backingSharingState

Code shared between the two functions is pushed into CompositingState::updateWithDescendantStateAndLayer().

This moves code around but should not cause any behavior change.

  • rendering/RenderLayerBacking.cpp:

(WebCore::RenderLayerBacking::updateConfiguration):

  • rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::OverlapExtent::knownToBeHaveExtentUncertainty const):
(WebCore::RenderLayerCompositor::CompositingState::updateWithDescendantStateAndLayer):
(WebCore::RenderLayerCompositor::computeCompositingRequirements):
(WebCore::RenderLayerCompositor::traverseUnchangedSubtree):
(WebCore::RenderLayerCompositor::clipsCompositingDescendants):
(WebCore::RenderLayerCompositor::CompositingState::propagateStateFromChildren): Deleted.
(WebCore::RenderLayerCompositor::CompositingState::propagateStateFromChildrenForUnchangedSubtree): Deleted.
(WebCore::RenderLayerCompositor::clipsCompositingDescendants const): Deleted.

  • rendering/RenderLayerCompositor.h:
Location:
trunk/Source/WebCore
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r245370 r245371  
    6969        * loader/PingLoader.cpp:
    7070        (WebCore::PingLoader::sendPing):
     71
     722019-05-15  Simon Fraser  <simon.fraser@apple.com>
     73
     74        Clean up RenderLayerCompositor::computeCompositingRequirements() and traverseUnchangedSubtree()
     75        https://bugs.webkit.org/show_bug.cgi?id=197931
     76
     77        Reviewed by Zalan Bujtas.
     78
     79        These functions have grown and become hard to maintain, so try to undo some technical debt.
     80
     81        Rename "childState" to "currentState" since it's the state we pass to children, but also
     82        is state we change when the current layer becomes composited.
     83
     84        Separate the layerWillComposite() lambda from layerWillCompositePostDescendants().
     85
     86        Group the chunks of code at end of the functions into:
     87            - updating bits on RenderLayer
     88            - updating compositingState with changes from children and our state
     89            - doing post-traversal work on overlapMap and backingSharingState
     90
     91        Code shared between the two functions is pushed into CompositingState::updateWithDescendantStateAndLayer().
     92
     93        This moves code around but should not cause any behavior change.
     94
     95        * rendering/RenderLayerBacking.cpp:
     96        (WebCore::RenderLayerBacking::updateConfiguration):
     97        * rendering/RenderLayerCompositor.cpp:
     98        (WebCore::RenderLayerCompositor::OverlapExtent::knownToBeHaveExtentUncertainty const):
     99        (WebCore::RenderLayerCompositor::CompositingState::updateWithDescendantStateAndLayer):
     100        (WebCore::RenderLayerCompositor::computeCompositingRequirements):
     101        (WebCore::RenderLayerCompositor::traverseUnchangedSubtree):
     102        (WebCore::RenderLayerCompositor::clipsCompositingDescendants):
     103        (WebCore::RenderLayerCompositor::CompositingState::propagateStateFromChildren): Deleted.
     104        (WebCore::RenderLayerCompositor::CompositingState::propagateStateFromChildrenForUnchangedSubtree): Deleted.
     105        (WebCore::RenderLayerCompositor::clipsCompositingDescendants const): Deleted.
     106        * rendering/RenderLayerCompositor.h:
    71107
    721082019-05-15  Simon Fraser  <simon.fraser@apple.com>

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

    r245293 r245371  
    772772        needsDescendantsClippingLayer = contentsClippingRect.isRounded();
    773773    } else
    774         needsDescendantsClippingLayer = compositor.clipsCompositingDescendants(m_owningLayer);
     774        needsDescendantsClippingLayer = RenderLayerCompositor::clipsCompositingDescendants(m_owningLayer);
    775775
    776776    if (updateScrollingLayers(usesCompositedScrolling))

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

    r245336 r245371  
    114114};
    115115
     116struct RenderLayerCompositor::OverlapExtent {
     117    LayoutRect bounds;
     118    bool extentComputed { false };
     119    bool hasTransformAnimation { false };
     120    bool animationCausesExtentUncertainty { false };
     121
     122    bool knownToBeHaveExtentUncertainty() const { return extentComputed && animationCausesExtentUncertainty; }
     123};
     124
    116125struct RenderLayerCompositor::CompositingState {
    117126    CompositingState(RenderLayer* compAncestor, bool testOverlap = true)
    … …  
    145154    }
    146155
    147     void propagateStateFromChildren(const CompositingState& childState)
     156    void updateWithDescendantStateAndLayer(const CompositingState& childState, const RenderLayer& layer, const OverlapExtent& layerExtent, bool isUnchangedSubtree = false)
    148157    {
    149158        // Subsequent layers in the parent stacking context also need to composite.
    150         subtreeIsCompositing |= childState.subtreeIsCompositing;
    151         fullPaintOrderTraversalRequired |= childState.fullPaintOrderTraversalRequired;
    152     }
    153 
    154     void propagateStateFromChildrenForUnchangedSubtree(const CompositingState& childState)
    155     {
    156         subtreeIsCompositing |= childState.subtreeIsCompositing;
     159        subtreeIsCompositing |= childState.subtreeIsCompositing | layer.isComposited();
     160        if (!isUnchangedSubtree)
     161            fullPaintOrderTraversalRequired |= childState.fullPaintOrderTraversalRequired;
     162
     163        // Turn overlap testing off for later layers if it's already off, or if we have an animating transform.
     164        // Note that if the layer clips its descendants, there's no reason to propagate the child animation to the parent layers. That's because
     165        // we know for sure the animation is contained inside the clipping rectangle, which is already added to the overlap map.
     166        auto canReenableOverlapTesting = [&layer]() {
     167            return layer.isComposited() && RenderLayerCompositor::clipsCompositingDescendants(layer);
     168        };
     169        if ((!childState.testingOverlap && !canReenableOverlapTesting()) || layerExtent.knownToBeHaveExtentUncertainty())
     170            testingOverlap = false;
     171
     172#if ENABLE(CSS_COMPOSITING)
     173        if ((layer.isComposited() && layer.hasBlendMode()) || (layer.hasNotIsolatedCompositedBlendingDescendants() && !layer.isolatesCompositedBlending()))
     174            hasNotIsolatedCompositedBlendingDescendants = true;
     175#endif
    157176    }
    158177
    … …  
    251270        layer.backing()->clearBackingSharingLayers();
    252271}
    253 
    254 struct RenderLayerCompositor::OverlapExtent {
    255     LayoutRect bounds;
    256     bool extentComputed { false };
    257     bool hasTransformAnimation { false };
    258     bool animationCausesExtentUncertainty { false };
    259 
    260     bool knownToBeHaveExtentUncertainty() const { return extentComputed && animationCausesExtentUncertainty; }
    261 };
    262272
    263273#if !LOG_DISABLED
    … …  
    900910    // a compositing layer among them, so start by inheriting the compositing
    901911    // ancestor with subtreeIsCompositing set to false.
    902     CompositingState childState = compositingState.stateForPaintOrderChildren(layer);
    903 
    904     auto layerWillComposite = [&](bool postDescendants = false) {
    905         // This layer now acts as the ancestor for kids.
    906         childState.compositingAncestor = &layer;
    907         overlapMap.pushCompositingContainer();
    908        
    909         if (postDescendants) {
    910             childState.subtreeIsCompositing = true;
    911             addToOverlapMapRecursive(overlapMap, layer);
    912         }
    913 
     912    CompositingState currentState = compositingState.stateForPaintOrderChildren(layer);
     913
     914    auto layerWillComposite = [&] {
    914915        // This layer is going to be composited, so children can safely ignore the fact that there's an
    915916        // animation running behind this layer, meaning they can rely on the overlap map testing again.
    916         childState.testingOverlap = true;
     917        currentState.testingOverlap = true;
     918        // This layer now acts as the ancestor for kids.
     919        currentState.compositingAncestor = &layer;
     920        overlapMap.pushCompositingContainer();
     921
    917922        willBeComposited = true;
    918923        layerPaintsIntoProvidedBacking = false;
    919924    };
    920925
     926    auto layerWillCompositePostDescendants = [&] {
     927        layerWillComposite();
     928        currentState.subtreeIsCompositing = true;
     929        addToOverlapMapRecursive(overlapMap, layer);
     930    };
     931
    921932    if (willBeComposited) {
    922         // Tell the parent it has compositing descendants.
    923         compositingState.subtreeIsCompositing = true;
    924        
    925933        layerWillComposite();
    926934
    927935        computeExtent(overlapMap, layer, layerExtent);
    928         childState.ancestorHasTransformAnimation |= layerExtent.hasTransformAnimation;
     936        currentState.ancestorHasTransformAnimation |= layerExtent.hasTransformAnimation;
    929937        // Too hard to compute animated bounds if both us and some ancestor is animating transform.
    930938        layerExtent.animationCausesExtentUncertainty |= layerExtent.hasTransformAnimation && compositingState.ancestorHasTransformAnimation;
    931939    } else if (layerPaintsIntoProvidedBacking) {
    932         childState.backingSharingAncestor = &layer;
     940        currentState.backingSharingAncestor = &layer;
    933941        overlapMap.pushCompositingContainer();
    934942    }
    … …  
    943951
    944952    for (auto* childLayer : layer.negativeZOrderLayers()) {
    945         computeCompositingRequirements(&layer, *childLayer, overlapMap, childState, backingSharingState, anyDescendantHas3DTransform);
     953        computeCompositingRequirements(&layer, *childLayer, overlapMap, currentState, backingSharingState, anyDescendantHas3DTransform);
    946954
    947955        // If we have to make a layer for this child, make one now so we can have a contents layer
    948956        // (since we need to ensure that the -ve z-order child renders underneath our contents).
    949         if (!willBeComposited && childState.subtreeIsCompositing) {
     957        if (!willBeComposited && currentState.subtreeIsCompositing) {
    950958            // make layer compositing
    951959            layer.setIndirectCompositingReason(RenderLayer::IndirectCompositingReason::BackgroundLayer);
    … …  
    955963   
    956964    for (auto* childLayer : layer.normalFlowLayers())
    957         computeCompositingRequirements(&layer, *childLayer, overlapMap, childState, backingSharingState, anyDescendantHas3DTransform);
     965        computeCompositingRequirements(&layer, *childLayer, overlapMap, currentState, backingSharingState, anyDescendantHas3DTransform);
    958966
    959967    for (auto* childLayer : layer.positiveZOrderLayers())
    960         computeCompositingRequirements(&layer, *childLayer, overlapMap, childState, backingSharingState, anyDescendantHas3DTransform);
     968        computeCompositingRequirements(&layer, *childLayer, overlapMap, currentState, backingSharingState, anyDescendantHas3DTransform);
    961969
    962970    // If we just entered compositing mode, the root will have become composited (as long as accelerated compositing is enabled).
    … …  
    971979    // FIXME: When layerExtent has taken animation bounds into account, we also know that the bounds
    972980    // include descendants, so we don't need to add them all to the overlap map.
    973     if (childState.compositingAncestor && !childState.compositingAncestor->isRenderViewLayer())
     981    if (currentState.compositingAncestor && !currentState.compositingAncestor->isRenderViewLayer())
    974982        addToOverlapMap(overlapMap, layer, layerExtent);
    975983
    976984#if ENABLE(CSS_COMPOSITING)
    977985    bool isolatedCompositedBlending = layer.isolatesCompositedBlending();
    978     layer.setHasNotIsolatedCompositedBlendingDescendants(childState.hasNotIsolatedCompositedBlendingDescendants);
     986    layer.setHasNotIsolatedCompositedBlendingDescendants(currentState.hasNotIsolatedCompositedBlendingDescendants);
    979987    if (layer.isolatesCompositedBlending() != isolatedCompositedBlending) {
    980988        // isolatedCompositedBlending affects the result of clippedByAncestor().
    … …  
    987995    RenderLayer::IndirectCompositingReason indirectCompositingReason;
    988996    if (!willBeComposited && canBeComposited(layer)
    989         && requiresCompositingForIndirectReason(layer, compositingState.compositingAncestor, childState.subtreeIsCompositing, anyDescendantHas3DTransform, layerPaintsIntoProvidedBacking, indirectCompositingReason)) {
     997        && requiresCompositingForIndirectReason(layer, compositingState.compositingAncestor, currentState.subtreeIsCompositing, anyDescendantHas3DTransform, layerPaintsIntoProvidedBacking, indirectCompositingReason)) {
    990998        layer.setIndirectCompositingReason(indirectCompositingReason);
    991         layerWillComposite(true);
     999        layerWillCompositePostDescendants();
    9921000    }
    9931001   
    … …  
    9981006
    9991007    // Set the flag to say that this layer has compositing children.
    1000     layer.setHasCompositingDescendant(childState.subtreeIsCompositing);
    1001 
    1002     // setHasCompositingDescendant() may have changed the answer to needsToBeComposited() when clipping, so test that again.
     1008    layer.setHasCompositingDescendant(currentState.subtreeIsCompositing);
     1009
     1010    // setHasCompositingDescendant() may have changed the answer to needsToBeComposited() when clipping, so test that now.
    10031011    bool isCompositedClippingLayer = canBeComposited(layer) && clipsCompositingDescendants(layer);
    1004 
    1005     // Turn overlap testing off for later layers if it's already off, or if we have an animating transform.
    1006     // Note that if the layer clips its descendants, there's no reason to propagate the child animation to the parent layers. That's because
    1007     // we know for sure the animation is contained inside the clipping rectangle, which is already added to the overlap map.
    1008     if ((!childState.testingOverlap && !isCompositedClippingLayer) || layerExtent.knownToBeHaveExtentUncertainty())
    1009         compositingState.testingOverlap = false;
    1010    
    10111012    if (isCompositedClippingLayer & !willBeComposited)
    1012         layerWillComposite(true);
    1013 
    1014 #if ENABLE(CSS_COMPOSITING)
    1015     if ((willBeComposited && layer.hasBlendMode()) || (layer.hasNotIsolatedCompositedBlendingDescendants() && !layer.isolatesCompositedBlending()))
    1016         compositingState.hasNotIsolatedCompositedBlendingDescendants = true;
    1017 #endif
    1018 
    1019     if ((childState.compositingAncestor == &layer && !layer.isRenderViewLayer()) || childState.backingSharingAncestor == &layer)
    1020         overlapMap.popCompositingContainer();
     1013        layerWillCompositePostDescendants();
    10211014
    10221015    // If we're back at the root, and no other layers need to be composited, and the root layer itself doesn't need
    … …  
    10241017    // if there are composited layers that we didn't hit in our traversal (e.g. because of visibility:hidden).
    10251018    RequiresCompositingData rootLayerQueryData;
    1026     if (layer.isRenderViewLayer() && !childState.subtreeIsCompositing && !requiresCompositingLayer(layer, rootLayerQueryData) && !m_forceCompositingMode && !needsCompositingForContentOrOverlays()) {
     1019    if (layer.isRenderViewLayer() && !currentState.subtreeIsCompositing && !requiresCompositingLayer(layer, rootLayerQueryData) && !m_forceCompositingMode && !needsCompositingForContentOrOverlays()) {
    10271020        // Don't drop out of compositing on iOS, because we may flash. See <rdar://problem/8348337>.
    10281021#if !PLATFORM(IOS_FAMILY)
    … …  
    10311024#endif
    10321025    }
    1033 
    1034     compositingState.propagateStateFromChildren(childState);
    10351026
    10361027    ASSERT(willBeComposited == needsToBeComposited(layer, queryData));
    … …  
    10461037    }
    10471038
    1048     backingSharingState.updateAfterDescendantTraversal(layer, compositingState.stackingContextAncestor);
    1049 
     1039    // Update layer state bits.
    10501040    if (layer.reflectionLayer() && updateLayerCompositingState(*layer.reflectionLayer(), queryData, CompositingChangeRepaintNow))
    10511041        layer.setNeedsCompositingLayerConnection();
    1052 
    1053     descendantHas3DTransform |= anyDescendantHas3DTransform || layer.has3DTransform();
    10541042   
    10551043    // FIXME: clarify needsCompositingPaintOrderChildrenUpdate. If a composited layer gets a new ancestor, it needs geometry computations.
    … …  
    10601048
    10611049    layer.clearCompositingRequirementsTraversalState();
     1050
     1051    // Compute state passed to the caller.
     1052    descendantHas3DTransform |= anyDescendantHas3DTransform || layer.has3DTransform();
     1053    compositingState.updateWithDescendantStateAndLayer(currentState, layer, layerExtent);
     1054
     1055    // Pop backing/overlap sharing state.
     1056    if ((willBeComposited && !layer.isRenderViewLayer()) || currentState.backingSharingAncestor == &layer)
     1057        overlapMap.popCompositingContainer();
     1058
     1059    backingSharingState.updateAfterDescendantTraversal(layer, compositingState.stackingContextAncestor);
    10621060    overlapMap.geometryMap().popMappingsToAncestor(ancestorLayer);
    10631061
    … …  
    10961094    }
    10971095
    1098     CompositingState childState = compositingState.stateForPaintOrderChildren(layer);
     1096    CompositingState currentState = compositingState.stateForPaintOrderChildren(layer);
    10991097
    11001098    if (layerIsComposited) {
    1101         // Tell the parent it has compositing descendants.
    1102         compositingState.subtreeIsCompositing = true;
    1103         // This layer now acts as the ancestor for kids.
    1104         childState.compositingAncestor = &layer;
    1105 
    1106         overlapMap.pushCompositingContainer();
    11071099        // This layer is going to be composited, so children can safely ignore the fact that there's an
    11081100        // animation running behind this layer, meaning they can rely on the overlap map testing again.
    1109         childState.testingOverlap = true;
     1101        currentState.testingOverlap = true;
     1102        // This layer now acts as the ancestor for kids.
     1103        currentState.compositingAncestor = &layer;
     1104        overlapMap.pushCompositingContainer();
    11101105
    11111106        computeExtent(overlapMap, layer, layerExtent);
    1112         childState.ancestorHasTransformAnimation |= layerExtent.hasTransformAnimation;
     1107        currentState.ancestorHasTransformAnimation |= layerExtent.hasTransformAnimation;
    11131108        // Too hard to compute animated bounds if both us and some ancestor is animating transform.
    11141109        layerExtent.animationCausesExtentUncertainty |= layerExtent.hasTransformAnimation && compositingState.ancestorHasTransformAnimation;
    … …  
    11241119
    11251120    for (auto* childLayer : layer.negativeZOrderLayers()) {
    1126         traverseUnchangedSubtree(&layer, *childLayer, overlapMap, childState, backingSharingState, anyDescendantHas3DTransform);
    1127         if (childState.subtreeIsCompositing)
     1121        traverseUnchangedSubtree(&layer, *childLayer, overlapMap, currentState, backingSharingState, anyDescendantHas3DTransform);
     1122        if (currentState.subtreeIsCompositing)
    11281123            ASSERT(layerIsComposited);
    11291124    }
    11301125   
    11311126    for (auto* childLayer : layer.normalFlowLayers())
    1132         traverseUnchangedSubtree(&layer, *childLayer, overlapMap, childState, backingSharingState, anyDescendantHas3DTransform);
     1127        traverseUnchangedSubtree(&layer, *childLayer, overlapMap, currentState, backingSharingState, anyDescendantHas3DTransform);
    11331128
    11341129    for (auto* childLayer : layer.positiveZOrderLayers())
    1135         traverseUnchangedSubtree(&layer, *childLayer, overlapMap, childState, backingSharingState, anyDescendantHas3DTransform);
     1130        traverseUnchangedSubtree(&layer, *childLayer, overlapMap, currentState, backingSharingState, anyDescendantHas3DTransform);
    11361131
    11371132    // All layers (even ones that aren't being composited) need to get added to
    … …  
    11401135    // FIXME: When layerExtent has taken animation bounds into account, we also know that the bounds
    11411136    // include descendants, so we don't need to add them all to the overlap map.
    1142     if (childState.compositingAncestor && !childState.compositingAncestor->isRenderViewLayer())
     1137    if (currentState.compositingAncestor && !currentState.compositingAncestor->isRenderViewLayer())
    11431138        addToOverlapMap(overlapMap, layer, layerExtent);
    11441139
    1145     compositingState.propagateStateFromChildrenForUnchangedSubtree(childState);
    1146 
    11471140    // Set the flag to say that this layer has compositing children.
    1148     ASSERT(layer.hasCompositingDescendant() == childState.subtreeIsCompositing);
    1149 
    1150     // setHasCompositingDescendant() may have changed the answer to needsToBeComposited() when clipping, so test that again.
    1151     bool isCompositedClippingLayer = canBeComposited(layer) && clipsCompositingDescendants(layer);
    1152 
    1153     // Turn overlap testing off for later layers if it's already off, or if we have an animating transform.
    1154     // Note that if the layer clips its descendants, there's no reason to propagate the child animation to the parent layers. That's because
    1155     // we know for sure the animation is contained inside the clipping rectangle, which is already added to the overlap map.
    1156     if ((!childState.testingOverlap && !isCompositedClippingLayer) || layerExtent.knownToBeHaveExtentUncertainty())
    1157         compositingState.testingOverlap = false;
    1158    
    1159     if (isCompositedClippingLayer)
    1160         ASSERT(layerIsComposited);
    1161 
    1162 #if ENABLE(CSS_COMPOSITING)
    1163     if ((layerIsComposited && layer.hasBlendMode())
    1164         || (layer.hasNotIsolatedCompositedBlendingDescendants() && !layer.isolatesCompositedBlending()))
    1165         compositingState.hasNotIsolatedCompositedBlendingDescendants = true;
    1166 #endif
    1167 
    1168     if ((childState.compositingAncestor == &layer && !layer.isRenderViewLayer()) || childState.backingSharingAncestor == &layer)
     1141    ASSERT(layer.hasCompositingDescendant() == currentState.subtreeIsCompositing);
     1142    ASSERT_IMPLIES(canBeComposited(layer) && clipsCompositingDescendants(layer), layerIsComposited);
     1143
     1144    descendantHas3DTransform |= anyDescendantHas3DTransform || layer.has3DTransform();
     1145
     1146    ASSERT(!currentState.fullPaintOrderTraversalRequired);
     1147    compositingState.updateWithDescendantStateAndLayer(currentState, layer, layerExtent, true);
     1148
     1149    if ((layerIsComposited && !layer.isRenderViewLayer()) || currentState.backingSharingAncestor == &layer)
    11691150        overlapMap.popCompositingContainer();
    11701151
    11711152    backingSharingState.updateAfterDescendantTraversal(layer, compositingState.stackingContextAncestor);
    1172 
    1173     descendantHas3DTransform |= anyDescendantHas3DTransform || layer.has3DTransform();
     1153    overlapMap.geometryMap().popMappingsToAncestor(ancestorLayer);
    11741154
    11751155    ASSERT(!layer.needsCompositingRequirementsTraversal());
    1176 
    1177     overlapMap.geometryMap().popMappingsToAncestor(ancestorLayer);
    11781156}
    11791157
    … …  
    12571235#endif
    12581236   
    1259     auto appendForegroundLayerIfNecessary = [&] () {
     1237    auto appendForegroundLayerIfNecessary = [&] {
    12601238        // If a negative z-order child is compositing, we get a foreground layer which needs to get parented.
    12611239        if (layer.negativeZOrderLayers().size()) {
    … …  
    25212499// layers that it needs to clip. In this case we insert a clipping GraphicsLayer
    25222500// into the hierarchy between this layer and its children in the z-order hierarchy.
    2523 bool RenderLayerCompositor::clipsCompositingDescendants(const RenderLayer& layer) const
     2501bool RenderLayerCompositor::clipsCompositingDescendants(const RenderLayer& layer)
    25242502{
    25252503    return layer.hasCompositingDescendant() && layer.renderer().hasClipOrOverflowClip() && !layer.isolatesCompositedBlending();

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

    r245326 r245371  
    204204    bool clippedByAncestor(RenderLayer&) const;
    205205    // Whether layer's backing needs a graphics layer to clip z-order children of the given layer.
    206     bool clipsCompositingDescendants(const RenderLayer&) const;
     206    static bool clipsCompositingDescendants(const RenderLayer&);
    207207
    208208    // Whether the given layer needs an extra 'contents' layer.
Note: See TracChangeset for help on using the changeset viewer.