Fix rounding of phase for background image

third_party/WebKit/Source/core/paint/BackgroundImageGeometry.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/BackgroundImageGeometry.h"
 
 #include "core/frame/FrameView.h"
 #include "core/layout/LayoutBox.h"
 #include "core/layout/LayoutBoxModelObject.h"
 #include "core/layout/LayoutView.h"
@@ skipping 128 matching lines @@
         if (block == container)
             break;
     }
     return result;
 }
 
 // When we match the sub-pixel fraction of the destination rect in a dimension, we
 // snap the same way. This commonly occurs when the background is meant to fill the
 // padding box but there's a border (which in Blink is always stored as an integer).
 // Otherwise we floor to avoid growing our tile size. Often these tiles are from a
-// sprite map, and bleeding adjactent sprites is visually worse than clipping the
-// intenteded one.
+// sprite map, and bleeding adjacent sprites is visually worse than clipping the
+// intended one.
 LayoutSize applySubPixelHeuristicToImageSize(const LayoutSize& size, const LayoutRect& destination)
 {
     LayoutSize snappedSize = LayoutSize(
         size.width().fraction() == destination.width().fraction() ? snapSizeToPixel(size.width(), destination.x()) : size.width().floor(),
         size.height().fraction() == destination.height().fraction() ? snapSizeToPixel(size.height(), destination.y()) : size.height().floor());
     return snappedSize;
 }
 
 } // anonymous namespace
 
 void BackgroundImageGeometry::setNoRepeatX(LayoutUnit xOffset)
 {
-    m_destRect.move(std::max(xOffset, LayoutUnit()), LayoutUnit());
-    m_phase.setX(-std::min(xOffset, LayoutUnit()));
-    m_destRect.setWidth(m_tileSize.width() + std::min(xOffset, LayoutUnit()));
+    int roundedOffset = roundToInt(xOffset);
+    m_destRect.move(std::max(roundedOffset, 0), LayoutUnit());

[Stephen Chennney, 2016/06/29 20:26:23]

If we round the dest rect differently to the phase we can end up with a dest
rect that is bigger than the tile and re-hit the bug. So whatever we do to the
phase we also need to do it to the dest rect.

+    m_phase.setX(LayoutUnit(-std::min(roundedOffset, 0)));
+    m_destRect.setWidth(m_tileSize.width() + std::min(roundedOffset, 0));
     setSpaceSize(LayoutSize(LayoutUnit(), spaceSize().height()));
 }
 
 void BackgroundImageGeometry::setNoRepeatY(LayoutUnit yOffset)
 {
-    m_destRect.move(LayoutUnit(), std::max(yOffset, LayoutUnit()));
-    m_phase.setY(-std::min(yOffset, LayoutUnit()));
-    m_destRect.setHeight(m_tileSize.height() + std::min(yOffset, LayoutUnit()));
+    int roundedOffset = roundToInt(yOffset);
+    m_destRect.move(LayoutUnit(), std::max(roundedOffset, 0));
+    m_phase.setY(LayoutUnit(-std::min(roundedOffset, 0)));
+    m_destRect.setHeight(m_tileSize.height() + std::min(roundedOffset, 0));
     setSpaceSize(LayoutSize(spaceSize().width(), LayoutUnit()));
 }
 
 void BackgroundImageGeometry::setRepeatX(
     const FillLayer& fillLayer,
     LayoutUnit unsnappedTileWidth,
     LayoutUnit snappedAvailableWidth,
     LayoutUnit unsnappedAvailableWidth,
     LayoutUnit extraOffset)
 {
     // We would like to identify the phase as a fraction of the image size in the absence of snapping,
     // then re-apply it to the snapped values. This is to handle large positions.
     if (unsnappedTileWidth) {
         LayoutUnit computedXPosition = roundedMinimumValueForLength(fillLayer.xPosition(), unsnappedAvailableWidth);
         if (fillLayer.backgroundXOrigin() == RightEdge) {
             float numberOfTilesInPosition = (snappedAvailableWidth - computedXPosition + extraOffset).toFloat() / unsnappedTileWidth.toFloat();
             float fractionalPositionWithinTile = numberOfTilesInPosition - truncf(numberOfTilesInPosition);
-            setPhaseX(LayoutUnit(fractionalPositionWithinTile * tileSize().width()));
+            setPhaseX(LayoutUnit(round(fractionalPositionWithinTile * tileSize().width())));
         } else {
             float numberOfTilesInPosition = (computedXPosition + extraOffset).toFloat() / unsnappedTileWidth.toFloat();
             float fractionalPositionWithinTile = 1.0f - (numberOfTilesInPosition - truncf(numberOfTilesInPosition));
-            setPhaseX(LayoutUnit(fractionalPositionWithinTile * tileSize().width()));
+            setPhaseX(LayoutUnit(round(fractionalPositionWithinTile * tileSize().width())));
         }
     } else {
         setPhaseX(LayoutUnit());
     }
     setSpaceSize(LayoutSize(LayoutUnit(), spaceSize().height()));
 }
 
 void BackgroundImageGeometry::setRepeatY(
     const FillLayer& fillLayer,
     LayoutUnit unsnappedTileHeight,
     LayoutUnit snappedAvailableHeight,
     LayoutUnit unsnappedAvailableHeight,
     LayoutUnit extraOffset)
 {
     // We would like to identify the phase as a fraction of the image size in the absence of snapping,
     // then re-apply it to the snapped values. This is to handle large positions.
     if (unsnappedTileHeight) {
         LayoutUnit computedYPosition = roundedMinimumValueForLength(fillLayer.yPosition(), unsnappedAvailableHeight);
         if (fillLayer.backgroundYOrigin() == BottomEdge) {
             float numberOfTilesInPosition = (snappedAvailableHeight - computedYPosition + extraOffset).toFloat() / unsnappedTileHeight.toFloat();
             float fractionalPositionWithinTile = numberOfTilesInPosition - truncf(numberOfTilesInPosition);
-            setPhaseY(LayoutUnit(fractionalPositionWithinTile * tileSize().height()));
+            setPhaseY(LayoutUnit(round(fractionalPositionWithinTile * tileSize().height())));
         } else {
             float numberOfTilesInPosition = (computedYPosition + extraOffset).toFloat() / unsnappedTileHeight.toFloat();
             float fractionalPositionWithinTile = 1.0f - (numberOfTilesInPosition - truncf(numberOfTilesInPosition));
-            setPhaseY(LayoutUnit(fractionalPositionWithinTile * tileSize().height()));
+            setPhaseY(LayoutUnit(round(fractionalPositionWithinTile * tileSize().height())));
         }
     } else {
         setPhaseY(LayoutUnit());
     }
     setSpaceSize(LayoutSize(spaceSize().width(), LayoutUnit()));
 }
 
 void BackgroundImageGeometry::setSpaceX(LayoutUnit space, LayoutUnit availableWidth, LayoutUnit extraOffset)
 {
     LayoutUnit computedXPosition = roundedMinimumValueForLength(Length(), availableWidth);
     setSpaceSize(LayoutSize(space.round(), spaceSize().height()));
     LayoutUnit actualWidth = tileSize().width() + space;
-    setPhaseX(actualWidth ? LayoutUnit(actualWidth - fmodf((computedXPosition + extraOffset), actualWidth)) : LayoutUnit());
+    setPhaseX(actualWidth ? LayoutUnit(round(actualWidth - fmodf((computedXPosition + extraOffset), actualWidth))) : LayoutUnit());
 }
 
 void BackgroundImageGeometry::setSpaceY(LayoutUnit space, LayoutUnit availableHeight, LayoutUnit extraOffset)
 {
     LayoutUnit computedYPosition = roundedMinimumValueForLength(Length(), availableHeight);
     setSpaceSize(LayoutSize(spaceSize().width(), space.round()));
     LayoutUnit actualHeight = tileSize().height() + space;
-    setPhaseY(actualHeight ? LayoutUnit(actualHeight - fmodf((computedYPosition + extraOffset), actualHeight)) : LayoutUnit());
+    setPhaseY(actualHeight ? LayoutUnit(round(actualHeight - fmodf((computedYPosition + extraOffset), actualHeight))) : LayoutUnit());
 }
 
 void BackgroundImageGeometry::useFixedAttachment(const LayoutPoint& attachmentPoint)
 {
     LayoutPoint alignedPoint = attachmentPoint;
     m_phase.move(std::max(alignedPoint.x() - m_destRect.x(), LayoutUnit()), std::max(alignedPoint.y() - m_destRect.y(), LayoutUnit()));
+    m_phase = LayoutPoint(roundedIntPoint(m_phase));
 }
 
 void BackgroundImageGeometry::calculate(const LayoutBoxModelObject& obj, const LayoutBoxModelObject* paintContainer,
     const GlobalPaintFlags globalPaintFlags, const FillLayer& fillLayer, const LayoutRect& paintRect)
 {
     LayoutUnit left;
     LayoutUnit top;
     LayoutSize positioningAreaSize;
     bool isLayoutView = obj.isLayoutView();
     const LayoutBox* rootBox = nullptr;
@@ skipping 71 matching lines @@
 
         setDestRect(viewportRect);
         positioningAreaSize = destRect().size();
     }
 
     LayoutSize fillTileSize(calculateFillTileSize(positioningBox, fillLayer, positioningAreaSize));
     // It's necessary to apply the heuristic here prior to any further calculations to avoid
     // incorrectly using sub-pixel values that won't be present in the painted tile.
     setTileSize(applySubPixelHeuristicToImageSize(fillTileSize, m_destRect));
 
+    setDestRect(LayoutRect(pixelSnappedIntRect(m_destRect)));
+
+
     EFillRepeat backgroundRepeatX = fillLayer.repeatX();
     EFillRepeat backgroundRepeatY = fillLayer.repeatY();
     LayoutUnit unsnappedAvailableWidth = positioningAreaSize.width() - fillTileSize.width();
     LayoutUnit unsnappedAvailableHeight = positioningAreaSize.height() - fillTileSize.height();
     positioningAreaSize = LayoutSize(snapSizeToPixel(positioningAreaSize.width(), m_destRect.x()), snapSizeToPixel(positioningAreaSize.height(), m_destRect.y()));
     LayoutUnit availableWidth = positioningAreaSize.width() - tileSize().width();
     LayoutUnit availableHeight = positioningAreaSize.height() - tileSize().height();
 
     LayoutUnit computedXPosition = roundedMinimumValueForLength(fillLayer.xPosition(), availableWidth);
     if (backgroundRepeatX == RoundFill && positioningAreaSize.width() > LayoutUnit() && fillTileSize.width() > LayoutUnit()) {
         int nrTiles = std::max(1, roundToInt(positioningAreaSize.width() / fillTileSize.width()));
 
         fillTileSize.setWidth(positioningAreaSize.width() / nrTiles);
 
         // Maintain aspect ratio if background-size: auto is set
         if (fillLayer.size().size.height().isAuto() && backgroundRepeatY != RoundFill) {
             fillTileSize.setHeight(fillTileSize.height() * positioningAreaSize.width() / (nrTiles * fillTileSize.width()));
         }
         setTileSize(applySubPixelHeuristicToImageSize(fillTileSize, m_destRect));
-        setPhaseX(tileSize().width() ? LayoutUnit(tileSize().width() - fmodf((computedXPosition + left), tileSize().width()))
+        setPhaseX(tileSize().width()
+            ? LayoutUnit(round(tileSize().width() - fmodf((computedXPosition + left), tileSize().width())))
             : LayoutUnit());
         setSpaceSize(LayoutSize());
     }
 
     LayoutUnit computedYPosition = roundedMinimumValueForLength(fillLayer.yPosition(), availableHeight);
     if (backgroundRepeatY == RoundFill && positioningAreaSize.height() > LayoutUnit() && fillTileSize.height() > LayoutUnit()) {
         int nrTiles = std::max(1, roundToInt(positioningAreaSize.height() / fillTileSize.height()));
 
         fillTileSize.setHeight(positioningAreaSize.height() / nrTiles);
 
         // Maintain aspect ratio if background-size: auto is set
         if (fillLayer.size().size.width().isAuto() && backgroundRepeatX != RoundFill) {
             fillTileSize.setWidth(fillTileSize.width() * positioningAreaSize.height() / (nrTiles * fillTileSize.height()));
         }
         setTileSize(applySubPixelHeuristicToImageSize(fillTileSize, m_destRect));
-        setPhaseY(tileSize().height() ? LayoutUnit(tileSize().height() - fmodf((computedYPosition + top), tileSize().height()))
+        setPhaseY(tileSize().height()
+            ? LayoutUnit(round(tileSize().height() - fmodf((computedYPosition + top), tileSize().height())))
             : LayoutUnit());
         setSpaceSize(LayoutSize());
     }
 
     if (backgroundRepeatX == RepeatFill) {
         setRepeatX(fillLayer, fillTileSize.width(), availableWidth, unsnappedAvailableWidth, left);
     } else if (backgroundRepeatX == SpaceFill && tileSize().width() > LayoutUnit()) {
         LayoutUnit space = getSpaceBetweenImageTiles(positioningAreaSize.width(), tileSize().width());
         if (space >= LayoutUnit())
             setSpaceX(space, availableWidth, left);
@@ skipping 19 matching lines @@
         setNoRepeatY(top + yOffset);
     }
 
     if (fixedAttachment)
         useFixedAttachment(paintRect.location());
 
     // Clip the final output rect to the paint rect
     m_destRect.intersect(paintRect);
 
     // Snap as-yet unsnapped values.
-    setPhase(LayoutPoint(roundedIntPoint(m_phase)));
+    DCHECK(m_phase == LayoutPoint(roundedIntPoint(m_phase)));
     setDestRect(LayoutRect(pixelSnappedIntRect(m_destRect)));
 
 }
 
 } // namespace blink