Force all LayoutUnit construction to be explicit

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"
 #include "core/layout/compositing/CompositedLayerMapping.h"
 #include "core/paint/PaintLayer.h"
 #include "platform/LayoutUnit.h"
 #include "platform/geometry/LayoutRect.h"
 
 namespace blink {
 
 namespace {
 
 // Return the amount of space to leave between image tiles for the background-repeat: space property.
 inline LayoutUnit getSpaceBetweenImageTiles(LayoutUnit areaSize, LayoutUnit tileSize)
 {
     int numberOfTiles = areaSize / tileSize;
-    LayoutUnit space = -1;
+    LayoutUnit space(-1);
 
     if (numberOfTiles > 1) {
         // Spec doesn't specify rounding, so use the same method as for background-repeat: round.
         space = (areaSize - numberOfTiles * tileSize) / (numberOfTiles - 1);
     }
 
     return space;
 }
 
 bool fixedBackgroundPaintsInLocalCoordinates(const LayoutObject& obj, const GlobalPaintFlags globalPaintFlags)
@@ skipping 21 matching lines @@
     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());
+            tileSize.setWidth(LayoutUnit(layerWidth.value()));
         else if (layerWidth.hasPercent())
             tileSize.setWidth(valueForLength(layerWidth, positioningAreaSize.width()));
 
         if (layerHeight.isFixed())
-            tileSize.setHeight(layerHeight.value());
+            tileSize.setHeight(LayoutUnit(layerHeight.value()));
         else if (layerHeight.hasPercent())
             tileSize.setHeight(valueForLength(layerHeight, positioningAreaSize.height()));
 
         // 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;
+                    adjustedWidth = LayoutUnit(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;
+                    adjustedHeight = LayoutUnit(1);
                 tileSize.setHeight(adjustedHeight);
             }
         } else if (layerWidth.isAuto() && layerHeight.isAuto()) {
             // If both width and height are auto, use the image's intrinsic size.
             tileSize = imageIntrinsicSize;
         }
 
         tileSize.clampNegativeToZero();
         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()
-            ? positioningAreaSize.width().toFloat() / imageIntrinsicSize.width() : 1;
+            ? positioningAreaSize.width().toFloat() / imageIntrinsicSize.width() : 1.0f;
         float verticalScaleFactor = imageIntrinsicSize.height()
-            ? positioningAreaSize.height().toFloat() / imageIntrinsicSize.height() : 1;
+            ? positioningAreaSize.height().toFloat() / imageIntrinsicSize.height() : 1.0f;
         float scaleFactor = type == Contain ? std::min(horizontalScaleFactor, verticalScaleFactor) : std::max(horizontalScaleFactor, verticalScaleFactor);
-        return LayoutSize(std::max<LayoutUnit>(1, imageIntrinsicSize.width() * scaleFactor), std::max<LayoutUnit>(1, imageIntrinsicSize.height() * scaleFactor));
+        return LayoutSize(std::max(1.0f, imageIntrinsicSize.width() * scaleFactor),
+            std::max(1.0f, imageIntrinsicSize.height() * scaleFactor));
     }
     }
 
     ASSERT_NOT_REACHED();
     return LayoutSize();
 }
 
 IntPoint accumulatedScrollOffsetForFixedBackground(const LayoutBoxModelObject& object, const LayoutBoxModelObject* container)
 {
     IntPoint result;
@@ skipping 89 matching lines @@
         fixedAttachment = false;
     }
 
     if (!fixedAttachment) {
         setDestRect(paintRect);
 
         LayoutUnit right;
         LayoutUnit bottom;
         // Scroll and Local.
         if (fillLayer.origin() != BorderFillBox) {
-            left = positioningBox.borderLeft();
-            right = positioningBox.borderRight();
-            top = positioningBox.borderTop();
-            bottom = positioningBox.borderBottom();
+            left = LayoutUnit(positioningBox.borderLeft());
+            right = LayoutUnit(positioningBox.borderRight());
+            top = LayoutUnit(positioningBox.borderTop());
+            bottom = LayoutUnit(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
@@ skipping 48 matching lines @@
 
         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);
         setImageContainerSize(fillTileSize);
-        setPhaseX(tileSize().width() ? tileSize().width() - fmodf((computedXPosition + left), tileSize().width()) : 0.0f);
+        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()));
         }
 
         setTileSize(fillTileSize);
         setImageContainerSize(fillTileSize);
-        setPhaseY(tileSize().height() ? tileSize().height() - fmodf((computedYPosition + top), tileSize().height()) : 0.0f);
+        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() ? tileSize().width() - fmodf((xOffset + left), tileSize().width()) : 0.0f);
+        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()));
-            setPhaseX(actualWidth ? actualWidth - fmodf((computedXPosition + left), actualWidth) : 0.0f);
+            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() ? tileSize().height() - fmodf((yOffset + top), tileSize().height()) : 0.0f);
+        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));
-            setPhaseY(actualHeight ? actualHeight - fmodf((computedYPosition + top), actualHeight) : 0.0f);
+            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();
 }
 
 } // namespace blink