Make squashing work with subpixel layout

Source/core/rendering/CompositedLayerMapping.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 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 557 matching lines @@
 
     ASSERT(compositor()->layerSquashingEnabled());
 
     LayoutRect totalSquashBounds;
     for (size_t i = 0; i < m_squashedLayers.size(); ++i) {
         LayoutRect squashedBounds = compositor()->calculateCompositedBounds(m_squashedLayers[i].renderLayer, m_squashedLayers[i].renderLayer);
 
         // Store the local bounds of the RenderLayer subtree before applying the offset.
         m_squashedLayers[i].compositedBounds = squashedBounds;
 
-        squashedBounds.move(m_squashedLayers[i].offsetFromSquashingCLM);
+        squashedBounds.move(roundedIntSize(m_squashedLayers[i].offsetFromSquashingCLM + m_subpixelAccumulation));
         totalSquashBounds.unite(squashedBounds);
     }
 
     // The totalSquashBounds is positioned with respect to m_owningLayer of this CompositedLayerMapping.
     // But the squashingLayer needs to be positioned with respect to the ancestor CompositedLayerMapping.
-    // The conversion between m_owningLayer and the ancestor CLM is already computed in the caller as |delta|.
-    // FIXME: probably not the right place to round from LayoutPoint to IntPoint?
-    IntPoint squashLayerPosition = pixelSnappedIntRect(totalSquashBounds).location();
-    squashLayerPosition.moveBy(delta);
+    // The conversion between m_owningLayer and the ancestor CLM is already computed above as |delta|.

[ajuma, 2014/02/03 21:00:44]

What if the compositing ancestor has a clip layer? Shouldn't we position w.r.t.
that layer instead of converting using |delta|?

+    IntRect squashLayerBounds = pixelSnappedIntRect(totalSquashBounds);
+    IntPoint squashLayerOrigin = squashLayerBounds.location();
+    squashLayerBounds.moveBy(delta);
 
     // FIXME: this could be skipped for accelerated overflow scrolling, somehow.
     m_squashingLayer->setNeedsDisplay();
 
-    m_squashingLayer->setPosition(squashLayerPosition);
-    m_squashingLayer->setSize(totalSquashBounds.size());
+    m_squashingLayer->setPosition(squashLayerBounds.location());
+    m_squashingLayer->setSize(squashLayerBounds.size());
 
     // Now that the squashing bounds are known, we can convert the RenderLayer painting offsets
     // from CLM owning layer space to the squashing layer space.
     //
     // The painting offset we want to compute for each squashed RenderLayer is essentially the position of
     // the squashed RenderLayer described w.r.t. m_squashingLayer's origin. For this purpose we already cached
     // offsetFromSquashingCLM before, which describes where the squashed RenderLayer is located w.r.t.
     // m_owningLayer. So we just need to convert that point from m_owningLayer space to m_squashingLayer
-    // space. This is simply done by subtracing totalSquashBounds... but then the offset overall needs to be
+    // space. This is simply done by subtracing squashLayerOrigin... but then the offset overall needs to be
     // negated because that's the direction that the painting code expects the offset to be.
     for (size_t i = 0; i < m_squashedLayers.size(); ++i) {
-        m_squashedLayers[i].offsetFromRenderer = IntSize(-m_squashedLayers[i].offsetFromSquashingCLM.width() + totalSquashBounds.x(),
-            -m_squashedLayers[i].offsetFromSquashingCLM.height() + totalSquashBounds.y());
+        m_squashedLayers[i].offsetFromRenderer = -roundedIntSize(LayoutSize(m_squashedLayers[i].offsetFromSquashingCLM.width() - squashLayerOrigin.x() + m_subpixelAccumulation.width(),
+            m_squashedLayers[i].offsetFromSquashingCLM.height() - squashLayerOrigin.y() + m_subpixelAccumulation.height()));
 
         // FIXME: find a better design to avoid this redundant value - most likely it will make
         // sense to move the paint task info into RenderLayer's m_compositingProperties.
         m_squashedLayers[i].renderLayer->setOffsetFromSquashingLayerOrigin(m_squashedLayers[i].offsetFromRenderer);
     }
 }
 
 void CompositedLayerMapping::updateGraphicsLayerGeometry()
 {
     // If we haven't built z-order lists yet, wait until later.
@@ skipping 1440 matching lines @@
 LayoutRect CompositedLayerMapping::compositedBounds() const
 {
     return m_compositedBounds;
 }
 
 void CompositedLayerMapping::setCompositedBounds(const LayoutRect& bounds)
 {
     m_compositedBounds = bounds;
 }
 
-void CompositedLayerMapping::addRenderLayerToSquashingGraphicsLayer(RenderLayer* layer, IntSize offsetFromSquashingCLM, size_t nextSquashedLayerIndex)
+void CompositedLayerMapping::addRenderLayerToSquashingGraphicsLayer(RenderLayer* layer, LayoutSize offsetFromSquashingCLM, size_t nextSquashedLayerIndex)
 {
     ASSERT(compositor()->layerSquashingEnabled());
 
     GraphicsLayerPaintInfo paintInfo;
     paintInfo.renderLayer = layer;
     // NOTE: composited bounds are updated elsewhere
     // NOTE: offsetFromRenderer is updated elsewhere
     paintInfo.offsetFromSquashingCLM = offsetFromSquashingCLM;
     paintInfo.paintingPhase = GraphicsLayerPaintAllWithOverflowClip;
     paintInfo.isBackgroundLayer = false;
@@ skipping 69 matching lines @@
     } else if (graphicsLayer == m_scrollingContentsLayer.get()) {
         name = "Scrolling Contents Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore