Templatize SkToXXX.

Makes the checked cast in debug more correct, avoiding new
warnings in vs2015.

BUG=skia:4553

Review URL: https://codereview.chromium.org/1814153003

4 files changed, 246 insertions, 27 deletions

diff --git a/include/core/SkString.h b/include/core/SkString.h
index 42466af80b..1c3ee3a20c 100644
--- a/include/core/SkString.h
+++ b/include/core/SkString.h
@@ -36,13 +36,13 @@ int SkStrStartsWithOneOf(const char string[], const char prefixes[]);
 static int SkStrFind(const char string[], const char substring[]) {
     const char *first = strstr(string, substring);
     if (NULL == first) return -1;
-    return SkToS32(first - &string[0]);
+    return SkToInt(first - &string[0]);
 }
 
 static int SkStrFindLastOf(const char string[], const char subchar) {
     const char* last = strrchr(string, subchar);
     if (NULL == last) return -1;
-    return SkToS32(last - &string[0]);
+    return SkToInt(last - &string[0]);
 }
 
 static bool SkStrContains(const char string[], const char substring[]) {
diff --git a/include/core/SkTypes.h b/include/core/SkTypes.h
index 1051f08cea..d7a791163b 100644
--- a/include/core/SkTypes.h
+++ b/include/core/SkTypes.h
@@ -256,27 +256,20 @@ typedef unsigned U16CPU;
  */
 typedef uint8_t SkBool8;
 
-#ifdef SK_DEBUG
-    SK_API int8_t      SkToS8(intmax_t);
-    SK_API uint8_t     SkToU8(uintmax_t);
-    SK_API int16_t     SkToS16(intmax_t);
-    SK_API uint16_t    SkToU16(uintmax_t);
-    SK_API int32_t     SkToS32(intmax_t);
-    SK_API uint32_t    SkToU32(uintmax_t);
-    SK_API int         SkToInt(intmax_t);
-    SK_API unsigned    SkToUInt(uintmax_t);
-    SK_API size_t      SkToSizeT(uintmax_t);
-#else
-    #define SkToS8(x)   ((int8_t)(x))
-    #define SkToU8(x)   ((uint8_t)(x))
-    #define SkToS16(x)  ((int16_t)(x))
-    #define SkToU16(x)  ((uint16_t)(x))
-    #define SkToS32(x)  ((int32_t)(x))
-    #define SkToU32(x)  ((uint32_t)(x))
-    #define SkToInt(x)  ((int)(x))
-    #define SkToUInt(x) ((unsigned)(x))
-    #define SkToSizeT(x) ((size_t)(x))
-#endif
+#include "../private/SkTFitsIn.h"
+template <typename D, typename S> D SkTo(S s) {
+    SkASSERT(SkTFitsIn<D>(s));
+    return static_cast<D>(s);
+}
+#define SkToS8(x)    SkTo<int8_t>(x)
+#define SkToU8(x)    SkTo<uint8_t>(x)
+#define SkToS16(x)   SkTo<int16_t>(x)
+#define SkToU16(x)   SkTo<uint16_t>(x)
+#define SkToS32(x)   SkTo<int32_t>(x)
+#define SkToU32(x)   SkTo<uint32_t>(x)
+#define SkToInt(x)   SkTo<int>(x)
+#define SkToUInt(x)  SkTo<unsigned>(x)
+#define SkToSizeT(x) SkTo<size_t>(x)
 
 /** Returns 0 or 1 based on the condition
 */
diff --git a/include/private/SkTFitsIn.h b/include/private/SkTFitsIn.h
new file mode 100644
index 0000000000..4802aff1eb
--- /dev/null
+++ b/include/private/SkTFitsIn.h
@@ -0,0 +1,227 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkTFitsIn_DEFINED
+#define SkTFitsIn_DEFINED
+
+#include "../private/SkTLogic.h"
+#include <limits>
+#include <type_traits>
+
+namespace sktfitsin {
+namespace Private {
+
+/** SkTMux::type = (a && b) ? Both : (a) ? A : (b) ? B : Neither; */
+template <bool a, bool b, typename Both, typename A, typename B, typename Neither>
+struct SkTMux {
+    using type = skstd::conditional_t<a, skstd::conditional_t<b, Both, A>,
+                                         skstd::conditional_t<b, B, Neither>>;
+};
+
+/** SkTHasMoreDigits = (digits(A) >= digits(B)) ? true_type : false_type. */
+template <typename A, typename B> struct SkTHasMoreDigits
+    : skstd::bool_constant<std::numeric_limits<A>::digits >= std::numeric_limits<B>::digits>
+{ };
+
+/** A high or low side predicate which is used when it is statically known
+ *  that source values are in the range of the Destination.
+ */
+template <typename S> struct SkTOutOfRange_False {
+    using can_be_true = std::false_type;
+    using source_type = S;
+    static bool apply(S) {
+        return false;
+    }
+};
+
+/** A low side predicate which tests if the source value < Min(D).
+ *  Assumes that Min(S) <= Min(D).
+ */
+template <typename D, typename S> struct SkTOutOfRange_LT_MinD {
+    using can_be_true = std::true_type;
+    using source_type = S;
+    static bool apply(S s) {
+        using precondition = SkTHasMoreDigits<S, D>;
+        static_assert(precondition::value, "minS > minD");
+
+        return s < static_cast<S>((std::numeric_limits<D>::min)());
+    }
+};
+
+/** A low side predicate which tests if the source value is less than 0. */
+template <typename D, typename S> struct SkTOutOfRange_LT_Zero {
+    using can_be_true = std::true_type;
+    using source_type = S;
+    static bool apply(S s) {
+        return s < static_cast<S>(0);
+    }
+};
+
+/** A high side predicate which tests if the source value > Max(D).
+ *  Assumes that Max(S) >= Max(D).
+ */
+template <typename D, typename S> struct SkTOutOfRange_GT_MaxD {
+    using can_be_true = std::true_type;
+    using source_type = S;
+    static bool apply(S s) {
+        using precondition = SkTHasMoreDigits<S, D>;
+        static_assert(precondition::value, "maxS < maxD");
+
+        return s > static_cast<S>((std::numeric_limits<D>::max)());
+    }
+};
+
+/** Composes two SkTOutOfRange predicates.
+ *  First checks OutOfRange_Low then, if in range, OutOfRange_High.
+ */
+template <typename OutOfRange_Low, typename OutOfRange_High> struct SkTOutOfRange_Either {
+    using can_be_true = std::true_type;
+    using source_type = typename OutOfRange_Low::source_type;
+    static bool apply(source_type s) {
+        bool outOfRange = OutOfRange_Low::apply(s);
+        if (!outOfRange) {
+            outOfRange = OutOfRange_High::apply(s);
+        }
+        return outOfRange;
+    }
+};
+
+/** SkTCombineOutOfRange::type is an SkTOutOfRange_XXX type which is the
+ *  optimal combination of OutOfRange_Low and OutOfRange_High.
+ */
+template <typename OutOfRange_Low, typename OutOfRange_High> struct SkTCombineOutOfRange {
+    using Both = SkTOutOfRange_Either<OutOfRange_Low, OutOfRange_High>;
+    using Neither = SkTOutOfRange_False<typename OutOfRange_Low::source_type>;
+
+    using apply_low = typename OutOfRange_Low::can_be_true;
+    using apply_high = typename OutOfRange_High::can_be_true;
+
+    using type = typename SkTMux<apply_low::value, apply_high::value,
+                                 Both, OutOfRange_Low, OutOfRange_High, Neither>::type;
+};
+
+template <typename D, typename S, typename OutOfRange_Low, typename OutOfRange_High>
+struct SkTRangeChecker {
+    /** This is the method which is called at runtime to do the range check. */
+    static bool OutOfRange(S s) {
+        using Combined = typename SkTCombineOutOfRange<OutOfRange_Low, OutOfRange_High>::type;
+        return Combined::apply(s);
+    }
+};
+
+/** SkTFitsIn_Unsigned2Unsiged::type is an SkTRangeChecker with an OutOfRange(S s) method
+ *  the implementation of which is tailored for the source and destination types.
+ *  Assumes that S and D are unsigned integer types.
+ */
+template <typename D, typename S> struct SkTFitsIn_Unsigned2Unsiged {
+    using OutOfRange_Low = SkTOutOfRange_False<S>;
+    using OutOfRange_High = SkTOutOfRange_GT_MaxD<D, S>;
+
+    using HighSideOnlyCheck = SkTRangeChecker<D, S, OutOfRange_Low, OutOfRange_High>;
+    using NoCheck = SkTRangeChecker<D, S, SkTOutOfRange_False<S>, SkTOutOfRange_False<S>>;
+
+    // If std::numeric_limits<D>::digits >= std::numeric_limits<S>::digits, nothing to check.
+    // This also protects the precondition of SkTOutOfRange_GT_MaxD.
+    using sourceFitsInDesitination = SkTHasMoreDigits<D, S>;
+    using type = skstd::conditional_t<sourceFitsInDesitination::value, NoCheck, HighSideOnlyCheck>;
+};
+
+/** SkTFitsIn_Signed2Signed::type is an SkTRangeChecker with an OutOfRange(S s) method
+ *  the implementation of which is tailored for the source and destination types.
+ *  Assumes that S and D are signed integer types.
+ */
+template <typename D, typename S> struct SkTFitsIn_Signed2Signed {
+    using OutOfRange_Low = SkTOutOfRange_LT_MinD<D, S>;
+    using OutOfRange_High = SkTOutOfRange_GT_MaxD<D, S>;
+
+    using FullCheck = SkTRangeChecker<D, S, OutOfRange_Low, OutOfRange_High>;
+    using NoCheck = SkTRangeChecker<D, S, SkTOutOfRange_False<S>, SkTOutOfRange_False<S>>;
+
+    // If std::numeric_limits<D>::digits >= std::numeric_limits<S>::digits, nothing to check.
+    // This also protects the precondition of SkTOutOfRange_LT_MinD and SkTOutOfRange_GT_MaxD.
+    using sourceFitsInDesitination = SkTHasMoreDigits<D, S>;
+    using type = skstd::conditional_t<sourceFitsInDesitination::value, NoCheck, FullCheck>;
+};
+
+/** SkTFitsIn_Signed2Unsigned::type is an SkTRangeChecker with an OutOfRange(S s) method
+ *  the implementation of which is tailored for the source and destination types.
+ *  Assumes that S is a signed integer type and D is an unsigned integer type.
+ */
+template <typename D, typename S> struct SkTFitsIn_Signed2Unsigned {
+    using OutOfRange_Low = SkTOutOfRange_LT_Zero<D, S>;
+    using OutOfRange_High = SkTOutOfRange_GT_MaxD<D, S>;
+
+    using FullCheck = SkTRangeChecker<D, S, OutOfRange_Low, OutOfRange_High>;
+    using LowSideOnlyCheck = SkTRangeChecker<D, S, OutOfRange_Low, SkTOutOfRange_False<S>>;
+
+    // If std::numeric_limits<D>::max() >= std::numeric_limits<S>::max(),
+    // no need to check the high side. (Until C++11, assume more digits means greater max.)
+    // This also protects the precondition of SkTOutOfRange_GT_MaxD.
+    using sourceCannotExceedDest = SkTHasMoreDigits<D, S>;
+    using type = skstd::conditional_t<sourceCannotExceedDest::value, LowSideOnlyCheck, FullCheck>;
+};
+
+/** SkTFitsIn_Unsigned2Signed::type is an SkTRangeChecker with an OutOfRange(S s) method
+ *  the implementation of which is tailored for the source and destination types.
+ *  Assumes that S is an usigned integer type and D is a signed integer type.
+ */
+template <typename D, typename S> struct SkTFitsIn_Unsigned2Signed {
+    using OutOfRange_Low = SkTOutOfRange_False<S>;
+    using OutOfRange_High = SkTOutOfRange_GT_MaxD<D, S>;
+
+    using HighSideOnlyCheck = SkTRangeChecker<D, S, OutOfRange_Low, OutOfRange_High>;
+    using NoCheck = SkTRangeChecker<D, S, SkTOutOfRange_False<S>, SkTOutOfRange_False<S>>;
+
+    // If std::numeric_limits<D>::max() >= std::numeric_limits<S>::max(), nothing to check.
+    // (Until C++11, assume more digits means greater max.)
+    // This also protects the precondition of SkTOutOfRange_GT_MaxD.
+    using sourceCannotExceedDest = SkTHasMoreDigits<D, S>;
+    using type = skstd::conditional_t<sourceCannotExceedDest::value, NoCheck, HighSideOnlyCheck>;
+};
+
+/** SkTFitsIn::type is an SkTRangeChecker with an OutOfRange(S s) method
+ *  the implementation of which is tailored for the source and destination types.
+ *  Assumes that S and D are integer types.
+ */
+template <typename D, typename S> struct SkTFitsIn {
+    // One of the following will be the 'selector' type.
+    using S2S = SkTFitsIn_Signed2Signed<D, S>;
+    using S2U = SkTFitsIn_Signed2Unsigned<D, S>;
+    using U2S = SkTFitsIn_Unsigned2Signed<D, S>;
+    using U2U = SkTFitsIn_Unsigned2Unsiged<D, S>;
+
+    using S_is_signed = skstd::bool_constant<std::numeric_limits<S>::is_signed>;
+    using D_is_signed = skstd::bool_constant<std::numeric_limits<D>::is_signed>;
+
+    using selector = typename SkTMux<S_is_signed::value, D_is_signed::value,
+                                     S2S, S2U, U2S, U2U>::type;
+    // This type is an SkTRangeChecker.
+    using type = typename selector::type;
+};
+
+template <typename T, bool = std::is_enum<T>::value> struct underlying_type {
+    using type = skstd::underlying_type_t<T>;
+};
+template <typename T> struct underlying_type<T, false> {
+    using type = T;
+};
+
+} // namespace Private
+} // namespace sktfitsin
+
+/** Returns true if the integer source value 's' will fit in the integer destination type 'D'. */
+template <typename D, typename S> inline bool SkTFitsIn(S s) {
+    static_assert(std::is_integral<S>::value || std::is_enum<S>::value, "S must be integral.");
+    static_assert(std::is_integral<D>::value || std::is_enum<D>::value, "D must be integral.");
+
+    using RealS = typename sktfitsin::Private::underlying_type<S>::type;
+    using RealD = typename sktfitsin::Private::underlying_type<D>::type;
+
+    return !sktfitsin::Private::SkTFitsIn<RealD, RealS>::type::OutOfRange(s);
+}
+
+#endif
diff --git a/include/private/SkTLogic.h b/include/private/SkTLogic.h
index b38fd50435..a3bc55e14e 100644
--- a/include/private/SkTLogic.h
+++ b/include/private/SkTLogic.h
@@ -14,8 +14,6 @@
 #ifndef SkTLogic_DEFINED
 #define SkTLogic_DEFINED
 
-#include "SkTypes.h"
-
 #include <stddef.h>
 #include <stdint.h>
 #include <type_traits>
@@ -42,7 +40,7 @@ template <typename T> using remove_extent_t = typename std::remove_extent<T>::ty
 // On all platforms, variadic functions only exist in the c calling convention.
 // mcvc 2013 introduced __vectorcall, but it wan't until 2015 that it was added to is_function.
 template <typename> struct is_function : std::false_type {};
-#if !defined(SK_BUILD_FOR_WIN)
+#if !defined(WIN32)
 template <typename R, typename... Args> struct is_function<R(Args...)> : std::true_type {};
 #else
 template <typename R, typename... Args> struct is_function<R __cdecl (Args...)> : std::true_type {};
@@ -50,7 +48,7 @@ template <typename R, typename... Args> struct is_function<R __cdecl (Args...)>
 template <typename R, typename... Args> struct is_function<R __stdcall (Args...)> : std::true_type {};
 template <typename R, typename... Args> struct is_function<R __fastcall (Args...)> : std::true_type {};
 #endif
-#if defined(_MSC_VER) && SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
+#if defined(_MSC_VER) && (_M_IX86_FP >= 2 || defined(_M_AMD64) || defined(_M_X64))
 template <typename R, typename... Args> struct is_function<R __vectorcall (Args...)> : std::true_type {};
 #endif
 #endif
@@ -63,6 +61,7 @@ template <typename T> using add_pointer_t = typename std::add_pointer<T>::type;
 template <typename T> using add_lvalue_reference_t = typename std::add_lvalue_reference<T>::type;
 
 template <typename... T> using common_type_t = typename std::common_type<T...>::type;
+template <typename T> using underlying_type_t = typename std::underlying_type<T>::type;
 
 template <typename S, typename D,
           bool=std::is_void<S>::value || is_function<D>::value || std::is_array<D>::value>