Add support for CheckedNumeric bitshift operators

base/numerics/safe_math_impl.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_NUMERICS_SAFE_MATH_IMPL_H_
 #define BASE_NUMERICS_SAFE_MATH_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 109 matching lines @@
   return !!(static_cast<typename UnsignedIntegerForSize<T>::type>(x) >>
             PositionOfSignBit<T>::value);
 }
 
 // This wrapper undoes the standard integer promotions.
 template <typename T>
 constexpr T BinaryComplement(T x) {
   return static_cast<T>(~x);
 }
 
+// Return if a numeric value is negative regardless of type.
+template <typename T,
+          typename std::enable_if<std::is_arithmetic<T>::value &&
+                                  std::is_signed<T>::value>::type* = nullptr>
+constexpr bool IsNegative(T x) {
+  return x < 0;
+}
+
+template <typename T,
+          typename std::enable_if<std::is_arithmetic<T>::value &&
+                                  !std::is_signed<T>::value>::type* = nullptr>
+constexpr bool IsNegative(T x) {
+  return false;
+}
+
 enum ArithmeticPromotionCategory {
   LEFT_PROMOTION,          // Use the type of the left-hand argument.
   RIGHT_PROMOTION,         // Use the type of the right-hand argument.
   MAX_EXPONENT_PROMOTION,  // Use the type supporting the largest exponent.
   BIG_ENOUGH_PROMOTION     // Attempt to find a big enough type.
 };
 
 template <ArithmeticPromotionCategory Promotion,
           typename Lhs,
           typename Rhs = Lhs>
@@ skipping 315 matching lines @@
 CheckedMod(T x, U y, V* result) {
   using Promotion =
       typename ArithmeticPromotion<BIG_ENOUGH_PROMOTION, T, U>::type;
   Promotion presult;
   bool is_valid = CheckedModImpl(static_cast<Promotion>(x),
                                  static_cast<Promotion>(y), &presult);
   *result = static_cast<V>(presult);
   return is_valid && IsValueInRangeForNumericType<V>(presult);
 }
 
+// Left shift. Shifts less than 0 or greater than or equal to the number
+// of bits in the promoted type are undefined. Shifts of negative values
+// are undefined. Otherwise it is defined when the result fits.
+template <typename T, typename U, typename V>
+typename std::enable_if<std::numeric_limits<T>::is_integer &&
+                            std::numeric_limits<U>::is_integer &&
+                            std::numeric_limits<V>::is_integer,
+                        bool>::type
+CheckedLeftShift(T x, U shift, V* result) {
+  using ShiftType = typename UnsignedIntegerForSize<T>::type;
+  static const ShiftType kBitWidth = CHAR_BIT * sizeof(T);
+  const ShiftType real_shift = static_cast<ShiftType>(shift);
+  // Signed shift is not legal on negative values.
+  if (!IsNegative(x) && real_shift < kBitWidth) {
+    // Just use a multiplication because it's easy.
+    // TODO(jschuh): This could probably be made more efficient.
+    if (!std::is_signed<T>::value || real_shift != kBitWidth - 1)
+      return CheckedMul(x, static_cast<T>(1) << shift, result);
+    return !x;  // Special case zero for a full width signed shift.
+  }
+  return false;
+}
+
+// Right shift. Shifts less than 0 or greater than or equal to the number
+// of bits in the promoted type are undefined. Otherwise, it is always defined,
+// but a right shift of a negative value is implementation-dependent.
+template <typename T, typename U, typename V>
+typename std::enable_if<std::numeric_limits<T>::is_integer &&
+                            std::numeric_limits<U>::is_integer &&
+                            std::numeric_limits<V>::is_integer,
+                        bool>::type
+CheckedRightShift(T x, U shift, V* result) {
+  // Use the type conversion push negative values out of range.
+  using ShiftType = typename UnsignedIntegerForSize<T>::type;
+  if (static_cast<ShiftType>(shift) < (CHAR_BIT * sizeof(T))) {
+    T tmp = x >> shift;
+    *result = static_cast<V>(tmp);
+    return IsValueInRangeForNumericType<unsigned>(tmp);
+  }
+  return false;
+}
+
 template <typename T>
 typename std::enable_if<std::numeric_limits<T>::is_integer &&
                             std::numeric_limits<T>::is_signed,
                         bool>::type
 CheckedNeg(T value, T* result) {
   // The negation of signed min is min, so catch that one.
   if (value != std::numeric_limits<T>::min()) {
     *result = static_cast<T>(-value);
     return true;
   }
@@ skipping 200 matching lines @@
       : value_(static_cast<T>(rhs.value())) {}
 
   bool is_valid() const { return std::isfinite(value_); }
   T value() const { return value_; }
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_NUMERICS_SAFE_MATH_IMPL_H_