Revert of Revert "Update legacy Tuple-using code."

ipc/ipc_message_macros.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.
 
 // Defining IPC Messages
 //
 // Your IPC messages will be defined by macros inside of an XXX_messages.h
 // header file.  Most of the time, the system can automatically generate all
 // of messaging mechanism from these definitions, but sometimes some manual
 // coding is required.  In these cases, you will also have an XXX_messages.cc
@@ skipping 439 matching lines @@
 
 // The following macros are for for async IPCs which have a dispatcher with an
 // extra parameter specified using IPC_BEGIN_MESSAGE_MAP_WITH_PARAM.
 #define IPC_ASYNC_MESSAGE_METHODS_1                                           \
   IPC_ASYNC_MESSAGE_METHODS_GENERIC                                           \
   template<class T, class S, class P, typename TA>                            \
   static bool Dispatch(const Message* msg, T* obj, S* sender, P* parameter,   \
                        void (T::*func)(P*, TA)) {                             \
     Schema::Param p;                                                          \
     if (Read(msg, &p)) {                                                      \
-      (obj->*func)(parameter, p.a);                                           \
+      (obj->*func)(parameter, get<0>(p));                                     \
       return true;                                                            \
     }                                                                         \
     return false;                                                             \
   }
 #define IPC_ASYNC_MESSAGE_METHODS_2                                           \
   IPC_ASYNC_MESSAGE_METHODS_GENERIC                                           \
   template<class T, class S, class P, typename TA, typename TB>               \
   static bool Dispatch(const Message* msg, T* obj, S* sender, P* parameter,   \
                        void (T::*func)(P*, TA, TB)) {                         \
     Schema::Param p;                                                          \
     if (Read(msg, &p)) {                                                      \
-      (obj->*func)(parameter, p.a, p.b);                                      \
+      (obj->*func)(parameter, get<0>(p), get<1>(p));                          \
       return true;                                                            \
     }                                                                         \
     return false;                                                             \
   }
 #define IPC_ASYNC_MESSAGE_METHODS_3                                           \
   IPC_ASYNC_MESSAGE_METHODS_GENERIC                                           \
   template<class T, class S, class P, typename TA, typename TB, typename TC>  \
   static bool Dispatch(const Message* msg, T* obj, S* sender, P* parameter,   \
                        void (T::*func)(P*, TA, TB, TC)) {                     \
     Schema::Param p;                                                          \
     if (Read(msg, &p)) {                                                      \
-      (obj->*func)(parameter, p.a, p.b, p.c);                                 \
+      (obj->*func)(parameter, get<0>(p), get<1>(p), get<2>(p));               \
       return true;                                                            \
     }                                                                         \
     return false;                                                             \
   }
 #define IPC_ASYNC_MESSAGE_METHODS_4                                           \
   IPC_ASYNC_MESSAGE_METHODS_GENERIC                                           \
   template<class T, class S, class P, typename TA, typename TB, typename TC,  \
            typename TD>                                                       \
   static bool Dispatch(const Message* msg, T* obj, S* sender, P* parameter,   \
                        void (T::*func)(P*, TA, TB, TC, TD)) {                 \
     Schema::Param p;                                                          \
     if (Read(msg, &p)) {                                                      \
-      (obj->*func)(parameter, p.a, p.b, p.c, p.d);                            \
+      (obj->*func)(parameter, get<0>(p), get<1>(p), get<2>(p), get<3>(p));    \
       return true;                                                            \
     }                                                                         \
     return false;                                                             \
   }
 #define IPC_ASYNC_MESSAGE_METHODS_5                                           \
   IPC_ASYNC_MESSAGE_METHODS_GENERIC                                           \
   template<class T, class S, class P, typename TA, typename TB, typename TC,  \
            typename TD, typename TE>                                          \
   static bool Dispatch(const Message* msg, T* obj, S* sender, P* parameter,   \
                        void (T::*func)(P*, TA, TB, TC, TD, TE)) {             \
     Schema::Param p;                                                          \
     if (Read(msg, &p)) {                                                      \
-      (obj->*func)(parameter, p.a, p.b, p.c, p.d, p.e);                       \
+      (obj->*func)(parameter, get<0>(p), get<1>(p), get<2>(p), get<3>(p),     \
+                   get<4>(p));                                                \
       return true;                                                            \
     }                                                                         \
     return false;                                                             \
   }
 
 // The following macros define the common set of methods provided by SYNC
 // message classes.
 #define IPC_SYNC_MESSAGE_METHODS_GENERIC                                      \
   template<class T, class S, class P, class Method>                           \
   static bool Dispatch(const Message* msg, T* obj, S* sender, P* parameter,   \
@@ skipping 289 matching lines @@
 #define IPC_TYPE_IN_3(t1, t2, t3)           const t1& arg1, const t2& arg2, const t3& arg3
 #define IPC_TYPE_IN_4(t1, t2, t3, t4)       const t1& arg1, const t2& arg2, const t3& arg3, const t4& arg4
 #define IPC_TYPE_IN_5(t1, t2, t3, t4, t5)   const t1& arg1, const t2& arg2, const t3& arg3, const t4& arg4, const t5& arg5
 
 #define IPC_TYPE_OUT_0()
 #define IPC_TYPE_OUT_1(t1)                  t1* arg6
 #define IPC_TYPE_OUT_2(t1, t2)              t1* arg6, t2* arg7
 #define IPC_TYPE_OUT_3(t1, t2, t3)          t1* arg6, t2* arg7, t3* arg8
 #define IPC_TYPE_OUT_4(t1, t2, t3, t4)      t1* arg6, t2* arg7, t3* arg8, t4* arg9
 
-#define IPC_TUPLE_IN_0()                    Tuple0
-#define IPC_TUPLE_IN_1(t1)                  Tuple1<t1>
-#define IPC_TUPLE_IN_2(t1, t2)              Tuple2<t1, t2>
-#define IPC_TUPLE_IN_3(t1, t2, t3)          Tuple3<t1, t2, t3>
-#define IPC_TUPLE_IN_4(t1, t2, t3, t4)      Tuple4<t1, t2, t3, t4>
-#define IPC_TUPLE_IN_5(t1, t2, t3, t4, t5)  Tuple5<t1, t2, t3, t4, t5>
+#define IPC_TUPLE_IN_0()                    Tuple<>
+#define IPC_TUPLE_IN_1(t1)                  Tuple<t1>
+#define IPC_TUPLE_IN_2(t1, t2)              Tuple<t1, t2>
+#define IPC_TUPLE_IN_3(t1, t2, t3)          Tuple<t1, t2, t3>
+#define IPC_TUPLE_IN_4(t1, t2, t3, t4)      Tuple<t1, t2, t3, t4>
+#define IPC_TUPLE_IN_5(t1, t2, t3, t4, t5)  Tuple<t1, t2, t3, t4, t5>
 
-#define IPC_TUPLE_OUT_0()                   Tuple0
-#define IPC_TUPLE_OUT_1(t1)                 Tuple1<t1&>
-#define IPC_TUPLE_OUT_2(t1, t2)             Tuple2<t1&, t2&>
-#define IPC_TUPLE_OUT_3(t1, t2, t3)         Tuple3<t1&, t2&, t3&>
-#define IPC_TUPLE_OUT_4(t1, t2, t3, t4)     Tuple4<t1&, t2&, t3&, t4&>
+#define IPC_TUPLE_OUT_0()                   Tuple<>
+#define IPC_TUPLE_OUT_1(t1)                 Tuple<t1&>
+#define IPC_TUPLE_OUT_2(t1, t2)             Tuple<t1&, t2&>
+#define IPC_TUPLE_OUT_3(t1, t2, t3)         Tuple<t1&, t2&, t3&>
+#define IPC_TUPLE_OUT_4(t1, t2, t3, t4)     Tuple<t1&, t2&, t3&, t4&>
 
 #define IPC_NAME_IN_0()                     MakeTuple()
 #define IPC_NAME_IN_1(t1)                   MakeRefTuple(arg1)
 #define IPC_NAME_IN_2(t1, t2)               MakeRefTuple(arg1, arg2)
 #define IPC_NAME_IN_3(t1, t2, t3)           MakeRefTuple(arg1, arg2, arg3)
 #define IPC_NAME_IN_4(t1, t2, t3, t4)       MakeRefTuple(arg1, arg2, arg3, arg4)
 #define IPC_NAME_IN_5(t1, t2, t3, t4, t5)   MakeRefTuple(arg1, arg2, arg3, arg4, arg5)
 
 #define IPC_NAME_OUT_0()                    MakeTuple()
 #define IPC_NAME_OUT_1(t1)                  MakeRefTuple(*arg6)
@@ skipping 128 matching lines @@
 // equivalent without the #ifdef, VS2013 contains a bug where it is
 // over-aggressive in optimizing out #includes.  Putting the #ifdef is a
 // workaround for this bug.  See http://goo.gl/eGt2Fb for more details.
 // This can be removed once VS2013 is fixed.
 #ifdef IPC_MESSAGE_START
 // Clean up IPC_MESSAGE_START in this unguarded section so that the
 // XXX_messages.h files need not do so themselves.  This makes the
 // XXX_messages.h files easier to write.
 #undef IPC_MESSAGE_START
 #endif