Adjust the rounding methodology for tiled background phase

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 151 matching lines @@
     m_phase.setY(-std::min(yOffset, LayoutUnit()));
     m_destRect.setHeight(m_tileSize.height() + std::min(yOffset, 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()));
 }
 
-void BackgroundImageGeometry::clip(const LayoutRect& clipRect)
-{
-    m_destRect.intersect(clipRect);
-}
-
-void BackgroundImageGeometry::pixelSnapGeometry()
-{
-    setTileSize(applySubPixelHeuristicToImageSize(m_tileSize, m_destRect));
-    setImageContainerSize(applySubPixelHeuristicToImageSize(m_imageContainerSize, m_destRect));
-    setSpaceSize(LayoutSize(roundedIntSize(m_repeatSpacing)));
-    setDestRect(LayoutRect(pixelSnappedIntRect(m_destRect)));
-    setPhase(LayoutPoint(flooredIntPoint(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;
     if (isLayoutView) {
         // It is only possible reach here when root element has a box.
@@ skipping 87 matching lines @@
     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()));
         }
-
+        fillTileSize = applySubPixelHeuristicToImageSize(fillTileSize, m_destRect);
         setTileSize(fillTileSize);
         setImageContainerSize(fillTileSize);
         setPhaseX(tileSize().width() ? LayoutUnit(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()));
         }
 
+        fillTileSize = applySubPixelHeuristicToImageSize(fillTileSize, m_destRect);
         setTileSize(fillTileSize);
         setImageContainerSize(fillTileSize);
         setPhaseY(tileSize().height() ? LayoutUnit(tileSize().height() - fmodf((computedYPosition + top), tileSize().height()))
             : LayoutUnit());
         setSpaceSize(LayoutSize());
     }
 
     if (backgroundRepeatX == RepeatFill) {
         LayoutUnit xOffset = fillLayer.backgroundXOrigin() == RightEdge ? availableWidth - computedXPosition : computedXPosition;
         setPhaseX(tileSize().width() ? LayoutUnit(tileSize().width() - fmodf((xOffset + left), tileSize().width()))
             : LayoutUnit());
         setSpaceSize(LayoutSize());
     } else if (backgroundRepeatX == SpaceFill && fillTileSize.width() > LayoutUnit()) {
         LayoutUnit space = getSpaceBetweenImageTiles(positioningAreaSize.width(), tileSize().width());
         LayoutUnit actualWidth = tileSize().width() + space;
 
         if (space >= LayoutUnit()) {
             computedXPosition = roundedMinimumValueForLength(Length(), availableWidth);
-            setSpaceSize(LayoutSize(space, LayoutUnit()));
+            setSpaceSize(LayoutSize(space.round(), LayoutUnit()));
             setPhaseX(actualWidth ? LayoutUnit(actualWidth - fmodf((computedXPosition + left), actualWidth)) : LayoutUnit());
         } else {
             backgroundRepeatX = NoRepeatFill;
         }
     }
     if (backgroundRepeatX == NoRepeatFill) {
         LayoutUnit xOffset = fillLayer.backgroundXOrigin() == RightEdge ? availableWidth - computedXPosition : computedXPosition;
         setNoRepeatX(left + xOffset);
         setSpaceSize(LayoutSize(LayoutUnit(), spaceSize().height()));
     }
 
     if (backgroundRepeatY == RepeatFill) {
         LayoutUnit yOffset = fillLayer.backgroundYOrigin() == BottomEdge ? availableHeight - computedYPosition : computedYPosition;
         setPhaseY(tileSize().height() ? LayoutUnit(tileSize().height() - fmodf((yOffset + top), tileSize().height()))
             : LayoutUnit());
         setSpaceSize(LayoutSize(spaceSize().width(), LayoutUnit()));
     } else if (backgroundRepeatY == SpaceFill && fillTileSize.height() > LayoutUnit()) {
         LayoutUnit space = getSpaceBetweenImageTiles(positioningAreaSize.height(), tileSize().height());
         LayoutUnit actualHeight = tileSize().height() + space;
 
         if (space >= LayoutUnit()) {
             computedYPosition = roundedMinimumValueForLength(Length(), availableHeight);
-            setSpaceSize(LayoutSize(spaceSize().width(), space));
+            setSpaceSize(LayoutSize(spaceSize().width(), space.round()));
             setPhaseY(actualHeight ? LayoutUnit(actualHeight - fmodf((computedYPosition + top), actualHeight)) : LayoutUnit());
         } else {
             backgroundRepeatY = NoRepeatFill;
         }
     }
     if (backgroundRepeatY == NoRepeatFill) {
         LayoutUnit yOffset = fillLayer.backgroundYOrigin() == BottomEdge ? availableHeight - computedYPosition : computedYPosition;
         setNoRepeatY(top + yOffset);
         setSpaceSize(LayoutSize(spaceSize().width(), LayoutUnit()));
     }
 
     if (fixedAttachment)
         useFixedAttachment(paintRect.location());
 
-    clip(paintRect);
-    pixelSnapGeometry();
+    // Clip the final output rect to the paint rect
+    m_destRect.intersect(paintRect);
+
+    // Snap as-yet unsnapped values.
+    setPhase(LayoutPoint(roundedIntPoint(m_phase)));
+    setDestRect(LayoutRect(pixelSnappedIntRect(m_destRect)));
+
 }
 
 } // namespace blink