diff --git a/base/tuple.h b/base/tuple.h
index 12f7f84..16f5124 100644
--- a/base/tuple.h
+++ b/base/tuple.h
@@ -31,6 +31,29 @@
 
 #include "base/bind_helpers.h"
 
+// Index sequences
+//
+// Minimal clone of the similarly-named C++14 functionality.
+
+template <size_t...>
+struct IndexSequence {};
+
+template <size_t... Ns>
+struct MakeIndexSequenceImpl;
+
+template <size_t... Ns>
+struct MakeIndexSequenceImpl<0, Ns...> {
+  using Type = IndexSequence<Ns...>;
+};
+
+template <size_t N, size_t... Ns>
+struct MakeIndexSequenceImpl<N, Ns...> {
+  using Type = typename MakeIndexSequenceImpl<N - 1, N - 1, Ns...>::Type;
+};
+
+template <size_t N>
+using MakeIndexSequence = typename MakeIndexSequenceImpl<N>::Type;
+
 // Traits ----------------------------------------------------------------------
 //
 // A simple traits class for tuple arguments.
@@ -53,9 +76,6 @@
   typedef P& ParamType;
 };
 
-template <class P>
-struct TupleTypes { };
-
 // Tuple -----------------------------------------------------------------------
 //
 // This set of classes is useful for bundling 0 or more heterogeneous data types
@@ -70,73 +90,70 @@
 // want filled by the dispatchee, and the tuple is merely a container for that
 // output (a "tier").  See MakeRefTuple and its usages.
 
-struct Tuple0 {
-  typedef Tuple0 ValueTuple;
-  typedef Tuple0 RefTuple;
-  typedef Tuple0 ParamTuple;
-};
+template <typename... Ts>
+struct Tuple;
 
-template <class A>
-struct Tuple1 {
+template <>
+struct Tuple<> {};
+
+template <typename A>
+struct Tuple<A> {
  public:
   typedef A TypeA;
 
-  Tuple1() {}
-  explicit Tuple1(typename TupleTraits<A>::ParamType a) : a(a) {}
+  Tuple() {}
+  explicit Tuple(typename TupleTraits<A>::ParamType a) : a(a) {}
 
   A a;
 };
 
-template <class A, class B>
-struct Tuple2 {
+template <typename A, typename B>
+struct Tuple<A, B> {
  public:
   typedef A TypeA;
   typedef B TypeB;
 
-  Tuple2() {}
-  Tuple2(typename TupleTraits<A>::ParamType a,
-         typename TupleTraits<B>::ParamType b)
-      : a(a), b(b) {
-  }
+  Tuple() {}
+  Tuple(typename TupleTraits<A>::ParamType a,
+        typename TupleTraits<B>::ParamType b)
+      : a(a), b(b) {}
 
   A a;
   B b;
 };
 
-template <class A, class B, class C>
-struct Tuple3 {
+template <typename A, typename B, typename C>
+struct Tuple<A, B, C> {
  public:
   typedef A TypeA;
   typedef B TypeB;
   typedef C TypeC;
 
-  Tuple3() {}
-  Tuple3(typename TupleTraits<A>::ParamType a,
-         typename TupleTraits<B>::ParamType b,
-         typename TupleTraits<C>::ParamType c)
-      : a(a), b(b), c(c){
-  }
+  Tuple() {}
+  Tuple(typename TupleTraits<A>::ParamType a,
+        typename TupleTraits<B>::ParamType b,
+        typename TupleTraits<C>::ParamType c)
+      : a(a), b(b), c(c) {}
 
   A a;
   B b;
   C c;
 };
 
-template <class A, class B, class C, class D>
-struct Tuple4 {
+template <typename A, typename B, typename C, typename D>
+struct Tuple<A, B, C, D> {
  public:
   typedef A TypeA;
   typedef B TypeB;
   typedef C TypeC;
   typedef D TypeD;
 
-  Tuple4() {}
-  Tuple4(typename TupleTraits<A>::ParamType a,
-         typename TupleTraits<B>::ParamType b,
-         typename TupleTraits<C>::ParamType c,
-         typename TupleTraits<D>::ParamType d)
-      : a(a), b(b), c(c), d(d) {
-  }
+  Tuple() {}
+  Tuple(typename TupleTraits<A>::ParamType a,
+        typename TupleTraits<B>::ParamType b,
+        typename TupleTraits<C>::ParamType c,
+        typename TupleTraits<D>::ParamType d)
+      : a(a), b(b), c(c), d(d) {}
 
   A a;
   B b;
@@ -144,8 +161,8 @@
   D d;
 };
 
-template <class A, class B, class C, class D, class E>
-struct Tuple5 {
+template <typename A, typename B, typename C, typename D, typename E>
+struct Tuple<A, B, C, D, E> {
  public:
   typedef A TypeA;
   typedef B TypeB;
@@ -153,14 +170,13 @@
   typedef D TypeD;
   typedef E TypeE;
 
-  Tuple5() {}
-  Tuple5(typename TupleTraits<A>::ParamType a,
-    typename TupleTraits<B>::ParamType b,
-    typename TupleTraits<C>::ParamType c,
-    typename TupleTraits<D>::ParamType d,
-    typename TupleTraits<E>::ParamType e)
-    : a(a), b(b), c(c), d(d), e(e) {
-  }
+  Tuple() {}
+  Tuple(typename TupleTraits<A>::ParamType a,
+        typename TupleTraits<B>::ParamType b,
+        typename TupleTraits<C>::ParamType c,
+        typename TupleTraits<D>::ParamType d,
+        typename TupleTraits<E>::ParamType e)
+      : a(a), b(b), c(c), d(d), e(e) {}
 
   A a;
   B b;
@@ -169,8 +185,13 @@
   E e;
 };
 
-template <class A, class B, class C, class D, class E, class F>
-struct Tuple6 {
+template <typename A,
+          typename B,
+          typename C,
+          typename D,
+          typename E,
+          typename F>
+struct Tuple<A, B, C, D, E, F> {
  public:
   typedef A TypeA;
   typedef B TypeB;
@@ -179,15 +200,14 @@
   typedef E TypeE;
   typedef F TypeF;
 
-  Tuple6() {}
-  Tuple6(typename TupleTraits<A>::ParamType a,
-    typename TupleTraits<B>::ParamType b,
-    typename TupleTraits<C>::ParamType c,
-    typename TupleTraits<D>::ParamType d,
-    typename TupleTraits<E>::ParamType e,
-    typename TupleTraits<F>::ParamType f)
-    : a(a), b(b), c(c), d(d), e(e), f(f) {
-  }
+  Tuple() {}
+  Tuple(typename TupleTraits<A>::ParamType a,
+        typename TupleTraits<B>::ParamType b,
+        typename TupleTraits<C>::ParamType c,
+        typename TupleTraits<D>::ParamType d,
+        typename TupleTraits<E>::ParamType e,
+        typename TupleTraits<F>::ParamType f)
+      : a(a), b(b), c(c), d(d), e(e), f(f) {}
 
   A a;
   B b;
@@ -197,8 +217,14 @@
   F f;
 };
 
-template <class A, class B, class C, class D, class E, class F, class G>
-struct Tuple7 {
+template <typename A,
+          typename B,
+          typename C,
+          typename D,
+          typename E,
+          typename F,
+          typename G>
+struct Tuple<A, B, C, D, E, F, G> {
  public:
   typedef A TypeA;
   typedef B TypeB;
@@ -208,16 +234,15 @@
   typedef F TypeF;
   typedef G TypeG;
 
-  Tuple7() {}
-  Tuple7(typename TupleTraits<A>::ParamType a,
-    typename TupleTraits<B>::ParamType b,
-    typename TupleTraits<C>::ParamType c,
-    typename TupleTraits<D>::ParamType d,
-    typename TupleTraits<E>::ParamType e,
-    typename TupleTraits<F>::ParamType f,
-    typename TupleTraits<G>::ParamType g)
-    : a(a), b(b), c(c), d(d), e(e), f(f), g(g) {
-  }
+  Tuple() {}
+  Tuple(typename TupleTraits<A>::ParamType a,
+        typename TupleTraits<B>::ParamType b,
+        typename TupleTraits<C>::ParamType c,
+        typename TupleTraits<D>::ParamType d,
+        typename TupleTraits<E>::ParamType e,
+        typename TupleTraits<F>::ParamType f,
+        typename TupleTraits<G>::ParamType g)
+      : a(a), b(b), c(c), d(d), e(e), f(f), g(g) {}
 
   A a;
   B b;
@@ -228,9 +253,15 @@
   G g;
 };
 
-template <class A, class B, class C, class D, class E, class F, class G,
-          class H>
-struct Tuple8 {
+template <typename A,
+          typename B,
+          typename C,
+          typename D,
+          typename E,
+          typename F,
+          typename G,
+          typename H>
+struct Tuple<A, B, C, D, E, F, G, H> {
  public:
   typedef A TypeA;
   typedef B TypeB;
@@ -241,17 +272,16 @@
   typedef G TypeG;
   typedef H TypeH;
 
-  Tuple8() {}
-  Tuple8(typename TupleTraits<A>::ParamType a,
-    typename TupleTraits<B>::ParamType b,
-    typename TupleTraits<C>::ParamType c,
-    typename TupleTraits<D>::ParamType d,
-    typename TupleTraits<E>::ParamType e,
-    typename TupleTraits<F>::ParamType f,
-    typename TupleTraits<G>::ParamType g,
-    typename TupleTraits<H>::ParamType h)
-    : a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h) {
-  }
+  Tuple() {}
+  Tuple(typename TupleTraits<A>::ParamType a,
+        typename TupleTraits<B>::ParamType b,
+        typename TupleTraits<C>::ParamType c,
+        typename TupleTraits<D>::ParamType d,
+        typename TupleTraits<E>::ParamType e,
+        typename TupleTraits<F>::ParamType f,
+        typename TupleTraits<G>::ParamType g,
+        typename TupleTraits<H>::ParamType h)
+      : a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h) {}
 
   A a;
   B b;
@@ -263,157 +293,144 @@
   H h;
 };
 
+// Deprecated compat aliases
+
+using Tuple0 = Tuple<>;
+template <typename A>
+using Tuple1 = Tuple<A>;
+template <typename A, typename B>
+using Tuple2 = Tuple<A, B>;
+template <typename A, typename B, typename C>
+using Tuple3 = Tuple<A, B, C>;
+template <typename A, typename B, typename C, typename D>
+using Tuple4 = Tuple<A, B, C, D>;
+template <typename A, typename B, typename C, typename D, typename E>
+using Tuple5 = Tuple<A, B, C, D, E>;
+template <typename A,
+          typename B,
+          typename C,
+          typename D,
+          typename E,
+          typename F>
+using Tuple6 = Tuple<A, B, C, D, E, F>;
+template <typename A,
+          typename B,
+          typename C,
+          typename D,
+          typename E,
+          typename F,
+          typename G>
+using Tuple7 = Tuple<A, B, C, D, E, F, G>;
+template <typename A,
+          typename B,
+          typename C,
+          typename D,
+          typename E,
+          typename F,
+          typename G,
+          typename H>
+using Tuple8 = Tuple<A, B, C, D, E, F, G, H>;
+
+// Tuple element --------------------------------------------------------------
+
+template <size_t N, typename T>
+struct TupleElement;
+
+template <typename T, typename... Ts>
+struct TupleElement<0, Tuple<T, Ts...>> {
+  using Type = T;
+};
+
+template <size_t N, typename T, typename... Ts>
+struct TupleElement<N, Tuple<T, Ts...>> {
+  using Type = typename TupleElement<N - 1, Tuple<Ts...>>::Type;
+};
+
+// Tuple getters --------------------------------------------------------------
+
+template <size_t, typename T>
+struct TupleGetter;
+
+template <typename... Ts>
+struct TupleGetter<0, Tuple<Ts...>> {
+  using Elem = typename TupleElement<0, Tuple<Ts...>>::Type;
+  static Elem& Get(Tuple<Ts...>& t) { return t.a; }
+  static const Elem& Get(const Tuple<Ts...>& t) { return t.a; }
+};
+
+template <typename... Ts>
+struct TupleGetter<1, Tuple<Ts...>> {
+  using Elem = typename TupleElement<1, Tuple<Ts...>>::Type;
+  static Elem& Get(Tuple<Ts...>& t) { return t.b; }
+  static const Elem& Get(const Tuple<Ts...>& t) { return t.b; }
+};
+
+template <typename... Ts>
+struct TupleGetter<2, Tuple<Ts...>> {
+  using Elem = typename TupleElement<2, Tuple<Ts...>>::Type;
+  static Elem& Get(Tuple<Ts...>& t) { return t.c; }
+  static const Elem& Get(const Tuple<Ts...>& t) { return t.c; }
+};
+
+template <typename... Ts>
+struct TupleGetter<3, Tuple<Ts...>> {
+  using Elem = typename TupleElement<3, Tuple<Ts...>>::Type;
+  static Elem& Get(Tuple<Ts...>& t) { return t.d; }
+  static const Elem& Get(const Tuple<Ts...>& t) { return t.d; }
+};
+
+template <typename... Ts>
+struct TupleGetter<4, Tuple<Ts...>> {
+  using Elem = typename TupleElement<4, Tuple<Ts...>>::Type;
+  static Elem& Get(Tuple<Ts...>& t) { return t.e; }
+  static const Elem& Get(const Tuple<Ts...>& t) { return t.e; }
+};
+
+template <typename... Ts>
+struct TupleGetter<5, Tuple<Ts...>> {
+  using Elem = typename TupleElement<5, Tuple<Ts...>>::Type;
+  static Elem& Get(Tuple<Ts...>& t) { return t.f; }
+  static const Elem& Get(const Tuple<Ts...>& t) { return t.f; }
+};
+
+template <typename... Ts>
+struct TupleGetter<6, Tuple<Ts...>> {
+  using Elem = typename TupleElement<6, Tuple<Ts...>>::Type;
+  static Elem& Get(Tuple<Ts...>& t) { return t.g; }
+  static const Elem& Get(const Tuple<Ts...>& t) { return t.g; }
+};
+
+template <typename... Ts>
+struct TupleGetter<7, Tuple<Ts...>> {
+  using Elem = typename TupleElement<7, Tuple<Ts...>>::Type;
+  static Elem& Get(Tuple<Ts...>& t) { return t.h; }
+  static const Elem& Get(const Tuple<Ts...>& t) { return t.h; }
+};
+
+template <size_t I, typename... Ts>
+typename TupleElement<I, Tuple<Ts...>>::Type& get(Tuple<Ts...>& tuple) {
+  return TupleGetter<I, Tuple<Ts...>>::Get(tuple);
+}
+
+template <size_t I, typename... Ts>
+const typename TupleElement<I, Tuple<Ts...>>::Type& get(
+    const Tuple<Ts...>& tuple) {
+  return TupleGetter<I, Tuple<Ts...>>::Get(tuple);
+}
+
 // Tuple types ----------------------------------------------------------------
 //
 // Allows for selection of ValueTuple/RefTuple/ParamTuple without needing the
 // definitions of class types the tuple takes as parameters.
 
-template <>
-struct TupleTypes< Tuple0 > {
-  typedef Tuple0 ValueTuple;
-  typedef Tuple0 RefTuple;
-  typedef Tuple0 ParamTuple;
-};
+template <typename T>
+struct TupleTypes;
 
-template <class A>
-struct TupleTypes< Tuple1<A> > {
-  typedef Tuple1<typename TupleTraits<A>::ValueType> ValueTuple;
-  typedef Tuple1<typename TupleTraits<A>::RefType> RefTuple;
-  typedef Tuple1<typename TupleTraits<A>::ParamType> ParamTuple;
-};
-
-template <class A, class B>
-struct TupleTypes< Tuple2<A, B> > {
-  typedef Tuple2<typename TupleTraits<A>::ValueType,
-                 typename TupleTraits<B>::ValueType> ValueTuple;
-typedef Tuple2<typename TupleTraits<A>::RefType,
-               typename TupleTraits<B>::RefType> RefTuple;
-  typedef Tuple2<typename TupleTraits<A>::ParamType,
-                 typename TupleTraits<B>::ParamType> ParamTuple;
-};
-
-template <class A, class B, class C>
-struct TupleTypes< Tuple3<A, B, C> > {
-  typedef Tuple3<typename TupleTraits<A>::ValueType,
-                 typename TupleTraits<B>::ValueType,
-                 typename TupleTraits<C>::ValueType> ValueTuple;
-typedef Tuple3<typename TupleTraits<A>::RefType,
-               typename TupleTraits<B>::RefType,
-               typename TupleTraits<C>::RefType> RefTuple;
-  typedef Tuple3<typename TupleTraits<A>::ParamType,
-                 typename TupleTraits<B>::ParamType,
-                 typename TupleTraits<C>::ParamType> ParamTuple;
-};
-
-template <class A, class B, class C, class D>
-struct TupleTypes< Tuple4<A, B, C, D> > {
-  typedef Tuple4<typename TupleTraits<A>::ValueType,
-                 typename TupleTraits<B>::ValueType,
-                 typename TupleTraits<C>::ValueType,
-                 typename TupleTraits<D>::ValueType> ValueTuple;
-typedef Tuple4<typename TupleTraits<A>::RefType,
-               typename TupleTraits<B>::RefType,
-               typename TupleTraits<C>::RefType,
-               typename TupleTraits<D>::RefType> RefTuple;
-  typedef Tuple4<typename TupleTraits<A>::ParamType,
-                 typename TupleTraits<B>::ParamType,
-                 typename TupleTraits<C>::ParamType,
-                 typename TupleTraits<D>::ParamType> ParamTuple;
-};
-
-template <class A, class B, class C, class D, class E>
-struct TupleTypes< Tuple5<A, B, C, D, E> > {
-  typedef Tuple5<typename TupleTraits<A>::ValueType,
-                 typename TupleTraits<B>::ValueType,
-                 typename TupleTraits<C>::ValueType,
-                 typename TupleTraits<D>::ValueType,
-                 typename TupleTraits<E>::ValueType> ValueTuple;
-typedef Tuple5<typename TupleTraits<A>::RefType,
-               typename TupleTraits<B>::RefType,
-               typename TupleTraits<C>::RefType,
-               typename TupleTraits<D>::RefType,
-               typename TupleTraits<E>::RefType> RefTuple;
-  typedef Tuple5<typename TupleTraits<A>::ParamType,
-                 typename TupleTraits<B>::ParamType,
-                 typename TupleTraits<C>::ParamType,
-                 typename TupleTraits<D>::ParamType,
-                 typename TupleTraits<E>::ParamType> ParamTuple;
-};
-
-template <class A, class B, class C, class D, class E, class F>
-struct TupleTypes< Tuple6<A, B, C, D, E, F> > {
-  typedef Tuple6<typename TupleTraits<A>::ValueType,
-                 typename TupleTraits<B>::ValueType,
-                 typename TupleTraits<C>::ValueType,
-                 typename TupleTraits<D>::ValueType,
-                 typename TupleTraits<E>::ValueType,
-                 typename TupleTraits<F>::ValueType> ValueTuple;
-typedef Tuple6<typename TupleTraits<A>::RefType,
-               typename TupleTraits<B>::RefType,
-               typename TupleTraits<C>::RefType,
-               typename TupleTraits<D>::RefType,
-               typename TupleTraits<E>::RefType,
-               typename TupleTraits<F>::RefType> RefTuple;
-  typedef Tuple6<typename TupleTraits<A>::ParamType,
-                 typename TupleTraits<B>::ParamType,
-                 typename TupleTraits<C>::ParamType,
-                 typename TupleTraits<D>::ParamType,
-                 typename TupleTraits<E>::ParamType,
-                 typename TupleTraits<F>::ParamType> ParamTuple;
-};
-
-template <class A, class B, class C, class D, class E, class F, class G>
-struct TupleTypes< Tuple7<A, B, C, D, E, F, G> > {
-  typedef Tuple7<typename TupleTraits<A>::ValueType,
-                 typename TupleTraits<B>::ValueType,
-                 typename TupleTraits<C>::ValueType,
-                 typename TupleTraits<D>::ValueType,
-                 typename TupleTraits<E>::ValueType,
-                 typename TupleTraits<F>::ValueType,
-                 typename TupleTraits<G>::ValueType> ValueTuple;
-typedef Tuple7<typename TupleTraits<A>::RefType,
-               typename TupleTraits<B>::RefType,
-               typename TupleTraits<C>::RefType,
-               typename TupleTraits<D>::RefType,
-               typename TupleTraits<E>::RefType,
-               typename TupleTraits<F>::RefType,
-               typename TupleTraits<G>::RefType> RefTuple;
-  typedef Tuple7<typename TupleTraits<A>::ParamType,
-                 typename TupleTraits<B>::ParamType,
-                 typename TupleTraits<C>::ParamType,
-                 typename TupleTraits<D>::ParamType,
-                 typename TupleTraits<E>::ParamType,
-                 typename TupleTraits<F>::ParamType,
-                 typename TupleTraits<G>::ParamType> ParamTuple;
-};
-
-template <class A, class B, class C, class D, class E, class F, class G,
-          class H>
-struct TupleTypes< Tuple8<A, B, C, D, E, F, G, H> > {
-  typedef Tuple8<typename TupleTraits<A>::ValueType,
-                 typename TupleTraits<B>::ValueType,
-                 typename TupleTraits<C>::ValueType,
-                 typename TupleTraits<D>::ValueType,
-                 typename TupleTraits<E>::ValueType,
-                 typename TupleTraits<F>::ValueType,
-                 typename TupleTraits<G>::ValueType,
-                 typename TupleTraits<H>::ValueType> ValueTuple;
-typedef Tuple8<typename TupleTraits<A>::RefType,
-               typename TupleTraits<B>::RefType,
-               typename TupleTraits<C>::RefType,
-               typename TupleTraits<D>::RefType,
-               typename TupleTraits<E>::RefType,
-               typename TupleTraits<F>::RefType,
-               typename TupleTraits<G>::RefType,
-               typename TupleTraits<H>::RefType> RefTuple;
-  typedef Tuple8<typename TupleTraits<A>::ParamType,
-                 typename TupleTraits<B>::ParamType,
-                 typename TupleTraits<C>::ParamType,
-                 typename TupleTraits<D>::ParamType,
-                 typename TupleTraits<E>::ParamType,
-                 typename TupleTraits<F>::ParamType,
-                 typename TupleTraits<G>::ParamType,
-                 typename TupleTraits<H>::ParamType> ParamTuple;
+template <typename... Ts>
+struct TupleTypes<Tuple<Ts...>> {
+  using ValueTuple = Tuple<typename TupleTraits<Ts>::ValueType...>;
+  using RefTuple = Tuple<typename TupleTraits<Ts>::RefType...>;
+  using ParamTuple = Tuple<typename TupleTraits<Ts>::ParamType...>;
 };
 
 // Tuple creators -------------------------------------------------------------
@@ -421,105 +438,17 @@
 // Helper functions for constructing tuples while inferring the template
 // argument types.
 
-inline Tuple0 MakeTuple() {
-  return Tuple0();
-}
-
-template <class A>
-inline Tuple1<A> MakeTuple(const A& a) {
-  return Tuple1<A>(a);
-}
-
-template <class A, class B>
-inline Tuple2<A, B> MakeTuple(const A& a, const B& b) {
-  return Tuple2<A, B>(a, b);
-}
-
-template <class A, class B, class C>
-inline Tuple3<A, B, C> MakeTuple(const A& a, const B& b, const C& c) {
-  return Tuple3<A, B, C>(a, b, c);
-}
-
-template <class A, class B, class C, class D>
-inline Tuple4<A, B, C, D> MakeTuple(const A& a, const B& b, const C& c,
-                                    const D& d) {
-  return Tuple4<A, B, C, D>(a, b, c, d);
-}
-
-template <class A, class B, class C, class D, class E>
-inline Tuple5<A, B, C, D, E> MakeTuple(const A& a, const B& b, const C& c,
-                                       const D& d, const E& e) {
-  return Tuple5<A, B, C, D, E>(a, b, c, d, e);
-}
-
-template <class A, class B, class C, class D, class E, class F>
-inline Tuple6<A, B, C, D, E, F> MakeTuple(const A& a, const B& b, const C& c,
-                                          const D& d, const E& e, const F& f) {
-  return Tuple6<A, B, C, D, E, F>(a, b, c, d, e, f);
-}
-
-template <class A, class B, class C, class D, class E, class F, class G>
-inline Tuple7<A, B, C, D, E, F, G> MakeTuple(const A& a, const B& b, const C& c,
-                                             const D& d, const E& e, const F& f,
-                                             const G& g) {
-  return Tuple7<A, B, C, D, E, F, G>(a, b, c, d, e, f, g);
-}
-
-template <class A, class B, class C, class D, class E, class F, class G,
-          class H>
-inline Tuple8<A, B, C, D, E, F, G, H> MakeTuple(const A& a, const B& b,
-                                                const C& c, const D& d,
-                                                const E& e, const F& f,
-                                                const G& g, const H& h) {
-  return Tuple8<A, B, C, D, E, F, G, H>(a, b, c, d, e, f, g, h);
+template <typename... Ts>
+inline Tuple<Ts...> MakeTuple(const Ts&... arg) {
+  return Tuple<Ts...>(arg...);
 }
 
 // The following set of helpers make what Boost refers to as "Tiers" - a tuple
 // of references.
 
-template <class A>
-inline Tuple1<A&> MakeRefTuple(A& a) {
-  return Tuple1<A&>(a);
-}
-
-template <class A, class B>
-inline Tuple2<A&, B&> MakeRefTuple(A& a, B& b) {
-  return Tuple2<A&, B&>(a, b);
-}
-
-template <class A, class B, class C>
-inline Tuple3<A&, B&, C&> MakeRefTuple(A& a, B& b, C& c) {
-  return Tuple3<A&, B&, C&>(a, b, c);
-}
-
-template <class A, class B, class C, class D>
-inline Tuple4<A&, B&, C&, D&> MakeRefTuple(A& a, B& b, C& c, D& d) {
-  return Tuple4<A&, B&, C&, D&>(a, b, c, d);
-}
-
-template <class A, class B, class C, class D, class E>
-inline Tuple5<A&, B&, C&, D&, E&> MakeRefTuple(A& a, B& b, C& c, D& d, E& e) {
-  return Tuple5<A&, B&, C&, D&, E&>(a, b, c, d, e);
-}
-
-template <class A, class B, class C, class D, class E, class F>
-inline Tuple6<A&, B&, C&, D&, E&, F&> MakeRefTuple(A& a, B& b, C& c, D& d, E& e,
-                                                   F& f) {
-  return Tuple6<A&, B&, C&, D&, E&, F&>(a, b, c, d, e, f);
-}
-
-template <class A, class B, class C, class D, class E, class F, class G>
-inline Tuple7<A&, B&, C&, D&, E&, F&, G&> MakeRefTuple(A& a, B& b, C& c, D& d,
-                                                       E& e, F& f, G& g) {
-  return Tuple7<A&, B&, C&, D&, E&, F&, G&>(a, b, c, d, e, f, g);
-}
-
-template <class A, class B, class C, class D, class E, class F, class G,
-          class H>
-inline Tuple8<A&, B&, C&, D&, E&, F&, G&, H&> MakeRefTuple(A& a, B& b, C& c,
-                                                           D& d, E& e, F& f,
-                                                           G& g, H& h) {
-  return Tuple8<A&, B&, C&, D&, E&, F&, G&, H&>(a, b, c, d, e, f, g, h);
+template <typename... Ts>
+inline Tuple<Ts&...> MakeRefTuple(Ts&... arg) {
+  return Tuple<Ts&...>(arg...);
 }
 
 // Dispatchers ----------------------------------------------------------------
@@ -533,759 +462,94 @@
 
 // Non-Static Dispatchers with no out params.
 
-template <class ObjT, class Method>
-inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& arg) {
-  (obj->*method)();
-}
-
-template <class ObjT, class Method, class A>
+template <typename ObjT, typename Method, typename A>
 inline void DispatchToMethod(ObjT* obj, Method method, const A& arg) {
   (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg));
 }
 
-template <class ObjT, class Method, class A>
-inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1<A>& arg) {
-  (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a));
+template <typename ObjT, typename Method, typename... Ts, size_t... Ns>
+inline void DispatchToMethodImpl(ObjT* obj,
+                                 Method method,
+                                 const Tuple<Ts...>& arg,
+                                 IndexSequence<Ns...>) {
+  (obj->*method)(base::internal::UnwrapTraits<Ts>::Unwrap(get<Ns>(arg))...);
 }
 
-template<class ObjT, class Method, class A, class B>
+template <typename ObjT, typename Method, typename... Ts>
 inline void DispatchToMethod(ObjT* obj,
                              Method method,
-                             const Tuple2<A, B>& arg) {
-  (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
-                 base::internal::UnwrapTraits<B>::Unwrap(arg.b));
-}
-
-template<class ObjT, class Method, class A, class B, class C>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple3<A, B, C>& arg) {
-  (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
-                 base::internal::UnwrapTraits<B>::Unwrap(arg.b),
-                 base::internal::UnwrapTraits<C>::Unwrap(arg.c));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple4<A, B, C, D>& arg) {
-  (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
-                 base::internal::UnwrapTraits<B>::Unwrap(arg.b),
-                 base::internal::UnwrapTraits<C>::Unwrap(arg.c),
-                 base::internal::UnwrapTraits<D>::Unwrap(arg.d));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D, class E>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple5<A, B, C, D, E>& arg) {
-  (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
-                 base::internal::UnwrapTraits<B>::Unwrap(arg.b),
-                 base::internal::UnwrapTraits<C>::Unwrap(arg.c),
-                 base::internal::UnwrapTraits<D>::Unwrap(arg.d),
-                 base::internal::UnwrapTraits<E>::Unwrap(arg.e));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D, class E,
-         class F>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple6<A, B, C, D, E, F>& arg) {
-  (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
-                 base::internal::UnwrapTraits<B>::Unwrap(arg.b),
-                 base::internal::UnwrapTraits<C>::Unwrap(arg.c),
-                 base::internal::UnwrapTraits<D>::Unwrap(arg.d),
-                 base::internal::UnwrapTraits<E>::Unwrap(arg.e),
-                 base::internal::UnwrapTraits<F>::Unwrap(arg.f));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D, class E,
-         class F, class G>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple7<A, B, C, D, E, F, G>& arg) {
-  (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
-                 base::internal::UnwrapTraits<B>::Unwrap(arg.b),
-                 base::internal::UnwrapTraits<C>::Unwrap(arg.c),
-                 base::internal::UnwrapTraits<D>::Unwrap(arg.d),
-                 base::internal::UnwrapTraits<E>::Unwrap(arg.e),
-                 base::internal::UnwrapTraits<F>::Unwrap(arg.f),
-                 base::internal::UnwrapTraits<G>::Unwrap(arg.g));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D, class E,
-         class F, class G, class H>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple8<A, B, C, D, E, F, G, H>& arg) {
-  (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
-                 base::internal::UnwrapTraits<B>::Unwrap(arg.b),
-                 base::internal::UnwrapTraits<C>::Unwrap(arg.c),
-                 base::internal::UnwrapTraits<D>::Unwrap(arg.d),
-                 base::internal::UnwrapTraits<E>::Unwrap(arg.e),
-                 base::internal::UnwrapTraits<F>::Unwrap(arg.f),
-                 base::internal::UnwrapTraits<G>::Unwrap(arg.g),
-                 base::internal::UnwrapTraits<H>::Unwrap(arg.h));
+                             const Tuple<Ts...>& arg) {
+  DispatchToMethodImpl(obj, method, arg, MakeIndexSequence<sizeof...(Ts)>());
 }
 
 // Static Dispatchers with no out params.
 
-template <class Function>
-inline void DispatchToFunction(Function function, const Tuple0& arg) {
-  (*function)();
+template <typename Function, typename A>
+inline void DispatchToMethod(Function function, const A& arg) {
+  (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg));
 }
 
-template <class Function, class A>
-inline void DispatchToFunction(Function function, const A& arg) {
-  (*function)(arg);
+template <typename Function, typename... Ts, size_t... Ns>
+inline void DispatchToFunctionImpl(Function function,
+                                   const Tuple<Ts...>& arg,
+                                   IndexSequence<Ns...>) {
+  (*function)(base::internal::UnwrapTraits<Ts>::Unwrap(get<Ns>(arg))...);
 }
 
-template <class Function, class A>
-inline void DispatchToFunction(Function function, const Tuple1<A>& arg) {
-  (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a));
+template <typename Function, typename... Ts>
+inline void DispatchToFunction(Function function, const Tuple<Ts...>& arg) {
+  DispatchToFunctionImpl(function, arg, MakeIndexSequence<sizeof...(Ts)>());
 }
 
-template<class Function, class A, class B>
-inline void DispatchToFunction(Function function, const Tuple2<A, B>& arg) {
-  (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
-              base::internal::UnwrapTraits<B>::Unwrap(arg.b));
+// Dispatchers with out parameters.
+
+template <typename ObjT,
+          typename Method,
+          typename In,
+          typename... OutTs,
+          size_t... OutNs>
+inline void DispatchToMethodImpl(ObjT* obj,
+                                 Method method,
+                                 const In& in,
+                                 Tuple<OutTs...>* out,
+                                 IndexSequence<OutNs...>) {
+  (obj->*method)(base::internal::UnwrapTraits<In>::Unwrap(in),
+                 &get<OutNs>(*out)...);
 }
 
-template<class Function, class A, class B, class C>
-inline void DispatchToFunction(Function function, const Tuple3<A, B, C>& arg) {
-  (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
-              base::internal::UnwrapTraits<B>::Unwrap(arg.b),
-              base::internal::UnwrapTraits<C>::Unwrap(arg.c));
-}
-
-template<class Function, class A, class B, class C, class D>
-inline void DispatchToFunction(Function function,
-                               const Tuple4<A, B, C, D>& arg) {
-  (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
-              base::internal::UnwrapTraits<B>::Unwrap(arg.b),
-              base::internal::UnwrapTraits<C>::Unwrap(arg.c),
-              base::internal::UnwrapTraits<D>::Unwrap(arg.d));
-}
-
-template<class Function, class A, class B, class C, class D, class E>
-inline void DispatchToFunction(Function function,
-                               const Tuple5<A, B, C, D, E>& arg) {
-  (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
-              base::internal::UnwrapTraits<B>::Unwrap(arg.b),
-              base::internal::UnwrapTraits<C>::Unwrap(arg.c),
-              base::internal::UnwrapTraits<D>::Unwrap(arg.d),
-              base::internal::UnwrapTraits<E>::Unwrap(arg.e));
-}
-
-template<class Function, class A, class B, class C, class D, class E, class F>
-inline void DispatchToFunction(Function function,
-                               const Tuple6<A, B, C, D, E, F>& arg) {
-  (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
-              base::internal::UnwrapTraits<B>::Unwrap(arg.b),
-              base::internal::UnwrapTraits<C>::Unwrap(arg.c),
-              base::internal::UnwrapTraits<D>::Unwrap(arg.d),
-              base::internal::UnwrapTraits<E>::Unwrap(arg.e),
-              base::internal::UnwrapTraits<F>::Unwrap(arg.f));
-}
-
-template<class Function, class A, class B, class C, class D, class E, class F,
-         class G>
-inline void DispatchToFunction(Function function,
-                               const Tuple7<A, B, C, D, E, F, G>& arg) {
-  (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
-              base::internal::UnwrapTraits<B>::Unwrap(arg.b),
-              base::internal::UnwrapTraits<C>::Unwrap(arg.c),
-              base::internal::UnwrapTraits<D>::Unwrap(arg.d),
-              base::internal::UnwrapTraits<E>::Unwrap(arg.e),
-              base::internal::UnwrapTraits<F>::Unwrap(arg.f),
-              base::internal::UnwrapTraits<G>::Unwrap(arg.g));
-}
-
-template<class Function, class A, class B, class C, class D, class E, class F,
-         class G, class H>
-inline void DispatchToFunction(Function function,
-                               const Tuple8<A, B, C, D, E, F, G, H>& arg) {
-  (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
-              base::internal::UnwrapTraits<B>::Unwrap(arg.b),
-              base::internal::UnwrapTraits<C>::Unwrap(arg.c),
-              base::internal::UnwrapTraits<D>::Unwrap(arg.d),
-              base::internal::UnwrapTraits<E>::Unwrap(arg.e),
-              base::internal::UnwrapTraits<F>::Unwrap(arg.f),
-              base::internal::UnwrapTraits<G>::Unwrap(arg.g),
-              base::internal::UnwrapTraits<H>::Unwrap(arg.h));
-}
-
-// Dispatchers with 0 out param (as a Tuple0).
-
-template <class ObjT, class Method>
+template <typename ObjT, typename Method, typename In, typename... OutTs>
 inline void DispatchToMethod(ObjT* obj,
                              Method method,
-                             const Tuple0& arg, Tuple0*) {
-  (obj->*method)();
+                             const In& in,
+                             Tuple<OutTs...>* out) {
+  DispatchToMethodImpl(obj, method, in, out,
+                       MakeIndexSequence<sizeof...(OutTs)>());
 }
 
-template <class ObjT, class Method, class A>
-inline void DispatchToMethod(ObjT* obj, Method method, const A& arg, Tuple0*) {
-  (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg));
+template <typename ObjT,
+          typename Method,
+          typename... InTs,
+          typename... OutTs,
+          size_t... InNs,
+          size_t... OutNs>
+inline void DispatchToMethodImpl(ObjT* obj,
+                                 Method method,
+                                 const Tuple<InTs...>& in,
+                                 Tuple<OutTs...>* out,
+                                 IndexSequence<InNs...>,
+                                 IndexSequence<OutNs...>) {
+  (obj->*method)(base::internal::UnwrapTraits<InTs>::Unwrap(get<InNs>(in))...,
+                 &get<OutNs>(*out)...);
 }
 
-template <class ObjT, class Method, class A>
+template <typename ObjT, typename Method, typename... InTs, typename... OutTs>
 inline void DispatchToMethod(ObjT* obj,
                              Method method,
-                             const Tuple1<A>& arg, Tuple0*) {
-  (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a));
-}
-
-template<class ObjT, class Method, class A, class B>
-inline void DispatchToMethod(ObjT* obj,
-                             Method method,
-                             const Tuple2<A, B>& arg, Tuple0*) {
-  (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
-                 base::internal::UnwrapTraits<B>::Unwrap(arg.b));
-}
-
-template<class ObjT, class Method, class A, class B, class C>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple3<A, B, C>& arg, Tuple0*) {
-  (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
-                 base::internal::UnwrapTraits<B>::Unwrap(arg.b),
-                 base::internal::UnwrapTraits<C>::Unwrap(arg.c));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple4<A, B, C, D>& arg, Tuple0*) {
-  (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
-                 base::internal::UnwrapTraits<B>::Unwrap(arg.b),
-                 base::internal::UnwrapTraits<C>::Unwrap(arg.c),
-                 base::internal::UnwrapTraits<D>::Unwrap(arg.d));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D, class E>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple5<A, B, C, D, E>& arg, Tuple0*) {
-  (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
-                 base::internal::UnwrapTraits<B>::Unwrap(arg.b),
-                 base::internal::UnwrapTraits<C>::Unwrap(arg.c),
-                 base::internal::UnwrapTraits<D>::Unwrap(arg.d),
-                 base::internal::UnwrapTraits<E>::Unwrap(arg.e));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D, class E,
-         class F>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple6<A, B, C, D, E, F>& arg, Tuple0*) {
-  (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
-                 base::internal::UnwrapTraits<B>::Unwrap(arg.b),
-                 base::internal::UnwrapTraits<C>::Unwrap(arg.c),
-                 base::internal::UnwrapTraits<D>::Unwrap(arg.d),
-                 base::internal::UnwrapTraits<E>::Unwrap(arg.e),
-                 base::internal::UnwrapTraits<F>::Unwrap(arg.f));
-}
-
-// Dispatchers with 1 out param.
-
-template<class ObjT, class Method,
-         class OutA>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple0& in,
-                             Tuple1<OutA>* out) {
-  (obj->*method)(&out->a);
-}
-
-template<class ObjT, class Method, class InA,
-         class OutA>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const InA& in,
-                             Tuple1<OutA>* out) {
-  (obj->*method)(in, &out->a);
-}
-
-template<class ObjT, class Method, class InA,
-         class OutA>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple1<InA>& in,
-                             Tuple1<OutA>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a), &out->a);
-}
-
-template<class ObjT, class Method, class InA, class InB,
-         class OutA>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple2<InA, InB>& in,
-                             Tuple1<OutA>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 &out->a);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC,
-         class OutA>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple3<InA, InB, InC>& in,
-                             Tuple1<OutA>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 base::internal::UnwrapTraits<InC>::Unwrap(in.c),
-                 &out->a);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC, class InD,
-         class OutA>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple4<InA, InB, InC, InD>& in,
-                             Tuple1<OutA>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 base::internal::UnwrapTraits<InC>::Unwrap(in.c),
-                 base::internal::UnwrapTraits<InD>::Unwrap(in.d),
-                 &out->a);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC, class InD,
-         class InE, class OutA>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple5<InA, InB, InC, InD, InE>& in,
-                             Tuple1<OutA>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 base::internal::UnwrapTraits<InC>::Unwrap(in.c),
-                 base::internal::UnwrapTraits<InD>::Unwrap(in.d),
-                 base::internal::UnwrapTraits<InE>::Unwrap(in.e),
-                 &out->a);
-}
-
-template<class ObjT, class Method,
-         class InA, class InB, class InC, class InD, class InE, class InF,
-         class OutA>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple6<InA, InB, InC, InD, InE, InF>& in,
-                             Tuple1<OutA>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 base::internal::UnwrapTraits<InC>::Unwrap(in.c),
-                 base::internal::UnwrapTraits<InD>::Unwrap(in.d),
-                 base::internal::UnwrapTraits<InE>::Unwrap(in.e),
-                 base::internal::UnwrapTraits<InF>::Unwrap(in.f),
-                 &out->a);
-}
-
-// Dispatchers with 2 out params.
-
-template<class ObjT, class Method,
-         class OutA, class OutB>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple0& in,
-                             Tuple2<OutA, OutB>* out) {
-  (obj->*method)(&out->a, &out->b);
-}
-
-template<class ObjT, class Method, class InA,
-         class OutA, class OutB>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const InA& in,
-                             Tuple2<OutA, OutB>* out) {
-  (obj->*method)(in, &out->a, &out->b);
-}
-
-template<class ObjT, class Method, class InA,
-         class OutA, class OutB>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple1<InA>& in,
-                             Tuple2<OutA, OutB>* out) {
-  (obj->*method)(
-      base::internal::UnwrapTraits<InA>::Unwrap(in.a), &out->a, &out->b);
-}
-
-template<class ObjT, class Method, class InA, class InB,
-         class OutA, class OutB>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple2<InA, InB>& in,
-                             Tuple2<OutA, OutB>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 &out->a,
-                 &out->b);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC,
-         class OutA, class OutB>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple3<InA, InB, InC>& in,
-                             Tuple2<OutA, OutB>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 base::internal::UnwrapTraits<InC>::Unwrap(in.c),
-                 &out->a,
-                 &out->b);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC, class InD,
-         class OutA, class OutB>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple4<InA, InB, InC, InD>& in,
-                             Tuple2<OutA, OutB>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 base::internal::UnwrapTraits<InC>::Unwrap(in.c),
-                 base::internal::UnwrapTraits<InD>::Unwrap(in.d),
-                 &out->a,
-                 &out->b);
-}
-
-template<class ObjT, class Method,
-         class InA, class InB, class InC, class InD, class InE,
-         class OutA, class OutB>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple5<InA, InB, InC, InD, InE>& in,
-                             Tuple2<OutA, OutB>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 base::internal::UnwrapTraits<InC>::Unwrap(in.c),
-                 base::internal::UnwrapTraits<InD>::Unwrap(in.d),
-                 base::internal::UnwrapTraits<InE>::Unwrap(in.e),
-                 &out->a,
-                 &out->b);
-}
-
-template<class ObjT, class Method,
-         class InA, class InB, class InC, class InD, class InE, class InF,
-         class OutA, class OutB>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple6<InA, InB, InC, InD, InE, InF>& in,
-                             Tuple2<OutA, OutB>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 base::internal::UnwrapTraits<InC>::Unwrap(in.c),
-                 base::internal::UnwrapTraits<InD>::Unwrap(in.d),
-                 base::internal::UnwrapTraits<InE>::Unwrap(in.e),
-                 base::internal::UnwrapTraits<InF>::Unwrap(in.f),
-                 &out->a,
-                 &out->b);
-}
-
-// Dispatchers with 3 out params.
-
-template<class ObjT, class Method,
-         class OutA, class OutB, class OutC>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple0& in,
-                             Tuple3<OutA, OutB, OutC>* out) {
-  (obj->*method)(&out->a, &out->b, &out->c);
-}
-
-template<class ObjT, class Method, class InA,
-         class OutA, class OutB, class OutC>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const InA& in,
-                             Tuple3<OutA, OutB, OutC>* out) {
-  (obj->*method)(in, &out->a, &out->b, &out->c);
-}
-
-template<class ObjT, class Method, class InA,
-         class OutA, class OutB, class OutC>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple1<InA>& in,
-                             Tuple3<OutA, OutB, OutC>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 &out->a,
-                 &out->b,
-                 &out->c);
-}
-
-template<class ObjT, class Method, class InA, class InB,
-         class OutA, class OutB, class OutC>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple2<InA, InB>& in,
-                             Tuple3<OutA, OutB, OutC>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 &out->a,
-                 &out->b,
-                 &out->c);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC,
-         class OutA, class OutB, class OutC>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple3<InA, InB, InC>& in,
-                             Tuple3<OutA, OutB, OutC>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 base::internal::UnwrapTraits<InC>::Unwrap(in.c),
-                 &out->a,
-                 &out->b,
-                 &out->c);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC, class InD,
-         class OutA, class OutB, class OutC>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple4<InA, InB, InC, InD>& in,
-                             Tuple3<OutA, OutB, OutC>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 base::internal::UnwrapTraits<InC>::Unwrap(in.c),
-                 base::internal::UnwrapTraits<InD>::Unwrap(in.d),
-                 &out->a,
-                 &out->b,
-                 &out->c);
-}
-
-template<class ObjT, class Method,
-         class InA, class InB, class InC, class InD, class InE,
-         class OutA, class OutB, class OutC>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple5<InA, InB, InC, InD, InE>& in,
-                             Tuple3<OutA, OutB, OutC>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 base::internal::UnwrapTraits<InC>::Unwrap(in.c),
-                 base::internal::UnwrapTraits<InD>::Unwrap(in.d),
-                 base::internal::UnwrapTraits<InE>::Unwrap(in.e),
-                 &out->a,
-                 &out->b,
-                 &out->c);
-}
-
-template<class ObjT, class Method,
-         class InA, class InB, class InC, class InD, class InE, class InF,
-         class OutA, class OutB, class OutC>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple6<InA, InB, InC, InD, InE, InF>& in,
-                             Tuple3<OutA, OutB, OutC>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 base::internal::UnwrapTraits<InC>::Unwrap(in.c),
-                 base::internal::UnwrapTraits<InD>::Unwrap(in.d),
-                 base::internal::UnwrapTraits<InE>::Unwrap(in.e),
-                 base::internal::UnwrapTraits<InF>::Unwrap(in.f),
-                 &out->a,
-                 &out->b,
-                 &out->c);
-}
-
-// Dispatchers with 4 out params.
-
-template<class ObjT, class Method,
-         class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple0& in,
-                             Tuple4<OutA, OutB, OutC, OutD>* out) {
-  (obj->*method)(&out->a, &out->b, &out->c, &out->d);
-}
-
-template<class ObjT, class Method, class InA,
-         class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const InA& in,
-                             Tuple4<OutA, OutB, OutC, OutD>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in),
-                 &out->a,
-                 &out->b,
-                 &out->c,
-                 &out->d);
-}
-
-template<class ObjT, class Method, class InA,
-         class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple1<InA>& in,
-                             Tuple4<OutA, OutB, OutC, OutD>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 &out->a,
-                 &out->b,
-                 &out->c,
-                 &out->d);
-}
-
-template<class ObjT, class Method, class InA, class InB,
-         class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple2<InA, InB>& in,
-                             Tuple4<OutA, OutB, OutC, OutD>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 &out->a,
-                 &out->b,
-                 &out->c,
-                 &out->d);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC,
-         class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple3<InA, InB, InC>& in,
-                             Tuple4<OutA, OutB, OutC, OutD>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 base::internal::UnwrapTraits<InC>::Unwrap(in.c),
-                 &out->a,
-                 &out->b,
-                 &out->c,
-                 &out->d);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC, class InD,
-         class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple4<InA, InB, InC, InD>& in,
-                             Tuple4<OutA, OutB, OutC, OutD>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 base::internal::UnwrapTraits<InC>::Unwrap(in.c),
-                 base::internal::UnwrapTraits<InD>::Unwrap(in.d),
-                 &out->a,
-                 &out->b,
-                 &out->c,
-                 &out->d);
-}
-
-template<class ObjT, class Method,
-         class InA, class InB, class InC, class InD, class InE,
-         class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple5<InA, InB, InC, InD, InE>& in,
-                             Tuple4<OutA, OutB, OutC, OutD>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 base::internal::UnwrapTraits<InC>::Unwrap(in.c),
-                 base::internal::UnwrapTraits<InD>::Unwrap(in.d),
-                 base::internal::UnwrapTraits<InE>::Unwrap(in.e),
-                 &out->a,
-                 &out->b,
-                 &out->c,
-                 &out->d);
-}
-
-template<class ObjT, class Method,
-         class InA, class InB, class InC, class InD, class InE, class InF,
-         class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple6<InA, InB, InC, InD, InE, InF>& in,
-                             Tuple4<OutA, OutB, OutC, OutD>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 base::internal::UnwrapTraits<InC>::Unwrap(in.c),
-                 base::internal::UnwrapTraits<InD>::Unwrap(in.d),
-                 base::internal::UnwrapTraits<InE>::Unwrap(in.e),
-                 base::internal::UnwrapTraits<InF>::Unwrap(in.f),
-                 &out->a,
-                 &out->b,
-                 &out->c,
-                 &out->d);
-}
-
-// Dispatchers with 5 out params.
-
-template<class ObjT, class Method,
-         class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple0& in,
-                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
-  (obj->*method)(&out->a, &out->b, &out->c, &out->d, &out->e);
-}
-
-template<class ObjT, class Method, class InA,
-         class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const InA& in,
-                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in),
-                 &out->a,
-                 &out->b,
-                 &out->c,
-                 &out->d,
-                 &out->e);
-}
-
-template<class ObjT, class Method, class InA,
-         class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple1<InA>& in,
-                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 &out->a,
-                 &out->b,
-                 &out->c,
-                 &out->d,
-                 &out->e);
-}
-
-template<class ObjT, class Method, class InA, class InB,
-         class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple2<InA, InB>& in,
-                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 &out->a,
-                 &out->b,
-                 &out->c,
-                 &out->d,
-                 &out->e);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC,
-         class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple3<InA, InB, InC>& in,
-                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 base::internal::UnwrapTraits<InC>::Unwrap(in.c),
-                 &out->a,
-                 &out->b,
-                 &out->c,
-                 &out->d,
-                 &out->e);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC, class InD,
-         class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple4<InA, InB, InC, InD>& in,
-                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 base::internal::UnwrapTraits<InC>::Unwrap(in.c),
-                 base::internal::UnwrapTraits<InD>::Unwrap(in.d),
-                 &out->a,
-                 &out->b,
-                 &out->c,
-                 &out->d,
-                 &out->e);
-}
-
-template<class ObjT, class Method,
-         class InA, class InB, class InC, class InD, class InE,
-         class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple5<InA, InB, InC, InD, InE>& in,
-                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 base::internal::UnwrapTraits<InC>::Unwrap(in.c),
-                 base::internal::UnwrapTraits<InD>::Unwrap(in.d),
-                 base::internal::UnwrapTraits<InE>::Unwrap(in.e),
-                 &out->a,
-                 &out->b,
-                 &out->c,
-                 &out->d,
-                 &out->e);
-}
-
-template<class ObjT, class Method,
-         class InA, class InB, class InC, class InD, class InE, class InF,
-         class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
-                             const Tuple6<InA, InB, InC, InD, InE, InF>& in,
-                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
-                 base::internal::UnwrapTraits<InB>::Unwrap(in.b),
-                 base::internal::UnwrapTraits<InC>::Unwrap(in.c),
-                 base::internal::UnwrapTraits<InD>::Unwrap(in.d),
-                 base::internal::UnwrapTraits<InE>::Unwrap(in.e),
-                 base::internal::UnwrapTraits<InF>::Unwrap(in.f),
-                 &out->a,
-                 &out->b,
-                 &out->c,
-                 &out->d,
-                 &out->e);
+                             const Tuple<InTs...>& in,
+                             Tuple<OutTs...>* out) {
+  DispatchToMethodImpl(obj, method, in, out,
+                       MakeIndexSequence<sizeof...(InTs)>(),
+                       MakeIndexSequence<sizeof...(OutTs)>());
 }
 
 #endif  // BASE_TUPLE_H__