Add skstd::unique_ptr and use it.

include/private/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.
  */
 
 #ifndef SkTLogic_DEFINED
 #define SkTLogic_DEFINED
 
+#include "SkTypes.h"
+
+#include <stddef.h>
 #include <stdint.h>
 
 namespace skstd {
 
+using nullptr_t = decltype(nullptr);
+
 template <typename T, T v> struct integral_constant {
     static const/*expr*/ T value = v;
     using value_type = T;
     using type = integral_constant<T, v>;
     //constexpr operator value_type() const noexcept { return value; }
     //constexpr value_type operator()() const noexcept { return value; }
 };
 
 template <bool B> using bool_constant = integral_constant<bool, B>;
 
@@ skipping 17 matching lines @@
 template <typename T> using remove_volatile_t = typename remove_volatile<T>::type;
 
 template <typename T> struct remove_cv { using type = remove_volatile_t<remove_const_t<T>>; };
 template <typename T> using remove_cv_t = typename remove_cv<T>::type;
 
 template <typename T> struct remove_reference { using type = T; };
 template <typename T> struct remove_reference<T&> { using type = T; };
 template <typename T> struct remove_reference<T&&> { using type = T; };
 template <typename T> using remove_reference_t = typename remove_reference<T>::type;
 
+template <typename T> struct remove_extent { using type = T; };
+template <typename T> struct remove_extent<T[]> { using type = T; };
+template <typename T, size_t N> struct remove_extent<T[N]> { using type = T;};
+template <typename T> using remove_extent_t = typename remove_extent<T>::type;
+
 template <typename T, typename U> struct is_same : false_type {};
 template <typename T> struct is_same<T, T> : true_type {};
 
 template <typename T> struct is_void : is_same<void, remove_cv_t<T>> {};
 
 template <typename T> struct is_const : false_type {};
 template <typename T> struct is_const<const T> : true_type {};
 
 template <typename T> struct is_volatile : false_type {};
 template <typename T> struct is_volatile<volatile T> : true_type {};
 
+template <typename T> struct is_pointer_detector : false_type {};
+template <typename T> struct is_pointer_detector<T*> : true_type {};
+template <typename T> struct is_pointer : is_pointer_detector<remove_cv_t<T>> {};
+
 template <typename T> struct is_reference : false_type {};
 template <typename T> struct is_reference<T&> : true_type {};
 template <typename T> struct is_reference<T&&> : true_type {};
 
 template <typename T> struct is_lvalue_reference : false_type {};
 template <typename T> struct is_lvalue_reference<T&> : true_type {};
 
-template <typename T> struct is_empty_detector {
-    struct Derived : public remove_cv_t<T> { char unused; };
-    static const bool value = sizeof(Derived) == sizeof(char);
+template <typename T> struct is_rvalue_reference : false_type {};
+template <typename T> struct is_rvalue_reference<T&&> : true_type {};
+
+template <typename T> struct is_class_detector {
+    using yes_type = uint8_t;
+    using no_type = uint16_t;
+    template <typename U> static yes_type clazz(int U::*);
+    template <typename U> static no_type clazz(...);
+    static const/*expr*/ bool value = sizeof(clazz<T>(0)) == sizeof(yes_type) /*&& !is_union<T>::value*/;
+};
+template <typename T> struct is_class : bool_constant<is_class_detector<T>::value> {};
+
+template <typename T, bool = is_class<T>::value> struct is_empty_detector {
+    struct Derived : public T { char unused; };
+    static const/*expr*/ bool value = sizeof(Derived) == sizeof(char);
+};
+template <typename T> struct is_empty_detector<T, false> {
+    static const/*expr*/ bool value = false;
 };
 template <typename T> struct is_empty : bool_constant<is_empty_detector<T>::value> {};
 
+template <typename T> struct is_array : false_type {};
+template <typename T> struct is_array<T[]> : true_type {};
+template <typename T, size_t N> struct is_array<T[N]> : true_type {};
+
+// template<typename R, typename... Args> struct is_function<
+//     R [calling-convention] (Args...[, ...]) [const] [volatile] [&|&&]> : true_type {};
+// The cv and ref-qualified versions are strange types we're currently avoiding, so not supported.
+// On all platforms, variadic functions only exist in the c calling convention.
+template <typename> struct is_function : false_type { };
+#if !defined(SK_BUILD_FOR_WIN)
+template <typename R, typename... Args> struct is_function<R(Args...)> : true_type {};
+#else
+template <typename R, typename... Args> struct is_function<R __cdecl (Args...)> : true_type {};
+template <typename R, typename... Args> struct is_function<R __stdcall (Args...)> : true_type {};

[bungeman-skia, 2015/09/03 23:15:17]

As it turns out the compiler on Windows just ignores __stdcall on x86_64
completely, so this type ends up __cdecl anyway, which causes errors. I'm not
sure why it doesn't go into the type anyway, but then get translated afterword.
There are already plenty of of valid types for which no object can be created
with that type anyway. In any event, x86 and x86_64 need to be considered
different here.

+template <typename R, typename... Args> struct is_function<R __fastcall (Args...)> : true_type {};
+template <typename R, typename... Args> struct is_function<R __vectorcall (Args...)> : true_type {};
+#endif
+template <typename R, typename... Args> struct is_function<R(Args..., ...)> : true_type {};
+
 template <typename T> struct add_const { using type = const T; };
 template <typename T> using add_const_t = typename add_const<T>::type;
 
 template <typename T> struct add_volatile { using type = volatile T; };
 template <typename T> using add_volatile_t = typename add_volatile<T>::type;
 
 template <typename T> struct add_cv { using type = add_volatile_t<add_const_t<T>>; };
 template <typename T> using add_cv_t = typename add_cv<T>::type;
 
+template <typename T> struct add_pointer { using type = remove_reference_t<T>*; };
+template <typename T> using add_pointer_t = typename add_pointer<T>::type;
+
+template <typename T> struct add_lvalue_reference {
+    using type = conditional_t<is_void<T>::value, T, T&>;

[bungeman-skia, 2015/09/03 23:15:17]

This (and the existing add_rvalue_reference below) are wrong, one cannot check
for void here to avoid creating a reference to void. The reference to void type
cannot be created at all here, regardless if it's actually going to be assigned
to 'type'. Instead some sort of SFINAE needs to be used to detect void.

+};
+template <typename T> using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;
+
 template <typename T> struct add_rvalue_reference {
     using type = conditional_t<is_void<T>::value || is_reference<T>::value, T, T&&>;

[bungeman-skia, 2015/09/03 23:15:17]

I honestly don't remember why I added this 'is_reference<T> test here. The
result should be the same both ways, considering the reference collapsing rules
T& -> T& (current) or T& && -> T& (without).

 };
 template <typename T> using add_rvalue_reference_t = typename add_rvalue_reference<T>::type;
 
+/* This is 'just' a forward declaration. */
+template <typename T> add_rvalue_reference_t<T> declval() /*noexcept*/;
+
+template <typename S, typename D, bool=is_void<S>::value||is_function<D>::value||is_array<D>::value>
+struct is_convertible_detector {
+    static const/*expr*/ bool value = is_void<D>::value;
+};
+template <typename S, typename D> struct is_convertible_detector<S, D, false> {
+    using yes_type = uint8_t;
+    using no_type = uint16_t;
+
+    template <typename To> static void param_convertable_to(To);
+
+    template <typename From, typename To>
+    static decltype(param_convertable_to<To>(declval<From>()), yes_type()) convertible(int);
+
+    template <typename, typename> static no_type convertible(...);
+
+    static const/*expr*/ bool value = sizeof(convertible<S, D>(0)) == sizeof(yes_type);
+};
+template<typename S, typename D> struct is_convertible
+    : bool_constant<is_convertible_detector<S, D>::value> { };
+
+template <typename T> struct decay {
+    using U = remove_reference_t<T>;
+    using type = conditional_t<is_array<U>::value,
+        remove_extent_t<U>*,
+        conditional_t<is_function<U>::value, add_pointer_t<U>, remove_cv_t<U>>>;
+};
+template <typename T> using decay_t = typename decay<T>::type;
+
 }  // namespace skstd
 
 // The sknonstd namespace contains things we would like to be proposed and feel std-ish.
 namespace sknonstd {
 
 // The name 'copy' here is fraught with peril. In this case it means 'append', not 'overwrite'.
 // Alternate proposed names are 'propagate', 'augment', or 'append' (and 'add', but already taken).
 // std::experimental::propagate_const already exists for other purposes in TSv2.
 // These also follow the <dest, source> pattern used by boost.
 template <typename D, typename S> struct copy_const {
@@ skipping 48 matching lines @@
 #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