Set up clip and scroll parents on the blink side.

Source/core/rendering/RenderLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 1794 matching lines @@
 
     if (oldChild->m_hasVisibleContent || oldChild->m_hasVisibleDescendant)
         dirtyAncestorChainVisibleDescendantStatus();
 
     if (oldChild->isSelfPaintingLayer() || oldChild->hasSelfPaintingLayerDescendant())
         dirtyAncestorChainHasSelfPaintingLayerDescendantStatus();
 
     return oldChild;
 }
 
+bool RenderLayer::hasAncestor(const RenderLayer* ancestor) const
+{
+    if (!ancestor)
+        return false;
+
+    for (const RenderLayer* layer = this; layer; layer = layer->parent()) {
+        if (layer == ancestor)
+            return true;
+    }
+
+    return false;
+}
+
 void RenderLayer::removeOnlyThisLayer()
 {
     if (!m_parent)
         return;
 
     // Mark that we are about to lose our layer. This makes render tree
     // walks ignore this layer while we're removing it.
     m_renderer->setHasLayer(false);
 
     compositor()->layerWillBeRemoved(m_parent, this);
@@ skipping 3063 matching lines @@
 void RenderLayer::calculateClipRects(const ClipRectsContext& clipRectsContext, ClipRects& clipRects) const
 {
     if (!parent()) {
         // The root layer's clip rect is always infinite.
         clipRects.reset(PaintInfo::infiniteRect());
         return;
     }
 
     ClipRectsType clipRectsType = clipRectsContext.clipRectsType;
     bool useCached = clipRectsType != TemporaryClipRects;
+    bool isRoot = this == clipRectsContext.rootLayer;
 
     // For transformed layers, the root layer was shifted to be us, so there is no need to
     // examine the parent.  We want to cache clip rects with us as the root.
-    RenderLayer* parentLayer = clipRectsContext.rootLayer != this ? parent() : 0;
+    RenderLayer* parentLayer = isRoot ? 0 : parent();
 
     // Ensure that our parent's clip has been calculated so that we can examine the values.
     if (parentLayer) {
         if (useCached && parentLayer->clipRects(clipRectsContext))
             clipRects = *parentLayer->clipRects(clipRectsContext);
         else {
             ClipRectsContext parentContext(clipRectsContext);
             parentContext.overlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize; // FIXME: why?
+            if (this == clipRectsContext.scrollParent)
+                parentContext.scrollParent = 0;
             parentLayer->calculateClipRects(parentContext, clipRects);
         }
     } else
         clipRects.reset(PaintInfo::infiniteRect());
 
     // A fixed object is essentially the root of its containing block hierarchy, so when
     // we encounter such an object, we reset our clip rects to the fixedClipRect.
     if (renderer()->style()->position() == FixedPosition) {
         clipRects.setPosClipRect(clipRects.fixedClipRect());
         clipRects.setOverflowClipRect(clipRects.fixedClipRect());
         clipRects.setFixed(true);
     } else if (renderer()->style()->hasInFlowPosition())
         clipRects.setPosClipRect(clipRects.overflowClipRect());
     else if (renderer()->style()->position() == AbsolutePosition)
         clipRects.setOverflowClipRect(clipRects.posClipRect());
 
-    // Update the clip rects that will be passed to child layers.
-    if ((renderer()->hasOverflowClip() && (clipRectsContext.respectOverflowClip == RespectOverflowClip || this != clipRectsContext.rootLayer)) || renderer()->hasClip()) {
+    // Update the clip rects that will be passed to child layers. There are two reasons
+    // we may ignor the cilp here. If we've been told to ignore the overflow clip (via
+    // ClipRectsContext::respectOverflowClip), we do so, but only if this is the clip
+    // root (this setting only applies to the root layer). Also, if a scroll parent is
+    // set, we ignore all clips until we've reached it (the point of the scrollParent
+    // member of ClipRectsContext is to determine the clip the scrollParent establishes
+    // with respect to the clipRoot, regardless of any subsequent clipping that may happen
+    // between us and our scroll parent).
+    bool shouldIgnoreClip = clipRectsContext.scrollParent && this != clipRectsContext.scrollParent;
+    bool shouldIgnoreOverflowClip = clipRectsContext.respectOverflowClip == IgnoreOverflowClip && isRoot;
+
+    bool shouldApplyClip = renderer()->hasClip() && !shouldIgnoreClip;
+    bool shouldApplyOverflowClip = renderer()->hasOverflowClip() && !shouldIgnoreOverflowClip && !shouldIgnoreClip;
+
+    if (shouldApplyOverflowClip || shouldApplyClip) {
         // This layer establishes a clip of some kind.
 
         // This offset cannot use convertToLayerCoords, because sometimes our rootLayer may be across
         // some transformed layer boundary, for example, in the RenderLayerCompositor overlapMap, where
         // clipRects are needed in view space.
         LayoutPoint offset;
         offset = roundedLayoutPoint(renderer()->localToContainerPoint(FloatPoint(), clipRectsContext.rootLayer->renderer()));
         RenderView* view = renderer()->view();
         ASSERT(view);
         if (view && clipRects.fixed() && clipRectsContext.rootLayer->renderer() == view) {
@@ skipping 493 matching lines @@
 bool RenderLayer::hasCompositedMask() const
 {
     return m_backing && m_backing->hasMaskLayer();
 }
 
 GraphicsLayer* RenderLayer::layerForScrolling() const
 {
     return m_backing ? m_backing->scrollingContentsLayer() : 0;
 }
 
+GraphicsLayer* RenderLayer::layerForScrollChild() const
+{
+    // If we have an ancestor clipping layer because of our scroll parent, we do not want to
+    // scroll that clip layer -- we need it to stay put and we will slide within it. If, on
+    // the other hand, we have an ancestor clipping layer due to some other clipping layer, we
+    // want to scroll the root of the layer's associate graphics layer subtree. I.e., we want it
+    // and its clip to move in concert.
+
+    if (!backing())
+        return 0;
+
+    if (backing()->hasAncestorScrollClippingLayer()) {
+        return backing()->hasAncestorClippingLayer()
+            ? backing()->ancestorClippingLayer()
+            : backing()->graphicsLayer();
+    }
+
+    if (renderer()->containingBlock()->enclosingLayer() == ancestorScrollingLayer())
+        return backing()->graphicsLayer();
+
+    return backing()->childForSuperlayers();
+}
+
 GraphicsLayer* RenderLayer::layerForHorizontalScrollbar() const
 {
     return m_backing ? m_backing->layerForHorizontalScrollbar() : 0;
 }
 
 GraphicsLayer* RenderLayer::layerForVerticalScrollbar() const
 {
     return m_backing ? m_backing->layerForVerticalScrollbar() : 0;
 }
 
@@ skipping 976 matching lines @@
     }
 }
 
 void showLayerTree(const WebCore::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif