Start using type traits in src/record instead of macros.

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 40 matching lines @@
     typedef typename SkTIf_c<static_cast<bool>(Condition::value), T, F>::type type;
 };
 
 /** SkTMux::type = (a && b) ? Both : (a) ? A : (b) ? B : Neither; */
 template <typename a, typename b, typename Both, typename A, typename B, typename Neither>
 struct SkTMux {
     typedef typename SkTIf<a, typename SkTIf<b, Both, A>::type,
                               typename SkTIf<b, B, Neither>::type>::type type;
 };
 
+/** SkTEnableIf is a pre-C++11 std::enable_if. */

[bungeman-skia, 2014/04/25 21:45:55]

The first time I wrote this:
https://codereview.chromium.org/18503009/diff/37001/src/utils/SkTLogic.h

In particular, I like the comments there, which state how to use it. FOr example
here

/** SkTEnableIf::type = (Condition::value) ? T : [does not exist]; */

[mtklein, 2014/04/28 15:47:05]

Done.

+template <bool B, class T = void>
+struct SkTEnableIf {};
+
+template <class T>
+struct SkTEnableIf<true, T> { typedef T type; };
+
+// A macro that makes it clearer to use SkTEnableIf in parameter lists.
+// template <typaname T> void foo(T a, SK_ENABLE_IF(condition)) { ... }

[bungeman-skia, 2014/04/25 21:45:55]

'condition' here seems misleading, since this is actually a 'type'. Note that
the first time I wrote this I made two (following the boost pattern, see
http://www.boost.org/doc/libs/1_55_0/libs/utility/enable_if.html), one with _c
(for condition) and the other without (which was for type). c++11 traits get
around this by using constexpr conversion functions.

[mtklein, 2014/04/28 15:47:05]

Done.

+// template <typaname T> void foo(T a, SK_ENABLE_IF(!condition)) { ... }

[bungeman-skia, 2014/04/25 21:45:55]

For example this is somewhat odd, in that this really is !type::value.

[mtklein, 2014/04/28 15:47:05]

Done.

+#define SK_ENABLE_IF(cond) typename SkTEnableIf<cond::value, bool>::type = false

[bungeman-skia, 2014/04/25 21:45:55]

#define SK_FUNCTION_ARGUMENT_REQUIRES(type) typename SkTEnableIf<type::value,
bool>::type = false

enable_if already has a meaning, this is the application as a function argument.

Can we use the 'return' version instead of the 'parameter' version?

#define SK_FUNCTION_REQUIRES(cond_type, return_type) typename
SkTEnableIf<cond_type::value, return_type>::type

used like 

template <typename T> SK_FUNCTION_REQUIRES(ChangesClip<T>, void) updateClip()

[mtklein, 2014/04/28 15:47:05]

Done.

+
+// 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; \
+    enum { value = sizeof(func<Derived>(NULL)) == 2 }; \

[bungeman-skia, 2014/04/25 21:45:55]

We don't normally write it like this, something more like

static const bool value = sizeof(test<Derived>(NULL)) == sizeof(uint16_t);

seems clearer.

[mtklein, 2014/04/28 15:47:05]

Done.

+}
+
 #endif