Attachment 368464 Details for Bug 197373 – Proposed patch

[patch] Proposed patch

increase-timeout-webkitperl-v2.patch (text/plain), 19.33 KB, created by Aakash Jain on 2019-04-29 10:17:05 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Aakash Jain

Created: 2019-04-29 10:17:05 PDT

Size: 19.33 KB

patch

obsolete

>Index: Tools/ChangeLog
>===================================================================
>--- Tools/ChangeLog	(revision 244598)
>+++ Tools/ChangeLog	(working copy)
>@@ -1,3 +1,12 @@
>+2019-04-24  Aakash Jain  <aakash_jain@apple.com>
>+
>+        [ews-build] Increase timeout for WebKitPerl Tests
>+        https://bugs.webkit.org/show_bug.cgi?id=197059
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * BuildSlaveSupport/ews-build/steps.py:
>+
> 2019-04-24  Alex Christensen  <achristensen@webkit.org>
> 
>         WKContentRuleLists should have a maximum FileProtection of CompleteUnlessOpen
>Index: Tools/BuildSlaveSupport/ews-build/steps.py
>===================================================================
>--- Tools/BuildSlaveSupport/ews-build/steps.py	(revision 244598)
>+++ Tools/BuildSlaveSupport/ews-build/steps.py	(working copy)
>@@ -476,7 +476,7 @@ class RunWebKitPerlTests(shell.ShellComm
>     command = ['Tools/Scripts/test-webkitperl']
> 
>     def __init__(self, **kwargs):
>-        super(RunWebKitPerlTests, self).__init__(timeout=2 * 60, **kwargs)
>+        super(RunWebKitPerlTests, self).__init__(timeout=5 * 60, **kwargs)
> 
> 
> class RunWebKitPyTests(shell.ShellCommand):
>Index: Tools/TestWebKitAPI/Tests/WTF/CheckedArithmeticOperations.cpp
>===================================================================
>--- Tools/TestWebKitAPI/Tests/WTF/CheckedArithmeticOperations.cpp	(revision 244598)
>+++ Tools/TestWebKitAPI/Tests/WTF/CheckedArithmeticOperations.cpp	(working copy)
>@@ -73,7 +73,7 @@ static void resetOverflow(Checked<type, 
> }
> 
> #define CheckedArithmeticTest(type, Coercer, MixedSignednessTester) \
>-    TEST(WTF, Checked_##type) \
>+    TEST(WTF_CheckedArithmeticTest, Checked_##type) \
>     { \
>         typedef Coercer<type> CoercerType; \
>         typedef MixedSignednessTester<type, CoercerType> MixedSignednessTesterType; \
>@@ -128,6 +128,14 @@ public:
>         EXPECT_EQ(true, (value += coerceLiteral(1)).hasOverflowed());
>         EXPECT_EQ(true, value.hasOverflowed());
> 
>+        value = 0x8;
>+        EXPECT_EQ(coerceLiteral(0x9), (value | coerceLiteral(0x1)).unsafeGet());
>+        EXPECT_EQ(coerceLiteral(0x8), (value | coerceLiteral(0x8)).unsafeGet());
>+        EXPECT_EQ(coerceLiteral(0xf), (coerceLiteral(0xf) | value).unsafeGet());
>+        EXPECT_EQ(coerceLiteral(0x1b), (coerceLiteral(0x13) | value).unsafeGet());
>+        EXPECT_EQ(coerceLiteral(0x2), (value >> 0x2).unsafeGet());
>+        EXPECT_EQ(coerceLiteral(0), (value >> 4).unsafeGet());
>+
>         value = 10;
>         type _value = 0;
>         EXPECT_EQ(true, CheckedState::DidNotOverflow == (value * Checked<type, RecordOverflow>(0)).safeGet(_value));
>@@ -165,7 +173,6 @@ public:
>         value = 10;
>         EXPECT_EQ(true, (value * Checked<type, RecordOverflow>(std::numeric_limits<type>::max())).hasOverflowed());
> 
>-
>         Checked<type, OverflowCrashLogger> nvalue; // to hold a not overflowed value.
>         Checked<type, OverflowCrashLogger> ovalue; // to hold an overflowed value.
> 
>@@ -428,7 +435,7 @@ CheckedArithmeticTest(uint32_t, CoerceLi
> CheckedArithmeticTest(int64_t, CoerceLiteralNop, IgnoreMixedSignednessTest)
> CheckedArithmeticTest(uint64_t, CoerceLiteralToUnsigned, IgnoreMixedSignednessTest)
> 
>-TEST(CheckedArithmeticTest, IsInBounds)
>+TEST(WTF_CheckedArithmeticTest, IsInBounds)
> {
>     // bigger precision, signed, signed
>     EXPECT_TRUE(WTF::isInBounds<int32_t>(std::numeric_limits<int16_t>::max()));
>@@ -486,4 +493,136 @@ TEST(CheckedArithmeticTest, IsInBounds)
>     EXPECT_TRUE(WTF::isInBounds<uint16_t>((uint32_t)1));
> }
> 
>+TEST(WTF_CheckedArithmeticTest, BitwiseOperations)
>+{
>+    {
>+        Checked<int16_t, RecordOverflow> value;
>+        int16_t allBitsSet = 0xffff;
>+
>+        value = std::numeric_limits<int16_t>::max();
>+        EXPECT_EQ(allBitsSet, (value | std::numeric_limits<int16_t>::min()).unsafeGet());
>+        EXPECT_EQ(allBitsSet, (std::numeric_limits<int16_t>::min() | value).unsafeGet());
>+
>+        value = std::numeric_limits<int16_t>::min();
>+        EXPECT_EQ(allBitsSet, (value | std::numeric_limits<int16_t>::max()).unsafeGet());
>+        EXPECT_EQ(allBitsSet, (std::numeric_limits<int16_t>::max() | value).unsafeGet());
>+
>+        value = 0x7fff;
>+        EXPECT_EQ(0x7fff, (value | 0x1).unsafeGet());
>+        EXPECT_EQ(0x7fff, (0x1 | value).unsafeGet());
>+
>+        int32_t anotherValue = 0xffff;
>+        EXPECT_EQ(0xffff, (value | anotherValue).unsafeGet());
>+        EXPECT_EQ(0xffff, (anotherValue | value).unsafeGet());
>+        value |= anotherValue;
>+        EXPECT_TRUE(value.hasOverflowed());
>+
>+        value = 0x7fff;
>+        anotherValue++;
>+        EXPECT_EQ(0x17fff, (value | anotherValue).unsafeGet());
>+        EXPECT_EQ(0x17fff, (anotherValue | value).unsafeGet());
>+        value |= anotherValue;
>+        EXPECT_TRUE(value.hasOverflowed());
>+
>+        value = -1;
>+        anotherValue = 0xffff;
>+        EXPECT_EQ(-1, (value | anotherValue).unsafeGet());
>+        EXPECT_EQ(-1, (anotherValue | value).unsafeGet());
>+        value |= anotherValue;
>+        EXPECT_TRUE(value.hasOverflowed());
>+
>+        value = -1;
>+        anotherValue++;
>+        EXPECT_EQ(-1, (value | anotherValue).unsafeGet());
>+        EXPECT_EQ(-1, (anotherValue | value).unsafeGet());
>+        value |= anotherValue;
>+        EXPECT_TRUE(value.hasOverflowed());
>+    }
>+
>+    {
>+        Checked<uint16_t, RecordOverflow> value;
>+        value = std::numeric_limits<uint16_t>::max();
>+        uint16_t result = (value | std::numeric_limits<uint16_t>::min()).unsafeGet();
>+        EXPECT_EQ(0xffffu, result);
>+        EXPECT_EQ(0xffffu, (std::numeric_limits<uint16_t>::min() | value).unsafeGet());
>+
>+        value = std::numeric_limits<uint16_t>::min();
>+        EXPECT_EQ(0xffffu, (value | std::numeric_limits<uint16_t>::max()).unsafeGet());
>+        EXPECT_EQ(0xffffu, (std::numeric_limits<uint16_t>::max() | value).unsafeGet());
>+
>+        value = 0x7fff;
>+        // Unsigned oprands
>+        EXPECT_EQ(0x7fffu, (value | 0x1u).unsafeGet());
>+        EXPECT_EQ(0x7fffu, (0x1u | value).unsafeGet());
>+
>+        value = 0x7fff;
>+        // Signed oprands
>+        EXPECT_EQ(0x7fff, (value | 1).unsafeGet());
>+        EXPECT_EQ(0x7fff, (1 | value).unsafeGet());
>+
>+        int32_t anotherValue = 0xffff;
>+        EXPECT_EQ(0xffff, (value | anotherValue).unsafeGet());
>+        EXPECT_EQ(0xffff, (anotherValue | value).unsafeGet());
>+        value |= anotherValue;
>+        EXPECT_EQ(0xffff, value.unsafeGet());
>+
>+        value = 0x7fff;
>+        anotherValue++;
>+        EXPECT_EQ(0x17fff, (value | anotherValue).unsafeGet());
>+        EXPECT_EQ(0x17fff, (anotherValue | value).unsafeGet());
>+        value |= anotherValue;
>+        EXPECT_TRUE(value.hasOverflowed());
>+    }
>+
>+    {
>+        Checked<int16_t, RecordOverflow> value;
>+
>+        value = 0x7fff;
>+        EXPECT_EQ(0x1fff, (value >> 2).unsafeGet());
>+        EXPECT_EQ(0x07ff, (value >> 4).unsafeGet());
>+        EXPECT_EQ(0, (value >> 15).unsafeGet());
>+        EXPECT_TRUE((value >> 16).hasOverflowed());
>+        EXPECT_TRUE((value >> 0xffffffffu).hasOverflowed());
>+
>+        value = 0;
>+        EXPECT_EQ(0, (value >> 1).unsafeGet());
>+
>+        value = 3;
>+        value >>= 0;
>+        EXPECT_EQ(3, value.unsafeGet());
>+        value >>= 1;
>+        EXPECT_EQ(1, value.unsafeGet());
>+
>+        value = -1;
>+        EXPECT_EQ(-1, (value >> 3).unsafeGet());
>+        EXPECT_EQ(-1, (value >> 15).unsafeGet());
>+        EXPECT_TRUE((value >> 16).hasOverflowed());
>+    }
>+
>+    {
>+        Checked<uint16_t, RecordOverflow> value;
>+
>+        value = 0x7fff;
>+        EXPECT_EQ(0x1fff, (value >> 2).unsafeGet());
>+        EXPECT_EQ(0x07ff, (value >> 4).unsafeGet());
>+        EXPECT_EQ(0, (value >> 15).unsafeGet());
>+        EXPECT_TRUE((value >> 16).hasOverflowed());
>+        EXPECT_TRUE((value >> 0xffffffffu).hasOverflowed());
>+
>+        value = 0;
>+        EXPECT_EQ(0, (value >> 1).unsafeGet());
>+
>+        value = 3;
>+        value >>= 0;
>+        EXPECT_EQ(3, value.unsafeGet());
>+        value >>= 1;
>+        EXPECT_EQ(1, value.unsafeGet());
>+
>+        value = 0xffff;
>+        EXPECT_EQ(0x1fff, (value >> 3).unsafeGet());
>+        EXPECT_EQ(1, (value >> 15).unsafeGet());
>+        EXPECT_TRUE((value >> 16).hasOverflowed());
>+    }
>+}
>+
> } // namespace TestWebKitAPI
>Index: Source/WTF/wtf/CheckedArithmetic.h
>===================================================================
>--- Source/WTF/wtf/CheckedArithmetic.h	(revision 244597)
>+++ Source/WTF/wtf/CheckedArithmetic.h	(working copy)
>@@ -391,6 +391,14 @@ template <typename LHS, typename RHS, ty
> #endif
>     }
> 
>+    static inline bool bitwiseOr(LHS lhs, RHS rhs, ResultType& result) WARN_UNUSED_RETURN
>+    {
>+        if (!isInBounds<ResultType>(lhs) || !isInBounds<ResultType>(rhs))
>+            return false;
>+        result = lhs | rhs;
>+        return true;
>+    }
>+
>     static inline bool equals(LHS lhs, RHS rhs) { return lhs == rhs; }
> 
> };
>@@ -451,11 +459,28 @@ template <typename LHS, typename RHS, ty
> #endif
>     }
> 
>+    static inline bool bitwiseOr(LHS lhs, RHS rhs, ResultType& result) WARN_UNUSED_RETURN
>+    {
>+        if (!isInBounds<ResultType>(lhs) || !isInBounds<ResultType>(rhs))
>+            return false;
>+        result = lhs | rhs;
>+        return true;
>+    }
>+
>+    static inline bool bitwiseRightShift(LHS lhs, RHS rhs, ResultType& result) WARN_UNUSED_RETURN
>+    {
>+        const unsigned numberOfBitsInLHS = sizeof(LHS) * 8;
>+        if (rhs >= numberOfBitsInLHS)
>+            return false;
>+        result = lhs >> rhs;
>+        return true;
>+    }
>+
>     static inline bool equals(LHS lhs, RHS rhs) { return lhs == rhs; }
> 
> };
> 
>-template <typename ResultType> struct ArithmeticOperations<int, unsigned, ResultType, true, false> {
>+template <typename LHS, typename RHS, typename ResultType> struct ArithmeticOperations<LHS, RHS, ResultType, true, false> {
>     static inline bool add(int64_t lhs, int64_t rhs, ResultType& result)
>     {
> #if COMPILER(GCC_COMPATIBLE)
>@@ -513,31 +538,53 @@ template <typename ResultType> struct Ar
> #endif
>     }
> 
>-    static inline bool equals(int lhs, unsigned rhs)
>+    static inline bool bitwiseOr(int64_t lhs, int64_t rhs, ResultType& result)
>+    {
>+        if (!isInBounds<ResultType>(lhs) || !isInBounds<ResultType>(rhs))
>+            return false;
>+        result = lhs | rhs;
>+        return true;
>+    }
>+
>+    static inline bool bitwiseRightShift(int64_t lhs, unsigned rhs, ResultType& result)
>+    {
>+        const unsigned numberOfBitsInLHS = sizeof(ResultType) * 8;
>+        if (rhs >= numberOfBitsInLHS)
>+            return false;
>+        result = lhs >> rhs;
>+        return true;
>+    }
>+
>+    static inline bool equals(LHS lhs, RHS rhs)
>     {
>         return static_cast<int64_t>(lhs) == static_cast<int64_t>(rhs);
>     }
> };
> 
>-template <typename ResultType> struct ArithmeticOperations<unsigned, int, ResultType, false, true> {
>-    static inline bool add(int64_t lhs, int64_t rhs, ResultType& result)
>+template <typename LHS, typename RHS, typename ResultType> struct ArithmeticOperations<LHS, RHS, ResultType, false, true> {
>+    static inline bool add(LHS lhs, RHS rhs, ResultType& result)
>     {
>-        return ArithmeticOperations<int, unsigned, ResultType>::add(rhs, lhs, result);
>+        return ArithmeticOperations<RHS, LHS, ResultType>::add(rhs, lhs, result);
>     }
>     
>     static inline bool sub(int64_t lhs, int64_t rhs, ResultType& result)
>     {
>-        return ArithmeticOperations<int, unsigned, ResultType>::sub(lhs, rhs, result);
>+        return ArithmeticOperations<int64_t, int64_t, ResultType>::sub(lhs, rhs, result);
>     }
> 
>-    static inline bool multiply(int64_t lhs, int64_t rhs, ResultType& result)
>+    static inline bool multiply(LHS lhs, RHS rhs, ResultType& result)
>+    {
>+        return ArithmeticOperations<RHS, LHS, ResultType>::multiply(lhs, rhs, result);
>+    }
>+
>+    static inline bool bitwiseOr(LHS lhs, RHS rhs, ResultType& result)
>     {
>-        return ArithmeticOperations<int, unsigned, ResultType>::multiply(lhs, rhs, result);
>+        return ArithmeticOperations<RHS, LHS, ResultType>::bitwiseOr(lhs, rhs, result);
>     }
> 
>-    static inline bool equals(unsigned lhs, int rhs)
>+    static inline bool equals(LHS lhs, RHS rhs)
>     {
>-        return ArithmeticOperations<int, unsigned, ResultType>::equals(rhs, lhs);
>+        return ArithmeticOperations<LHS, RHS, ResultType>::equals(rhs, lhs);
>     }
> };
> 
>@@ -590,6 +637,34 @@ static inline bool safeMultiply(U lhs, V
>     return true;
> }
> 
>+template <typename U, typename V, typename R> static inline bool safeBitwiseOr(U lhs, V rhs, R& result)
>+{
>+    return ArithmeticOperations<U, V, R>::bitwiseOr(lhs, rhs, result);
>+}
>+
>+template <class OverflowHandler, typename U, typename V, typename R, typename = typename std::enable_if<!std::is_scalar<OverflowHandler>::value>::type>
>+static inline bool safeBitwiseOr(U lhs, V rhs, R& result)
>+{
>+    if (observesOverflow<OverflowHandler>())
>+        return safeBitwiseOr(lhs, rhs, result);
>+    result = lhs | rhs;
>+    return true;
>+}
>+
>+template <typename U, typename R> static inline bool safeBitwiseRightShift(U lhs, unsigned rhs, R& result)
>+{
>+    return ArithmeticOperations<U, unsigned, R>::bitwiseRightShift(lhs, rhs, result);
>+}
>+
>+template <class OverflowHandler, typename U, typename R, typename = typename std::enable_if<!std::is_scalar<OverflowHandler>::value>::type>
>+static inline bool safeBitwiseRightShift(U lhs, unsigned rhs, R& result)
>+{
>+    if (observesOverflow<OverflowHandler>())
>+        return safeBitwiseRightShift(lhs, rhs, result);
>+    result = lhs >> rhs;
>+    return true;
>+}
>+
> template <typename U, typename V> static inline bool safeEquals(U lhs, V rhs)
> {
>     return ArithmeticOperations<U, V>::equals(lhs, rhs);
>@@ -768,7 +843,21 @@ public:
>     {
>         return *this *= (double)rhs;
>     }
>-    
>+
>+    template <typename U> const Checked operator|=(U rhs)
>+    {
>+        if (!safeBitwiseOr<OverflowHandler>(m_value, rhs, m_value))
>+            this->overflowed();
>+        return *this;
>+    }
>+
>+    const Checked operator>>=(unsigned rhs)
>+    {
>+        if (!safeBitwiseRightShift<OverflowHandler>(m_value, rhs, m_value))
>+            this->overflowed();
>+        return *this;
>+    }
>+
>     template <typename U, typename V> const Checked operator+=(Checked<U, V> rhs)
>     {
>         if (rhs.hasOverflowed())
>@@ -790,6 +879,13 @@ public:
>         return *this *= rhs.m_value;
>     }
> 
>+    template <typename U, typename V> const Checked operator|=(Checked<U, V> rhs)
>+    {
>+        if (rhs.hasOverflowed())
>+            this->overflowed();
>+        return *this |= rhs.m_value;
>+    }
>+
>     // Equality comparisons
>     template <typename V> bool operator==(Checked<T, V> rhs)
>     {
>@@ -903,6 +999,29 @@ template <typename U, typename V, typena
>     return result;
> }
> 
>+template <typename U, typename V, typename OverflowHandler> static inline Checked<typename Result<U, V>::ResultType, OverflowHandler> operator|(Checked<U, OverflowHandler> lhs, Checked<V, OverflowHandler> rhs)
>+{
>+    U x = 0;
>+    V y = 0;
>+    bool overflowed = lhs.safeGet(x) == CheckedState::DidOverflow || rhs.safeGet(y) == CheckedState::DidOverflow;
>+    typename Result<U, V>::ResultType result = 0;
>+    overflowed |= !safeBitwiseOr<OverflowHandler>(x, y, result);
>+    if (overflowed)
>+        return ResultOverflowed;
>+    return result;
>+}
>+
>+template <typename U, typename OverflowHandler> static inline Checked<U, OverflowHandler> operator>>(Checked<U, OverflowHandler> lhs, unsigned rhs)
>+{
>+    U x = 0;
>+    bool overflowed = lhs.safeGet(x) == CheckedState::DidOverflow;
>+    U result = 0;
>+    overflowed |= !safeBitwiseRightShift<OverflowHandler>(x, rhs, result);
>+    if (overflowed)
>+        return ResultOverflowed;
>+    return result;
>+}
>+
> template <typename U, typename V, typename OverflowHandler> static inline Checked<typename Result<U, V>::ResultType, OverflowHandler> operator+(Checked<U, OverflowHandler> lhs, V rhs)
> {
>     return lhs + Checked<V, OverflowHandler>(rhs);
>@@ -918,6 +1037,11 @@ template <typename U, typename V, typena
>     return lhs * Checked<V, OverflowHandler>(rhs);
> }
> 
>+template <typename U, typename V, typename OverflowHandler> static inline Checked<typename Result<U, V>::ResultType, OverflowHandler> operator|(Checked<U, OverflowHandler> lhs, V rhs)
>+{
>+    return lhs | Checked<V, OverflowHandler>(rhs);
>+}
>+
> template <typename U, typename V, typename OverflowHandler> static inline Checked<typename Result<U, V>::ResultType, OverflowHandler> operator+(U lhs, Checked<V, OverflowHandler> rhs)
> {
>     return Checked<U, OverflowHandler>(lhs) + rhs;
>@@ -933,6 +1057,11 @@ template <typename U, typename V, typena
>     return Checked<U, OverflowHandler>(lhs) * rhs;
> }
> 
>+template <typename U, typename V, typename OverflowHandler> static inline Checked<typename Result<U, V>::ResultType, OverflowHandler> operator|(U lhs, Checked<V, OverflowHandler> rhs)
>+{
>+    return Checked<U, OverflowHandler>(lhs) | rhs;
>+}
>+
> // Convenience typedefs.
> typedef Checked<int8_t, RecordOverflow> CheckedInt8;
> typedef Checked<uint8_t, RecordOverflow> CheckedUint8;
>@@ -987,6 +1116,14 @@ template<typename T, typename... Args> b
>     return checkedProduct<T>(args...).hasOverflowed();
> }
> 
>+template<bool isUnsignedInteger, typename T> struct UnderlyingIntegralType;
>+
>+template <typename U, typename OverflowHandler>
>+struct UnderlyingIntegralType<false, Checked<U, OverflowHandler>>
>+{
>+    using type = U;
>+};
>+
> }
> 
> using WTF::AssertNoOverflow;
>Index: Source/WTF/wtf/MathExtras.h
>===================================================================
>--- Source/WTF/wtf/MathExtras.h	(revision 244597)
>+++ Source/WTF/wtf/MathExtras.h	(working copy)
>@@ -416,8 +416,32 @@ inline void doubleToInteger(double d, un
> 
> namespace WTF {
> 
>+template<bool isUnsignedInteger, typename T> struct UnderlyingIntegralType;
>+
>+template <typename T>
>+struct UnderlyingIntegralType<true, T> {
>+    using type = T;
>+};
>+
> // From http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
>-constexpr uint32_t roundUpToPowerOfTwo(uint32_t v)
>+template <typename T>
>+typename std::enable_if<sizeof(typename UnderlyingIntegralType<std::is_unsigned<T>::value, T>::type) == sizeof(uint32_t), T>::type
>+roundUpToPowerOfTwo(T v)
>+{
>+    v--;
>+    v |= v >> 1;
>+    v |= v >> 2;
>+    v |= v >> 4;
>+    v |= v >> 8;
>+    v |= v >> 16;
>+    v++;
>+    return v;
>+}
>+
>+// From https://opensource.apple.com/source/objc4/objc4-706/runtime/llvm-MathExtras.h
>+template <typename T>
>+typename std::enable_if<sizeof(typename UnderlyingIntegralType<std::is_unsigned<T>::value, T>::type) == sizeof(uint64_t), T>::type
>+roundUpToPowerOfTwo(T v)
> {
>     v--;
>     v |= v >> 1;
>@@ -425,11 +449,12 @@ constexpr uint32_t roundUpToPowerOfTwo(u
>     v |= v >> 4;
>     v |= v >> 8;
>     v |= v >> 16;
>+    v |= v >> 32;
>     v++;
>     return v;
> }
> 
>-constexpr unsigned maskForSize(unsigned size)
>+inline unsigned maskForSize(unsigned size)
> {
>     if (!size)
>         return 0;
>Index: Source/WebCore/platform/mediastream/mac/MockRealtimeAudioSourceMac.mm
>===================================================================
>--- Source/WebCore/platform/mediastream/mac/MockRealtimeAudioSourceMac.mm	(revision 244597)
>+++ Source/WebCore/platform/mediastream/mac/MockRealtimeAudioSourceMac.mm	(working copy)
>@@ -120,7 +120,7 @@ void MockRealtimeAudioSourceMac::emitSam
> 
> void MockRealtimeAudioSourceMac::reconfigure()
> {
>-    m_maximiumFrameCount = WTF::roundUpToPowerOfTwo(renderInterval().seconds() * sampleRate() * 2);
>+    m_maximiumFrameCount = WTF::roundUpToPowerOfTwo(static_cast<uint32_t>(renderInterval().seconds() * sampleRate() * 2));
>     ASSERT(m_maximiumFrameCount);
> 
>     const int bytesPerFloat = sizeof(Float32);

Flags:

ews-watchlist: commit-queue-

Actions: View | Formatted Diff | Diff

Attachments on bug 197373: 368464 | 368468 | 368469 | 368471 | 368477 | 368601