Disallow cast/implicit conversion from LayoutUnit to int/unsigned

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;
+    int numberOfTiles = (areaSize / tileSize).toInt();
     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;
 }
 
@@ skipping 120 matching lines @@
         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)
 {
     int roundedOffset = roundToInt(xOffset);
-    m_destRect.move(std::max(roundedOffset, 0), LayoutUnit());
+    m_destRect.move(std::max(roundedOffset, 0), 0);
     setPhaseX(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)
 {
     int roundedOffset = roundToInt(yOffset);
-    m_destRect.move(LayoutUnit(), std::max(roundedOffset, 0));
+    m_destRect.move(0, std::max(roundedOffset, 0));
     setPhaseY(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,
@@ skipping 40 matching lines @@
         }
     } 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()));
+    setSpaceSize(LayoutSize(space.round(), spaceSize().height().toInt()));
     LayoutUnit actualWidth = tileSize().width() + space;
     setPhaseX(actualWidth ? LayoutUnit(roundf(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()));
+    setSpaceSize(LayoutSize(spaceSize().width().toInt(), space.round()));
     LayoutUnit actualHeight = tileSize().height() + space;
     setPhaseY(actualHeight ? LayoutUnit(roundf(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()));
     setPhase(LayoutPoint(roundedIntPoint(m_phase)));
 }
@@ skipping 162 matching lines @@
         useFixedAttachment(paintRect.location());
 
     // Clip the final output rect to the paint rect
     m_destRect.intersect(paintRect);
 
     // Snap as-yet unsnapped values.
     setDestRect(LayoutRect(pixelSnappedIntRect(m_destRect)));
 }
 
 } // namespace blink