⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 245421 in webkit


Ignore:
Timestamp:
May 16, 2019, 4:27:33 PM (7 years ago)
Author:
Kocsen Chung
Message:

Revert r245218. rdar://problem/50705506

Location:
branches/safari-608.1.24-branch/Source/WebCore
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • branches/safari-608.1.24-branch/Source/WebCore/ChangeLog

    r245420 r245421  
     12019-05-16  Kocsen Chung  <kocsen_chung@apple.com>
     2
     3        Revert r245218. rdar://problem/50705506
     4
    152019-05-16  Kocsen Chung  <kocsen_chung@apple.com>
    26

  • branches/safari-608.1.24-branch/Source/WebCore/rendering/RenderLayerBacking.cpp

    r245420 r245421  
    261261    compositor().removeFromScrollCoordinatedLayers(m_owningLayer);
    262262
     263    LOG(Compositing, "RenderLayer(backing) %p willBeDestroyed", &m_owningLayer);
     264
    263265    clearBackingSharingLayers();
    264266}
    … …  
    281283void RenderLayerBacking::setBackingSharingLayers(Vector<WeakPtr<RenderLayer>>&& sharingLayers)
    282284{
     285    if (m_backingSharingLayers == sharingLayers) {
     286        sharingLayers.clear();
     287        return;
     288    }
     289
    283290    clearBackingSharingLayerProviders(m_backingSharingLayers);
    284291    m_backingSharingLayers = WTFMove(sharingLayers);
    285 
    286292    for (auto& layerWeakPtr : m_backingSharingLayers)
    287293        layerWeakPtr->setBackingProviderLayer(&m_owningLayer);
    … …  
    290296void RenderLayerBacking::removeBackingSharingLayer(RenderLayer& layer)
    291297{
     298    LOG(Compositing, "RenderLayer %p removeBackingSharingLayer %p", &m_owningLayer, &layer);
     299
    292300    layer.setBackingProviderLayer(nullptr);
    293301    m_backingSharingLayers.removeAll(&layer);
    … …  
    296304void RenderLayerBacking::clearBackingSharingLayers()
    297305{
     306    LOG(Compositing, "RenderLayer %p clearBackingSharingLayers", &m_owningLayer);
     307
    298308    clearBackingSharingLayerProviders(m_backingSharingLayers);
    299309    m_backingSharingLayers.clear();

  • branches/safari-608.1.24-branch/Source/WebCore/rendering/RenderLayerCompositor.cpp

    r245390 r245421  
    285285};
    286286
    287 class RenderLayerCompositor::BackingSharingState {
    288     WTF_MAKE_NONCOPYABLE(BackingSharingState);
    289 public:
    290     BackingSharingState() = default;
    291 
    292     RenderLayer* backingProviderCandidate() const { return m_backingProviderCandidate; };
    293    
    294     void appendSharingLayer(RenderLayer& layer)
     287struct RenderLayerCompositor::BackingSharingState {
     288    RenderLayer* backingProviderCandidate { nullptr };
     289    RenderLayer* backingProviderStackingContext { nullptr };
     290    Vector<WeakPtr<RenderLayer>> backingSharingLayers;
     291
     292    void resetBackingProviderCandidate(RenderLayer* candidateLayer = nullptr, RenderLayer* candidateStackingContext = nullptr)
    295293    {
    296         LOG_WITH_STREAM(Compositing, stream << &layer << " appendSharingLayer " << &layer << " for backing provider " << m_backingProviderCandidate);
    297         m_backingSharingLayers.append(makeWeakPtr(layer));
    298     }
    299 
    300     void updateBeforeDescendantTraversal(RenderLayer&, bool willBeComposited);
    301     void updateAfterDescendantTraversal(RenderLayer&, RenderLayer* stackingContextAncestor);
    302 
    303 private:
    304     void layerWillBeComposited(RenderLayer&);
    305 
    306     void startBackingSharingSequence(RenderLayer& candidateLayer, RenderLayer* candidateStackingContext);
    307     void endBackingSharingSequence();
    308 
    309     RenderLayer* m_backingProviderCandidate { nullptr };
    310     RenderLayer* m_backingProviderStackingContext { nullptr };
    311     Vector<WeakPtr<RenderLayer>> m_backingSharingLayers;
     294        if (!backingSharingLayers.isEmpty()) {
     295            ASSERT(backingProviderCandidate);
     296            backingProviderCandidate->backing()->setBackingSharingLayers(WTFMove(backingSharingLayers));
     297        }
     298        backingProviderCandidate = candidateLayer;
     299        backingProviderStackingContext = candidateLayer ? candidateStackingContext : nullptr;
     300    }
    312301};
    313 
    314 void RenderLayerCompositor::BackingSharingState::startBackingSharingSequence(RenderLayer& candidateLayer, RenderLayer* candidateStackingContext)
    315 {
    316     ASSERT(!m_backingProviderCandidate);
    317     ASSERT(m_backingSharingLayers.isEmpty());
    318 
    319     m_backingProviderCandidate = &candidateLayer;
    320     m_backingProviderStackingContext = candidateStackingContext;
    321 }
    322 
    323 void RenderLayerCompositor::BackingSharingState::endBackingSharingSequence()
    324 {
    325     if (m_backingProviderCandidate) {
    326         m_backingProviderCandidate->backing()->setBackingSharingLayers(WTFMove(m_backingSharingLayers));
    327         m_backingSharingLayers.clear();
    328     }
    329    
    330     m_backingProviderCandidate = nullptr;
    331 }
    332 
    333 void RenderLayerCompositor::BackingSharingState::updateBeforeDescendantTraversal(RenderLayer& layer, bool willBeComposited)
    334 {
    335     layer.setBackingProviderLayer(nullptr);
    336 
    337     // A layer that composites resets backing-sharing, since subsequent layers need to composite to overlap it.
    338     if (willBeComposited) {
    339         m_backingSharingLayers.removeAll(&layer);
    340         LOG_WITH_STREAM(Compositing, stream << "Pre-descendant compositing of " << &layer << ", ending sharing sequence for " << m_backingProviderCandidate << " with " << m_backingSharingLayers.size() << " sharing layers");
    341         endBackingSharingSequence();
    342     }
    343 }
    344 
    345 void RenderLayerCompositor::BackingSharingState::updateAfterDescendantTraversal(RenderLayer& layer, RenderLayer* stackingContextAncestor)
    346 {
    347     if (layer.isComposited()) {
    348         // If this layer is being composited, clean up sharing-related state.
    349         layer.disconnectFromBackingProviderLayer();
    350         m_backingSharingLayers.removeAll(&layer);
    351     }
    352 
    353     if (m_backingProviderCandidate && &layer == m_backingProviderStackingContext) {
    354         LOG_WITH_STREAM(Compositing, stream << "End of stacking context for backing provider " << m_backingProviderCandidate << ", ending sharing sequence with " << m_backingSharingLayers.size() << " sharing layers");
    355         endBackingSharingSequence();
    356     } else if (!m_backingProviderCandidate && layer.isComposited()) {
    357         LOG_WITH_STREAM(Compositing, stream << "Post-descendant compositing of " << &layer << ", ending sharing sequence for " << m_backingProviderCandidate << " with " << m_backingSharingLayers.size() << " sharing layers");
    358         endBackingSharingSequence();
    359         startBackingSharingSequence(layer, stackingContextAncestor);
    360     }
    361    
    362     if (&layer != m_backingProviderCandidate && layer.isComposited())
    363         layer.backing()->clearBackingSharingLayers();
    364 }
    365302
    366303struct RenderLayerCompositor::OverlapExtent {
    … …  
    944881
    945882#if ENABLE(TREE_DEBUGGING)
    946     LOG(Compositing, "%*p %s computeCompositingRequirements (backing provider candidate %p)", 12 + compositingState.depth * 2, &layer, layer.isNormalFlowOnly() ? "n" : "s", backingSharingState.backingProviderCandidate());
     883    LOG(Compositing, "%*p %s computeCompositingRequirements (backing provider candidate %p)", 12 + compositingState.depth * 2, &layer, layer.isNormalFlowOnly() ? "n" : "s", backingSharingState.backingProviderCandidate);
    947884#endif
    948885
    … …  
    955892
    956893    layer.setHasCompositingDescendant(false);
     894    layer.setBackingProviderLayer(nullptr);
    957895
    958896    // We updated compositing for direct reasons in layerStyleChanged(). Here, check for compositing that can only be evaluated after layout.
    … …  
    984922        // If we're testing for overlap, we only need to composite if we overlap something that is already composited.
    985923        if (overlapMap.overlapsLayers(layerExtent.bounds)) {
    986             if (backingSharingState.backingProviderCandidate() && canBeComposited(layer) && backingProviderLayerCanIncludeLayer(*backingSharingState.backingProviderCandidate(), layer)) {
    987                 backingSharingState.appendSharingLayer(layer);
    988                 LOG(Compositing, " layer %p can share with %p", &layer, backingSharingState.backingProviderCandidate());
     924            if (backingSharingState.backingProviderCandidate && canBeComposited(layer) && backingProviderLayerCanIncludeLayer(*backingSharingState.backingProviderCandidate, layer)) {
     925                backingSharingState.backingSharingLayers.append(makeWeakPtr(layer));
     926                LOG(Compositing, " layer %p can share with %p", &layer, backingSharingState.backingProviderCandidate);
    989927                compositingReason = RenderLayer::IndirectCompositingReason::None;
    990928                layerPaintsIntoProvidedBacking = true;
    … …  
    1030968        childState.testingOverlap = true;
    1031969        willBeComposited = true;
     970
    1032971        layerPaintsIntoProvidedBacking = false;
     972        layer.disconnectFromBackingProviderLayer();
     973        backingSharingState.backingSharingLayers.removeAll(&layer);
    1033974    };
    1034975
    … …  
    1043984        // Too hard to compute animated bounds if both us and some ancestor is animating transform.
    1044985        layerExtent.animationCausesExtentUncertainty |= layerExtent.hasTransformAnimation && compositingState.ancestorHasTransformAnimation;
     986
     987        // Compositing for any reason disables backing sharing.
     988        LOG_WITH_STREAM(Compositing, stream << &layer << " is compositing - flushing sharing to " << backingSharingState.backingProviderCandidate << " with " << backingSharingState.backingSharingLayers.size() << " sharing layers");
     989        backingSharingState.resetBackingProviderCandidate();
    1045990    } else if (layerPaintsIntoProvidedBacking) {
    1046991        childState.backingSharingAncestor = &layer;
    1047992        overlapMap.pushCompositingContainer();
    1048993    }
    1049 
    1050     backingSharingState.updateBeforeDescendantTraversal(layer, willBeComposited);
    1051994
    1052995#if !ASSERT_DISABLED
    … …  
    11581101        // The composited bounds of enclosing layers depends on which descendants are composited, so they need a geometry update.
    11591102        layer.setNeedsCompositingGeometryUpdateOnAncestors();
    1160     }
    1161 
    1162     backingSharingState.updateAfterDescendantTraversal(layer, compositingState.stackingContextAncestor);
     1103    } else if (layer.isComposited())
     1104        layer.backing()->clearBackingSharingLayers();
     1105
     1106    if (backingSharingState.backingProviderCandidate && &layer == backingSharingState.backingProviderStackingContext) {
     1107        LOG_WITH_STREAM(Compositing, stream << &layer << " popping stacking context " << backingSharingState.backingProviderStackingContext << ", flushing candidate " << backingSharingState.backingProviderCandidate << " with " << backingSharingState.backingSharingLayers.size() << " sharing layers");
     1108        backingSharingState.resetBackingProviderCandidate();
     1109    } else if (!backingSharingState.backingProviderCandidate && layer.isComposited()) {
     1110        LOG_WITH_STREAM(Compositing, stream << &layer << " compositing - sharing candidate " << backingSharingState.backingProviderCandidate << " with " << backingSharingState.backingSharingLayers.size() << " sharing layers");
     1111        // Flush out any earlier candidate in this stacking context. This layer becomes a candidate.
     1112        backingSharingState.resetBackingProviderCandidate(&layer, compositingState.stackingContextAncestor);
     1113    }
    11631114
    11641115    if (layer.reflectionLayer() && updateLayerCompositingState(*layer.reflectionLayer(), queryData, CompositingChangeRepaintNow))
    … …  
    11741125
    11751126#if ENABLE(TREE_DEBUGGING)
    1176     LOG(Compositing, "%*p computeCompositingRequirements - willBeComposited %d (backing provider candidate %p)", 12 + compositingState.depth * 2, &layer, willBeComposited, backingSharingState.backingProviderCandidate());
     1127    LOG(Compositing, "%*p computeCompositingRequirements - willBeComposited %d (backing provider candidate %p)", 12 + compositingState.depth * 2, &layer, willBeComposited, backingSharingState.backingProviderCandidate);
    11771128#endif
    11781129
    … …  
    12101161
    12111162    if (layer.paintsIntoProvidedBacking()) {
    1212         ASSERT(backingSharingState.backingProviderCandidate());
    1213         ASSERT(backingProviderLayerCanIncludeLayer(*backingSharingState.backingProviderCandidate(), layer));
    1214         backingSharingState.appendSharingLayer(layer);
     1163        ASSERT(backingSharingState.backingProviderCandidate);
     1164        ASSERT(backingProviderLayerCanIncludeLayer(*backingSharingState.backingProviderCandidate, layer));
     1165        backingSharingState.backingSharingLayers.append(makeWeakPtr(layer));
    12151166    }
    12161167
    … …  
    12321183        // Too hard to compute animated bounds if both us and some ancestor is animating transform.
    12331184        layerExtent.animationCausesExtentUncertainty |= layerExtent.hasTransformAnimation && compositingState.ancestorHasTransformAnimation;
    1234     }
    1235 
    1236     backingSharingState.updateBeforeDescendantTraversal(layer, layerIsComposited);
     1185
     1186        // Compositing for any reason disables backing sharing.
     1187        LOG_WITH_STREAM(Compositing, stream << "tus: " << &layer << " is compositing - flushing sharing to " << backingSharingState.backingProviderCandidate << " with " << backingSharingState.backingSharingLayers.size() << " sharing layers");
     1188        backingSharingState.resetBackingProviderCandidate();
     1189    }
    12371190
    12381191#if !ASSERT_DISABLED
    … …  
    12881241        overlapMap.popCompositingContainer();
    12891242
    1290     backingSharingState.updateAfterDescendantTraversal(layer, compositingState.stackingContextAncestor);
     1243    if (layer.isComposited())
     1244        layer.backing()->clearBackingSharingLayers();
     1245
     1246    if (backingSharingState.backingProviderCandidate && &layer == backingSharingState.backingProviderStackingContext) {
     1247        LOG_WITH_STREAM(Compositing, stream << &layer << " tus: popping stacking context " << backingSharingState.backingProviderStackingContext << ", flushing candidate " << backingSharingState.backingProviderCandidate << " with " << backingSharingState.backingSharingLayers.size() << " sharing layers");
     1248        backingSharingState.resetBackingProviderCandidate();
     1249    } else if (!backingSharingState.backingProviderCandidate && layer.isComposited()) {
     1250        LOG_WITH_STREAM(Compositing, stream << &layer << " tus: compositing - sharing candidate " << backingSharingState.backingProviderCandidate << " with " << backingSharingState.backingSharingLayers.size() << " sharing layers");
     1251        // Flush out any earlier candidate in this stacking context. This layer becomes a candidate.
     1252        backingSharingState.resetBackingProviderCandidate(&layer, compositingState.stackingContextAncestor);
     1253    }
    12911254
    12921255    descendantHas3DTransform |= anyDescendantHas3DTransform || layer.has3DTransform();

  • branches/safari-608.1.24-branch/Source/WebCore/rendering/RenderLayerCompositor.h

    r245390 r245421  
    368368
    369369private:
    370     class BackingSharingState;
    371370    class OverlapMap;
    372371    struct CompositingState;
     372    struct BackingSharingState;
    373373    struct OverlapExtent;
    374374
Note: See TracChangeset for help on using the changeset viewer.