Cleanup some constexpr nits in base/numerics

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>
 #include <type_traits>
 
 #include "base/logging.h"
 #include "base/numerics/safe_conversions_impl.h"
 
 namespace base {
 
 // Convenience function that returns true if the supplied value is in range
 // for the destination type.
 template <typename Dst, typename Src>
-inline constexpr bool IsValueInRangeForNumericType(Src value) {
+constexpr bool IsValueInRangeForNumericType(Src value) {
   return internal::DstRangeRelationToSrcRange<Dst>(value) ==
          internal::RANGE_VALID;
 }
 
 // Convenience function for determining if a numeric value is negative without
 // throwing compiler warnings on: unsigned(value) < 0.
 template <typename T>
 constexpr typename std::enable_if<std::numeric_limits<T>::is_signed, bool>::type
 IsValueNegative(T value) {
   static_assert(std::numeric_limits<T>::is_specialized,
@@ skipping 32 matching lines @@
   template <typename T>
   static constexpr T HandleNaN() {
     return T();
   }
 };
 
 namespace internal {
 // This wrapper is used for C++11 constexpr support by avoiding the declaration
 // of local variables in the saturated_cast template function.
 template <typename Dst, class NaNHandler, typename Src>
-inline constexpr Dst saturated_cast_impl(const Src value,
-                                         const RangeConstraint constraint) {
+constexpr Dst saturated_cast_impl(const Src value,
+                                  const RangeConstraint constraint) {
   return constraint == RANGE_VALID
              ? static_cast<Dst>(value)
              : (constraint == RANGE_UNDERFLOW
                     ? std::numeric_limits<Dst>::min()
                     : (constraint == RANGE_OVERFLOW
                            ? std::numeric_limits<Dst>::max()
                            : (constraint == RANGE_INVALID
                                   ? NaNHandler::template HandleNaN<Dst>()
                                   : (NOTREACHED(), static_cast<Dst>(value)))));
 }
 }  // namespace internal
 
 // saturated_cast<> is analogous to static_cast<> for numeric types, except
 // that the specified numeric conversion will saturate rather than overflow or
 // underflow. NaN assignment to an integral will defer the behavior to a
 // specified class. By default, it will return 0.
 template <typename Dst,
           class NaNHandler = SaturatedCastNaNBehaviorReturnZero,
           typename Src>
-inline constexpr Dst saturated_cast(Src value) {
+constexpr Dst saturated_cast(Src value) {
   return std::numeric_limits<Dst>::is_iec559
              ? static_cast<Dst>(value)  // Floating point optimization.
              : internal::saturated_cast_impl<Dst, NaNHandler>(
                    value, internal::DstRangeRelationToSrcRange<Dst>(value));
 }
 
 // strict_cast<> is analogous to static_cast<> for numeric types, except that
 // it will cause a compile failure if the destination type is not large enough
 // to contain any value in the source type. It performs no runtime checking.
 template <typename Dst, typename Src>
-inline constexpr Dst strict_cast(Src value) {
+constexpr Dst strict_cast(Src value) {
   static_assert(std::numeric_limits<Src>::is_specialized,
                 "Argument must be numeric.");
   static_assert(std::numeric_limits<Dst>::is_specialized,
                 "Result must be numeric.");
   static_assert((internal::StaticDstRangeRelationToSrcRange<Dst, Src>::value ==
                  internal::NUMERIC_RANGE_CONTAINED),
                 "The numeric conversion is out of range for this type. You "
                 "should probably use one of the following conversion "
                 "mechanisms on the value you want to pass:\n"
                 "- base::checked_cast\n"
@@ skipping 40 matching lines @@
  private:
   const T value_;
 };
 
 // Explicitly make a shorter size_t typedef for convenience.
 typedef StrictNumeric<size_t> SizeT;
 
 }  // namespace base
 
 #endif  // BASE_NUMERICS_SAFE_CONVERSIONS_H_