Minor base/numerics cleanup

base/numerics/safe_conversions_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_CONVERSIONS_IMPL_H_
 #define BASE_NUMERICS_SAFE_CONVERSIONS_IMPL_H_
 
 #include <stdint.h>
 
 #include <limits>
@@ skipping 19 matching lines @@
                            std::is_signed<NumericType>::value;
 };
 
 // Helper templates for integer manipulations.
 
 template <typename Integer>
 struct PositionOfSignBit {
   static const size_t value = IntegerBitsPlusSign<Integer>::value - 1;
 };
 
-template <typename T>
-constexpr bool HasSignBit(T x) {
-  // Cast to unsigned since right shift on signed is undefined.
-  return (static_cast<typename std::make_unsigned<T>::type>(x) >>
-          PositionOfSignBit<T>::value) != 0;
-}
-
-// This wrapper undoes the standard integer promotions.
-template <typename T>
-constexpr T BinaryComplement(T x) {
-  return static_cast<T>(~x);
-}
-
 // Determines if a numeric value is negative without throwing compiler
 // warnings on: unsigned(value) < 0.
 template <typename T,
           typename std::enable_if<std::is_signed<T>::value>::type* = nullptr>
 constexpr bool IsValueNegative(T value) {
   static_assert(std::is_arithmetic<T>::value, "Argument must be numeric.");
   return value < 0;
 }
 
 template <typename T,
@@ skipping 21 matching lines @@
 template <typename T>
 constexpr T SignMask(T x) {
   using SignedT = typename std::make_signed<T>::type;
   // Right shift on a signed number is implementation defined, but it's often
   // implemented as arithmetic shift. If the compiler uses an arithmetic shift,
   // then use that to avoid the extra negation.
   return static_cast<T>(
       (static_cast<SignedT>(-1) >> PositionOfSignBit<T>::value) ==
               static_cast<SignedT>(-1)
           ? (static_cast<SignedT>(x) >> PositionOfSignBit<T>::value)
-          : -static_cast<SignedT>(HasSignBit(x)));
+          : -static_cast<SignedT>(static_cast<SignedT>(x) < 0));
 }
 static_assert(SignMask(-2) == -1,
               "Inconsistent handling of signed right shift.");
 static_assert(SignMask(-3L) == -1L,
               "Inconsistent handling of signed right shift.");
 static_assert(SignMask(-4LL) == -1LL,
               "Inconsistent handling of signed right shift.");
 
 // This performs a safe, non-branching absolute value via unsigned overflow.
 template <typename T,
@@ skipping 637 matching lines @@
                    static_cast<BigType>(static_cast<L>(lhs)),
                    static_cast<BigType>(static_cast<R>(rhs)))
              // Let the template functions figure it out for mixed types.
              : C<L, R>::Test(lhs, rhs);
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_NUMERICS_SAFE_CONVERSIONS_IMPL_H_