Attachment 361236 Details for Bug 194263 – Patch

[patch] Patch

bug-194263-20190205160640.patch (text/plain), 20.93 KB, created by Benjamin Poulain on 2019-02-05 16:06:41 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Benjamin Poulain

Created: 2019-02-05 16:06:41 PST

Size: 20.93 KB

patch

obsolete

>Subversion Revision: 240992
>diff --git a/Source/WTF/ChangeLog b/Source/WTF/ChangeLog
>index f3a9db473d90992b0216d9871108b10dd6b2af24..67a1dc7a217bb9e6e0d71fd2729441130f8438b8 100644
>--- a/Source/WTF/ChangeLog
>+++ b/Source/WTF/ChangeLog
>@@ -1,3 +1,23 @@
>+2019-02-05  Benjamin Poulain  <benjamin@webkit.org>
>+
>+        clampTo(): do not convert the input to double when dealing with integers
>+        https://bugs.webkit.org/show_bug.cgi?id=194263
>+        <rdar://problem/47692312>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Previously, every use of clampTo() was converting the input to double,
>+        doing the comparison in double, then casting back to whatever type was needed.
>+
>+        In many case, that was very wasteful. WebKit has many uses of clampTo() with
>+        the same type as input/output, or with integer types of different size/size.
>+
>+        This patch adds a few versions of clampTo() for the common cases seen in WebKit.
>+        In each case, I tried to minimize the amount of conversion needed at runtime.
>+
>+        * wtf/MathExtras.h:
>+        (clampTo):
>+
> 2019-02-05  Yusuke Suzuki  <ysuzuki@apple.com>
> 
>         [JSC] Shrink sizeof(UnlinkedCodeBlock)
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 6ebd36c6181f4d2a1cd97db58dc5d851fd5c781d..eaef200b874cb4bb908ca5b3e96914985a81cf3d 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,19 @@
>+2019-02-05  Benjamin Poulain  <benjamin@webkit.org>
>+
>+        clampTo(): do not convert the input to double when dealing with integers
>+        https://bugs.webkit.org/show_bug.cgi?id=194263
>+        <rdar://problem/47692312>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Make the calls to clampTo<float>() unambiguous.
>+
>+        * page/FrameView.cpp:
>+        (WebCore::FrameView::computeUpdatedLayoutViewportRect):
>+        * rendering/style/RenderStyle.h:
>+        (WebCore::RenderStyle::setOpacity):
>+        (WebCore::RenderStyle::setShapeImageThreshold):
>+
> 2019-02-05  Alex Christensen  <achristensen@webkit.org>
> 
>         Stop using blobRegistry in NetworkProcess
>diff --git a/Source/WTF/wtf/MathExtras.h b/Source/WTF/wtf/MathExtras.h
>index 5eef198790cb1ee86490d49ee1e7e69a5c92a32a..7b1631535538e0da83da49baad030054ebef4d92 100644
>--- a/Source/WTF/wtf/MathExtras.h
>+++ b/Source/WTF/wtf/MathExtras.h
>@@ -123,15 +123,94 @@ template<> constexpr float defaultMinimumForClamp() { return -std::numeric_limit
> template<> constexpr double defaultMinimumForClamp() { return -std::numeric_limits<double>::max(); }
> template<typename T> constexpr T defaultMaximumForClamp() { return std::numeric_limits<T>::max(); }
> 
>-template<typename T> inline T clampTo(double value, T min = defaultMinimumForClamp<T>(), T max = defaultMaximumForClamp<T>())
>+// Same type in and out.
>+template<typename TargetType, typename SourceType>
>+typename std::enable_if<std::is_same<TargetType, SourceType>::value, TargetType>::type
>+clampTo(SourceType value, TargetType min = defaultMinimumForClamp<TargetType>(), TargetType max = defaultMaximumForClamp<TargetType>())
> {
>-    if (value >= static_cast<double>(max))
>+    if (value >= max)
>         return max;
>-    if (value <= static_cast<double>(min))
>+    if (value <= min)
>         return min;
>-    return static_cast<T>(value);
>+    return value;
>+}
>+
>+// Floating point source.
>+template<typename TargetType, typename SourceType>
>+typename std::enable_if<!std::is_same<TargetType, SourceType>::value
>+    && std::is_floating_point<SourceType>::value, TargetType>::type
>+clampTo(SourceType value, TargetType min = defaultMinimumForClamp<TargetType>(), TargetType max = defaultMaximumForClamp<TargetType>())
>+{
>+    if (value >= static_cast<SourceType>(max))
>+        return max;
>+    if (value <= static_cast<SourceType>(min))
>+        return min;
>+    return static_cast<TargetType>(value);
>+}
>+
>+// Source and Target have the same sign and Source is larger or equal to Target
>+template<typename TargetType, typename SourceType>
>+typename std::enable_if<!std::is_same<TargetType, SourceType>::value
>+    && std::numeric_limits<SourceType>::is_integer
>+    && std::numeric_limits<TargetType>::is_integer
>+    && std::numeric_limits<TargetType>::is_signed == std::numeric_limits<SourceType>::is_signed
>+    && sizeof(SourceType) >= sizeof(TargetType), TargetType>::type
>+clampTo(SourceType value, TargetType min = defaultMinimumForClamp<TargetType>(), TargetType max = defaultMaximumForClamp<TargetType>())
>+{
>+    if (value >= static_cast<SourceType>(max))
>+        return max;
>+    if (value <= static_cast<SourceType>(min))
>+        return min;
>+    return static_cast<TargetType>(value);
>+}
>+
>+// Clamping a unsigned integer to the max signed value.
>+template<typename TargetType, typename SourceType>
>+typename std::enable_if<!std::is_same<TargetType, SourceType>::value
>+    && std::numeric_limits<SourceType>::is_integer
>+    && std::numeric_limits<TargetType>::is_integer
>+    && std::numeric_limits<TargetType>::is_signed
>+    && !std::numeric_limits<SourceType>::is_signed
>+    && sizeof(SourceType) >= sizeof(TargetType), TargetType>::type
>+clampTo(SourceType value)
>+{
>+    TargetType max = std::numeric_limits<TargetType>::max();
>+    if (value >= static_cast<SourceType>(max))
>+        return max;
>+    return static_cast<TargetType>(value);
>+}
>+
>+// Clamping a signed integer into a valid unsigned integer.
>+template<typename TargetType, typename SourceType>
>+typename std::enable_if<!std::is_same<TargetType, SourceType>::value
>+    && std::numeric_limits<SourceType>::is_integer
>+    && std::numeric_limits<TargetType>::is_integer
>+    && !std::numeric_limits<TargetType>::is_signed
>+    && std::numeric_limits<SourceType>::is_signed
>+    && sizeof(SourceType) == sizeof(TargetType), TargetType>::type
>+clampTo(SourceType value)
>+{
>+    if (value < 0)
>+        return 0;
>+    return static_cast<TargetType>(value);
>+}
>+
>+template<typename TargetType, typename SourceType>
>+typename std::enable_if<!std::is_same<TargetType, SourceType>::value
>+    && std::numeric_limits<SourceType>::is_integer
>+    && std::numeric_limits<TargetType>::is_integer
>+    && !std::numeric_limits<TargetType>::is_signed
>+    && std::numeric_limits<SourceType>::is_signed
>+    && (sizeof(SourceType) > sizeof(TargetType)), TargetType>::type
>+clampTo(SourceType value)
>+{
>+    if (value < 0)
>+        return 0;
>+    TargetType max = std::numeric_limits<TargetType>::max();
>+    if (value >= static_cast<SourceType>(max))
>+        return max;
>+    return static_cast<TargetType>(value);
> }
>-template<> inline long long int clampTo(double, long long int, long long int); // clampTo does not support long long ints.
> 
> inline int clampToInteger(double value)
> {
>diff --git a/Source/WebCore/page/FrameView.cpp b/Source/WebCore/page/FrameView.cpp
>index 5a9ded2ec03842295580881c920f13477da82466..aabc02bfc1d608d1ef1360b49bfc47badc1c7239 100644
>--- a/Source/WebCore/page/FrameView.cpp
>+++ b/Source/WebCore/page/FrameView.cpp
>@@ -1530,8 +1530,8 @@ LayoutRect FrameView::computeUpdatedLayoutViewportRect(const LayoutRect& layoutV
>         // The max stable layout viewport origin really depends on the size of the layout viewport itself, so we need to adjust the location of the layout viewport one final time to make sure it does not end up out of bounds of the document.
>         // Without this adjustment (and with using the non-constrained unobscuredContentRect's size as the size of the layout viewport) the layout viewport can be pushed past the bounds of the document during rubber-banding, and cannot be pushed
>         // back in until the user scrolls back in the other direction.
>-        layoutViewportOrigin.setX(clampTo<float>(layoutViewportOrigin.x(), 0, documentRect.width() - layoutViewportRect.width()));
>-        layoutViewportOrigin.setY(clampTo<float>(layoutViewportOrigin.y(), 0, documentRect.height() - layoutViewportRect.height()));
>+        layoutViewportOrigin.setX(clampTo<float>(layoutViewportOrigin.x().toFloat(), 0, documentRect.width() - layoutViewportRect.width()));
>+        layoutViewportOrigin.setY(clampTo<float>(layoutViewportOrigin.y().toFloat(), 0, documentRect.height() - layoutViewportRect.height()));
>     }
>     layoutViewportRect.setLocation(layoutViewportOrigin);
>     
>diff --git a/Source/WebCore/rendering/style/RenderStyle.h b/Source/WebCore/rendering/style/RenderStyle.h
>index 324efe58cd09e9e44ac86209c8a3249816d02c43..69650df20f08e9de9325fdff067e477222b1348a 100644
>--- a/Source/WebCore/rendering/style/RenderStyle.h
>+++ b/Source/WebCore/rendering/style/RenderStyle.h
>@@ -1055,7 +1055,7 @@ public:
>     void setTextStrokeWidth(float w) { SET_VAR(m_rareInheritedData, textStrokeWidth, w); }
>     void setTextFillColor(const Color& c) { SET_VAR(m_rareInheritedData, textFillColor, c); }
>     void setCaretColor(const Color& c) { SET_VAR(m_rareInheritedData, caretColor, c); }
>-    void setOpacity(float f) { float v = clampTo<float>(f, 0, 1); SET_VAR(m_rareNonInheritedData, opacity, v); }
>+    void setOpacity(float f) { float v = clampTo<float>(f, 0.f, 1.f); SET_VAR(m_rareNonInheritedData, opacity, v); }
>     void setAppearance(ControlPart a) { SET_VAR(m_rareNonInheritedData, appearance, a); }
>     // For valid values of box-align see http://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#alignment
>     void setBoxAlign(BoxAlignment a) { SET_NESTED_VAR(m_rareNonInheritedData, deprecatedFlexibleBox, align, static_cast<unsigned>(a)); }
>@@ -2196,7 +2196,7 @@ inline void RenderStyle::setShapeOutside(RefPtr<ShapeValue>&& value)
> 
> inline void RenderStyle::setShapeImageThreshold(float shapeImageThreshold)
> {
>-    float clampedShapeImageThreshold = clampTo<float>(shapeImageThreshold, 0, 1);
>+    float clampedShapeImageThreshold = clampTo<float>(shapeImageThreshold, 0.f, 1.f);
>     SET_VAR(m_rareNonInheritedData, shapeImageThreshold, clampedShapeImageThreshold);
> }
> 
>diff --git a/Tools/ChangeLog b/Tools/ChangeLog
>index 92a073378190e608763da9d651d9c7e5a1b90bc4..8b2797f88972b4c6ca75aec517fd2d6568dcf2a8 100644
>--- a/Tools/ChangeLog
>+++ b/Tools/ChangeLog
>@@ -1,3 +1,18 @@
>+2019-02-05  Benjamin Poulain  <benjamin@webkit.org>
>+
>+        clampTo(): do not convert the input to double when dealing with integers
>+        https://bugs.webkit.org/show_bug.cgi?id=194263
>+        <rdar://problem/47692312>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * TestWebKitAPI/Tests/WTF/MathExtras.cpp:
>+        (TestWebKitAPI::testClampFloatingPointToFloatingPoint):
>+        (TestWebKitAPI::testClampFloatingPointToInteger):
>+        (TestWebKitAPI::testClampSameSignIntegers):
>+        (TestWebKitAPI::testClampUnsignedToSigned):
>+        (TestWebKitAPI::testClampSignedToUnsigned):
>+
> 2019-02-05  Olivier Blin  <olivier.blin@softathome.com>
> 
>         [GTK][WPE] force libpsl build to use ICU in jhbuild
>diff --git a/Tools/TestWebKitAPI/Tests/WTF/MathExtras.cpp b/Tools/TestWebKitAPI/Tests/WTF/MathExtras.cpp
>index 1789a0eb8b07730b9a3d12c05393f459ba9eae6d..8442347bcb3a5ffd1cd389bedacb09193d18d880 100644
>--- a/Tools/TestWebKitAPI/Tests/WTF/MathExtras.cpp
>+++ b/Tools/TestWebKitAPI/Tests/WTF/MathExtras.cpp
>@@ -1,5 +1,6 @@
> /*
>  * Copyright (C) 2012 Intel Corporation
>+ * Copyright (C) 2019 Apple Inc. All rights reserved.
>  *
>  * Redistribution and use in source and binary forms, with or without
>  * modification, are permitted provided that the following conditions
>@@ -25,6 +26,7 @@
> 
> #include "config.h"
> 
>+#include <wtf/Compiler.h>
> #include <wtf/MathExtras.h>
> 
> namespace TestWebKitAPI {
>@@ -174,6 +176,150 @@ TEST(WTF, clampToUnsignedLongLong)
>     EXPECT_EQ(clampTo<unsigned>(-1), 0u);
> }
> 
>+template<typename TargetType, typename SourceType>
>+static void testClampFloatingPointToFloatingPoint()
>+{
>+    EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(0)), static_cast<TargetType>(0));
>+    EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(1)), static_cast<TargetType>(1));
>+    EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(1.5)), static_cast<TargetType>(1.5));
>+    EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(-1)), static_cast<TargetType>(-1));
>+    EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(-1.5)), static_cast<TargetType>(-1.5));
>+
>+    EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(std::numeric_limits<int32_t>::max()) + 1), static_cast<TargetType>(std::numeric_limits<int32_t>::max()) + 1);
>+    EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(std::numeric_limits<int64_t>::max())), static_cast<TargetType>(std::numeric_limits<int64_t>::max()));
>+    EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(std::numeric_limits<int32_t>::max()) + 1), static_cast<TargetType>(std::numeric_limits<int32_t>::max()) + 1);
>+
>+    EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(std::numeric_limits<int32_t>::min())), static_cast<TargetType>(std::numeric_limits<int32_t>::min()));
>+    EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(std::numeric_limits<int64_t>::min())), static_cast<TargetType>(std::numeric_limits<int64_t>::min()));
>+
>+    if (std::is_same<TargetType, double>::value && std::is_same<SourceType, float>::value) {
>+        // If the source is float and target is double, the input of those cases has lost bits in float.
>+        // In that case, we also round the expectation to float.
>+        EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(std::numeric_limits<int32_t>::max())), static_cast<TargetType>(static_cast<SourceType>(std::numeric_limits<int32_t>::max())));
>+        EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(std::numeric_limits<int32_t>::min()) - 1), static_cast<TargetType>(static_cast<SourceType>(std::numeric_limits<int32_t>::min()) - 1));
>+        EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(std::numeric_limits<int32_t>::min()) - 1), static_cast<TargetType>(static_cast<SourceType>(std::numeric_limits<int32_t>::min()) - 1));
>+    } else {
>+        EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(std::numeric_limits<int32_t>::max())), static_cast<TargetType>(std::numeric_limits<int32_t>::max()));
>+        EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(std::numeric_limits<int32_t>::min()) - 1), static_cast<TargetType>(std::numeric_limits<int32_t>::min()) - 1);
>+        EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(std::numeric_limits<int32_t>::min()) - 1), static_cast<TargetType>(std::numeric_limits<int32_t>::min()) - 1);
>+    }
>+
>+#if !COMPILER(MSVC)
>+    EXPECT_EQ(clampTo<TargetType>(std::numeric_limits<SourceType>::infinity()), std::numeric_limits<TargetType>::max());
>+    EXPECT_EQ(clampTo<TargetType>(-std::numeric_limits<SourceType>::infinity()), -std::numeric_limits<TargetType>::max());
>+#endif
>+}
>+
>+TEST(WTF, clampFloatingPointToFloatingPoint)
>+{
>+    testClampFloatingPointToFloatingPoint<float, float>();
>+    testClampFloatingPointToFloatingPoint<double, double>();
>+    testClampFloatingPointToFloatingPoint<double, float>();
>+    testClampFloatingPointToFloatingPoint<float, double>();
>+}
>+
>+template<typename FloatingPointType>
>+static void testClampFloatingPointToInteger()
>+{
>+    EXPECT_EQ(clampTo<int32_t>(static_cast<FloatingPointType>(0)), 0);
>+    EXPECT_EQ(clampTo<int32_t>(static_cast<FloatingPointType>(1)), 1);
>+    EXPECT_EQ(clampTo<int32_t>(static_cast<FloatingPointType>(-1)), -1);
>+    EXPECT_EQ(clampTo<int32_t>(static_cast<FloatingPointType>(std::numeric_limits<int32_t>::max())), std::numeric_limits<int32_t>::max());
>+    EXPECT_EQ(clampTo<int32_t>(static_cast<FloatingPointType>(std::numeric_limits<int32_t>::max()) + 1.f), std::numeric_limits<int32_t>::max());
>+    EXPECT_EQ(clampTo<int32_t>(static_cast<FloatingPointType>(std::numeric_limits<int32_t>::min())), std::numeric_limits<int32_t>::min());
>+    EXPECT_EQ(clampTo<int32_t>(static_cast<FloatingPointType>(std::numeric_limits<int32_t>::min()) - 1.f), std::numeric_limits<int32_t>::min());
>+    EXPECT_EQ(clampTo<int32_t>(static_cast<FloatingPointType>(std::numeric_limits<uint32_t>::max())), std::numeric_limits<int32_t>::max());
>+    EXPECT_EQ(clampTo<int32_t>(static_cast<FloatingPointType>(std::numeric_limits<uint32_t>::max()) + 1.f), std::numeric_limits<int32_t>::max());
>+    EXPECT_EQ(clampTo<int32_t>(static_cast<FloatingPointType>(std::numeric_limits<uint32_t>::min())), 0.f);
>+    EXPECT_EQ(clampTo<int32_t>(static_cast<FloatingPointType>(std::numeric_limits<int64_t>::max())), std::numeric_limits<int32_t>::max());
>+    EXPECT_EQ(clampTo<int32_t>(static_cast<FloatingPointType>(std::numeric_limits<int64_t>::max()) + 1.f), std::numeric_limits<int32_t>::max());
>+    EXPECT_EQ(clampTo<int32_t>(static_cast<FloatingPointType>(std::numeric_limits<int64_t>::min())), std::numeric_limits<int32_t>::min());
>+    EXPECT_EQ(clampTo<int32_t>(static_cast<FloatingPointType>(std::numeric_limits<int64_t>::min()) - 1.f), std::numeric_limits<int32_t>::min());
>+    EXPECT_EQ(clampTo<int32_t>(static_cast<FloatingPointType>(std::numeric_limits<uint64_t>::max())), std::numeric_limits<int32_t>::max());
>+    EXPECT_EQ(clampTo<int32_t>(static_cast<FloatingPointType>(std::numeric_limits<uint64_t>::max()) + 1.f), std::numeric_limits<int32_t>::max());
>+    EXPECT_EQ(clampTo<int32_t>(static_cast<FloatingPointType>(std::numeric_limits<uint64_t>::min())), 0.f);
>+
>+    EXPECT_EQ(clampTo<int32_t>(static_cast<FloatingPointType>(std::numeric_limits<FloatingPointType>::infinity())), std::numeric_limits<int32_t>::max());
>+    EXPECT_EQ(clampTo<int32_t>(static_cast<FloatingPointType>(-std::numeric_limits<FloatingPointType>::infinity())), std::numeric_limits<int32_t>::min());
>+}
>+
>+TEST(WTF, clampFloatToInt)
>+{
>+    testClampFloatingPointToInteger<float>();
>+    testClampFloatingPointToInteger<double>();
>+}
>+
>+template<typename TargetType, typename SourceType>
>+static void testClampSameSignIntegers()
>+{
>+    EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(0)), static_cast<TargetType>(0));
>+    EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(1)), static_cast<TargetType>(1));
>+    EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(-1)), std::numeric_limits<TargetType>::is_signed ? static_cast<TargetType>(-1) : std::numeric_limits<TargetType>::max());
>+
>+    EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(std::numeric_limits<TargetType>::min())), std::numeric_limits<TargetType>::min());
>+    EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(std::numeric_limits<TargetType>::max())), std::numeric_limits<TargetType>::max());
>+
>+    EXPECT_EQ(clampTo<TargetType>(std::numeric_limits<SourceType>::min()), std::numeric_limits<TargetType>::min());
>+    EXPECT_EQ(clampTo<TargetType>(std::numeric_limits<SourceType>::max()), std::numeric_limits<TargetType>::max());
>+}
>+
>+TEST(WTF, clampSameSignIntegers)
>+{
>+    testClampSameSignIntegers<int32_t, int32_t>();
>+    testClampSameSignIntegers<uint32_t, uint32_t>();
>+    testClampSameSignIntegers<int32_t, int64_t>();
>+    testClampSameSignIntegers<uint32_t, uint64_t>();
>+    testClampSameSignIntegers<int16_t, int64_t>();
>+    testClampSameSignIntegers<uint16_t, uint64_t>();
>+}
>+
>+template<typename TargetType, typename SourceType>
>+static void testClampUnsignedToSigned()
>+{
>+    EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(0)), static_cast<TargetType>(0));
>+    EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(1)), static_cast<TargetType>(1));
>+
>+    EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(std::numeric_limits<TargetType>::max())), std::numeric_limits<TargetType>::max());
>+    EXPECT_EQ(clampTo<TargetType>(std::numeric_limits<SourceType>::max()), std::numeric_limits<TargetType>::max());
>+}
>+
>+TEST(WTF, clampUnsignedToSigned)
>+{
>+    testClampUnsignedToSigned<int32_t, uint32_t>();
>+    testClampUnsignedToSigned<int64_t, uint64_t>();
>+    testClampUnsignedToSigned<int32_t, uint64_t>();
>+    testClampUnsignedToSigned<int16_t, uint32_t>();
>+    testClampUnsignedToSigned<int16_t, uint64_t>();
>+}
>+
>+template<typename TargetType, typename SourceType>
>+static void testClampSignedToUnsigned()
>+{
>+    EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(0)), static_cast<TargetType>(0));
>+    EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(1)), static_cast<TargetType>(1));
>+    EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(-1)), static_cast<TargetType>(0));
>+
>+    if (sizeof(TargetType) < sizeof(SourceType)) {
>+        EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(std::numeric_limits<TargetType>::min())), static_cast<TargetType>(0));
>+        EXPECT_EQ(clampTo<TargetType>(static_cast<SourceType>(std::numeric_limits<TargetType>::max())), std::numeric_limits<TargetType>::max());
>+    }
>+
>+    EXPECT_EQ(clampTo<TargetType>(std::numeric_limits<SourceType>::min()), static_cast<TargetType>(0));
>+    if (sizeof(TargetType) < sizeof(SourceType))
>+        EXPECT_EQ(clampTo<TargetType>(std::numeric_limits<SourceType>::max()), std::numeric_limits<TargetType>::max());
>+    else
>+        EXPECT_EQ(clampTo<TargetType>(std::numeric_limits<SourceType>::max()), static_cast<TargetType>(std::numeric_limits<SourceType>::max()));
>+}
>+
>+TEST(WTF, clampSignedToUnsigned)
>+{
>+    testClampSignedToUnsigned<uint32_t, int32_t>();
>+    testClampSignedToUnsigned<uint64_t, int64_t>();
>+    testClampSignedToUnsigned<uint32_t, int64_t>();
>+    testClampSignedToUnsigned<uint16_t, int32_t>();
>+    testClampSignedToUnsigned<uint16_t, int64_t>();
>+}
>+
> TEST(WTF, roundUpToPowerOfTwo)
> {
>     EXPECT_EQ(WTF::roundUpToPowerOfTwo(UINT32_MAX), 0U);

Actions: View | Formatted Diff | Diff

Attachments on bug 194263: 361143 | 361236 | 361273 | 361445 | 361473 | 361492