Add skstd::move and skstd::forward.

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.
  *
  * Because we lack constexpr, we cannot mimic
  * std::integral_constant::'constexpr operator T()'.
  * As a result we introduce SkTBool and SkTIf similar to Boost in order to
  * minimize the visual noise of many uses of '::value'.
  */
 
 #ifndef SkTLogic_DEFINED
 #define SkTLogic_DEFINED
 
+#include <stdint.h>
+
 /** Represents a templated integer constant.
  *  Pre-C++11 version of std::integral_constant.
  */
 template <typename T, T v> struct SkTIntegralConstant {
     static const T value = v;
     typedef T value_type;
     typedef SkTIntegralConstant<T, v> type;
 };
 
 /** Convenience specialization of SkTIntegralConstant. */
@@ skipping 70 matching lines @@
 // 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); \
 }
 
+namespace skstd {
+
+/** SkTRemoveReference<T>::type is the type of T with any top-level lvalue or rvalue removed. */
+template <typename T> struct remove_reference { typedef T type; };
+template <typename T> struct remove_reference<T&> { typedef T type; };
+template <typename T> struct remove_reference<T&&> { typedef T type; };
+template <typename T> using remove_reference_t = typename remove_reference<T>::type;
+
+/** SkTIsLValueReference<T>::value is true if the type T is an lvalue reference. */
+template <typename T> struct is_lvalue_reference : SkFalse {};
+template <typename T> struct is_lvalue_reference<T&> : SkTrue {};
+
+}  // namespace skstd
+
+/**
+ *  SkTIsConst<T>::value is true if the type T is const.
+ *  The type T is constrained not to be an array or reference type.
+ */
+template <typename T> struct SkTIsConst {
+    static T* t;
+    static uint16_t test(const volatile void*);
+    static uint32_t test(volatile void *);
+    static const bool value = (sizeof(uint16_t) == sizeof(test(t)));
+};
+
 #endif