Layer squashing prototype

Source/WebCore/rendering/RenderLayerBacking.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 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 138 matching lines @@
         }
     }
 }
 
 RenderLayerBacking::~RenderLayerBacking()
 {
     updateClippingLayers(false, false);
     updateOverflowControlsLayers(false, false, false);
     updateForegroundLayer(false);
     updateBackgroundLayer(false);
+    updateOverlapLayer(false);
     updateMaskLayer(false);
     updateScrollingLayers(false);
     detachFromScrollingCoordinator();
     destroyGraphicsLayers();
 }
 
 void RenderLayerBacking::willDestroyLayer(const GraphicsLayer* layer)
 {
     if (layer && layer->usingTiledBacking()) {
         if (RenderLayerCompositor* compositor = this->compositor())
@@ skipping 81 matching lines @@
     }
 ····
     if (m_contentsContainmentLayer)
         m_contentsContainmentLayer->setShowDebugBorder(showBorder);
 ····
     if (m_backgroundLayer) {
         m_backgroundLayer->setShowDebugBorder(showBorder);
         m_backgroundLayer->setShowRepaintCounter(showRepaintCounter);
     }
 
+    if (m_overlapLayer) {
+        m_overlapLayer->setShowDebugBorder(showBorder);
+        m_overlapLayer->setShowRepaintCounter(showRepaintCounter);
+    }
+
     if (m_maskLayer) {
         m_maskLayer->setShowDebugBorder(showBorder);
         m_maskLayer->setShowRepaintCounter(showRepaintCounter);
     }
 
     if (m_layerForHorizontalScrollbar)
         m_layerForHorizontalScrollbar->setShowDebugBorder(showBorder);
 
     if (m_layerForVerticalScrollbar)
         m_layerForVerticalScrollbar->setShowDebugBorder(showBorder);
@@ skipping 57 matching lines @@
     if (m_graphicsLayer) {
         willDestroyLayer(m_graphicsLayer.get());
         m_graphicsLayer->removeFromParent();
     }
 
     m_ancestorClippingLayer = nullptr;
     m_contentsContainmentLayer = nullptr;
     m_graphicsLayer = nullptr;
     m_foregroundLayer = nullptr;
     m_backgroundLayer = nullptr;
+    m_overlapLayer = nullptr;
     m_childContainmentLayer = nullptr;
     m_maskLayer = nullptr;
 
     m_scrollingLayer = nullptr;
     m_scrollingContentsLayer = nullptr;
 }
 
 void RenderLayerBacking::updateOpacity(const RenderStyle* style)
 {
     m_graphicsLayer->setOpacity(compositingOpacity(style->opacity()));
@@ skipping 153 matching lines @@
 
     bool layerConfigChanged = false;
     setBackgroundLayerPaintsFixedRootBackground(compositor->needsFixedRootBackgroundLayer(m_owningLayer));
 ····
     // The background layer is currently only used for fixed root backgrounds.
     if (updateBackgroundLayer(m_backgroundLayerPaintsFixedRootBackground))
         layerConfigChanged = true;
 
     if (updateForegroundLayer(compositor->needsContentsCompositingLayer(m_owningLayer)))
         layerConfigChanged = true;
-····
+
+    if (updateOverlapLayer(compositor->needsOverlapLayer(m_owningLayer)))
+        layerConfigChanged = true;
+
     bool needsDescendentsClippingLayer = compositor->clipsCompositingDescendants(m_owningLayer);
 
     // Our scrolling layer will clip.
     if (m_owningLayer->needsCompositedScrolling())
         needsDescendentsClippingLayer = false;
 
     if (updateClippingLayers(compositor->clippedByAncestor(m_owningLayer), needsDescendentsClippingLayer))
         layerConfigChanged = true;
 
     if (updateOverflowControlsLayers(requiresHorizontalScrollbarLayer(), requiresVerticalScrollbarLayer(), requiresScrollCornerLayer()))
@@ skipping 261 matching lines @@
             backgroundSize = frameView->visibleContentRect().size();
         }
         m_backgroundLayer->setPosition(backgroundPosition);
         if (backgroundSize != m_backgroundLayer->size()) {
             m_backgroundLayer->setSize(backgroundSize);
             m_backgroundLayer->setNeedsDisplay();
         }
         m_backgroundLayer->setOffsetFromRenderer(m_graphicsLayer->offsetFromRenderer());
     }
 
+    if (m_overlapLayer) {
+        // The overlap layer should be treated as essentially the same level of abstraction as the foreground layer
+        // (except that it renders on top of composited children, rather than below them)
+        FloatPoint overlapPosition;
+        FloatSize overlapSize = contentsSize;
+        IntSize overlapOffset = m_graphicsLayer->offsetFromRenderer();
+        if (hasClippingLayer()) {
+            // If we have a clipping layer (which clips descendants), then the overlap layer is a child of it,
+            // so that it gets correctly sorted with children. In that case, position relative to the clipping layer.
+            overlapSize = FloatSize(clippingBox.size());
+            overlapOffset = toIntSize(clippingBox.location());
+        }
+
+        m_overlapLayer->setPosition(overlapPosition);
+        if (overlapSize != m_overlapLayer->size()) {
+            m_overlapLayer->setSize(overlapSize);
+            m_overlapLayer->setNeedsDisplay();
+        }
+        m_overlapLayer->setOffsetFromRenderer(overlapOffset);
+    }
+
     if (m_owningLayer->reflectionLayer() && m_owningLayer->reflectionLayer()->isComposited()) {
         RenderLayerBacking* reflectionBacking = m_owningLayer->reflectionLayer()->backing();
         reflectionBacking->updateGraphicsLayerGeometry();
 ········
         // The reflection layer has the bounds of m_owningLayer->reflectionLayer(),
         // but the reflected layer is the bounds of this layer, so we need to position it appropriately.
         FloatRect layerBounds = compositedBounds();
         FloatRect reflectionLayerBounds = reflectionBacking->compositedBounds();
         reflectionBacking->graphicsLayer()->setReplicatedLayerPosition(FloatPoint(layerBounds.location() - reflectionLayerBounds.location()));
     }
@@ skipping 63 matching lines @@
     }
     // Page scale is applied as a transform on the root render view layer. Because the scroll
     // layer is further up in the hierarchy, we need to avoid marking the root render view
     // layer as a container.
     bool isContainer = m_owningLayer->hasTransform() && !m_owningLayer->isRootLayer();
     scrollingCoordinator->setLayerIsContainerForFixedPositionLayers(childForSuperlayers(), isContainer);
 }
 
 void RenderLayerBacking::updateInternalHierarchy()
 {
-    // m_foregroundLayer has to be inserted in the correct order with child layers,
-    // so it's not inserted here.
+    // m_foregroundLayer and m_overlapLayer have to be inserted in the correct order with child layers,
+    // so they're not inserted here.
     if (m_ancestorClippingLayer)
         m_ancestorClippingLayer->removeAllChildren();
 ····
     if (m_contentsContainmentLayer) {
         m_contentsContainmentLayer->removeAllChildren();
         if (m_ancestorClippingLayer)
             m_ancestorClippingLayer->addChild(m_contentsContainmentLayer.get());
     }
 ····
     if (m_backgroundLayer)
@@ skipping 66 matching lines @@
 
     bool hasPaintedContent = !isSimpleContainer && containsPaintedContent();
 
     // FIXME: we could refine this to only allocate backing for one of these layers if possible.
     m_graphicsLayer->setDrawsContent(hasPaintedContent);
     if (m_foregroundLayer)
         m_foregroundLayer->setDrawsContent(hasPaintedContent);
 
     if (m_backgroundLayer)
         m_backgroundLayer->setDrawsContent(hasPaintedContent);
+
+    if (m_overlapLayer)
+        m_overlapLayer->setDrawsContent(hasPaintedContent);
 }
 
 // Return true if the layers changed.
 bool RenderLayerBacking::updateClippingLayers(bool needsAncestorClip, bool needsDescendantClip)
 {
     bool layersChanged = false;
 
     if (needsAncestorClip) {
         if (!m_ancestorClippingLayer) {
             m_ancestorClippingLayer = createGraphicsLayer("Ancestor clipping Layer");
@@ skipping 224 matching lines @@
 ····
     if (layerChanged) {
         // This assumes that the background layer is only used for fixed backgrounds, which is currently a correct assumption.
         if (renderer()->view())
             compositor()->fixedRootBackgroundLayerChanged();
     }
 ····
     return layerChanged;
 }
 
+bool RenderLayerBacking::updateOverlapLayer(bool needsOverlapLayer)
+{
+    bool layerChanged = false;
+    if (needsOverlapLayer) {
+        if (!m_overlapLayer) {
+            String layerName;
+#ifndef NDEBUG
+            layerName = m_owningLayer->name() + " (overlap)";
+#endif
+            m_overlapLayer = createGraphicsLayer(layerName);
+            m_overlapLayer->setDrawsContent(true);
+            m_overlapLayer->setPaintingPhase(GraphicsLayerPaintOverlap);
+            layerChanged = true;
+        }
+    } else if (m_overlapLayer) {
+        m_overlapLayer->removeFromParent();
+        m_overlapLayer = nullptr;
+        layerChanged = true;
+    }
+
+    if (layerChanged)
+        m_graphicsLayer->setPaintingPhase(paintingPhaseForPrimaryLayer());
+
+    return layerChanged;
+}
+
 bool RenderLayerBacking::updateMaskLayer(bool needsMaskLayer)
 {
     bool layerChanged = false;
     if (needsMaskLayer) {
         if (!m_maskLayer) {
             m_maskLayer = createGraphicsLayer("Mask");
             m_maskLayer->setDrawsContent(true);
             m_maskLayer->setPaintingPhase(GraphicsLayerPaintMask);
             layerChanged = true;
         }
@@ skipping 17 matching lines @@
     if (needsScrollingLayers) {
         if (!m_scrollingLayer) {
             // Outer layer which corresponds with the scroll view.
             m_scrollingLayer = createGraphicsLayer("Scrolling container");
             m_scrollingLayer->setDrawsContent(false);
             m_scrollingLayer->setMasksToBounds(true);
 
             // Inner layer which renders the content that scrolls.
             m_scrollingContentsLayer = createGraphicsLayer("Scrolled Contents");
             m_scrollingContentsLayer->setDrawsContent(true);
-            GraphicsLayerPaintingPhase paintPhase = GraphicsLayerPaintOverflowContents | GraphicsLayerPaintCompositedScroll;
+
+            GraphicsLayerPaintingPhase paintPhase = GraphicsLayerPaintOverflowContents | GraphicsLayerPaintCompositedScroll | GraphicsLayerPaintOverlap;
             if (!m_foregroundLayer)
                 paintPhase |= GraphicsLayerPaintForeground;
             m_scrollingContentsLayer->setPaintingPhase(paintPhase);
             m_scrollingLayer->addChild(m_scrollingContentsLayer.get());
 
             layerChanged = true;
             if (scrollingCoordinator)
                 scrollingCoordinator->scrollableAreaScrollLayerDidChange(m_owningLayer);
         }
     } else if (m_scrollingLayer) {
@@ skipping 51 matching lines @@
     m_scrollLayerID = 0;
 }
 
 GraphicsLayerPaintingPhase RenderLayerBacking::paintingPhaseForPrimaryLayer() const
 {
     unsigned phase = 0;
     if (!m_backgroundLayer)
         phase |= GraphicsLayerPaintBackground;
     if (!m_foregroundLayer)
         phase |= GraphicsLayerPaintForeground;
+    if (!m_overlapLayer)
+        phase |= GraphicsLayerPaintOverlap;
     if (!m_maskLayer)
         phase |= GraphicsLayerPaintMask;
 
     if (m_scrollingContentsLayer) {
-        phase &= ~GraphicsLayerPaintForeground;
+        phase &= ~(GraphicsLayerPaintForeground & GraphicsLayerPaintOverlap);

[shawnsingh, 2013/03/21 05:01:02]

Actually I think this should be bitwise OR |  instead of AND &.

         phase |= GraphicsLayerPaintCompositedScroll;
     }
 
     return static_cast<GraphicsLayerPaintingPhase>(phase);
 }
 
 float RenderLayerBacking::compositingOpacity(float rendererOpacity) const
 {
     float finalOpacity = rendererOpacity;
 ····
@@ skipping 448 matching lines @@
 ····
     if (m_graphicsLayer && m_graphicsLayer->drawsContent())
         m_graphicsLayer->setNeedsDisplay();
 ····
     if (m_foregroundLayer && m_foregroundLayer->drawsContent())
         m_foregroundLayer->setNeedsDisplay();
 
     if (m_backgroundLayer && m_backgroundLayer->drawsContent())
         m_backgroundLayer->setNeedsDisplay();
 
+    if (m_overlapLayer && m_overlapLayer->drawsContent())
+        m_overlapLayer->setNeedsDisplay();
+
     if (m_maskLayer && m_maskLayer->drawsContent())
         m_maskLayer->setNeedsDisplay();
 
     if (m_scrollingContentsLayer && m_scrollingContentsLayer->drawsContent())
         m_scrollingContentsLayer->setNeedsDisplay();
 }
 
 // r is in the coordinate space of the layer's render object
 void RenderLayerBacking::setContentsNeedDisplayInRect(const IntRect& r)
 {
     ASSERT(!paintsIntoCompositedAncestor());
 
     if (m_graphicsLayer && m_graphicsLayer->drawsContent()) {
         IntRect layerDirtyRect = r;
         layerDirtyRect.move(-m_graphicsLayer->offsetFromRenderer());
         m_graphicsLayer->setNeedsDisplayInRect(layerDirtyRect);
     }
 
     if (m_foregroundLayer && m_foregroundLayer->drawsContent()) {
         IntRect layerDirtyRect = r;
         layerDirtyRect.move(-m_foregroundLayer->offsetFromRenderer());
         m_foregroundLayer->setNeedsDisplayInRect(layerDirtyRect);
     }
 
+    if (m_overlapLayer && m_overlapLayer->drawsContent()) {
+        IntRect layerDirtyRect = r;
+        layerDirtyRect.move(-m_overlapLayer->offsetFromRenderer());
+        m_overlapLayer->setNeedsDisplayInRect(layerDirtyRect);
+    }
+
     // FIXME: need to split out repaints for the background.
     if (m_backgroundLayer && m_backgroundLayer->drawsContent()) {
         IntRect layerDirtyRect = r;
         layerDirtyRect.move(-m_backgroundLayer->offsetFromRenderer());
         m_backgroundLayer->setNeedsDisplayInRect(layerDirtyRect);
     }
 
     if (m_maskLayer && m_maskLayer->drawsContent()) {
         IntRect layerDirtyRect = r;
         layerDirtyRect.move(-m_maskLayer->offsetFromRenderer());
@@ skipping 16 matching lines @@
         return;
     }
 
     FontCachePurgePreventer fontCachePurgePreventer;
 ····
     RenderLayer::PaintLayerFlags paintFlags = 0;
     if (paintingPhase & GraphicsLayerPaintBackground)
         paintFlags |= RenderLayer::PaintLayerPaintingCompositingBackgroundPhase;
     if (paintingPhase & GraphicsLayerPaintForeground)
         paintFlags |= RenderLayer::PaintLayerPaintingCompositingForegroundPhase;
+    if (paintingPhase & GraphicsLayerPaintOverlap)
+        paintFlags |= RenderLayer::PaintLayerPaintingCompositingOverlapPhase;
     if (paintingPhase & GraphicsLayerPaintMask)
         paintFlags |= RenderLayer::PaintLayerPaintingCompositingMaskPhase;
     if (paintingPhase & GraphicsLayerPaintOverflowContents)
         paintFlags |= RenderLayer::PaintLayerPaintingOverflowContents;
     if (paintingPhase & GraphicsLayerPaintCompositedScroll)
         paintFlags |= RenderLayer::PaintLayerPaintingCompositingScrollingPhase;
 
-    if (graphicsLayer == m_backgroundLayer)
-        paintFlags |= (RenderLayer::PaintLayerPaintingRootBackgroundOnly | RenderLayer::PaintLayerPaintingCompositingForegroundPhase); // Need PaintLayerPaintingCompositingForegroundPhase to walk child layers.
+    if (graphicsLayer == m_backgroundLayer) {
+        paintFlags |= (RenderLayer::PaintLayerPaintingRootBackgroundOnly
+                       | RenderLayer::PaintLayerPaintingCompositingForegroundPhase
+                       | RenderLayer::PaintLayerPaintingCompositingOverlapPhase); // Need ForegroundPhase and OverlapPhase here, to correctly walk child layers.
+    }
     else if (m_backgroundLayer)
         paintFlags |= RenderLayer::PaintLayerPaintingSkipRootBackground;
 ····
     // FIXME: GraphicsLayers need a way to split for RenderRegions.
     RenderLayer::LayerPaintingInfo paintingInfo(m_owningLayer, paintDirtyRect, paintBehavior, LayoutSize());
     m_owningLayer->paintLayerContents(context, paintingInfo, paintFlags);
 
     if (m_owningLayer->containsDirtyOverlayScrollbars())
         m_owningLayer->paintLayerContents(context, paintingInfo, paintFlags | RenderLayer::PaintLayerPaintingOverlayScrollbars);
 
@@ skipping 18 matching lines @@
 void RenderLayerBacking::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase paintingPhase, const IntRect& clip)
 {
 #ifndef NDEBUG
     if (Page* page = renderer()->frame()->page())
         page->setIsPainting(true);
 #endif
 
     if (graphicsLayer == m_graphicsLayer.get()
         || graphicsLayer == m_foregroundLayer.get()
         || graphicsLayer == m_backgroundLayer.get()
+        || graphicsLayer == m_overlapLayer.get()
         || graphicsLayer == m_maskLayer.get()
         || graphicsLayer == m_scrollingContentsLayer.get()) {
         InspectorInstrumentationCookie cookie = InspectorInstrumentation::willPaint(m_owningLayer->renderer()->frame());
 
         // The dirtyRect is in the coords of the painting root.
         IntRect dirtyRect = clip;
         if (!(paintingPhase & GraphicsLayerPaintOverflowContents))
             dirtyRect.intersect(compositedBounds());
 
         // We have to use the same root as for hit testing, because both methods can compute and cache clipRects.
@@ skipping 315 matching lines @@
 double RenderLayerBacking::backingStoreMemoryEstimate() const
 {
     double backingMemory;
 ····
     // m_ancestorClippingLayer, m_contentsContainmentLayer and m_childContainmentLayer are just used for masking or containment, so have no backing.
     backingMemory = m_graphicsLayer->backingStoreMemoryEstimate();
     if (m_foregroundLayer)
         backingMemory += m_foregroundLayer->backingStoreMemoryEstimate();
     if (m_backgroundLayer)
         backingMemory += m_backgroundLayer->backingStoreMemoryEstimate();
+    if (m_overlapLayer)
+        backingMemory += m_overlapLayer->backingStoreMemoryEstimate();
     if (m_maskLayer)
         backingMemory += m_maskLayer->backingStoreMemoryEstimate();
 
     if (m_scrollingContentsLayer)
         backingMemory += m_scrollingContentsLayer->backingStoreMemoryEstimate();
 
     if (m_layerForHorizontalScrollbar)
         backingMemory += m_layerForHorizontalScrollbar->backingStoreMemoryEstimate();
 
     if (m_layerForVerticalScrollbar)
@@ skipping 21 matching lines @@
 
 void RenderLayerBacking::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
     MemoryClassInfo info(memoryObjectInfo, this, PlatformMemoryTypes::Rendering);
     info.addWeakPointer(m_owningLayer);
     info.addMember(m_ancestorClippingLayer, "ancestorClippingLayer");
     info.addMember(m_contentsContainmentLayer, "contentsContainmentLayer");
     info.addMember(m_graphicsLayer, "graphicsLayer");
     info.addMember(m_foregroundLayer, "foregroundLayer");
     info.addMember(m_backgroundLayer, "backgroundLayer");
+    info.addMember(m_overlapLayer, "overlapLayer");
     info.addMember(m_childContainmentLayer, "childContainmentLayer");
     info.addMember(m_maskLayer, "maskLayer");
     info.addMember(m_layerForHorizontalScrollbar, "layerForHorizontalScrollbar");
     info.addMember(m_layerForVerticalScrollbar, "layerForVerticalScrollbar");
     info.addMember(m_layerForScrollCorner, "layerForScrollCorner");
     info.addMember(m_scrollingLayer, "scrollingLayer");
     info.addMember(m_scrollingContentsLayer, "scrollingContentsLayer");
 }
 
 } // namespace WebCore
 
 #endif // USE(ACCELERATED_COMPOSITING)