Fix bug in RenderLayer::scrollsWithRespectTo.

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 398 matching lines @@
     // (including having a real, non-viewport containing block).
     //
     // Below, a "root" fixed position element is defined to be one whose
     // containing block is the root. These root-fixed-position elements are
     // the only ones that need this special case code - other fixed position
     // elements, as well as all absolute, relative, and static elements use the
     // logic below.
     const bool isRootFixedPos = position == FixedPosition && containingBlock->enclosingLayer() == rootLayer;
     const bool otherIsRootFixedPos = otherPosition == FixedPosition && otherContainingBlock->enclosingLayer() == rootLayer;
 
+    // FIXME: some of these cases don't look quite right.
     if (isRootFixedPos && otherIsRootFixedPos)
         return false;
     if (isRootFixedPos || otherIsRootFixedPos)
         return true;
 
     if (containingBlock == otherContainingBlock)
         return false;
 
     // Maintain a set of containing blocks between the first layer and its
     // closest scrollable ancestor.
     HashSet<const RenderObject*> containingBlocks;
     while (containingBlock) {
-        if (containingBlock->enclosingLayer()->scrollsOverflow())
+        if (containingBlock->enclosingLayer()->scrollsOverflow()) {
             break;
+        }
+        if (containingBlock->enclosingLayer() == other) {
+            // This layer does not scroll with respect to the other layer if the other one does not scroll and this one is a child.
+            return false;
+        }
         containingBlocks.add(containingBlock);
         containingBlock = containingBlock->containingBlock();
     }
 
     // Do the same for the 2nd layer, but if we find a common containing block,
     // it means both layers are contained within a single non-scrolling subtree.
     // Hence, they will not scroll with respect to each other.
+    bool thisLayerScrollsOverflow = scrollsOverflow();
     while (otherContainingBlock) {
         if (containingBlocks.contains(otherContainingBlock))
             return false;
+        // The other layer scrolls with respect to this one if this one scrolls and it's a child.
+        if (!thisLayerScrollsOverflow && otherContainingBlock->enclosingLayer() == this)
+            return false;
+        // The other layer does not scroll with respect to this one if this one does not scroll and it's a child.
         if (otherContainingBlock->enclosingLayer()->scrollsOverflow())
             break;
         otherContainingBlock = otherContainingBlock->containingBlock();
     }
 
     return true;
 }
 
 void RenderLayer::updateLayerPositionsAfterDocumentScroll()
 {
@@ skipping 3557 matching lines @@
     }
 }
 
 void showLayerTree(const WebCore::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif