Move NinePieceImageGrid to LayoutUnit

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

 // Copyright 2015 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/NinePieceImageGrid.h"
 
 #include "core/style/ComputedStyle.h"
 #include "core/style/NinePieceImage.h"
 #include "platform/LengthFunctions.h"
 #include "platform/geometry/FloatSize.h"
-#include "platform/geometry/IntSize.h"
 
 namespace blink {
 
 static LayoutUnit computeEdgeWidth(const BorderImageLength& borderSlice, int borderSide, const LayoutUnit& imageSide,
     const LayoutUnit& boxExtent)
 {
     if (borderSlice.isNumber())
         return borderSlice.number() * borderSide;
     if (borderSlice.length().isAuto())
         return imageSide;
     return valueForLength(borderSlice.length(), boxExtent);
 }
 
 static int computeEdgeSlice(const Length& slice, LayoutUnit maximum)
 {
     return std::min<int>(maximum, valueForLength(slice, maximum));
 }
 
-NinePieceImageGrid::NinePieceImageGrid(const NinePieceImage& ninePieceImage, IntSize imageSize, IntRect borderImageArea,
+NinePieceImageGrid::NinePieceImageGrid(const NinePieceImage& ninePieceImage, LayoutSize imageSize, LayoutRect borderImageArea,
     const IntRectOutsets& borderWidths)
     : m_borderImageArea(borderImageArea)
     , m_imageSize(imageSize)
     , m_horizontalTileRule((Image::TileRule)ninePieceImage.horizontalRule())
     , m_verticalTileRule((Image::TileRule)ninePieceImage.verticalRule())
     , m_fill(ninePieceImage.fill())
 {
     StyleImage* styleImage = ninePieceImage.image();
     ASSERT(styleImage);
 
@@ skipping 22 matching lines @@
     if (borderSideScaleFactor < 1) {
         m_top.width *= borderSideScaleFactor;
         m_right.width *= borderSideScaleFactor;
         m_bottom.width *= borderSideScaleFactor;
         m_left.width *= borderSideScaleFactor;
     }
 }
 
 // Given a rectangle, construct a subrectangle using offset, width and height. Negative offsets are relative to the
 // extent of the given rectangle.
-static FloatRect subrect(IntRect rect, float offsetX, float offsetY, float width, float height)
+static FloatRect subrect(LayoutRect rect, float offsetX, float offsetY, float width, float height)
 {
     float baseX = rect.x();
     if (offsetX < 0)
         baseX = rect.maxX();
 
     float baseY = rect.y();
     if (offsetY < 0)
         baseY = rect.maxY();
 
     return FloatRect(baseX + offsetX, baseY + offsetY, width, height);
 }
 
-static FloatRect subrect(IntSize size, float offsetX, float offsetY, float width, float height)
+// Given a size, construct a subrectangle using offset, width and height. Negative offsets are relative to the
+// extent of the given size.
+static FloatRect subrect(LayoutSize size, float offsetX, float offsetY, float width, float height)
 {
-    return subrect(IntRect(IntPoint(), size), offsetX, offsetY, width, height);
+    return subrect(LayoutRect(LayoutPoint(), size), offsetX, offsetY, width, height);
 }
 
 static inline void setCornerPiece(NinePieceImageGrid::NinePieceDrawInfo& drawInfo, bool isDrawable,
     const FloatRect& source, const FloatRect& destination)
 {
     drawInfo.isDrawable = isDrawable;
     if (drawInfo.isDrawable) {
         drawInfo.source = source;
         drawInfo.destination = destination;
     }
@@ skipping 49 matching lines @@
     if (drawInfo.isDrawable) {
         drawInfo.source = source;
         drawInfo.destination = destination;
         drawInfo.tileScale = FloatSize(edge.scale(), edge.scale());
         drawInfo.tileRule = { Image::StretchTile, tileRule };
     }
 }
 
 void NinePieceImageGrid::setDrawInfoEdge(NinePieceDrawInfo& drawInfo, NinePiece piece) const
 {
-    IntSize edgeSourceSize = m_imageSize - IntSize(m_left.slice + m_right.slice, m_top.slice + m_bottom.slice);
-    IntSize edgeDestinationSize = m_borderImageArea.size() - IntSize(m_left.width + m_right.width, m_top.width + m_bottom.width);
+    LayoutSize edgeSourceSize = m_imageSize - LayoutSize(m_left.slice + m_right.slice, m_top.slice + m_bottom.slice);
+    LayoutSize edgeDestinationSize = m_borderImageArea.size() - LayoutSize(m_left.width + m_right.width, m_top.width + m_bottom.width);
 
     switch (piece) {
     case LeftPiece:
         setVerticalEdge(drawInfo, m_left,
             subrect(m_imageSize, 0, m_top.slice, m_left.slice, edgeSourceSize.height()),
             subrect(m_borderImageArea, 0, m_top.width, m_left.width, edgeDestinationSize.height()),
             m_verticalTileRule);
         break;
     case RightPiece:
         setVerticalEdge(drawInfo, m_right,
@@ skipping 14 matching lines @@
             m_horizontalTileRule);
         break;
     default:
         ASSERT_NOT_REACHED();
         break;
     }
 }
 
 void NinePieceImageGrid::setDrawInfoMiddle(NinePieceDrawInfo& drawInfo) const
 {
-    IntSize sourceSize = m_imageSize - IntSize(m_left.slice + m_right.slice, m_top.slice + m_bottom.slice);
-    IntSize destinationSize =
-        m_borderImageArea.size() - IntSize(m_left.width + m_right.width, m_top.width + m_bottom.width);
+    LayoutSize sourceSize = m_imageSize - LayoutSize(m_left.slice + m_right.slice, m_top.slice + m_bottom.slice);
+    LayoutSize destinationSize =
+        m_borderImageArea.size() - LayoutSize(m_left.width + m_right.width, m_top.width + m_bottom.width);
 
     drawInfo.isDrawable = m_fill && !sourceSize.isEmpty() && !destinationSize.isEmpty();
     if (!drawInfo.isDrawable)
         return;
 
     drawInfo.source = subrect(m_imageSize, m_left.slice, m_top.slice, sourceSize.width(), sourceSize.height());
     drawInfo.destination = subrect(m_borderImageArea, m_left.width, m_top.width,
         destinationSize.width(), destinationSize.height());
 
     FloatSize middleScaleFactor(1, 1);
@@ skipping 33 matching lines @@
         setDrawInfoCorner(drawInfo, piece);
     else if (piece != MiddlePiece)
         setDrawInfoEdge(drawInfo, piece);
     else
         setDrawInfoMiddle(drawInfo);
 
     return drawInfo;
 }
 
 } // namespace blink