Performance optimizations for base/numerics absolute value and multiply

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 18 matching lines @@
 //  strict_cast<> - 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 and thus introduces no runtime overhead.
 //  IsValueInRangeForNumericType<>() - A convenience function that returns true
 //      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.
+//  SafeUnsignedAbs() - Returns the absolute value of the supplied integer
+//      parameter as an unsigned result (thus avoiding an overflow if the value
+//      is the signed, two's complement minimum).
 //  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.
 //  MakeStrictNum() - 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.
@@ skipping 223 matching lines @@
 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::SafeUnsignedAbs;
 using internal::StrictNumeric;
 using internal::MakeStrictNum;
 
 // Explicitly make a shorter size_t alias for convenience.
 using SizeT = StrictNumeric<size_t>;
 
 }  // namespace base
 
 #endif  // BASE_NUMERICS_SAFE_CONVERSIONS_H_