Move computation of RenderLayer::isUnclippedDescendant into CompositingPropertyUpdater

Source/core/rendering/compositing/RenderLayerCompositor.cpp

 /*
  * Copyright (C) 2009, 2010 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 98 matching lines @@
 
 RenderLayerCompositor::RenderLayerCompositor(RenderView& renderView)
     : m_renderView(renderView)
     , m_compositingReasonFinder(renderView)
     , m_pendingUpdateType(CompositingUpdateNone)
     , m_hasAcceleratedCompositing(true)
     , m_needsToRecomputeCompositingRequirements(false)
     , m_compositing(false)
     , m_compositingLayersNeedRebuild(false)
     , m_rootShouldAlwaysCompositeDirty(true)
-    , m_needsUpdateCompositingRequirementsState(false)
     , m_needsUpdateFixedBackground(false)
     , m_isTrackingRepaints(false)
     , m_rootLayerAttachment(RootLayerUnattached)
 {
     updateAcceleratedCompositingSettings();
 }
 
 RenderLayerCompositor::~RenderLayerCompositor()
 {
     ASSERT(m_rootLayerAttachment == RootLayerUnattached);
@@ skipping 91 matching lines @@
 {
     // FIXME: crbug.com/332248 ideally this could be merged with setNeedsCompositingUpdate().
     // FIXME: We can remove the staleInCompositingMode check once we get rid of the
     // forceCompositingMode setting.
     if (staleInCompositingMode())
         m_compositingLayersNeedRebuild = true;
     page()->animator().scheduleVisualUpdate();
     lifecycle().ensureStateAtMost(DocumentLifecycle::LayoutClean);
 }
 
-void RenderLayerCompositor::updateCompositingRequirementsState()
-{
-    if (!m_needsUpdateCompositingRequirementsState)
-        return;
-
-    TRACE_EVENT0("blink_rendering,comp-scroll", "RenderLayerCompositor::updateCompositingRequirementsState");
-
-    m_needsUpdateCompositingRequirementsState = false;
-    if (!rootRenderLayer() || !acceleratedCompositingForOverflowScrollEnabled())
-        return;
-
-    for (HashSet<RenderLayer*>::iterator it = m_outOfFlowPositionedLayers.begin(); it != m_outOfFlowPositionedLayers.end(); ++it)
-        (*it)->updateIsUnclippedDescendant();
-}
-
 static RenderVideo* findFullscreenVideoRenderer(Document& document)
 {
     Element* fullscreenElement = FullscreenElementStack::fullscreenElementFrom(document);
     while (fullscreenElement && fullscreenElement->isFrameOwnerElement()) {
         Document* contentDocument = toHTMLFrameOwnerElement(fullscreenElement)->contentDocument();
         if (!contentDocument)
             return 0;
         fullscreenElement = FullscreenElementStack::fullscreenElementFrom(*contentDocument);
     }
     if (!isHTMLVideoElement(fullscreenElement))
@@ skipping 48 matching lines @@
 
     m_pendingUpdateType = std::max(m_pendingUpdateType, updateType);
 
     page()->animator().scheduleVisualUpdate();
     lifecycle().ensureStateAtMost(DocumentLifecycle::LayoutClean);
 }
 
 void RenderLayerCompositor::assertNoUnresolvedDirtyBits()
 {
     ASSERT(!compositingLayersNeedRebuild());
-    ASSERT(!m_needsUpdateCompositingRequirementsState);
     ASSERT(m_pendingUpdateType == CompositingUpdateNone);
     ASSERT(!m_rootShouldAlwaysCompositeDirty);
     ASSERT(!m_needsToRecomputeCompositingRequirements);
 }
 
 void RenderLayerCompositor::applyOverlayFullscreenVideoAdjustment()
 {
     if (!m_rootContentLayer)
         return;
 
@@ skipping 24 matching lines @@
         backgroundLayer->removeFromParent();
 }
 
 void RenderLayerCompositor::updateIfNeeded()
 {
     {
         // FIXME: Notice that we call this function before checking the dirty bits below.
         // We'll need to remove DeprecatedDirtyCompositingDuringCompositingUpdate
         // before moving this function after checking the dirty bits.
         DeprecatedDirtyCompositingDuringCompositingUpdate marker(lifecycle());
-        updateCompositingRequirementsState();
 
         // FIXME: enableCompositingModeIfNeeded can call setCompositingLayersNeedRebuild,
         // which asserts that it's not InCompositingUpdate.
         enableCompositingModeIfNeeded();
     }
 
     CompositingUpdateType updateType = m_pendingUpdateType;
     bool needCompositingRequirementsUpdate = m_needsToRecomputeCompositingRequirements;
     bool needHierarchyAndGeometryUpdate = compositingLayersNeedRebuild();
 
@@ skipping 17 matching lines @@
         compositingPropertyUpdateType = CompositingPropertyUpdater::ForceUpdate;
     }
 
     RenderLayer* updateRoot = rootRenderLayer();
 
     if (needCompositingRequirementsUpdate || updateType >= CompositingUpdateAfterCompositingInputChange) {
         bool layersChanged = false;
 
         {
             TRACE_EVENT0("blink_rendering", "CompositingPropertyUpdater::updateAncestorDependentProperties");
-            CompositingPropertyUpdater(updateRoot).updateAncestorDependentProperties(updateRoot, compositingPropertyUpdateType, 0);
+            CompositingPropertyUpdater(updateRoot).updateAncestorDependentProperties(updateRoot, compositingPropertyUpdateType);
 #if ASSERT_ENABLED
             CompositingPropertyUpdater::assertNeedsToUpdateAncestorDependantPropertiesBitsCleared(updateRoot);
 #endif
         }
 
         CompositingRequirementsUpdater(m_renderView, m_compositingReasonFinder).update(updateRoot);
 
         {
             TRACE_EVENT0("blink_rendering", "CompositingLayerAssigner::assign");
             CompositingLayerAssigner(this).assign(updateRoot, layersChanged);
@@ skipping 53 matching lines @@
     // The scrolling coordinator may realize that it needs updating while compositing was being updated in this function.
     needsToUpdateScrollingCoordinator |= scrollingCoordinator() && scrollingCoordinator()->needsToUpdateAfterCompositingChange();
     if (needsToUpdateScrollingCoordinator && m_renderView.frame()->isMainFrame() && scrollingCoordinator() && inCompositingMode())
         scrollingCoordinator()->updateAfterCompositingChange();
 
     // Inform the inspector that the layer tree has changed.
     if (m_renderView.frame()->isMainFrame())
         InspectorInstrumentation::layerTreeDidChange(m_renderView.frame());
 }
 
-void RenderLayerCompositor::addOutOfFlowPositionedLayer(RenderLayer* layer)
-{
-    m_outOfFlowPositionedLayers.add(layer);
-}
-
-void RenderLayerCompositor::removeOutOfFlowPositionedLayer(RenderLayer* layer)
-{
-    m_outOfFlowPositionedLayers.remove(layer);
-}
-
 bool RenderLayerCompositor::allocateOrClearCompositedLayerMapping(RenderLayer* layer, const CompositingStateTransitionType compositedLayerUpdate)
 {
     bool compositedLayerMappingChanged = false;
     bool nonCompositedReasonChanged = updateLayerIfViewportConstrained(layer);
 
     // FIXME: It would be nice to directly use the layer's compositing reason,
     // but allocateOrClearCompositedLayerMapping also gets called without having updated compositing
     // requirements fully.
     switch (compositedLayerUpdate) {
     case AllocateOwnCompositedLayerMapping:
@@ skipping 927 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "LocalFrame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore