[Base] Use variadic template in base/callback.h (wave 1)

base/callback_internal.h

 // Copyright (c) 2012 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.
 
 // This file contains utility functions and classes that help the
 // implementation, and management of the Callback objects.
 
 #ifndef BASE_CALLBACK_INTERNAL_H_
 #define BASE_CALLBACK_INTERNAL_H_
 
@@ skipping 63 matching lines @@
   template <typename U>
   static YesType Test(const typename U::MoveOnlyTypeForCPP03*);
 
   template <typename U>
   static NoType Test(...);
 
   static const bool value = sizeof(Test<T>(0)) == sizeof(YesType) &&
                             !is_const<T>::value;
 };
 
+// Returns |Then| as SelectType::Type if |condition| is true. Otherwise returns
+// |Else|.
+template <bool condition, typename Then, typename Else>
+struct SelectType {
+  typedef Then Type;
+};
+
+template <typename Then, typename Else>
+struct SelectType<false, Then, Else> {
+  typedef Else Type;
+};
+
+template <typename>
+struct CallbackParamTraitsForMoveOnlyType;
+
+template <typename>
+struct CallbackParamTraitsForNonMoveOnlyType;
+
+// TODO(tzik): Use a default parameter once MSVS supports variadic templates
+// with default values.

[awong, 2014/10/07 18:45:39]

Can we cite a bit that has a reference to the MSVS issue that's requiring this
code change?

[tzik, 2014/10/08 15:56:11]

Added an upstream bug link.
Though, actually, I still don't understand when the compiler fails to compile,
and which usage we should really avoid...

I removed SFINAE/default template parameters, variable number of inheritance in
single level, complex template specialization match, and multiple template pack
expansion in single expression from the following CL.
Each of them works fine individually though.

+//
 // This is a typetraits object that's used to take an argument type, and
 // extract a suitable type for storing and forwarding arguments.
 //
 // In particular, it strips off references, and converts arrays to
 // pointers for storage; and it avoids accidentally trying to create a
 // "reference of a reference" if the argument is a reference type.
 //
 // This array type becomes an issue for storage because we are passing bound
 // parameters by const reference. In this case, we end up passing an actual
 // array type in the initializer list which C++ does not allow.  This will
 // break passing of C-string literals.
-template <typename T, bool is_move_only = IsMoveOnlyType<T>::value>
-struct CallbackParamTraits {
+template <typename T>
+struct CallbackParamTraits
+    : SelectType<IsMoveOnlyType<T>::value,
+         CallbackParamTraitsForMoveOnlyType<T>,
+         CallbackParamTraitsForNonMoveOnlyType<T> >::Type {
+};
+
+template <typename T>
+struct CallbackParamTraitsForNonMoveOnlyType {
   typedef const T& ForwardType;
   typedef T StorageType;
 };
 
 // The Storage should almost be impossible to trigger unless someone manually
 // specifies type of the bind parameters.  However, in case they do,
 // this will guard against us accidentally storing a reference parameter.
 //
 // The ForwardType should only be used for unbound arguments.
 template <typename T>
-struct CallbackParamTraits<T&, false> {
+struct CallbackParamTraitsForNonMoveOnlyType<T&> {
   typedef T& ForwardType;
   typedef T StorageType;
 };
 
 // Note that for array types, we implicitly add a const in the conversion. This
 // means that it is not possible to bind array arguments to functions that take
 // a non-const pointer. Trying to specialize the template based on a "const
 // T[n]" does not seem to match correctly, so we are stuck with this
 // restriction.
 template <typename T, size_t n>
-struct CallbackParamTraits<T[n], false> {
+struct CallbackParamTraitsForNonMoveOnlyType<T[n]> {
   typedef const T* ForwardType;
   typedef const T* StorageType;
 };
 
 // See comment for CallbackParamTraits<T[n]>.
 template <typename T>
-struct CallbackParamTraits<T[], false> {
+struct CallbackParamTraitsForNonMoveOnlyType<T[]> {
   typedef const T* ForwardType;
   typedef const T* StorageType;
 };
 
 // Parameter traits for movable-but-not-copyable scopers.
 //
 // Callback<>/Bind() understands movable-but-not-copyable semantics where
 // the type cannot be copied but can still have its state destructively
 // transferred (aka. moved) to another instance of the same type by calling a
 // helper function.  When used with Bind(), this signifies transferal of the
 // object's state to the target function.
 //
 // For these types, the ForwardType must not be a const reference, or a
 // reference.  A const reference is inappropriate, and would break const
 // correctness, because we are implementing a destructive move.  A non-const
 // reference cannot be used with temporaries which means the result of a
 // function or a cast would not be usable with Callback<> or Bind().
 template <typename T>
-struct CallbackParamTraits<T, true> {
+struct CallbackParamTraitsForMoveOnlyType {
   typedef T ForwardType;
   typedef T StorageType;
 };
 
 // CallbackForward() is a very limited simulation of C++11's std::forward()
 // used by the Callback/Bind system for a set of movable-but-not-copyable
 // types.  It is needed because forwarding a movable-but-not-copyable
 // argument to another function requires us to invoke the proper move
 // operator to create a rvalue version of the type.  The supported types are
 // whitelisted below as overloads of the CallbackForward() function. The
@@ skipping 14 matching lines @@
 
 template <typename T>
 typename enable_if<IsMoveOnlyType<T>::value, T>::type CallbackForward(T& t) {
   return t.Pass();
 }
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_CALLBACK_INTERNAL_H_