Changeset 249440 in webkit


Ignore:
Timestamp:
Sep 3, 2019 12:55:11 PM (5 years ago)
Author:
Simon Fraser
Message:

Cache "compositingAncestor" during the compositing updateBackingAndHierarchy() tree walk
​https://bugs.webkit.org/show_bug.cgi?id=201403

Reviewed by Antti Koivisto.

Finding a layer's compositingAncestor requires an ancestor tree walk. We can avoid this during
compositing updates, since we're already in the middle of a paint-order tree walk, and can just
keep track of the current compositingAncestor on the way down.

Shaves a few % off time in updateCompositingLayers().

  • rendering/RenderLayerBacking.cpp:

(WebCore::RenderLayerBacking::updateConfiguration):
(WebCore::ComputedOffsets::ComputedOffsets):
(WebCore::ComputedOffsets::fromAncestorGraphicsLayer):
(WebCore::RenderLayerBacking::computePrimaryGraphicsLayerRect const):
(WebCore::RenderLayerBacking::updateGeometry):

  • rendering/RenderLayerBacking.h:
  • rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::UpdateBackingTraversalState::UpdateBackingTraversalState):
(WebCore::RenderLayerCompositor::UpdateBackingTraversalState::stateForDescendants const):
(WebCore::RenderLayerCompositor::updateCompositingLayers):
(WebCore::RenderLayerCompositor::computeCompositingRequirements):
(WebCore::RenderLayerCompositor::updateBackingAndHierarchy):
(WebCore::RenderLayerCompositor::updateLayerCompositingState):
(WebCore::RenderLayerCompositor::computeCoordinatedPositioningForLayer const):
(WebCore::RenderLayerCompositor::coordinatedScrollingRolesForLayer const):
(WebCore::RenderLayerCompositor::updateScrollCoordinationForLayer):
(WebCore::RenderLayerCompositor::updateScrollingNodeForPositioningRole):

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

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r249439 r249440  
    8383        (WebCore::IOSApplication::isSafariViewService):
    8484        Adds a way to detect SafariViewService.
     85
     862019-09-03  Simon Fraser  <simon.fraser@apple.com>
     87
     88        Cache "compositingAncestor" during the compositing updateBackingAndHierarchy() tree walk
     89        https://bugs.webkit.org/show_bug.cgi?id=201403
     90
     91        Reviewed by Antti Koivisto.
     92
     93        Finding a layer's compositingAncestor requires an ancestor tree walk. We can avoid this during
     94        compositing updates, since we're already in the middle of a paint-order tree walk, and can just
     95        keep track of the current compositingAncestor on the way down.
     96
     97        Shaves a few % off time in updateCompositingLayers().
     98
     99        * rendering/RenderLayerBacking.cpp:
     100        (WebCore::RenderLayerBacking::updateConfiguration):
     101        (WebCore::ComputedOffsets::ComputedOffsets):
     102        (WebCore::ComputedOffsets::fromAncestorGraphicsLayer):
     103        (WebCore::RenderLayerBacking::computePrimaryGraphicsLayerRect const):
     104        (WebCore::RenderLayerBacking::updateGeometry):
     105        * rendering/RenderLayerBacking.h:
     106        * rendering/RenderLayerCompositor.cpp:
     107        (WebCore::RenderLayerCompositor::UpdateBackingTraversalState::UpdateBackingTraversalState):
     108        (WebCore::RenderLayerCompositor::UpdateBackingTraversalState::stateForDescendants const):
     109        (WebCore::RenderLayerCompositor::updateCompositingLayers):
     110        (WebCore::RenderLayerCompositor::computeCompositingRequirements):
     111        (WebCore::RenderLayerCompositor::updateBackingAndHierarchy):
     112        (WebCore::RenderLayerCompositor::updateLayerCompositingState):
     113        (WebCore::RenderLayerCompositor::computeCoordinatedPositioningForLayer const):
     114        (WebCore::RenderLayerCompositor::coordinatedScrollingRolesForLayer const):
     115        (WebCore::RenderLayerCompositor::updateScrollCoordinationForLayer):
     116        (WebCore::RenderLayerCompositor::updateScrollingNodeForPositioningRole):
     117        * rendering/RenderLayerCompositor.h:
    85118
    861192019-09-03  Simon Fraser  <simon.fraser@apple.com>

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

    r248879 r249440  
    832832}
    833833
    834 bool RenderLayerBacking::updateConfiguration()
     834bool RenderLayerBacking::updateConfiguration(const RenderLayer* compositingAncestor)
    835835{
    836836    ASSERT(!m_owningLayer.normalFlowListDirty());
    … …  
    866866        layerConfigChanged = true;
    867867
    868     auto* compositingAncestor = m_owningLayer.ancestorCompositingLayer();
     868    ASSERT(compositingAncestor == m_owningLayer.ancestorCompositingLayer());
    869869    if (updateAncestorClipping(compositor.clippedByAncestor(m_owningLayer, compositingAncestor), compositingAncestor))
    870870        layerConfigChanged = true;
    … …  
    10271027class ComputedOffsets {
    10281028public:
    1029     ComputedOffsets(const RenderLayer& renderLayer, const LayoutRect& localRect, const LayoutRect& parentGraphicsLayerRect, const LayoutRect& primaryGraphicsLayerRect)
     1029    ComputedOffsets(const RenderLayer& renderLayer, const RenderLayer* compositingAncestor, const LayoutRect& localRect, const LayoutRect& parentGraphicsLayerRect, const LayoutRect& primaryGraphicsLayerRect)
    10301030        : m_renderLayer(renderLayer)
     1031        , m_compositingAncestor(compositingAncestor)
    10311032        , m_location(localRect.location())
    10321033        , m_parentGraphicsLayerOffset(toLayoutSize(parentGraphicsLayerRect.location()))
    … …  
    10541055    {
    10551056        if (!m_fromAncestorGraphicsLayer) {
    1056             auto* compositedAncestor = m_renderLayer.ancestorCompositingLayer();
    1057             LayoutPoint localPointInAncestorRenderLayerCoords = m_renderLayer.convertToLayerCoords(compositedAncestor, m_location, RenderLayer::AdjustForColumns);
    1058             m_fromAncestorGraphicsLayer = computeOffsetFromAncestorGraphicsLayer(compositedAncestor, localPointInAncestorRenderLayerCoords, m_deviceScaleFactor);
     1057            LayoutPoint localPointInAncestorRenderLayerCoords = m_renderLayer.convertToLayerCoords(m_compositingAncestor, m_location, RenderLayer::AdjustForColumns);
     1058            m_fromAncestorGraphicsLayer = computeOffsetFromAncestorGraphicsLayer(m_compositingAncestor, localPointInAncestorRenderLayerCoords, m_deviceScaleFactor);
    10591059        }
    10601060        return m_fromAncestorGraphicsLayer.value();
    … …  
    10661066   
    10671067    const RenderLayer& m_renderLayer;
     1068    const RenderLayer* m_compositingAncestor;
    10681069    // Location is relative to the renderer.
    10691070    const LayoutPoint m_location;
    … …  
    10731074};
    10741075
    1075 LayoutRect RenderLayerBacking::computePrimaryGraphicsLayerRect(const LayoutRect& parentGraphicsLayerRect) const
    1076 {
    1077     ComputedOffsets compositedBoundsOffset(m_owningLayer, compositedBounds(), parentGraphicsLayerRect, { });
     1076LayoutRect RenderLayerBacking::computePrimaryGraphicsLayerRect(const RenderLayer* compositedAncestor, const LayoutRect& parentGraphicsLayerRect) const
     1077{
     1078    ComputedOffsets compositedBoundsOffset(m_owningLayer, compositedAncestor, compositedBounds(), parentGraphicsLayerRect, { });
    10781079    return LayoutRect(encloseRectToDevicePixels(LayoutRect(toLayoutPoint(compositedBoundsOffset.fromParentGraphicsLayer()), compositedBounds().size()),
    10791080        deviceScaleFactor()));
    … …  
    11131114}
    11141115
    1115 void RenderLayerBacking::updateGeometry()
     1116void RenderLayerBacking::updateGeometry(const RenderLayer* compositedAncestor)
    11161117{
    11171118    ASSERT(!m_owningLayer.normalFlowListDirty());
    … …  
    11391140#endif
    11401141
    1141     auto* compositedAncestor = m_owningLayer.ancestorCompositingLayer();
     1142    ASSERT(compositedAncestor == m_owningLayer.ancestorCompositingLayer());
    11421143    LayoutRect parentGraphicsLayerRect = computeParentGraphicsLayerRect(compositedAncestor);
    11431144
    … …  
    11691170    }
    11701171
    1171     LayoutRect primaryGraphicsLayerRect = computePrimaryGraphicsLayerRect(parentGraphicsLayerRect);
    1172 
    1173     ComputedOffsets compositedBoundsOffset(m_owningLayer, compositedBounds(), parentGraphicsLayerRect, primaryGraphicsLayerRect);
    1174     ComputedOffsets rendererOffset(m_owningLayer, { }, parentGraphicsLayerRect, primaryGraphicsLayerRect);
     1172    LayoutRect primaryGraphicsLayerRect = computePrimaryGraphicsLayerRect(compositedAncestor, parentGraphicsLayerRect);
     1173
     1174    ComputedOffsets compositedBoundsOffset(m_owningLayer, compositedAncestor, compositedBounds(), parentGraphicsLayerRect, primaryGraphicsLayerRect);
     1175    ComputedOffsets rendererOffset(m_owningLayer, compositedAncestor, { }, parentGraphicsLayerRect, primaryGraphicsLayerRect);
    11751176
    11761177    m_compositedBoundsOffsetFromGraphicsLayer = compositedBoundsOffset.fromPrimaryGraphicsLayer();
    … …  
    12821283    if (m_owningLayer.reflectionLayer() && m_owningLayer.reflectionLayer()->isComposited()) {
    12831284        auto* reflectionBacking = m_owningLayer.reflectionLayer()->backing();
    1284         reflectionBacking->updateGeometry();
     1285        reflectionBacking->updateGeometry(&m_owningLayer);
    12851286       
    12861287        // The reflection layer has the bounds of m_owningLayer.reflectionLayer(),

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

    r247540 r249440  
    8282
    8383    // Returns true if layer configuration changed.
    84     bool updateConfiguration();
     84    bool updateConfiguration(const RenderLayer* compositingAncestor);
    8585
    8686    // Update graphics layer position and bounds.
    87     void updateGeometry();
     87    void updateGeometry(const RenderLayer* compositingAncestor);
    8888
    8989    // Update state the requires that descendant layers have been updated.
    … …  
    386386    bool canIssueSetNeedsDisplay() const { return !paintsIntoWindow() && !paintsIntoCompositedAncestor(); }
    387387    LayoutRect computeParentGraphicsLayerRect(const RenderLayer* compositedAncestor) const;
    388     LayoutRect computePrimaryGraphicsLayerRect(const LayoutRect& parentGraphicsLayerRect) const;
     388    LayoutRect computePrimaryGraphicsLayerRect(const RenderLayer* compositedAncestor, const LayoutRect& parentGraphicsLayerRect) const;
    389389
    390390    RenderLayer& m_owningLayer;

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

    r249434 r249440  
    200200};
    201201
     202struct RenderLayerCompositor::UpdateBackingTraversalState {
     203
     204    UpdateBackingTraversalState(RenderLayer* compAncestor = nullptr)
     205        : compositingAncestor(compAncestor)
     206    {
     207    }
     208
     209    UpdateBackingTraversalState stateForDescendants() const
     210    {
     211        UpdateBackingTraversalState state(compositingAncestor);
     212#if !LOG_DISABLED
     213        state.depth = depth + 1;
     214#endif
     215        return state;
     216    }
     217
     218    RenderLayer* compositingAncestor;
     219#if !LOG_DISABLED
     220    unsigned depth { 0 };
     221#endif
     222};
     223
    202224class RenderLayerCompositor::BackingSharingState {
    203225    WTF_MAKE_NONCOPYABLE(BackingSharingState);
    … …  
    792814            scrollingTreeState.parentNodeID = frameHostingNodeForFrame(m_renderView.frame());
    793815
     816        UpdateBackingTraversalState traversalState;
    794817        Vector<Ref<GraphicsLayer>> childList;
    795         updateBackingAndHierarchy(*updateRoot, childList, scrollingTreeState);
     818        updateBackingAndHierarchy(*updateRoot, childList, traversalState, scrollingTreeState);
    796819
    797820        // Host the document layer in the RenderView's root layer.
    … …  
    10531076
    10541077    // Update layer state bits.
    1055     if (layer.reflectionLayer() && updateLayerCompositingState(*layer.reflectionLayer(), queryData, CompositingChangeRepaintNow))
     1078    if (layer.reflectionLayer() && updateLayerCompositingState(*layer.reflectionLayer(), &layer, queryData, CompositingChangeRepaintNow))
    10561079        layer.setNeedsCompositingLayerConnection();
    10571080   
    … …  
    11761199}
    11771200
    1178 void RenderLayerCompositor::updateBackingAndHierarchy(RenderLayer& layer, Vector<Ref<GraphicsLayer>>& childLayersOfEnclosingLayer, ScrollingTreeState& scrollingTreeState, OptionSet<UpdateLevel> updateLevel, int depth)
     1201void RenderLayerCompositor::updateBackingAndHierarchy(RenderLayer& layer, Vector<Ref<GraphicsLayer>>& childLayersOfEnclosingLayer, UpdateBackingTraversalState& traversalState, ScrollingTreeState& scrollingTreeState, OptionSet<UpdateLevel> updateLevel)
    11791202{
    11801203    layer.updateDescendantDependentFlags();
    … …  
    11851208        updateLevel.add(UpdateLevel::AllDescendants);
    11861209
    1187     ScrollingTreeState stateForDescendants = scrollingTreeState;
     1210    ScrollingTreeState scrollingStateForDescendants = scrollingTreeState;
     1211    UpdateBackingTraversalState traversalStateForDescendants = traversalState.stateForDescendants();
    11881212
    11891213    auto* layerBacking = layer.backing();
    … …  
    12001224       
    12011225        if (layerNeedsUpdate || layer.needsCompositingConfigurationUpdate()) {
    1202             if (layerBacking->updateConfiguration()) {
     1226            if (layerBacking->updateConfiguration(traversalState.compositingAncestor)) {
    12031227                layerNeedsUpdate = true; // We also need to update geometry.
    12041228                layer.setNeedsCompositingLayerConnection();
    … …  
    12101234        OptionSet<ScrollingNodeChangeFlags> scrollingNodeChanges = { ScrollingNodeChangeFlags::Layer };
    12111235        if (layerNeedsUpdate || layer.needsCompositingGeometryUpdate()) {
    1212             layerBacking->updateGeometry();
     1236            layerBacking->updateGeometry(traversalState.compositingAncestor);
    12131237            scrollingNodeChanges.add(ScrollingNodeChangeFlags::LayerGeometry);
    12141238        } else if (layer.needsScrollingTreeUpdate())
    … …  
    12231247            if (auto* reflectionBacking = reflection->backing()) {
    12241248                reflectionBacking->updateCompositedBounds();
    1225                 reflectionBacking->updateGeometry();
     1249                reflectionBacking->updateGeometry(&layer);
    12261250                reflectionBacking->updateAfterDescendants();
    12271251            }
    … …  
    12331257        // FIXME: do based on dirty flags. Need to do this for changes of geometry, configuration and hierarchy.
    12341258        // Need to be careful to do the right thing when a scroll-coordinated layer loses a scroll-coordinated ancestor.
    1235         stateForDescendants.parentNodeID = updateScrollCoordinationForLayer(layer, scrollingTreeState, scrollingNodeChanges);
    1236         stateForDescendants.nextChildIndex = 0;
     1259        scrollingStateForDescendants.parentNodeID = updateScrollCoordinationForLayer(layer, traversalState.compositingAncestor, scrollingTreeState, scrollingNodeChanges);
     1260        scrollingStateForDescendants.nextChildIndex = 0;
     1261       
     1262        traversalStateForDescendants.compositingAncestor = &layer;
    12371263
    12381264#if !LOG_DISABLED
    1239         logLayerInfo(layer, "updateBackingAndHierarchy", depth);
    1240 #else
    1241         UNUSED_PARAM(depth);
     1265        logLayerInfo(layer, "updateBackingAndHierarchy", traversalState.depth);
    12421266#endif
    12431267    }
    … …  
    12701294    if (requireDescendantTraversal) {
    12711295        for (auto* renderLayer : layer.negativeZOrderLayers())
    1272             updateBackingAndHierarchy(*renderLayer, childList, stateForDescendants, updateLevel, depth + 1);
     1296            updateBackingAndHierarchy(*renderLayer, childList, traversalStateForDescendants, scrollingStateForDescendants, updateLevel);
    12731297
    12741298        appendForegroundLayerIfNecessary();
    12751299
    12761300        for (auto* renderLayer : layer.normalFlowLayers())
    1277             updateBackingAndHierarchy(*renderLayer, childList, stateForDescendants, updateLevel, depth + 1);
     1301            updateBackingAndHierarchy(*renderLayer, childList, traversalStateForDescendants, scrollingStateForDescendants, updateLevel);
    12781302       
    12791303        for (auto* renderLayer : layer.positiveZOrderLayers())
    1280             updateBackingAndHierarchy(*renderLayer, childList, stateForDescendants, updateLevel, depth + 1);
     1304            updateBackingAndHierarchy(*renderLayer, childList, traversalStateForDescendants, scrollingStateForDescendants, updateLevel);
    12811305    } else if (requiresChildRebuild)
    12821306        appendForegroundLayerIfNecessary();
    … …  
    16901714}
    16911715
    1692 bool RenderLayerCompositor::updateLayerCompositingState(RenderLayer& layer, RequiresCompositingData& queryData, CompositingChangeRepaint shouldRepaint)
     1716bool RenderLayerCompositor::updateLayerCompositingState(RenderLayer& layer, const RenderLayer* compositingAncestor, RequiresCompositingData& queryData, CompositingChangeRepaint shouldRepaint)
    16931717{
    16941718    bool layerChanged = updateBacking(layer, queryData, shouldRepaint);
    … …  
    16961720    // See if we need content or clipping layers. Methods called here should assume
    16971721    // that the compositing state of descendant layers has not been updated yet.
    1698     if (layer.backing() && layer.backing()->updateConfiguration())
     1722    if (layer.backing() && layer.backing()->updateConfiguration(compositingAncestor))
    16991723        layerChanged = true;
    17001724
    … …  
    32423266}
    32433267
    3244 ScrollPositioningBehavior RenderLayerCompositor::computeCoordinatedPositioningForLayer(const RenderLayer& layer) const
     3268ScrollPositioningBehavior RenderLayerCompositor::computeCoordinatedPositioningForLayer(const RenderLayer& layer, const RenderLayer* compositedAncestor) const
    32453269{
    32463270    if (layer.isRenderViewLayer())
    … …  
    32573281        return ScrollPositioningBehavior::None;
    32583282
    3259     auto* compositedAncestor = layer.ancestorCompositingLayer();
    32603283    if (!compositedAncestor) {
    32613284        ASSERT_NOT_REACHED();
    … …  
    43074330}
    43084331
    4309 OptionSet<ScrollCoordinationRole> RenderLayerCompositor::coordinatedScrollingRolesForLayer(const RenderLayer& layer) const
     4332OptionSet<ScrollCoordinationRole> RenderLayerCompositor::coordinatedScrollingRolesForLayer(const RenderLayer& layer, const RenderLayer* compositingAncestor) const
    43104333{
    43114334    OptionSet<ScrollCoordinationRole> coordinationRoles;
    … …  
    43164339        coordinationRoles.add(ScrollCoordinationRole::Scrolling);
    43174340
    4318     auto coordinatedPositioning = computeCoordinatedPositioningForLayer(layer);
     4341    auto coordinatedPositioning = computeCoordinatedPositioningForLayer(layer, compositingAncestor);
    43194342    switch (coordinatedPositioning) {
    43204343    case ScrollPositioningBehavior::Moves:
    … …  
    43344357}
    43354358
    4336 ScrollingNodeID RenderLayerCompositor::updateScrollCoordinationForLayer(RenderLayer& layer, ScrollingTreeState& treeState, OptionSet<ScrollingNodeChangeFlags> changes)
    4337 {
    4338     auto roles = coordinatedScrollingRolesForLayer(layer);
     4359ScrollingNodeID RenderLayerCompositor::updateScrollCoordinationForLayer(RenderLayer& layer, const RenderLayer* compositingAncestor, ScrollingTreeState& treeState, OptionSet<ScrollingNodeChangeFlags> changes)
     4360{
     4361    auto roles = coordinatedScrollingRolesForLayer(layer, compositingAncestor);
    43394362
    43404363#if PLATFORM(IOS_FAMILY)
    … …  
    43594382    // If there's a positioning node, it's the parent scrolling node for fixed/sticky/scrolling/frame hosting.
    43604383    if (roles.contains(ScrollCoordinationRole::Positioning)) {
    4361         newNodeID = updateScrollingNodeForPositioningRole(layer, *currentTreeState, changes);
     4384        newNodeID = updateScrollingNodeForPositioningRole(layer, compositingAncestor, *currentTreeState, changes);
    43624385        childTreeState.parentNodeID = newNodeID;
    43634386        currentTreeState = &childTreeState;
    … …  
    45854608}
    45864609
    4587 ScrollingNodeID RenderLayerCompositor::updateScrollingNodeForPositioningRole(RenderLayer& layer, ScrollingTreeState& treeState, OptionSet<ScrollingNodeChangeFlags> changes)
     4610ScrollingNodeID RenderLayerCompositor::updateScrollingNodeForPositioningRole(RenderLayer& layer, const RenderLayer* compositingAncestor, ScrollingTreeState& treeState, OptionSet<ScrollingNodeChangeFlags> changes)
    45884611{
    45894612    auto* scrollingCoordinator = this->scrollingCoordinator();
    … …  
    46024625    if (changes & ScrollingNodeChangeFlags::LayerGeometry && treeState.parentNodeID) {
    46034626        // Would be nice to avoid calling computeCoordinatedPositioningForLayer() again.
    4604         auto positioningBehavior = computeCoordinatedPositioningForLayer(layer);
     4627        auto positioningBehavior = computeCoordinatedPositioningForLayer(layer, compositingAncestor);
    46054628        auto relatedNodeIDs = collectRelatedCoordinatedScrollingNodes(layer, positioningBehavior);
    46064629        scrollingCoordinator->setRelatedOverflowScrollingNodes(newNodeID, WTFMove(relatedNodeIDs));

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

    r249434 r249440  
    209209    };
    210210
    211     bool updateLayerCompositingState(RenderLayer&, RequiresCompositingData&, CompositingChangeRepaint = CompositingChangeRepaintNow);
     211    bool updateLayerCompositingState(RenderLayer&, const RenderLayer* compositingAncestor, RequiresCompositingData&, CompositingChangeRepaint = CompositingChangeRepaintNow);
    212212
    213213    // Whether layer's backing needs a graphics layer to do clipping by an ancestor (non-stacking-context parent with overflow).
    … …  
    348348    bool isViewportConstrainedFixedOrStickyLayer(const RenderLayer&) const;
    349349    bool useCoordinatedScrollingForLayer(const RenderLayer&) const;
    350     ScrollPositioningBehavior computeCoordinatedPositioningForLayer(const RenderLayer&) const;
     350    ScrollPositioningBehavior computeCoordinatedPositioningForLayer(const RenderLayer&, const RenderLayer* compositingAncestor) const;
    351351    bool isLayerForIFrameWithScrollCoordinatedContents(const RenderLayer&) const;
    352352
    … …  
    391391    struct CompositingState;
    392392    struct OverlapExtent;
     393    struct UpdateBackingTraversalState;
    393394
    394395    // Returns true if the policy changed.
    … …  
    441442    };
    442443    // Recurses down the tree, parenting descendant compositing layers and collecting an array of child layers for the current compositing layer.
    443     void updateBackingAndHierarchy(RenderLayer&, Vector<Ref<GraphicsLayer>>& childGraphicsLayersOfEnclosingLayer, struct ScrollingTreeState&, OptionSet<UpdateLevel> = { }, int depth = 0);
     444    void updateBackingAndHierarchy(RenderLayer&, Vector<Ref<GraphicsLayer>>& childGraphicsLayersOfEnclosingLayer, struct UpdateBackingTraversalState&, struct ScrollingTreeState&, OptionSet<UpdateLevel> = { });
    444445
    445446    bool layerHas3DContent(const RenderLayer&) const;
    … …  
    513514    ScrollingNodeID registerScrollingNodeID(ScrollingCoordinator&, ScrollingNodeID, ScrollingNodeType, struct ScrollingTreeState&);
    514515
    515     OptionSet<ScrollCoordinationRole> coordinatedScrollingRolesForLayer(const RenderLayer&) const;
     516    OptionSet<ScrollCoordinationRole> coordinatedScrollingRolesForLayer(const RenderLayer&, const RenderLayer* compositingAncestor) const;
    516517
    517518    // Returns the ScrollingNodeID which acts as the parent for children.
    518     ScrollingNodeID updateScrollCoordinationForLayer(RenderLayer&, struct ScrollingTreeState&, OptionSet<ScrollingNodeChangeFlags>);
     519    ScrollingNodeID updateScrollCoordinationForLayer(RenderLayer&, const RenderLayer* compositingAncestor, struct ScrollingTreeState&, OptionSet<ScrollingNodeChangeFlags>);
    519520
    520521    // These return the ScrollingNodeID which acts as the parent for children.
    … …  
    523524    ScrollingNodeID updateScrollingNodeForScrollingProxyRole(RenderLayer&, struct ScrollingTreeState&, OptionSet<ScrollingNodeChangeFlags>);
    524525    ScrollingNodeID updateScrollingNodeForFrameHostingRole(RenderLayer&, struct ScrollingTreeState&, OptionSet<ScrollingNodeChangeFlags>);
    525     ScrollingNodeID updateScrollingNodeForPositioningRole(RenderLayer&, struct ScrollingTreeState&, OptionSet<ScrollingNodeChangeFlags>);
     526    ScrollingNodeID updateScrollingNodeForPositioningRole(RenderLayer&, const RenderLayer* compositingAncestor, struct ScrollingTreeState&, OptionSet<ScrollingNodeChangeFlags>);
    526527
    527528    void updateScrollingNodeLayers(ScrollingNodeID, RenderLayer&, ScrollingCoordinator&);
Note: See TracChangeset for help on using the changeset viewer.