Start using <type_traits> and <utility> (C++11).

src/utils/SkTFitsIn.h

 /*
  * 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 "SkTypes.h"
 #include "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 {
-    typedef skstd::false_type can_be_true;
+    typedef std::false_type can_be_true;
     typedef S source_type;
     static bool apply(S 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 {
-    typedef skstd::true_type can_be_true;
+    typedef std::true_type can_be_true;
     typedef S source_type;
     static bool apply(S s) {
         typedef SkTHasMoreDigits<S, D> precondition;
         static_assert(precondition::value, "SkTOutOfRange_LT_MinD__minS_gt_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 {
-    typedef skstd::true_type can_be_true;
+    typedef std::true_type can_be_true;
     typedef S source_type;
     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 {
-    typedef skstd::true_type can_be_true;
+    typedef std::true_type can_be_true;
     typedef S source_type;
     static bool apply(S s) {
         typedef SkTHasMoreDigits<S, D> precondition;
         static_assert(precondition::value, "SkTOutOfRange_GT_MaxD__maxS_lt_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<class OutOfRange_Low, class OutOfRange_High> struct SkTOutOfRange_Either {
-    typedef skstd::true_type can_be_true;
+    typedef std::true_type can_be_true;
     typedef typename OutOfRange_Low::source_type source_type;
     static bool apply(source_type s) {
         bool outOfRange = OutOfRange_Low::apply(s);
         if (!outOfRange) {
             outOfRange = OutOfRange_High::apply(s);
         }
         return outOfRange;
     }
 };
 
@@ skipping 115 matching lines @@
 
 /** 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::numeric_limits<S>::is_integer, "SkTFitsIn_source_must_be_integer");
     static_assert(std::numeric_limits<D>::is_integer, "SkTFitsIn_destination_must_be_integer");
 
     return !sktfitsin::Private::SkTFitsIn<D, S>::type::OutOfRange(s);
 }
 
 #endif