Transition to explicit constructors in LayoutUnit

third_party/WebKit/Source/platform/LayoutUnit.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 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef LayoutUnit_h
 #define LayoutUnit_h
 
 #include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
 #include "wtf/MathExtras.h"
 #include "wtf/SaturatedArithmetic.h"
+#include <algorithm>
 #include <limits.h>
 #include <limits>
 #include <stdlib.h>
 
 namespace blink {
 
 #if !ERROR_DISABLED
 
 #define REPORT_OVERFLOW(doesOverflow) ((void)0)
 
@@ skipping 10 matching lines @@
 static const int kLayoutUnitFractionalBits = 6;
 static const int kFixedPointDenominator = 1 << kLayoutUnitFractionalBits;
 
 const int intMaxForLayoutUnit = INT_MAX / kFixedPointDenominator;
 const int intMinForLayoutUnit = INT_MIN / kFixedPointDenominator;
 
 class LayoutUnit {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 public:
     LayoutUnit() : m_value(0) { }
+    // TODO(leviw): All of the below constructors should be explicit. crbug.com/581254
     LayoutUnit(int value) { setValue(value); }
     LayoutUnit(unsigned short value) { setValue(value); }
     LayoutUnit(unsigned value) { setValue(value); }
     LayoutUnit(unsigned long value) { m_value = clampTo<int>(value * kFixedPointDenominator); }
     LayoutUnit(unsigned long long value) { m_value = clampTo<int>(value * kFixedPointDenominator); }
     LayoutUnit(float value) { m_value = clampTo<int>(value * kFixedPointDenominator); }
     LayoutUnit(double value) { m_value = clampTo<int>(value * kFixedPointDenominator); }
 
     static LayoutUnit fromFloatCeil(float value)
     {
@@ skipping 71 matching lines @@
     }
 
     int floor() const
     {
         if (UNLIKELY(m_value <= INT_MIN + kFixedPointDenominator - 1))
             return intMinForLayoutUnit;
 
         return m_value >> kLayoutUnitFractionalBits;
     }
 
+    LayoutUnit clampToZero() const
+    {
+        return std::max(*this, LayoutUnit());
+    }
+
     LayoutUnit fraction() const
     {
         // Add the fraction to the size (as opposed to the full location) to avoid overflows.
         // Compute fraction using the mod operator to preserve the sign of the value as it may affect rounding.
         LayoutUnit fraction;
         fraction.setRawValue(rawValue() % kFixedPointDenominator);
         return fraction;
     }
 
     bool mightBeSaturated() const
@@ skipping 502 matching lines @@
 }
 
 inline LayoutUnit& operator+=(LayoutUnit& a, const LayoutUnit& b)
 {
     a.setRawValue(saturatedAddition(a.rawValue(), b.rawValue()));
     return a;
 }
 
 inline LayoutUnit& operator+=(LayoutUnit& a, int b)
 {
-    a = a + b;
+    a = a + LayoutUnit(b);
     return a;
 }
 
 inline LayoutUnit& operator+=(LayoutUnit& a, float b)
 {
-    a = a + b;
+    a = LayoutUnit(a + b);
     return a;
 }
 
 inline float& operator+=(float& a, const LayoutUnit& b)
 {
     a = a + b;
     return a;
 }
 
 inline LayoutUnit& operator-=(LayoutUnit& a, int b)
 {
-    a = a - b;
+    a = a - LayoutUnit(b);
     return a;
 }
 
 inline LayoutUnit& operator-=(LayoutUnit& a, const LayoutUnit& b)
 {
     a.setRawValue(saturatedSubtraction(a.rawValue(), b.rawValue()));
     return a;
 }
 
 inline LayoutUnit& operator-=(LayoutUnit& a, float b)
 {
-    a = a - b;
+    a = LayoutUnit(a - b);
     return a;
 }
 
 inline float& operator-=(float& a, const LayoutUnit& b)
 {
     a = a - b;
     return a;
 }
 
 inline LayoutUnit& operator*=(LayoutUnit& a, const LayoutUnit& b)
 {
     a = a * b;
     return a;
 }
-// operator*=(LayoutUnit& a, int b) is supported by the operator above plus LayoutUnit(int).
-
-inline LayoutUnit& operator*=(LayoutUnit& a, float b)
-{
-    a = a * b;
-    return a;
-}
 
+inline LayoutUnit& operator*=(LayoutUnit& a, float b)
+{
+    a = LayoutUnit(a * b);
+    return a;
+}
+
 inline float& operator*=(float& a, const LayoutUnit& b)
 {
     a = a * b;
     return a;
 }
 
 inline LayoutUnit& operator/=(LayoutUnit& a, const LayoutUnit& b)
 {
     a = a / b;
     return a;
 }
-// operator/=(LayoutUnit& a, int b) is supported by the operator above plus LayoutUnit(int).
-
-inline LayoutUnit& operator/=(LayoutUnit& a, float b)
-{
-    a = a / b;
-    return a;
-}
 
+inline LayoutUnit& operator/=(LayoutUnit& a, float b)
+{
+    a = LayoutUnit(a / b);
+    return a;
+}
+
 inline float& operator/=(float& a, const LayoutUnit& b)
 {
     a = a / b;
     return a;
 }
 
 inline int snapSizeToPixel(LayoutUnit size, LayoutUnit location)
 {
     LayoutUnit fraction = location.fraction();
     return (fraction + size).round() - fraction.round();
@@ skipping 29 matching lines @@
     if (value >= max)
         return max;
     if (value <= min)
         return min;
     return value;
 }
 
 } // namespace blink
 
 #endif // LayoutUnit_h