Set up clip and scroll parents on the blink side.

Source/core/rendering/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 1728 matching lines @@
 // Return true if the given layer has some ancestor in the RenderLayer hierarchy that clips,
 // up to the enclosing compositing ancestor. This is required because compositing layers are parented
 // according to the z-order hierarchy, yet clipping goes down the renderer hierarchy.
 // Thus, a RenderLayer can be clipped by a RenderLayer that is an ancestor in the renderer hierarchy,
 // but a sibling in the z-order hierarchy.
 bool RenderLayerCompositor::clippedByAncestor(RenderLayer* layer) const
 {
     if (!layer->isComposited() || !layer->parent())
         return false;
 
-    RenderLayer* compositingAncestor = layer->ancestorCompositingLayer();
+    // Scroll children use their scrolling ancestor as their clip root.
+    RenderLayer* compositingAncestor = clippedByScrollingAncestor(layer)
+        ? layer->ancestorScrollingLayer()
+        : layer->ancestorCompositingLayer();
+
     if (!compositingAncestor)
         return false;
 
     // If the compositingAncestor clips, that will be taken care of by clipsCompositingDescendants(),
     // so we only care about clipping between its first child that is our ancestor (the computeClipRoot),
     // and layer.
     RenderLayer* computeClipRoot = 0;
     RenderLayer* curr = layer;
     while (curr) {
         RenderLayer* next = curr->parent();
         if (next == compositingAncestor) {
             computeClipRoot = curr;
             break;
         }
         curr = next;
     }
 
     if (!computeClipRoot || computeClipRoot == layer)
         return false;
 
     return layer->backgroundClipRect(RenderLayer::ClipRectsContext(computeClipRoot, 0, TemporaryClipRects)).rect() != PaintInfo::infiniteRect(); // FIXME: Incorrect for CSS regions.
 }
 
+bool RenderLayerCompositor::clippedByScrollingAncestor(RenderLayer* layer) const
+{
+    if (!layer->isComposited() || !layer->parent())
+        return false;
+
+    if (!requiresCompositingForOverflowScrollingParent(layer))
+        return false;
+
+    RenderLayer* compositingAncestor = layer->ancestorCompositingLayer();
+    if (!compositingAncestor)
+        return false;
+
+    RenderLayer* scrollingAncestor = layer->ancestorScrollingLayer();
+    if (!scrollingAncestor)
+        return false;
+
+    if (!scrollingAncestor->hasAncestor(compositingAncestor))
+        return false;
+
+    // FIXME: Incorrect for CSS regions.
+    RenderLayer::ClipRectsContext clipRectsContext(compositingAncestor, 0, TemporaryClipRects, IgnoreOverlayScrollbarSize, IgnoreOverflowClip, scrollingAncestor);
+    LayoutRect clipRect = layer->backgroundClipRect(clipRectsContext).rect();
+    return clipRect != PaintInfo::infiniteRect() && !clipRect.isEmpty();
+}
+
 // Return true if the given layer is a stacking context and has compositing child
 // layers that it needs to clip. In this case we insert a clipping GraphicsLayer
 // into the hierarchy between this layer and its children in the z-order hierarchy.
 bool RenderLayerCompositor::clipsCompositingDescendants(const RenderLayer* layer) const
 {
     return layer->hasCompositingDescendant() && layer->renderer()->hasClipOrOverflowClip();
 }
 
 bool RenderLayerCompositor::requiresCompositingForScrollableFrame() const
 {
@@ skipping 928 matching lines @@
 
 Page* RenderLayerCompositor::page() const
 {
     if (Frame* frame = m_renderView->frameView()->frame())
         return frame->page();
 
     return 0;
 }
 
 } // namespace WebCore