Land layer squashing behind a flag

Source/core/rendering/CompositedLayerMapping.cpp

Index: Source/core/rendering/CompositedLayerMapping.cpp
diff --git a/Source/core/rendering/CompositedLayerMapping.cpp b/Source/core/rendering/CompositedLayerMapping.cpp
index d60ab34e3c0bb51be192e48ea32396eba3ce5ab7..14a8bd202db5ca81d1db0179ec5eaa1be7a077d9 100644
--- a/Source/core/rendering/CompositedLayerMapping.cpp
+++ b/Source/core/rendering/CompositedLayerMapping.cpp
@@ -175,6 +175,12 @@ CompositedLayerMapping::CompositedLayerMapping(RenderLayer* layer)
 
 CompositedLayerMapping::~CompositedLayerMapping()
 {
+    // Do not leave the destroyed pointer dangling on any RenderLayers that painted to this mapping's squashing layer.
+    for (size_t i = 0; i < m_squashedLayers.size(); ++i) {
+        if (m_squashedLayers[i].renderLayer->groupedMapping() == this)
+            m_squashedLayers[i].renderLayer->setGroupedMapping(0);
+    }
+
     updateClippingLayers(false, false);
     updateOverflowControlsLayers(false, false, false);
     updateForegroundLayer(false);
@@ -182,6 +188,7 @@ CompositedLayerMapping::~CompositedLayerMapping()
     updateMaskLayer(false);
     updateClippingMaskLayers(false);
     updateScrollingLayers(false);
+    updateSquashingLayers(false);
     destroyGraphicsLayers();
 }
 
@@ -470,6 +477,9 @@ bool CompositedLayerMapping::updateGraphicsLayerConfiguration()
     updateScrollParent(scrollParent);
     updateClipParent(m_owningLayer->clipParent());
 
+    if (updateSquashingLayers(!m_squashedLayers.isEmpty()))
+        layerConfigChanged = true;
+
     if (layerConfigChanged)
         updateInternalHierarchy();
 
@@ -790,6 +800,45 @@ void CompositedLayerMapping::updateGraphicsLayerGeometry()
         }
     }
 
+    if (m_squashingLayer) {
+        ASSERT(compositor()->isLayerSquashingEnabled());
+
+        IntRect totalSquashBounds;
+        for (size_t i = 0; i < m_squashedLayers.size(); ++i) {
+            IntRect squashedBounds = compositor()->calculateCompositedBounds(m_squashedLayers[i].renderLayer, m_squashedLayers[i].renderLayer);
+
+            // Store the composited bounds before applying the offset.
+            // FIXME: consider whether it is more efficient or clarifies the math to store the compositedBounds after applying the offset.
+            m_squashedLayers[i].compositedBounds = squashedBounds;
+
+            squashedBounds.move(m_squashedLayers[i].offsetFromBackingRoot);
+            totalSquashBounds.unite(squashedBounds);
+        }
+
+        IntPoint squashLayerPosition;
+        // FIXME: this logic needs to update depending on what "containment" layers are added to CompositedLayerMapping due to other changes
+        if (m_ancestorClippingLayer) {
+            squashLayerPosition = IntPoint(m_ancestorClippingLayer->position().x() + totalSquashBounds.location().x(),
+                m_ancestorClippingLayer->position().y() + totalSquashBounds.location().y());
+        } else {
+            squashLayerPosition = IntPoint(m_graphicsLayer->position().x() + totalSquashBounds.location().x(),
+                m_graphicsLayer->position().y() + totalSquashBounds.location().y());
+        }
+
+        m_squashingLayer->setPosition(squashLayerPosition);
+        m_squashingLayer->setSize(totalSquashBounds.size());
+
+        // Now that the position of the squashing layer is known, update the offsets for each squashed RenderLayer.
+        for (size_t i = 0; i < m_squashedLayers.size(); ++i) {
+            m_squashedLayers[i].offsetFromRenderer = IntSize(-m_squashedLayers[i].offsetFromBackingRoot.width() - m_graphicsLayer->position().x() + m_squashingLayer->position().x(),
+                -m_squashedLayers[i].offsetFromBackingRoot.height() - m_graphicsLayer->position().y() + m_squashingLayer->position().y());
+
+            // FIXME: find a better design to avoid this redundant value - most likely it will make
+            // sense to move the paint task info into RenderLayer's m_compositingProperties.
+            m_squashedLayers[i].renderLayer->setOffsetFromSquashingLayerOrigin(m_squashedLayers[i].offsetFromRenderer);
+        }
+    }
+
     if (m_owningLayer->scrollableArea())
         m_owningLayer->scrollableArea()->positionOverflowControls();
 
@@ -868,6 +917,21 @@ void CompositedLayerMapping::updateInternalHierarchy()
         m_layerForScrollCorner->removeFromParent();
         m_graphicsLayer->addChild(m_layerForScrollCorner.get());
     }
+
+    // The squashing containment layer, if it exists, becomes a no-op parent.
+    if (m_squashingLayer) {
+        ASSERT(compositor()->isLayerSquashingEnabled());
+        ASSERT(m_squashingContainmentLayer);
+
+        m_squashingContainmentLayer->removeAllChildren();
+
+        if (m_ancestorClippingLayer)
+            m_squashingContainmentLayer->addChild(m_ancestorClippingLayer.get());
+        else
+            m_squashingContainmentLayer->addChild(m_graphicsLayer.get());
+
+        m_squashingContainmentLayer->addChild(m_squashingLayer.get());
+    }
 }
 
 void CompositedLayerMapping::updateContentsRect(bool isSimpleContainer)
@@ -1194,8 +1258,16 @@ bool CompositedLayerMapping::updateScrollingLayers(bool needsScrollingLayers)
 
 void CompositedLayerMapping::updateScrollParent(RenderLayer* scrollParent)
 {
+
     if (ScrollingCoordinator* scrollingCoordinator = scrollingCoordinatorFromLayer(m_owningLayer)) {
-        if (m_ancestorClippingLayer) {
+        // FIXME: not 100% certain if this scrollParent code adjustment for squashing is correct?.

[Ian Vollick, 2013/12/06 21:11:30]

Looks correct, but would you mind doing a minor cleanup for me?
RL* topLayer = childForSuperlayers();
updateScrollParent(m_squashingContainmentLayer.get(), topLayer, scrollParent,
sc);
updateScrollParent(m_ancestorClippingLayer.get(), ...
...

void updateScrollParent(layer, topLayer, scrollParent, sc)
{
  if (!layer) return;
  sc->updateScrollParentForGraphicsLayer(layer, layer == topLayer ? scrollParent
: 0);
}

I think this will scale better if we add more layers to the tree.

[Ian Vollick, 2013/12/07 02:44:42]

On second thought, I'm pretty confident this is correct. Let's just go with this
for now and I'll land a cleanup later.

[shawnsingh, 2013/12/11 18:50:34]

Your cleanup landed anyway, and the latest patch is rebased on top of it, so
that's that. =)

+        if (m_squashingContainmentLayer) {
+            ASSERT(childForSuperlayers() == m_squashingContainmentLayer.get());
+            scrollingCoordinator->updateScrollParentForGraphicsLayer(m_squashingContainmentLayer.get(), scrollParent);
+            if (m_ancestorClippingLayer)
+                scrollingCoordinator->updateScrollParentForGraphicsLayer(m_ancestorClippingLayer.get(), 0);
+            scrollingCoordinator->updateScrollParentForGraphicsLayer(m_graphicsLayer.get(), 0);
+        } else if (m_ancestorClippingLayer) {
             ASSERT(childForSuperlayers() == m_ancestorClippingLayer.get());
             // If we have an ancestor clipping layer, it is the scroll child. The other layer that may have
             // been the scroll child is the graphics layer. We will ensure that we clear its association
@@ -1215,6 +1287,49 @@ void CompositedLayerMapping::updateClipParent(RenderLayer* clipParent)
         scrollingCoordinator->updateClipParentForGraphicsLayer(m_graphicsLayer.get(), clipParent);
 }
 
+bool CompositedLayerMapping::updateSquashingLayers(bool needsSquashingLayers)
+{
+    bool layersChanged = false;
+
+    if (needsSquashingLayers) {
+        ASSERT(compositor()->isLayerSquashingEnabled());
+
+        if (!m_squashingLayer) {
+            ASSERT(!m_squashingContainmentLayer);
+
+            m_squashingLayer = createGraphicsLayer(CompositingReasonOverlap);
+            m_squashingLayer->setDrawsContent(true);
+            m_squashingLayer->setNeedsDisplay();
+            layersChanged = true;
+
+            // FIXME: containment layer needs a new CompositingReason, CompositingReasonOverlap is not appropriate.
+            m_squashingContainmentLayer = createGraphicsLayer(CompositingReasonOverlap);
+            // FIXME: reflections should force transform-style to be flat in the style: https://bugs.webkit.org/show_bug.cgi?id=106959
+            bool preserves3D = renderer()->style()->transformStyle3D() == TransformStyle3DPreserve3D && !renderer()->hasReflection();
+            m_squashingContainmentLayer->setPreserves3D(preserves3D);
+            layersChanged = true;
+        }
+
+        ASSERT(m_squashingLayer && m_squashingContainmentLayer);
+    } else {
+        if (m_squashingLayer) {
+            m_squashingLayer->removeFromParent();
+            m_squashingLayer = nullptr;
+            layersChanged = true;
+            // FIXME: do we need to invalidate something here?
+
+            ASSERT(m_squashingContainmentLayer);
+            m_squashingContainmentLayer->removeFromParent();
+            m_squashingContainmentLayer = nullptr;
+            layersChanged = true;
+        }
+
+        ASSERT(!m_squashingLayer && !m_squashingContainmentLayer);
+    }
+
+    return layersChanged;
+}
+
 GraphicsLayerPaintingPhase CompositedLayerMapping::paintingPhaseForPrimaryLayer() const
 {
     unsigned phase = 0;
@@ -1556,6 +1671,9 @@ GraphicsLayer* CompositedLayerMapping::parentForSublayers() const
 
 GraphicsLayer* CompositedLayerMapping::childForSuperlayers() const
 {
+    if (m_squashingContainmentLayer)
+        return m_squashingContainmentLayer.get();
+
     if (m_ancestorClippingLayer)
         return m_ancestorClippingLayer.get();
 
@@ -1730,14 +1848,20 @@ void CompositedLayerMapping::doPaintTask(GraphicsLayerPaintInfo& paintInfo, Grap
     paintInfo.renderLayer->renderer()->assertSubtreeIsLaidOut();
 #endif
 
-    // FIXME: GraphicsLayers need a way to split for RenderRegions.
-    LayerPaintingInfo paintingInfo(paintInfo.renderLayer, dirtyRect, PaintBehaviorNormal, LayoutSize());
-    paintInfo.renderLayer->paintLayerContents(context, paintingInfo, paintFlags);
+    if (paintInfo.renderLayer->compositingState() != PaintsIntoGroupedBacking) {
+        // FIXME: GraphicsLayers need a way to split for RenderRegions.
+        LayerPaintingInfo paintingInfo(paintInfo.renderLayer, dirtyRect, PaintBehaviorNormal, LayoutSize());
+        paintInfo.renderLayer->paintLayerContents(context, paintingInfo, paintFlags);
 
-    ASSERT(!paintInfo.isBackgroundLayer || paintFlags & PaintLayerPaintingRootBackgroundOnly);
+        ASSERT(!paintInfo.isBackgroundLayer || paintFlags & PaintLayerPaintingRootBackgroundOnly);
 
-    if (paintInfo.renderLayer->containsDirtyOverlayScrollbars())
-        paintInfo.renderLayer->paintLayerContents(context, paintingInfo, paintFlags | PaintLayerPaintingOverlayScrollbars);
+        if (paintInfo.renderLayer->containsDirtyOverlayScrollbars())
+            paintInfo.renderLayer->paintLayerContents(context, paintingInfo, paintFlags | PaintLayerPaintingOverlayScrollbars);
+    } else {
+        ASSERT(compositor()->isLayerSquashingEnabled());
+        LayerPaintingInfo paintingInfo(paintInfo.renderLayer, dirtyRect, PaintBehaviorNormal, LayoutSize());
+        paintInfo.renderLayer->paintLayer(context, paintingInfo, paintFlags);
+    }
 
     ASSERT(!paintInfo.renderLayer->m_usedTransparency);
 
@@ -1784,6 +1908,10 @@ void CompositedLayerMapping::paintContents(const GraphicsLayer* graphicsLayer, G
 
         // We have to use the same root as for hit testing, because both methods can compute and cache clipRects.
         doPaintTask(paintInfo, &context, clip);
+    } else if (graphicsLayer == m_squashingLayer.get()) {
+        ASSERT(compositor()->isLayerSquashingEnabled());
+        for (size_t i = 0; i < m_squashedLayers.size(); ++i)
+            doPaintTask(m_squashedLayers[i], &context, clip);
     } else if (graphicsLayer == layerForHorizontalScrollbar()) {
         paintScrollbar(m_owningLayer->scrollableArea()->horizontalScrollbar(), context, clip);
     } else if (graphicsLayer == layerForVerticalScrollbar()) {
@@ -1979,6 +2107,46 @@ void CompositedLayerMapping::setCompositedBounds(const IntRect& bounds)
     m_compositedBounds = bounds;
 }
 
+void CompositedLayerMapping::addRenderLayerToSquashingGraphicsLayer(RenderLayer* layer, IntSize offsetFromTargetBacking, size_t nextSquashedLayerIndex)
+{
+    ASSERT(compositor()->isLayerSquashingEnabled());
+
+    GraphicsLayerPaintInfo paintInfo;
+    paintInfo.renderLayer = layer;
+    // NOTE: composited bounds are updated elsewhere
+    // NOTE: offsetFromRenderer is updated elsewhere
+    paintInfo.offsetFromBackingRoot = offsetFromTargetBacking;
+    paintInfo.paintingPhase = GraphicsLayerPaintAllWithOverflowClip;
+    paintInfo.isBackgroundLayer = false;
+
+    // Change tracking on squashing layers: at the first sign of something changed, just invalidate the layer.
+    // FIXME: Perhaps we can find a tighter more clever mechanism later.
+    if (nextSquashedLayerIndex < m_squashedLayers.size()) {
+        if (m_squashedLayers[nextSquashedLayerIndex].renderLayer != layer) {
+            m_squashedLayers[nextSquashedLayerIndex] = paintInfo;
+            if (m_squashingLayer)
+                m_squashingLayer->setNeedsDisplay();
+        }
+    } else {
+        m_squashedLayers.append(paintInfo);
+        if (m_squashingLayer)
+            m_squashingLayer->setNeedsDisplay();
+    }
+    layer->setGroupedMapping(this);
+}
+
+void CompositedLayerMapping::finishAccumulatingSquashingLayers(size_t nextSquashedLayerIndex)
+{
+    ASSERT(compositor()->isLayerSquashingEnabled());
+
+    // Any additional squashed RenderLayers in the array no longer exist, and removing invalidates the squashingLayer contents.
+    if (nextSquashedLayerIndex < m_squashedLayers.size()) {
+        m_squashedLayers.remove(nextSquashedLayerIndex, m_squashedLayers.size() - nextSquashedLayerIndex);
+        if (m_squashingLayer)
+            m_squashingLayer->setNeedsDisplay();
+    }
+}
+
 CompositingLayerType CompositedLayerMapping::compositingLayerType() const
 {
     if (m_graphicsLayer->hasContentsLayer())