Calculate Background Image Geometries using sub-pixel values

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 "config.h"
 #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"
 #include "core/layout/compositing/CompositedLayerMapping.h"
 #include "core/paint/PaintLayer.h"
 #include "platform/LayoutUnit.h"
 #include "platform/geometry/LayoutRect.h"
 
 namespace blink {
 
 namespace {
 
-inline void applySubPixelHeuristicForTileSize(LayoutSize& tileSize, const IntSize& positioningAreaSize)
-{
-    tileSize.setWidth(positioningAreaSize.width() - tileSize.width() <= 1 ? tileSize.width().ceil() : tileSize.width().floor());
-    tileSize.setHeight(positioningAreaSize.height() - tileSize.height() <= 1 ? tileSize.height().ceil() : tileSize.height().floor());
-}
-
 // Return the amount of space to leave between image tiles for the background-repeat: space property.
-inline int getSpaceBetweenImageTiles(int areaSize, int tileSize)
+inline LayoutUnit getSpaceBetweenImageTiles(LayoutUnit areaSize, LayoutUnit tileSize)
 {
     int numberOfTiles = areaSize / tileSize;
-    int space = -1;
+    LayoutUnit space = -1;
 
     if (numberOfTiles > 1) {
         // Spec doesn't specify rounding, so use the same method as for background-repeat: round.
-        space = lroundf((areaSize - numberOfTiles * tileSize) / (float)(numberOfTiles - 1));
+        space = (areaSize - numberOfTiles * tileSize) / (numberOfTiles - 1);
     }
 
     return space;
 }
 
 bool fixedBackgroundPaintsInLocalCoordinates(const LayoutObject& obj, const GlobalPaintFlags globalPaintFlags)
 {
     if (!obj.isLayoutView())
         return false;
 
     const LayoutView& view = toLayoutView(obj);
 
     if (globalPaintFlags & GlobalPaintFlattenCompositingLayers)
         return false;
 
     PaintLayer* rootLayer = view.layer();
     if (!rootLayer || rootLayer->compositingState() == NotComposited)
         return false;
 
     return rootLayer->compositedLayerMapping()->backgroundLayerPaintsFixedRootBackground();
 }
 
-IntSize calculateFillTileSize(const LayoutBoxModelObject& obj, const FillLayer& fillLayer, const IntSize& positioningAreaSize)
+LayoutSize calculateFillTileSize(const LayoutBoxModelObject& obj, const FillLayer& fillLayer, const LayoutSize& positioningAreaSize)
 {
     StyleImage* image = fillLayer.image();
     EFillSizeType type = fillLayer.size().type;
 
-    IntSize imageIntrinsicSize = obj.calculateImageIntrinsicDimensions(image, positioningAreaSize, LayoutBoxModelObject::ScaleByEffectiveZoom);
+    LayoutSize imageIntrinsicSize = obj.calculateImageIntrinsicDimensions(image, positioningAreaSize, LayoutBoxModelObject::ScaleByEffectiveZoom);
     imageIntrinsicSize.scale(1 / image->imageScaleFactor(), 1 / image->imageScaleFactor());
     switch (type) {
     case SizeLength: {
         LayoutSize tileSize(positioningAreaSize);
 
         Length layerWidth = fillLayer.size().size.width();
         Length layerHeight = fillLayer.size().size.height();
 
         if (layerWidth.isFixed())
             tileSize.setWidth(layerWidth.value());
         else if (layerWidth.hasPercent())
             tileSize.setWidth(valueForLength(layerWidth, positioningAreaSize.width()));
 
         if (layerHeight.isFixed())
             tileSize.setHeight(layerHeight.value());
         else if (layerHeight.hasPercent())
             tileSize.setHeight(valueForLength(layerHeight, positioningAreaSize.height()));
 
-        applySubPixelHeuristicForTileSize(tileSize, positioningAreaSize);
-
         // If one of the values is auto we have to use the appropriate
         // scale to maintain our aspect ratio.
         if (layerWidth.isAuto() && !layerHeight.isAuto()) {
             if (imageIntrinsicSize.height()) {
                 LayoutUnit adjustedWidth = imageIntrinsicSize.width() * tileSize.height() / imageIntrinsicSize.height();
                 if (imageIntrinsicSize.width() >= 1 && adjustedWidth < 1)
                     adjustedWidth = 1;
                 tileSize.setWidth(adjustedWidth);
             }
         } else if (!layerWidth.isAuto() && layerHeight.isAuto()) {
             if (imageIntrinsicSize.width()) {
                 LayoutUnit adjustedHeight = imageIntrinsicSize.height() * tileSize.width() / imageIntrinsicSize.width();
                 if (imageIntrinsicSize.height() >= 1 && adjustedHeight < 1)
                     adjustedHeight = 1;
                 tileSize.setHeight(adjustedHeight);
             }
         } else if (layerWidth.isAuto() && layerHeight.isAuto()) {
             // If both width and height are auto, use the image's intrinsic size.
-            tileSize = LayoutSize(imageIntrinsicSize);
+            tileSize = imageIntrinsicSize;
         }
 
         tileSize.clampNegativeToZero();
-        return flooredIntSize(tileSize);
+        return tileSize;
     }
     case SizeNone: {
         // If both values are 'auto' then the intrinsic width and/or height of the image should be used, if any.
         if (!imageIntrinsicSize.isEmpty())
             return imageIntrinsicSize;
 
         // If the image has neither an intrinsic width nor an intrinsic height, its size is determined as for 'contain'.
         type = Contain;
     }
     case Contain:
     case Cover: {
         float horizontalScaleFactor = imageIntrinsicSize.width()
-            ? static_cast<float>(positioningAreaSize.width()) / imageIntrinsicSize.width() : 1;
+            ? positioningAreaSize.width().toFloat() / imageIntrinsicSize.width() : 1;
         float verticalScaleFactor = imageIntrinsicSize.height()
-            ? static_cast<float>(positioningAreaSize.height()) / imageIntrinsicSize.height() : 1;
+            ? positioningAreaSize.height().toFloat() / imageIntrinsicSize.height() : 1;
         float scaleFactor = type == Contain ? std::min(horizontalScaleFactor, verticalScaleFactor) : std::max(horizontalScaleFactor, verticalScaleFactor);
-        return IntSize(std::max(1l, lround(imageIntrinsicSize.width() * scaleFactor)), std::max(1l, lround(imageIntrinsicSize.height() * scaleFactor)));
+        return LayoutSize(std::max<LayoutUnit>(1, imageIntrinsicSize.width() * scaleFactor), std::max<LayoutUnit>(1, imageIntrinsicSize.height() * scaleFactor));
     }
     }
 
     ASSERT_NOT_REACHED();
-    return IntSize();
+    return LayoutSize();
 }
 
 IntPoint accumulatedScrollOffset(const LayoutBoxModelObject& object, const LayoutBoxModelObject* container)
 {
     const LayoutBlock* block = object.isLayoutBlock() ? toLayoutBlock(&object) : object.containingBlock();
     IntPoint result;
     while (block) {
         if (block->hasOverflowClip())
             result += block->scrolledContentOffset();
         if (block == container)
             break;
         block = block->containingBlock();
     }
     return result;
 }
 
 } // anonymous namespace
 
-void BackgroundImageGeometry::setNoRepeatX(int xOffset)
+void BackgroundImageGeometry::setNoRepeatX(LayoutUnit xOffset)
 {
-    m_destRect.move(std::max(xOffset, 0), 0);
-    m_phase.setX(-std::min(xOffset, 0));
-    m_destRect.setWidth(m_tileSize.width() + std::min(xOffset, 0));
+    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()));
 }
 
-void BackgroundImageGeometry::setNoRepeatY(int yOffset)
+void BackgroundImageGeometry::setNoRepeatY(LayoutUnit yOffset)
 {
-    m_destRect.move(0, std::max(yOffset, 0));
-    m_phase.setY(-std::min(yOffset, 0));
-    m_destRect.setHeight(m_tileSize.height() + std::min(yOffset, 0));
+    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()));
 }
 
-void BackgroundImageGeometry::useFixedAttachment(const IntPoint& attachmentPoint)
+void BackgroundImageGeometry::useFixedAttachment(const LayoutPoint& attachmentPoint)
 {
-    IntPoint alignedPoint = attachmentPoint;
-    m_phase.move(std::max(alignedPoint.x() - m_destRect.x(), 0), std::max(alignedPoint.y() - m_destRect.y(), 0));
+    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 IntRect& clipRect)
+void BackgroundImageGeometry::clip(const LayoutRect& clipRect)
 {
     m_destRect.intersect(clipRect);
 }
 
+// When we match the destination rect in a dimension, we snap the same way. 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.
+static LayoutSize applySubPixelHeuristicToImageSize(const LayoutSize& size, const LayoutRect& destination)
+{
+    LayoutSize snappedSize = LayoutSize(
+        size.width() == destination.width() ? destination.pixelSnappedWidth() : size.width().floor(),
+        size.height() == destination.height() ? destination.pixelSnappedHeight() : size.height().floor());
+    return snappedSize;
+}
+
+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 = 0;
-    LayoutUnit top = 0;
-    IntSize positioningAreaSize;
-    IntRect snappedPaintRect = pixelSnappedIntRect(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.
         Element* documentElement = obj.document().documentElement();
         ASSERT(documentElement);
         ASSERT(documentElement->layoutObject());
         ASSERT(documentElement->layoutObject()->isBox());
         rootBox = toLayoutBox(documentElement->layoutObject());
     }
     const LayoutBoxModelObject& positioningBox = isLayoutView ? static_cast<const LayoutBoxModelObject&>(*rootBox) : obj;
 
     // Determine the background positioning area and set destRect to the background painting area.
     // destRect will be adjusted later if the background is non-repeating.
     // FIXME: transforms spec says that fixed backgrounds behave like scroll inside transforms.
     bool fixedAttachment = fillLayer.attachment() == FixedBackgroundAttachment;
 
     if (RuntimeEnabledFeatures::fastMobileScrollingEnabled()) {
         // As a side effect of an optimization to blit on scroll, we do not honor the CSS
         // property "background-attachment: fixed" because it may result in rendering
         // artifacts. Note, these artifacts only appear if we are blitting on scroll of
         // a page that has fixed background images.
         fixedAttachment = false;
     }
 
     if (!fixedAttachment) {
-        setDestRect(snappedPaintRect);
+        setDestRect(paintRect);
 
-        LayoutUnit right = 0;
-        LayoutUnit bottom = 0;
+        LayoutUnit right;
+        LayoutUnit bottom;
         // Scroll and Local.
         if (fillLayer.origin() != BorderFillBox) {
             left = positioningBox.borderLeft();
             right = positioningBox.borderRight();
             top = positioningBox.borderTop();
             bottom = positioningBox.borderBottom();
             if (fillLayer.origin() == ContentFillBox) {
                 left += positioningBox.paddingLeft();
                 right += positioningBox.paddingRight();
                 top += positioningBox.paddingTop();
                 bottom += positioningBox.paddingBottom();
             }
         }
 
         if (isLayoutView) {
             // The background of the box generated by the root element covers the entire canvas and will
             // be painted by the view object, but the we should still use the root element box for
             // positioning.
-            positioningAreaSize = pixelSnappedIntSize(rootBox->size() - LayoutSize(left + right, top + bottom), rootBox->location());
+            positioningAreaSize = rootBox->size() - LayoutSize(left + right, top + bottom), rootBox->location();
             // The input paint rect is specified in root element local coordinate (i.e. a transform
             // is applied on the context for painting), and is expanded to cover the whole canvas.
             // Since left/top is relative to the paint rect, we need to offset them back.
             left -= paintRect.x();
             top -= paintRect.y();
         } else {
-            positioningAreaSize = pixelSnappedIntSize(paintRect.size() - LayoutSize(left + right, top + bottom), paintRect.location());
+            positioningAreaSize = paintRect.size() - LayoutSize(left + right, top + bottom);
         }
     } else {
         setHasNonLocalGeometry();
 
-        IntRect viewportRect = pixelSnappedIntRect(obj.viewRect());
+        LayoutRect viewportRect = obj.viewRect();
         if (fixedBackgroundPaintsInLocalCoordinates(obj, globalPaintFlags)) {
-            viewportRect.setLocation(IntPoint());
+            viewportRect.setLocation(LayoutPoint());
         } else {
             if (FrameView* frameView = obj.view()->frameView())
                 viewportRect.setLocation(frameView->scrollPosition());
             // Compensate the translations created by ScrollRecorders.
             // TODO(trchen): Fix this for SP phase 2. crbug.com/529963.
             viewportRect.moveBy(accumulatedScrollOffset(obj, paintContainer));
         }
 
-        if (paintContainer) {
-            IntPoint absoluteContainerOffset = roundedIntPoint(paintContainer->localToAbsolute(FloatPoint()));
-            viewportRect.moveBy(-absoluteContainerOffset);
-        }
+        if (paintContainer)
+            viewportRect.moveBy(LayoutPoint(-paintContainer->localToAbsolute(FloatPoint())));
 
         setDestRect(viewportRect);
         positioningAreaSize = destRect().size();
     }
 
-    IntSize fillTileSize = calculateFillTileSize(positioningBox, fillLayer, positioningAreaSize);
+    LayoutSize fillTileSize = calculateFillTileSize(positioningBox, fillLayer, positioningAreaSize);
     setTileSize(fillTileSize);
     setImageContainerSize(fillTileSize);
 
     EFillRepeat backgroundRepeatX = fillLayer.repeatX();
     EFillRepeat backgroundRepeatY = fillLayer.repeatY();
-    int availableWidth = positioningAreaSize.width() - tileSize().width();
-    int availableHeight = positioningAreaSize.height() - tileSize().height();
+    LayoutUnit availableWidth = positioningAreaSize.width() - tileSize().width();
+    LayoutUnit availableHeight = positioningAreaSize.height() - tileSize().height();
 
     LayoutUnit computedXPosition = roundedMinimumValueForLength(fillLayer.xPosition(), availableWidth);
-    if (backgroundRepeatX == RoundFill && positioningAreaSize.width() > 0 && fillTileSize.width() > 0) {
-        long nrTiles = std::max(1l, lroundf((float)positioningAreaSize.width() / fillTileSize.width()));
+    if (backgroundRepeatX == RoundFill && positioningAreaSize.width() > LayoutUnit() && fillTileSize.width() > LayoutUnit()) {
+        int nrTiles = std::max(1, roundToInt(positioningAreaSize.width() / fillTileSize.width()));
 
-        // Round tile size per css3-background spec.
-        fillTileSize.setWidth(lroundf(positioningAreaSize.width() / (float)nrTiles));
+        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(fillTileSize);
-        setPhaseX(tileSize().width() ? tileSize().width() - roundToInt(computedXPosition + left) % tileSize().width() : 0);
-        setSpaceSize(IntSize());
+        setImageContainerSize(fillTileSize);
+        setPhaseX(tileSize().width() ? tileSize().width() - fmodf((computedXPosition + left), tileSize().width()) : 0.0f);
+        setSpaceSize(LayoutSize());
     }
 
     LayoutUnit computedYPosition = roundedMinimumValueForLength(fillLayer.yPosition(), availableHeight);
-    if (backgroundRepeatY == RoundFill && positioningAreaSize.height() > 0 && fillTileSize.height() > 0) {
-        long nrTiles = std::max(1l, lroundf((float)positioningAreaSize.height() / fillTileSize.height()));
+    if (backgroundRepeatY == RoundFill && positioningAreaSize.height() > LayoutUnit() && fillTileSize.height() > LayoutUnit()) {
+        int nrTiles = std::max(1, roundToInt(positioningAreaSize.height() / fillTileSize.height()));
 
-        // Round tile size per css3-background spec.
-        fillTileSize.setHeight(lroundf(positioningAreaSize.height() / (float)nrTiles));
+        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(fillTileSize);
-        setPhaseY(tileSize().height() ? tileSize().height() - roundToInt(computedYPosition + top) % tileSize().height() : 0);
-        setSpaceSize(IntSize());
+        setImageContainerSize(fillTileSize);
+        setPhaseY(tileSize().height() ? tileSize().height() - fmodf((computedYPosition + top), tileSize().height()) : 0.0f);
+        setSpaceSize(LayoutSize());
     }
 
     if (backgroundRepeatX == RepeatFill) {
         LayoutUnit xOffset = fillLayer.backgroundXOrigin() == RightEdge ? availableWidth - computedXPosition : computedXPosition;
-        setPhaseX(tileSize().width() ? tileSize().width() - roundToInt(xOffset + left) % tileSize().width() : 0);
-        setSpaceSize(IntSize());
-    } else if (backgroundRepeatX == SpaceFill && fillTileSize.width() > 0) {
-        int space = getSpaceBetweenImageTiles(positioningAreaSize.width(), tileSize().width());
-        int actualWidth = tileSize().width() + space;
+        setPhaseX(tileSize().width() ? tileSize().width() - fmodf((xOffset + left), tileSize().width()) : 0.0f);
+        setSpaceSize(LayoutSize());
+    } else if (backgroundRepeatX == SpaceFill && fillTileSize.width() > LayoutUnit()) {
+        LayoutUnit space = getSpaceBetweenImageTiles(positioningAreaSize.width(), tileSize().width());
+        LayoutUnit actualWidth = tileSize().width() + space;
 
-        if (space >= 0) {
+        if (space >= LayoutUnit()) {
             computedXPosition = roundedMinimumValueForLength(Length(), availableWidth);
-            setSpaceSize(IntSize(space, 0));
-            setPhaseX(actualWidth ? actualWidth - roundToInt(computedXPosition + left) % actualWidth : 0);
+            setSpaceSize(LayoutSize(space, LayoutUnit()));
+            setPhaseX(actualWidth ? actualWidth - fmodf((computedXPosition + left), actualWidth) : 0.0f);
         } else {
             backgroundRepeatX = NoRepeatFill;
         }
     }
     if (backgroundRepeatX == NoRepeatFill) {
         LayoutUnit xOffset = fillLayer.backgroundXOrigin() == RightEdge ? availableWidth - computedXPosition : computedXPosition;
         setNoRepeatX(left + xOffset);
-        setSpaceSize(IntSize(0, spaceSize().height()));
+        setSpaceSize(LayoutSize(LayoutUnit(), spaceSize().height()));
     }
 
     if (backgroundRepeatY == RepeatFill) {
         LayoutUnit yOffset = fillLayer.backgroundYOrigin() == BottomEdge ? availableHeight - computedYPosition : computedYPosition;
-        setPhaseY(tileSize().height() ? tileSize().height() - roundToInt(yOffset + top) % tileSize().height() : 0);
-        setSpaceSize(IntSize(spaceSize().width(), 0));
-    } else if (backgroundRepeatY == SpaceFill && fillTileSize.height() > 0) {
-        int space = getSpaceBetweenImageTiles(positioningAreaSize.height(), tileSize().height());
-        int actualHeight = tileSize().height() + space;
+        setPhaseY(tileSize().height() ? tileSize().height() - fmodf((yOffset + top), tileSize().height()) : 0.0f);
+        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 >= 0) {
+        if (space >= LayoutUnit()) {
             computedYPosition = roundedMinimumValueForLength(Length(), availableHeight);
-            setSpaceSize(IntSize(spaceSize().width(), space));
-            setPhaseY(actualHeight ? actualHeight - roundToInt(computedYPosition + top) % actualHeight : 0);
+            setSpaceSize(LayoutSize(spaceSize().width(), space));
+            setPhaseY(actualHeight ? actualHeight - fmodf((computedYPosition + top), actualHeight) : 0.0f);
         } else {
             backgroundRepeatY = NoRepeatFill;
         }
     }
     if (backgroundRepeatY == NoRepeatFill) {
         LayoutUnit yOffset = fillLayer.backgroundYOrigin() == BottomEdge ? availableHeight - computedYPosition : computedYPosition;
         setNoRepeatY(top + yOffset);
-        setSpaceSize(IntSize(spaceSize().width(), 0));
+        setSpaceSize(LayoutSize(spaceSize().width(), LayoutUnit()));
     }
 
     if (fixedAttachment)
-        useFixedAttachment(snappedPaintRect.location());
+        useFixedAttachment(paintRect.location());
 
-    clip(snappedPaintRect);
+    clip(paintRect);
+    pixelSnapGeometry();
 }
 
 } // namespace blink