Add support for CheckedNumeric Max and Min constexpr functions

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 <cassert>
@@ skipping 24 matching lines @@
 //      if the type supplied to the template parameter can represent the value
 //      passed as an argument to the function.
 //  IsValueNegative<>() - A convenience function that will accept any arithmetic
 //      type as an argument and will return whether the value is less than zero.
 //      Unsigned types always return false.
 //  StrictNumeric<> - A wrapper type that performs assignments and copies via
 //      the strict_cast<> template, and can perform valid arithmetic comparisons
 //      across any range of arithmetic types. StrictNumeric is the return type
 //      for values extracted from a CheckedNumeric class instance. The raw
 //      arithmetic value is extracted via static_cast to the underlying type.
+//  StrictNum() - Creates a new StrictNumeric from the underlying type of the
+//          supplied arithmetic or StrictNumeric type.
 
 // Convenience function that returns true if the supplied value is in range
 // for the destination type.
 template <typename Dst, typename Src>
 constexpr bool IsValueInRangeForNumericType(Src value) {
   return internal::DstRangeRelationToSrcRange<Dst>(value) ==
          internal::RANGE_VALID;
 }
 
 // Convenience function for determining if a numeric value is negative without
@@ skipping 167 matching lines @@
             typename std::enable_if<
                 IsNumericRangeContained<Dst, T>::value>::type* = nullptr>
   constexpr operator Dst() const {
     return static_cast<typename ArithmeticOrUnderlyingEnum<Dst>::type>(value_);
   }
 
  private:
   const T value_;
 };
 
+// Convience wrapper returns a StrictNumeric from the provided arithmetic type.
+template <typename T>
+constexpr StrictNumeric<typename UnderlyingType<T>::type> StrictNum(

[dcheng, 2016/12/03 21:34:29]

Nit: usually we name the deducing helpers MakeFoo, e.g. MakeUnique or
make_scoped_refptr. I think that's what I'd personally prefer to see in the
base/numerics interface for consitency.

[jschuh, 2016/12/03 22:29:12]

Fair. I'll fix it here and convert CheckNum to MakeChecked in another CL as
well. 

[dcheng, 2016/12/04 01:42:14]

MakeStrict / MakeChecked almost feel too generic (it's not obvious they have
anything to do with arithmetic without context). But I'm happy to bikeshed in
the followup.

+    const T value) {
+  return value;
+}
+
 // Overload the ostream output operator to make logging work nicely.
 template <typename T>
 std::ostream& operator<<(std::ostream& os, const StrictNumeric<T>& value) {
   os << static_cast<T>(value);
   return os;
 }
 
 #define STRICT_COMPARISON_OP(NAME, OP)                               \
   template <typename L, typename R,                                  \
             typename std::enable_if<                                 \
                 internal::IsStrictOp<L, R>::value>::type* = nullptr> \
   constexpr bool operator OP(const L lhs, const R rhs) {             \
     return SafeCompare<NAME, typename UnderlyingType<L>::type,       \
                        typename UnderlyingType<R>::type>(lhs, rhs);  \
   }
 
 STRICT_COMPARISON_OP(IsLess, <);
 STRICT_COMPARISON_OP(IsLessOrEqual, <=);
 STRICT_COMPARISON_OP(IsGreater, >);
 STRICT_COMPARISON_OP(IsGreaterOrEqual, >=);
 STRICT_COMPARISON_OP(IsEqual, ==);
 STRICT_COMPARISON_OP(IsNotEqual, !=);
 
 #undef STRICT_COMPARISON_OP
 };
 
 using internal::strict_cast;
 using internal::saturated_cast;
 using internal::StrictNumeric;
+using internal::StrictNum;
 
 // Explicitly make a shorter size_t typedef for convenience.
 typedef StrictNumeric<size_t> SizeT;
 
 }  // namespace base
 
 #endif  // BASE_NUMERICS_SAFE_CONVERSIONS_H_