Reapply the non-MathExtras parts of

Source/wtf/CheckedArithmetic.h

 /*
  * Copyright (C) 2011 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 233 matching lines @@
         if (signsMatch(lhs, rhs)) {
             if (lhs >= 0) {
                 if ((std::numeric_limits<ResultType>::max() - rhs) < lhs)
                     return false;
             } else {
                 ResultType temp = lhs - std::numeric_limits<ResultType>::min();
                 if (rhs < -temp)
                     return false;
             }
         } // if the signs do not match this operation can't overflow
-        result = lhs + rhs;
+        result = static_cast<ResultType>(lhs + rhs);
         return true;
     }
 
     static inline bool sub(LHS lhs, RHS rhs, ResultType& result) WARN_UNUSED_RETURN
     {
         if (!signsMatch(lhs, rhs)) {
             if (lhs >= 0) {
                 if (lhs > std::numeric_limits<ResultType>::max() + rhs)
                     return false;
             } else {
                 if (rhs > std::numeric_limits<ResultType>::max() + lhs)
                     return false;
             }
         } // if the signs match this operation can't overflow
-        result = lhs - rhs;
+        result = static_cast<ResultType>(lhs - rhs);
         return true;
     }
 
     static inline bool multiply(LHS lhs, RHS rhs, ResultType& result) WARN_UNUSED_RETURN
     {
         if (signsMatch(lhs, rhs)) {
             if (lhs >= 0) {
                 if (lhs && (std::numeric_limits<ResultType>::max() / lhs) < rhs)
                     return false;
             } else {
                 if (static_cast<ResultType>(lhs) == std::numeric_limits<ResultType>::min() || static_cast<ResultType>(rhs) == std::numeric_limits<ResultType>::min())
                     return false;
                 if ((std::numeric_limits<ResultType>::max() / -lhs) < -rhs)
                     return false;
             }
         } else {
             if (lhs < 0) {
                 if (rhs && lhs < (std::numeric_limits<ResultType>::min() / rhs))
                     return false;
             } else {
                 if (lhs && rhs < (std::numeric_limits<ResultType>::min() / lhs))
                     return false;
             }
         }
-        result = lhs * rhs;
+        result = static_cast<ResultType>(lhs * rhs);
         return true;
     }
 
     static inline bool equals(LHS lhs, RHS rhs) { return lhs == rhs; }
 
 };
 
 template <typename LHS, typename RHS, typename ResultType> struct ArithmeticOperations<LHS, RHS, ResultType, false, false> {
     // LHS and RHS are unsigned types so bounds checks are nice and easy
     static inline bool add(LHS lhs, RHS rhs, ResultType& result) WARN_UNUSED_RETURN
@@ skipping 402 matching lines @@
     return Checked<U, OverflowHandler>(lhs) * rhs;
 }
 
 }
 
 using WTF::Checked;
 using WTF::CheckedState;
 using WTF::RecordOverflow;
 
 #endif