Cleanup RangeCheck class and dependencies

base/numerics/safe_conversions.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_CONVERSIONS_H_
 #define BASE_NUMERICS_SAFE_CONVERSIONS_H_
 
 #include <stddef.h>
 
 #include <limits>
@@ skipping 88 matching lines @@
   static constexpr T lowest() { return std::numeric_limits<T>::lowest(); }
   static constexpr T Underflow() {
     return std::numeric_limits<T>::has_infinity
                ? std::numeric_limits<T>::infinity() * -1
                : std::numeric_limits<T>::lowest();
   }
 };
 
 namespace internal {
 
-template <typename T, template <typename> class S>
-struct IsDefaultIntegralBounds {
-  static const bool value =
-      std::is_integral<T>::value &&
-      S<T>::max() == SaturationDefaultHandler<T>::max() &&
-      S<T>::lowest() == SaturationDefaultHandler<T>::lowest();
-};
-
-// Integral to integral conversions have a special optimization for the
-// standard bounds.
-template <typename Dst,
-          template <typename> class S,
-          typename Src,
-          typename std::enable_if<
-              std::is_integral<Src>::value &&
-              IsDefaultIntegralBounds<Dst, S>::value>::type* = nullptr>
-constexpr Dst saturated_cast_impl(Src value, RangeCheck constraint) {
-  using UnsignedDst = typename std::make_unsigned<Dst>::type;
-  // The member fields in this class are lined up such that the compiler
-  // can saturate without branching in this case by adding the register
-  // with the bitfields directly to the integral max.
-  return constraint.IsValid()
-             ? static_cast<Dst>(value)
-             : static_cast<Dst>(UnsignedDst(constraint.IsUnderflowFlagSet()) +
-                                std::numeric_limits<Dst>::max());
-}
-
-template <typename Dst,
-          template <typename> class S,
-          typename Src,
-          typename std::enable_if<
-              !std::is_integral<Src>::value ||
-              !IsDefaultIntegralBounds<Dst, S>::value>::type* = nullptr>
+template <typename Dst, template <typename> class S, typename Src>
 constexpr Dst saturated_cast_impl(Src value, RangeCheck constraint) {
   // For some reason clang generates much better code when the branch is
   // structured exactly this way, rather than a sequence of checks.
   return !constraint.IsOverflowFlagSet()
              ? (!constraint.IsUnderflowFlagSet() ? static_cast<Dst>(value)
                                                  : S<Dst>::Underflow())
              // Skip this check for integral Src, which cannot be NaN.
              : (std::is_integral<Src>::value || !constraint.IsUnderflowFlagSet()
                     ? S<Dst>::Overflow()
                     : S<Dst>::NaN());
@@ skipping 143 matching lines @@
 using internal::StrictNumeric;
 using internal::MakeStrictNum;
 using internal::IsValueNegative;
 
 // Explicitly make a shorter size_t alias for convenience.
 using SizeT = StrictNumeric<size_t>;
 
 }  // namespace base
 
 #endif  // BASE_NUMERICS_SAFE_CONVERSIONS_H_