Set up clip and scroll parents on the blink side.

Source/core/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 22 matching lines @@
 #include "core/html/HTMLIFrameElement.h"
 #include "core/html/HTMLMediaElement.h"
 #include "core/html/canvas/CanvasRenderingContext.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/loader/cache/CachedImage.h"
 #include "core/page/Chrome.h"
 #include "core/page/FrameView.h"
 #include "core/page/Settings.h"
 #include "core/page/animation/AnimationController.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
+#include "core/platform/chromium/TraceEvent.h"
 #include "core/platform/graphics/FontCache.h"
 #include "core/platform/graphics/GraphicsContext.h"
 #include "core/platform/graphics/GraphicsLayer.h"
 #include "core/plugins/PluginView.h"
 #include "core/rendering/RenderApplet.h"
 #include "core/rendering/RenderEmbeddedObject.h"
 #include "core/rendering/RenderIFrame.h"
 #include "core/rendering/RenderImage.h"
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderLayerCompositor.h"
@@ skipping 111 matching lines @@
         if (page && frame && page->mainFrame() == frame) {
             m_isMainFrameRenderViewLayer = true;
         }
     }
 
     createPrimaryGraphicsLayer();
 }
 
 RenderLayerBacking::~RenderLayerBacking()
 {
-    updateClippingLayers(false, false);
+    updateClippingLayers(false, false, false);
     updateOverflowControlsLayers(false, false, false);
     updateForegroundLayer(false);
     updateBackgroundLayer(false);
     updateMaskLayer(false);
     updateScrollingLayers(false);
     destroyGraphicsLayers();
 }
 
 PassOwnPtr<GraphicsLayer> RenderLayerBacking::createGraphicsLayer(const String& name, CompositingReasons reasons)
 {
@@ skipping 237 matching lines @@
 
     if (updateForegroundLayer(compositor->needsContentsCompositingLayer(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))
+    bool needsAncestorClip = compositor->clippedByAncestor(m_owningLayer);
+    bool needsScrollClip = compositor->clippedByScrollingAncestor(m_owningLayer);
+    if (updateClippingLayers(needsAncestorClip, needsDescendentsClippingLayer, needsScrollClip))
         layerConfigChanged = true;
 
     if (updateOverflowControlsLayers(requiresHorizontalScrollbarLayer(), requiresVerticalScrollbarLayer(), requiresScrollCornerLayer()))
         layerConfigChanged = true;
 
     if (updateScrollingLayers(m_owningLayer->needsCompositedScrolling()))
         layerConfigChanged = true;
 
+    updateScrollParent();
+
+    // If the clip we want to ignore is established by a stacking sibling, it won't affect us.
+    // We've already made sure that we don't get a troublesome m_ancestorClippingLayer in this case.
+    if (!needsAncestorClip)
+        updateClipParent();
+
     if (layerConfigChanged)
         updateInternalHierarchy();
 
     if (updateMaskLayer(renderer->hasMask()))
         m_graphicsLayer->setMaskLayer(m_maskLayer.get());
 
     if (m_owningLayer->hasReflection()) {
         if (m_owningLayer->reflectionLayer()->backing()) {
             GraphicsLayer* reflectionLayer = m_owningLayer->reflectionLayer()->backing()->graphicsLayer();
             m_graphicsLayer->setReplicatedByLayer(reflectionLayer);
@@ skipping 96 matching lines @@
     else
         graphicsLayerParentLocation = renderer()->view()->documentRect().location();
 
     if (compAncestor && compAncestor->needsCompositedScrolling()) {
         RenderBox* renderBox = toRenderBox(compAncestor->renderer());
         IntSize scrollOffset = compAncestor->scrolledContentOffset();
         IntPoint scrollOrigin(renderBox->borderLeft(), renderBox->borderTop());
         graphicsLayerParentLocation = scrollOrigin - scrollOffset;
     }
 
+    RenderLayer* scrollAncestor = 0;
+    if (compAncestor && m_ancestorScrollClippingLayer) {
+        scrollAncestor = m_owningLayer->ancestorScrollingLayer();
+        ASSERT(scrollAncestor);
+        RenderLayer::ClipRectsContext clipRectsContext(compAncestor, 0, TemporaryClipRects, IgnoreOverlayScrollbarSize, IgnoreOverflowClip, scrollAncestor);
+        IntRect parentClipRect = pixelSnappedIntRect(m_owningLayer->backgroundClipRect(clipRectsContext).rect()); // FIXME: Incorrect for CSS regions.
+        ASSERT(parentClipRect != PaintInfo::infiniteRect());
+
+        m_ancestorScrollClippingLayer->setPosition(FloatPoint(parentClipRect.location() - graphicsLayerParentLocation));
+        m_ancestorScrollClippingLayer->setSize(parentClipRect.size());
+
+        // backgroundRect is relative to compAncestor, so subtract deltaX/deltaY to get back to local coords.
+        m_ancestorScrollClippingLayer->setOffsetFromRenderer(parentClipRect.location() - delta);
+
+        graphicsLayerParentLocation = parentClipRect.location();
+    }
+
     if (compAncestor && m_ancestorClippingLayer) {
         // Call calculateRects to get the backgroundRect which is what is used to clip the contents of this
         // layer. Note that we call it with temporaryClipRects = true because normally when computing clip rects
-        // for a compositing layer, rootLayer is the layer itself.
-        RenderLayer::ClipRectsContext clipRectsContext(compAncestor, 0, TemporaryClipRects, IgnoreOverlayScrollbarSize, IgnoreOverflowClip);
+        // for a compositing layer, rootLayer is the layer itself. Also note that if we have an ancestor clipping
+        // layer, then we have a scroll parent. As such, we consider ourself unclipped with respect to that
+        // scroll parent -- it's as if we are contained within a large, unclipped scrolling layer that moves
+        // beneath the clip established by our scroll parent. If we did not do this, we would be completely
+        // clipped and ignored when we slid outside our scroll parent's clip, preventing us from being
+        // prepainted, etc.
+        RenderLayer* clipRoot = compAncestor;
+        IntPoint scrollToCompAncestorOffset;
+        IntPoint compToScrollAncestorOffset;
+        if (m_ancestorScrollClippingLayer) {
+            ASSERT(m_owningLayer->renderer()->containingBlock()->enclosingLayer() != scrollAncestor);
+            ASSERT(scrollAncestor && scrollAncestor->hasAncestor(compAncestor));
+            clipRoot = scrollAncestor;
+            scrollAncestor->convertToPixelSnappedLayerCoords(compAncestor, compToScrollAncestorOffset);
+            scrollToCompAncestorOffset = -compToScrollAncestorOffset;
+        }
+
+        RenderLayer::ClipRectsContext clipRectsContext(clipRoot, 0, TemporaryClipRects, IgnoreOverlayScrollbarSize, IgnoreOverflowClip);
         IntRect parentClipRect = pixelSnappedIntRect(m_owningLayer->backgroundClipRect(clipRectsContext).rect()); // FIXME: Incorrect for CSS regions.
+
         ASSERT(parentClipRect != PaintInfo::infiniteRect());
-        m_ancestorClippingLayer->setPosition(FloatPoint(parentClipRect.location() - graphicsLayerParentLocation));
+
+        // If we have an ancestor scroll clipping layer, then our clip rects will already be in our scroll
+        // parent's space (it would be the clip root), so there is no need to adjust the position of the
+        // ancestor clip's graphics layer. Otherwise, our clip is with respect to compAncestor, so we must
+        // adjust here.
+        IntPoint positionOffset;
+        if (!m_ancestorScrollClippingLayer)
+            positionOffset = graphicsLayerParentLocation;
+
+        m_ancestorClippingLayer->setPosition(FloatPoint(parentClipRect.location() - positionOffset));
         m_ancestorClippingLayer->setSize(parentClipRect.size());
 
-        // backgroundRect is relative to compAncestor, so subtract deltaX/deltaY to get back to local coords.
-        m_ancestorClippingLayer->setOffsetFromRenderer(parentClipRect.location() - delta);
+        // backgroundRect is relative to clipRoot, so subtract deltaX/deltaY and the scrollToCompAncestorOffset to get back to local coords.
+        IntPoint clipToLocalOffset = delta + scrollToCompAncestorOffset;
+        m_ancestorClippingLayer->setOffsetFromRenderer(parentClipRect.location() - clipToLocalOffset);
 
         // The primary layer is then parented in, and positioned relative to this clipping layer.
-        graphicsLayerParentLocation = parentClipRect.location();
+        graphicsLayerParentLocation = parentClipRect.location() + compToScrollAncestorOffset;
     }
 
     FloatSize contentsSize = relativeCompositingBounds.size();
 
     m_graphicsLayer->setPosition(FloatPoint(relativeCompositingBounds.location() - graphicsLayerParentLocation));
     m_graphicsLayer->setOffsetFromRenderer(toIntSize(localCompositingBounds.location()));
 
     FloatSize oldSize = m_graphicsLayer->size();
     if (oldSize != contentsSize) {
         m_graphicsLayer->setSize(contentsSize);
@@ skipping 171 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()
 {
+    if (m_ancestorScrollClippingLayer)
+        m_ancestorScrollClippingLayer->removeAllChildren();
+
     // m_foregroundLayer has to be inserted in the correct order with child layers,
     // so it's not inserted here.
     if (m_ancestorClippingLayer)
         m_ancestorClippingLayer->removeAllChildren();
 
     m_graphicsLayer->removeFromParent();
 
     if (m_ancestorClippingLayer)
         m_ancestorClippingLayer->addChild(m_graphicsLayer.get());
 
+    if (m_ancestorScrollClippingLayer) {
+        if (m_ancestorClippingLayer)
+            m_ancestorScrollClippingLayer->addChild(m_ancestorClippingLayer.get());
+        else
+            m_ancestorScrollClippingLayer->addChild(m_graphicsLayer.get());
+    }
+
     if (m_childContainmentLayer) {
         m_childContainmentLayer->removeFromParent();
         m_graphicsLayer->addChild(m_childContainmentLayer.get());
     }
 
     if (m_scrollingLayer) {
         GraphicsLayer* superlayer = m_childContainmentLayer ? m_childContainmentLayer.get() : m_graphicsLayer.get();
         m_scrollingLayer->removeFromParent();
         superlayer->addChild(m_scrollingLayer.get());
     }
@@ skipping 59 matching lines @@
     // 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);
 }
 
 // Return true if the layers changed.
-bool RenderLayerBacking::updateClippingLayers(bool needsAncestorClip, bool needsDescendantClip)
+bool RenderLayerBacking::updateClippingLayers(bool needsAncestorClip, bool needsDescendantClip, bool needsScrollClip)
 {
+    TRACE_EVENT_INSTANT2(
+        "comp-scroll",
+        "RenderLayerBacking::updateClippingLayers",
+        "needsAncestorClip", needsAncestorClip,
+        "needsScrollClip", needsScrollClip);
+
     bool layersChanged = false;
 
     if (needsAncestorClip) {
         if (!m_ancestorClippingLayer) {
             m_ancestorClippingLayer = createGraphicsLayer("Ancestor clipping Layer", CompositingReasonLayerForClip);
             m_ancestorClippingLayer->setMasksToBounds(true);
             layersChanged = true;
         }
     } else if (m_ancestorClippingLayer) {
         m_ancestorClippingLayer->removeFromParent();
         m_ancestorClippingLayer = nullptr;
         layersChanged = true;
     }
 
     if (needsDescendantClip) {
         // We don't need a child containment layer if we're the main frame render view
         // layer. It's redundant as the frame clip above us will handle this clipping.
         if (!m_childContainmentLayer && !m_isMainFrameRenderViewLayer) {
             m_childContainmentLayer = createGraphicsLayer("Child clipping Layer", CompositingReasonLayerForClip);
             m_childContainmentLayer->setMasksToBounds(true);
             layersChanged = true;
         }
     } else if (hasClippingLayer()) {
         m_childContainmentLayer->removeFromParent();
         m_childContainmentLayer = nullptr;
         layersChanged = true;
     }
 
+    if (needsScrollClip) {
+        if (!m_ancestorScrollClippingLayer) {
+            m_ancestorScrollClippingLayer = createGraphicsLayer("Ancestor scroll clipping Layer", CompositingReasonLayerForClip);
+            m_ancestorScrollClippingLayer->setMasksToBounds(true);
+            layersChanged = true;
+        }
+    } else if (m_ancestorScrollClippingLayer) {
+        m_ancestorScrollClippingLayer->removeFromParent();
+        m_ancestorScrollClippingLayer = nullptr;
+        layersChanged = true;
+    }
+
     return layersChanged;
 }
 
 void RenderLayerBacking::setBackgroundLayerPaintsFixedRootBackground(bool backgroundLayerPaintsFixedRootBackground)
 {
     m_backgroundLayerPaintsFixedRootBackground = backgroundLayerPaintsFixedRootBackground;
 }
 
 bool RenderLayerBacking::updateOverflowControlsLayers(bool needsHorizontalScrollbarLayer, bool needsVerticalScrollbarLayer, bool needsScrollCornerLayer)
 {
@@ skipping 210 matching lines @@
         updateInternalHierarchy();
         m_graphicsLayer->setPaintingPhase(paintingPhaseForPrimaryLayer());
         m_graphicsLayer->setNeedsDisplay();
         if (renderer()->view())
             compositor()->scrollingLayerDidChange(m_owningLayer);
     }
 
     return layerChanged;
 }
 
+void RenderLayerBacking::updateScrollParent()
+{
+    ScrollingCoordinator* scrollingCoordinator = scrollingCoordinatorFromLayer(m_owningLayer);
+    if (!scrollingCoordinator)
+        return;
+
+    RenderLayer* scrollParent = 0;
+    if (m_owningLayer->compositingReasons() & CompositingReasonOverflowScrollingParent)
+        scrollParent = m_owningLayer->ancestorScrollingLayer();
+
+    scrollingCoordinator->updateScrollParentForLayer(m_owningLayer, scrollParent);
+}
+
+void RenderLayerBacking::updateClipParent()
+{
+    ScrollingCoordinator* scrollingCoordinator = scrollingCoordinatorFromLayer(m_owningLayer);
+    if (!scrollingCoordinator)
+        return;
+
+    RenderLayer* clipParent = 0;
+    if (m_owningLayer->compositingReasons() & CompositingReasonOutOfFlowClipping) {
+        if (RenderObject* containingBlock = m_owningLayer->renderer()->containingBlock())
+            clipParent = containingBlock->enclosingLayer()->enclosingCompositingLayer(true);
+    }
+
+    scrollingCoordinator->updateClipParentForLayer(m_owningLayer, clipParent);
+}
+
 GraphicsLayerPaintingPhase RenderLayerBacking::paintingPhaseForPrimaryLayer() const
 {
     unsigned phase = 0;
     if (!m_backgroundLayer)
         phase |= GraphicsLayerPaintBackground;
     if (!m_foregroundLayer)
         phase |= GraphicsLayerPaintForeground;
     if (!m_maskLayer)
         phase |= GraphicsLayerPaintMask;
 
     if (m_scrollingContentsLayer) {
         phase &= ~GraphicsLayerPaintForeground;
         phase |= GraphicsLayerPaintCompositedScroll;
     }
 
+    if (m_owningLayer->compositingReasons() & CompositingReasonOverflowScrollingParent)
+        phase |= GraphicsLayerPaintCompositedScroll;
+
     return static_cast<GraphicsLayerPaintingPhase>(phase);
 }
 
 float RenderLayerBacking::compositingOpacity(float rendererOpacity) const
 {
     float finalOpacity = rendererOpacity;
 
     for (RenderLayer* curr = m_owningLayer->parent(); curr; curr = curr->parent()) {
         // We only care about parents that are stacking contexts.
         // Recall that opacity creates stacking context.
@@ skipping 317 matching lines @@
 GraphicsLayer* RenderLayerBacking::parentForSublayers() const
 {
     if (m_scrollingContentsLayer)
         return m_scrollingContentsLayer.get();
 
     return m_childContainmentLayer ? m_childContainmentLayer.get() : m_graphicsLayer.get();
 }
 
 GraphicsLayer* RenderLayerBacking::childForSuperlayers() const
 {
+    if (m_ancestorScrollClippingLayer)
+        return m_ancestorScrollClippingLayer.get();
+
     if (m_ancestorClippingLayer)
         return m_ancestorClippingLayer.get();
 
     return m_graphicsLayer.get();
 }
 
 void RenderLayerBacking::setRequiresOwnBackingStore(bool requiresOwnBacking)
 {
     if (requiresOwnBacking == m_requiresOwnBackingStore)
         return;
@@ skipping 442 matching lines @@
     if (m_layerForVerticalScrollbar)
         backingMemory += m_layerForVerticalScrollbar->backingStoreMemoryEstimate();
 
     if (m_layerForScrollCorner)
         backingMemory += m_layerForScrollCorner->backingStoreMemoryEstimate();
 
     return backingMemory;
 }
 
 } // namespace WebCore