Fix subpixel accumulation for composited content layers

third_party/WebKit/Source/core/layout/compositing/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 61 matching lines @@
 #include "wtf/CurrentTime.h"
 #include "wtf/text/StringBuilder.h"
 #include <memory>
 
 namespace blink {
 
 using namespace HTMLNames;
 
 static IntRect clipBox(LayoutBox* layoutObject);
 
-static IntRect contentsRect(const LayoutObject* layoutObject)
+static LayoutRect contentsRect(const LayoutObject* layoutObject)
 {
     if (!layoutObject->isBox())
-        return IntRect();
+        return LayoutRect();
     if (layoutObject->isCanvas())
-        return pixelSnappedIntRect(toLayoutHTMLCanvas(layoutObject)->replacedContentRect());
+        return toLayoutHTMLCanvas(layoutObject)->replacedContentRect();
     if (layoutObject->isVideo())
         return toLayoutVideo(layoutObject)->videoBox();
 
-    return pixelSnappedIntRect(toLayoutBox(layoutObject)->contentBoxRect());
+    if (layoutObject->isLayoutPart()) {
+        const LayoutPart* layoutPart = toLayoutPart(layoutObject);
+        // FrameView are somehow pre-snapped. This is to match behavior of LayoutPart::updateWidgetGeometry().

[chrishtr, 2016/07/21 18:02:31]

PartPainter::paintContents does rounded snapping that looks the same as this.
This is now the third place that this code appears.
Please refactor to have it centralized in a method on LayoutPart.

+        if (layoutPart->widget() && layoutPart->widget()->isFrameView()) {
+            LayoutRect contentBoxRect = layoutPart->contentBoxRect();
+            return LayoutRect(contentBoxRect.location(), LayoutSize(roundedIntSize(contentBoxRect.size())));
+        }
+    }
+
+    return toLayoutBox(layoutObject)->contentBoxRect();
 }
 
-static IntRect backgroundRect(const LayoutObject* layoutObject)
+static LayoutRect backgroundRect(const LayoutObject* layoutObject)
 {
     if (!layoutObject->isBox())
-        return IntRect();
+        return LayoutRect();
 
     LayoutRect rect;
     const LayoutBox* box = toLayoutBox(layoutObject);
     EFillBox clip = box->style()->backgroundClip();
     switch (clip) {
     case BorderFillBox:
         rect = box->borderBoxRect();
         break;
     case PaddingFillBox:
         rect = box->paddingBoxRect();
         break;
     case ContentFillBox:
         rect = box->contentBoxRect();
         break;
     case TextFillBox:
         break;
     }
 
-    return pixelSnappedIntRect(rect);
+    return rect;
 }
 
 static inline bool isAcceleratedCanvas(const LayoutObject* layoutObject)
 {
     if (layoutObject->isCanvas()) {
         HTMLCanvasElement* canvas = toHTMLCanvasElement(layoutObject->node());
         if (CanvasRenderingContext* context = canvas->renderingContext())
             return context->isAccelerated();
     }
     return false;
@@ skipping 49 matching lines @@
 
 // Get the scrolling coordinator in a way that works inside CompositedLayerMapping's destructor.
 static ScrollingCoordinator* scrollingCoordinatorFromLayer(PaintLayer& layer)
 {
     Page* page = layer.layoutObject()->frame()->page();
     return (!page) ? nullptr : page->scrollingCoordinator();
 }
 
 CompositedLayerMapping::CompositedLayerMapping(PaintLayer& layer)
     : m_owningLayer(layer)
-    , m_contentOffsetInCompositingLayerDirty(false)
     , m_pendingUpdateScope(GraphicsLayerUpdateNone)
     , m_isMainFrameLayoutViewLayer(false)
     , m_backgroundLayerPaintsFixedRootBackground(false)
     , m_scrollingContentsAreEmpty(false)
 {
     if (layer.isRootLayer() && layoutObject()->frame()->isMainFrame())
         m_isMainFrameLayoutViewLayer = true;
 
     createPrimaryGraphicsLayer();
 }
@@ skipping 130 matching lines @@
         // For non-root layers, background is always painted by the primary graphics layer.
         m_graphicsLayer->setContentsOpaque(m_owningLayer.backgroundIsKnownToBeOpaqueInRect(compositedBounds()));
     }
 }
 
 void CompositedLayerMapping::updateCompositedBounds()
 {
     ASSERT(m_owningLayer.compositor()->lifecycle().state() == DocumentLifecycle::InCompositingUpdate);
     // FIXME: if this is really needed for performance, it would be better to store it on Layer.
     m_compositedBounds = m_owningLayer.boundingBoxForCompositing();
-    m_contentOffsetInCompositingLayerDirty = true;
 }
 
 void CompositedLayerMapping::updateAfterPartResize()
 {
     if (layoutObject()->isLayoutPart()) {
         if (PaintLayerCompositor* innerCompositor = PaintLayerCompositor::frameContentsCompositor(toLayoutPart(layoutObject()))) {
             innerCompositor->frameViewDidChangeSize();
             // We can floor this point because our frameviews are always aligned to pixel boundaries.
             ASSERT(m_compositedBounds.location() == flooredIntPoint(m_compositedBounds.location()));
-            innerCompositor->frameViewDidChangeLocation(flooredIntPoint(contentsBox().location()));
+            innerCompositor->frameViewDidChangeLocation(roundedIntPoint(contentsBox().location()));

[chrishtr, 2016/07/21 18:02:31]

Yet another instance of frame rounding to be refactored?

         }
     }
 }
 
 void CompositedLayerMapping::updateCompositingReasons()
 {
     // All other layers owned by this mapping will have the same compositing reason
     // for their lifetime, so they are initialized only when created.
     m_graphicsLayer->setCompositingReasons(m_owningLayer.getCompositingReasons());
     m_graphicsLayer->setSquashingDisallowedReasons(m_owningLayer.getSquashingDisallowedReasons());
@@ skipping 382 matching lines @@
     IntPoint graphicsLayerParentLocation;
     computeGraphicsLayerParentLocation(compositingContainer, ancestorCompositingBounds, graphicsLayerParentLocation);
 
     // Might update graphicsLayerParentLocation.
     updateAncestorClippingLayerGeometry(compositingContainer, snappedOffsetFromCompositedAncestor, graphicsLayerParentLocation);
 
     FloatSize contentsSize(relativeCompositingBounds.size());
 
     updateMainGraphicsLayerGeometry(relativeCompositingBounds, localCompositingBounds, graphicsLayerParentLocation);
     updateOverflowControlsHostLayerGeometry(compositingStackingContext, compositingContainer);
-    updateContentsOffsetInCompositingLayer(snappedOffsetFromCompositedAncestor, graphicsLayerParentLocation);
     updateSquashingLayerGeometry(graphicsLayerParentLocation, compositingContainer, m_squashedLayers, m_squashingLayer.get(), &m_squashingLayerOffsetFromTransformedAncestor, layersNeedingPaintInvalidation);
 
     // If we have a layer that clips children, position it.
     IntRect clippingBox;
     if (m_childContainmentLayer)
         clippingBox = clipBox(toLayoutBox(layoutObject()));
 
     updateChildTransformLayerGeometry();
     updateChildContainmentLayerGeometry(clippingBox, localCompositingBounds);
 
@@ skipping 155 matching lines @@
     if (m_childClippingMaskLayer && !m_scrollingLayer && !layoutObject()->style()->clipPath()) {
         m_childClippingMaskLayer->setSize(m_childContainmentLayer->size());
         m_childClippingMaskLayer->setOffsetFromLayoutObject(m_childContainmentLayer->offsetFromLayoutObject());
     }
 }
 
 void CompositedLayerMapping::updateChildTransformLayerGeometry()
 {
     if (!m_childTransformLayer)
         return;
-    const IntRect borderBox = toLayoutBox(m_owningLayer.layoutObject())->pixelSnappedBorderBoxRect();
-    m_childTransformLayer->setSize(FloatSize(borderBox.size()));
-    m_childTransformLayer->setPosition(FloatPoint(contentOffsetInCompositingLayer()));
+    LayoutRect borderBox = toLayoutBox(m_owningLayer.layoutObject())->borderBoxRect();
+    borderBox.move(contentOffsetInCompositingLayer());
+    IntRect pixelSnappedBorderBox = pixelSnappedIntRect(borderBox);
+
+    m_childTransformLayer->setSize(FloatSize(pixelSnappedBorderBox.size()));
+    m_childTransformLayer->setPosition(FloatPoint(pixelSnappedBorderBox.location()));
 }
 
 void CompositedLayerMapping::updateMaskLayerGeometry()
 {
     if (!m_maskLayer)
         return;
 
     if (m_maskLayer->size() != m_graphicsLayer->size()) {
         m_maskLayer->setSize(m_graphicsLayer->size());
         m_maskLayer->setNeedsDisplay();
@@ skipping 245 matching lines @@
             paintPhase |= GraphicsLayerPaintOverflowContents;
         m_foregroundLayer->setPaintingPhase(paintPhase);
     }
 }
 
 void CompositedLayerMapping::updateContentsRect()
 {
     m_graphicsLayer->setContentsRect(pixelSnappedIntRect(contentsBox()));
 }
 
-void CompositedLayerMapping::updateContentsOffsetInCompositingLayer(const IntPoint& snappedOffsetFromCompositedAncestor, const IntPoint& graphicsLayerParentLocation)
-{
-    // m_graphicsLayer is positioned relative to our compositing ancestor
-    // PaintLayer, but it's not positioned at the origin of m_owningLayer, it's
-    // offset by m_contentBounds.location(). This is what
-    // contentOffsetInCompositingLayer is meant to capture, roughly speaking
-    // (ignoring rounding and subpixel accumulation).
-    //
-    // Our ancestor graphics layers in this CLM (m_graphicsLayer and potentially
-    // m_ancestorClippingLayer) have pixel snapped, so if we don't adjust this
-    // offset, we'll see accumulated rounding errors due to that snapping.
-    //
-    // In order to ensure that we account for this rounding, we compute
-    // contentsOffsetInCompositingLayer in a somewhat roundabout way.
-    //
-    // our position = (desired position) - (inherited graphics layer offset).
-    //
-    // Precisely,
-    // Offset = snappedOffsetFromCompositedAncestor - offsetDueToAncestorGraphicsLayers (See code below)
-    //      = snappedOffsetFromCompositedAncestor - (m_graphicsLayer->position() + graphicsLayerParentLocation)
-    //      = snappedOffsetFromCompositedAncestor - (relativeCompositingBounds.location() - graphicsLayerParentLocation + graphicsLayerParentLocation) (See updateMainGraphicsLayerGeometry)
-    //      = snappedOffsetFromCompositedAncestor - relativeCompositingBounds.location()
-    //      = snappedOffsetFromCompositedAncestor - (pixelSnappedIntRect(contentBounds.location()) + snappedOffsetFromCompositedAncestor) (See computeBoundsOfOwningLayer)
-    //      = -pixelSnappedIntRect(contentBounds.location())
-    //
-    // As you can see, we've ended up at the same spot (-contentBounds.location()),
-    // but by subtracting off our ancestor graphics layers positions, we can be
-    // sure we've accounted correctly for any pixel snapping due to ancestor
-    // graphics layers.
-    //
-    // And drawing of composited children takes into account the subpixel
-    // accumulation of this CLM already (through its own
-    // graphicsLayerParentLocation it appears).
-    FloatPoint offsetDueToAncestorGraphicsLayers = m_graphicsLayer->position() + graphicsLayerParentLocation;
-    m_contentOffsetInCompositingLayer = LayoutSize(snappedOffsetFromCompositedAncestor - offsetDueToAncestorGraphicsLayers);
-    m_contentOffsetInCompositingLayerDirty = false;
-}
-
 void CompositedLayerMapping::updateDrawsContent()
 {
     bool inOverlayFullscreenVideo = false;
     if (layoutObject()->isVideo()) {
         HTMLVideoElement* videoElement = toHTMLVideoElement(layoutObject()->node());
         if (videoElement->isFullscreen() && videoElement->usesOverlayFullscreenVideo())
             inOverlayFullscreenVideo = true;
     }
     bool hasPaintedContent = inOverlayFullscreenVideo ? false : containsPaintedContent();
     m_graphicsLayer->setDrawsContent(hasPaintedContent);
@@ skipping 765 matching lines @@
     origin.setY(floatValueForLength(style.transformOriginY(), borderBox.height()));
     origin.setZ(style.transformOriginZ());
 
     return origin;
 }
 
 // Return the offset from the top-left of this compositing layer at which the
 // LayoutObject's contents are painted.
 LayoutSize CompositedLayerMapping::contentOffsetInCompositingLayer() const
 {
-    ASSERT(!m_contentOffsetInCompositingLayerDirty);
-    return m_contentOffsetInCompositingLayer;
+    return m_owningLayer.subpixelAccumulation() - LayoutSize(m_graphicsLayer->offsetFromLayoutObject());

[chrishtr, 2016/07/21 18:02:31]

why subpixelAccumulation - offsetFromLayoutObject? Why not:

-(offsetFromLayoutObject + subpixelAccumulation)

 }
 
 LayoutRect CompositedLayerMapping::contentsBox() const
 {
-    LayoutRect contentsBox = LayoutRect(contentsRect(layoutObject()));
+    LayoutRect contentsBox = contentsRect(layoutObject());
     contentsBox.move(contentOffsetInCompositingLayer());
     return contentsBox;
 }
 
 bool CompositedLayerMapping::needsToReparentOverflowControls() const
 {
     return m_owningLayer.getScrollableArea()
         && m_owningLayer.getScrollableArea()->hasOverlayScrollbars()
         && m_owningLayer.getScrollableArea()->topmostScrollChild();
 }
@@ skipping 641 matching lines @@
     } else if (graphicsLayer == m_scrollingContentsLayer.get()) {
         name = "Scrolling Contents Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink