Store repaint rects in the coordinate space of their backing GraphicsLayer.

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 691 matching lines @@
     for (RenderLayer* curr = parent(); curr; curr = curr->parent()) {
         if (curr->renderer()->hasColumns()) {
             m_isPaginated = checkContainingBlockChainForPagination(renderer(), curr->renderBox());
             return;
         }
         if (curr->stackingNode() == ancestorStackingContextNode)
             return;
     }
 }
 
+void RenderLayer::computeRectForRepaint(const RenderLayerModelObject* repaintContainer, LayoutRect& rect) const
+{
+    if (!repaintContainer->groupedMapping()) {
+        m_renderer->computeRectForRepaint(repaintContainer, rect);
+        return;
+    }
+
+    ASSERT(enclosingTransformedAncestor());
+    ASSERT(enclosingTransformedAncestor()->renderer());
+
+    // FIXME: this defensive code should not have to exist. None of these pointers should ever be 0. See crbug.com/370410.
+    RenderLayerModelObject* transformedAncestor = 0;
+    if (RenderLayer* ancestor = repaintContainer->layer()->enclosingTransformedAncestor())
+        transformedAncestor = ancestor->renderer();
+    if (!transformedAncestor)
+        return;
+
+    // If the transformedAncestor is actually the RenderView, we might get
+    // confused and think that we can use LayoutState. Ideally, we'd made
+    // LayoutState work for all composited layers as well, but until then
+    // we need to disable LayoutState for squashed layers.
+    LayoutStateDisabler layoutStateDisabler(*transformedAncestor);

[leviw_travelin_and_unemployed, 2014/05/29 18:27:08]

:(

This should go away with RAL.

[chrishtr, 2014/05/29 18:34:11]

OK. FTR I just copied the code from its previous location.

+
+    // This code adjusts the repaint rectangle to be in the space of the transformed ancestor of the grouped (i.e. squashed)
+    // layer. This is because all layers that squash together need to repaint w.r.t. a single container that is
+    // an ancestor of all of them, in order to properly take into account any local transforms etc.
+    // FIXME: remove this special-case code that works around the repainting code structure.
+    m_renderer->computeRectForRepaint(transformedAncestor, rect);
+    rect.moveBy(-repaintContainer->groupedMapping()->squashingOffsetFromTransformedAncestor());
+
+    return;
+}
+
+LayoutRect RenderLayer::computeRepaintRect(const RenderLayerModelObject* repaintContainer) const
+{
+    if (!repaintContainer->groupedMapping())
+        return m_renderer->computeRepaintRect(repaintContainer);
+
+    LayoutRect rect = renderer()->clippedOverflowRectForRepaint(repaintContainer);
+    repaintContainer->layer()->computeRectForRepaint(repaintContainer, rect);
+    return rect;
+}
+
 void RenderLayer::setHasVisibleContent()
 {
     if (m_hasVisibleContent && !m_visibleContentStatusDirty) {
         ASSERT(!parent() || parent()->hasVisibleDescendant());
         return;
     }
 
     m_hasVisibleContent = true;
     m_visibleContentStatusDirty = false;
 
@@ skipping 3299 matching lines @@
     }
 }
 
 void showLayerTree(const WebCore::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif