small-object optimization for SkFunction

src/utils/SkTLogic.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.
  *
  *
  * This header provides some of the helpers (std::integral_constant) and
  * type transformations (std::conditional) which will become available with
  * C++11 in the type_traits header.
@@ skipping 64 matching lines @@
 /** SkTEnableIf::type = (Condition::value) ? T : [does not exist]; */
 template <class Condition, class T = void> struct SkTEnableIf
     : public SkTEnableIf_c<static_cast<bool>(Condition::value), T> { };
 
 /** Use as a return type to enable a function only when cond_type::value is true,
  *  like C++14's std::enable_if_t.  E.g.  (N.B. this is a dumb example.)
  *  SK_WHEN(SkTrue, int) f(void* ptr) { return 1; }
  *  SK_WHEN(!SkTrue, int) f(void* ptr) { return 2; }
  */
 #define SK_WHEN(cond_prefix, T) typename SkTEnableIf_c<cond_prefix::value, T>::type
+#define SK_WHEN_C(cond, T) typename SkTEnableIf_c<cond, T>::type
 
 // See http://en.wikibooks.org/wiki/More_C++_Idioms/Member_Detector
 #define SK_CREATE_MEMBER_DETECTOR(member)                                           \
 template <typename T>                                                               \
 class HasMember_##member {                                                          \
     struct Fallback { int member; };                                                \
     struct Derived : T, Fallback {};                                                \
     template <typename U, U> struct Check;                                          \
     template <typename U> static uint8_t func(Check<int Fallback::*, &U::member>*); \
     template <typename U> static uint16_t func(...);                                \
 public:                                                                             \
     typedef HasMember_##member type;                                                \
     static const bool value = sizeof(func<Derived>(NULL)) == sizeof(uint16_t);      \
 }
 
 // Same sort of thing as SK_CREATE_MEMBER_DETECTOR, but checks for the existence of a nested type.
 #define SK_CREATE_TYPE_DETECTOR(type)                                   \
 template <typename T>                                                   \
 class HasType_##type {                                                  \
     template <typename U> static uint8_t func(typename U::type*);       \
     template <typename U> static uint16_t func(...);                    \
 public:                                                                 \
     static const bool value = sizeof(func<T>(NULL)) == sizeof(uint8_t); \
 }
 
 #endif