Force all LayoutUnit construction to be explicit

third_party/WebKit/Source/platform/geometry/LayoutRect.h

 /*
  * Copyright (c) 2012, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 34 matching lines @@
 class DoubleRect;
 
 class PLATFORM_EXPORT LayoutRect {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 public:
     LayoutRect() { }
     LayoutRect(const LayoutPoint& location, const LayoutSize& size)
         : m_location(location), m_size(size) { }
     LayoutRect(LayoutUnit x, LayoutUnit y, LayoutUnit width, LayoutUnit height)
         : m_location(LayoutPoint(x, y)), m_size(LayoutSize(width, height)) { }
+    LayoutRect(int x, int y, int width, int height)
+        : m_location(LayoutPoint(x, y)), m_size(LayoutSize(width, height)) { }
     LayoutRect(const FloatPoint& location, const FloatSize& size)
         : m_location(location), m_size(size) { }
     LayoutRect(const DoublePoint& location, const DoubleSize& size)
         : m_location(location), m_size(size) { }
     LayoutRect(const IntPoint& location, const IntSize& size)
         : m_location(location), m_size(size) { }
     explicit LayoutRect(const IntRect& rect) : m_location(rect.location()), m_size(rect.size()) { }
 
     explicit LayoutRect(const FloatRect&); // don't do this implicitly since it's lossy
     explicit LayoutRect(const DoubleRect&); // don't do this implicitly since it's lossy
@@ skipping 26 matching lines @@
 
     // NOTE: The result is rounded to integer values, and thus may be not the exact
     // center point.
     LayoutPoint center() const { return LayoutPoint(x() + width() / 2, y() + height() / 2); }
 
     void move(const LayoutSize& size) { m_location += size; }
     void move(const IntSize& size) { m_location.move(LayoutUnit(size.width()), LayoutUnit(size.height())); }
     void moveBy(const LayoutPoint& offset) { m_location.move(offset.x(), offset.y()); }
     void moveBy(const IntPoint& offset) { m_location.move(LayoutUnit(offset.x()), LayoutUnit(offset.y())); }
     void move(LayoutUnit dx, LayoutUnit dy) { m_location.move(dx, dy); }
+    void move(int dx, int dy) { m_location.move(LayoutUnit(dx), LayoutUnit(dy)); }
 
     void expand(const LayoutSize& size) { m_size += size; }
     void expand(const LayoutRectOutsets& box)
     {
         m_location.move(-box.left(), -box.top());
         m_size.expand(box.left() + box.right(), box.top() + box.bottom());
     }
     void expand(LayoutUnit dw, LayoutUnit dh) { m_size.expand(dw, dh); }
     void expandEdges(LayoutUnit top, LayoutUnit right, LayoutUnit bottom, LayoutUnit left)
     {
         m_location.move(-left, -top);
         m_size.expand(left + right, top + bottom);
     }
     void contract(const LayoutSize& size) { m_size -= size; }
     void contract(LayoutUnit dw, LayoutUnit dh) { m_size.expand(-dw, -dh); }
+    void contract(int dw, int dh) { m_size.expand(-dw, -dh); }
     void contractEdges(LayoutUnit top, LayoutUnit right, LayoutUnit bottom, LayoutUnit left)
     {
         m_location.move(left, top);
         m_size.shrink(left + right, top + bottom);
     }
 
     void shiftXEdgeTo(LayoutUnit edge)
     {
         LayoutUnit delta = edge - x();
         setX(edge);
@@ skipping 42 matching lines @@
     {
         m_location.setX(m_location.x() - dx);
         m_size.setWidth(m_size.width() + dx + dx);
     }
     void inflateY(LayoutUnit dy)
     {
         m_location.setY(m_location.y() - dy);
         m_size.setHeight(m_size.height() + dy + dy);
     }
     void inflate(LayoutUnit d) { inflateX(d); inflateY(d); }
+    void inflate(int d) { inflate(LayoutUnit(d)); }
     void scale(float s);
     void scale(float xAxisScale, float yAxisScale);
 
     LayoutRect transposedRect() const { return LayoutRect(m_location.transposedPoint(), m_size.transposedSize()); }
 
     static IntRect infiniteIntRect()
     {
         // Due to saturated arithemetic this value is not the same as LayoutRect(IntRect(INT_MIN/2, INT_MIN/2, INT_MAX, INT_MAX)).
         static IntRect infiniteIntRect(LayoutRect(LayoutUnit::nearlyMin() / 2, LayoutUnit::nearlyMin() / 2, LayoutUnit::nearlyMax(), LayoutUnit::nearlyMax()));
         return infiniteIntRect;
@@ skipping 70 matching lines @@
     return IntRect(roundedIntPoint(location), pixelSnappedIntSize(size, location));
 }
 
 // Redeclared here to avoid ODR issues.
 // See platform/testing/GeometryPrinters.h.
 void PrintTo(const LayoutRect&, std::ostream*);
 
 } // namespace blink
 
 #endif // LayoutRect_h