Gin: Add support for binding JS methods to C++ instance methods.

base/template_util.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_TEMPLATE_UTIL_H_
 #define BASE_TEMPLATE_UTIL_H_
 
 #include <cstddef>  // For size_t.
 
 #include "build/build_config.h"
@@ skipping 10 matching lines @@
 };
 
 template <class T, T v> const T integral_constant<T, v>::value;
 
 typedef integral_constant<bool, true> true_type;
 typedef integral_constant<bool, false> false_type;
 
 template <class T> struct is_pointer : false_type {};
 template <class T> struct is_pointer<T*> : true_type {};
 
+// Member function pointer detection up to four params. Add more as needed
+// below. This is built-in to C++ 11, and we can remove this when we switch.
+template<typename T>
+struct is_member_function_pointer : false_type {};
+
+template <typename R, typename Z>
+struct is_member_function_pointer<R(Z::*)()> : true_type {};
+template <typename R, typename Z>
+struct is_member_function_pointer<R(Z::*)() const> : true_type {};
+
+template <typename R, typename Z, typename A>
+struct is_member_function_pointer<R(Z::*)(A)> : true_type {};
+template <typename R, typename Z, typename A>
+struct is_member_function_pointer<R(Z::*)(A) const> : true_type {};
+
+template <typename R, typename Z, typename A, typename B>
+struct is_member_function_pointer<R(Z::*)(A, B)> : true_type {};
+template <typename R, typename Z, typename A, typename B>
+struct is_member_function_pointer<R(Z::*)(A, B) const> : true_type {};
+
+template <typename R, typename Z, typename A, typename B, typename C>
+struct is_member_function_pointer<R(Z::*)(A, B, C)> : true_type {};
+template <typename R, typename Z, typename A, typename B, typename C>
+struct is_member_function_pointer<R(Z::*)(A, B, C) const> : true_type {};
+
+template <typename R, typename Z, typename A, typename B, typename C,
+          typename D>
+struct is_member_function_pointer<R(Z::*)(A, B, C, D)> : true_type {};
+template <typename R, typename Z, typename A, typename B, typename C,
+          typename D>
+struct is_member_function_pointer<R(Z::*)(A, B, C, D) const> : true_type {};
+
+
 template <class T, class U> struct is_same : public false_type {};
 template <class T> struct is_same<T,T> : true_type {};
 
 template<class> struct is_array : public false_type {};
 template<class T, size_t n> struct is_array<T[n]> : public true_type {};
 template<class T> struct is_array<T[]> : public true_type {};
 
 template <class T> struct is_non_const_reference : false_type {};
 template <class T> struct is_non_const_reference<T&> : true_type {};
 template <class T> struct is_non_const_reference<const T&> : false_type {};
@@ skipping 67 matching lines @@
 
 template<bool B, class T = void>
 struct enable_if {};
 
 template<class T>
 struct enable_if<true, T> { typedef T type; };
 
 }  // namespace base
 
 #endif  // BASE_TEMPLATE_UTIL_H_