Get rid of compositing and squashing helper methods on RenderLayerModelObject.

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 582 matching lines @@
             m_isPaginated = checkContainingBlockChainForPagination(renderer(), curr->renderBox());
             return;
         }
         if (curr->stackingNode() == ancestorStackingContextNode)
             return;
     }
 }
 
 LayoutPoint RenderLayer::positionFromPaintInvalidationContainer(const RenderObject* renderObject, const RenderLayerModelObject* paintInvalidationContainer)
 {
-    if (!paintInvalidationContainer || !paintInvalidationContainer->groupedMapping())
+    if (!paintInvalidationContainer || !paintInvalidationContainer->layer()->groupedMapping())
         return renderObject->positionFromPaintInvalidationContainer(paintInvalidationContainer);
 
     RenderLayerModelObject* transformedAncestor = paintInvalidationContainer->layer()->enclosingTransformedAncestor()->renderer();
     if (!transformedAncestor)
         return renderObject->positionFromPaintInvalidationContainer(paintInvalidationContainer);
 
     // 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.
     ForceHorriblySlowRectMapping slowRectMapping(*transformedAncestor);
 
     LayoutPoint point = renderObject->positionFromPaintInvalidationContainer(transformedAncestor);
-    point.moveBy(-paintInvalidationContainer->groupedMapping()->squashingOffsetFromTransformedAncestor());
+    point.moveBy(-paintInvalidationContainer->layer()->groupedMapping()->squashingOffsetFromTransformedAncestor());
     return point;
 }
 
 void RenderLayer::mapRectToPaintInvalidationBacking(const RenderObject* renderObject, const RenderLayerModelObject* paintInvalidationContainer, LayoutRect& rect)
 {
-    if (!paintInvalidationContainer->groupedMapping()) {
+    if (!paintInvalidationContainer->layer()->groupedMapping()) {
         renderObject->mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect);
         return;
     }
 
     RenderLayerModelObject* transformedAncestor = paintInvalidationContainer->layer()->enclosingTransformedAncestor()->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.
     ForceHorriblySlowRectMapping slowRectMapping(*transformedAncestor);
 
     // 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.
     renderObject->mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect);
 
     // |repaintContainer| may have a local 2D transform on it, so take that into account when mapping into the space of the
     // transformed ancestor.
     rect = LayoutRect(paintInvalidationContainer->localToContainerQuad(FloatRect(rect), transformedAncestor).boundingBox());
 
-    rect.moveBy(-paintInvalidationContainer->groupedMapping()->squashingOffsetFromTransformedAncestor());
+    rect.moveBy(-paintInvalidationContainer->layer()->groupedMapping()->squashingOffsetFromTransformedAncestor());
 }
 
 LayoutRect RenderLayer::computePaintInvalidationRect(const RenderObject* renderObject, const RenderLayer* paintInvalidationContainer)
 {
     if (!paintInvalidationContainer->groupedMapping())
         return renderObject->computePaintInvalidationRect(paintInvalidationContainer->renderer());
     LayoutRect rect = renderObject->clippedOverflowRectForPaintInvalidation(paintInvalidationContainer->renderer());
     mapRectToPaintInvalidationBacking(paintInvalidationContainer->renderer(), paintInvalidationContainer->renderer(), rect);
     return rect;
 }
@@ skipping 3106 matching lines @@
     }
 }
 
 void showLayerTree(const WebCore::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif