Revert "Update legacy Tuple-using code."

This reverts commit 12f4b98357b9dedc93cb546aac0aece2c8d9e850

BUG=440675, 444827

Review URL: https://codereview.chromium.org/826573002

Cr-Commit-Position: refs/heads/master@{#309583}

2 files changed, 75 insertions, 76 deletions

diff --git a/ipc/ipc_message_macros.h b/ipc/ipc_message_macros.h
index 01789cb..20c8335 100644
--- a/ipc/ipc_message_macros.h
+++ b/ipc/ipc_message_macros.h
@@ -457,7 +457,7 @@
                        void (T::*func)(P*, TA)) {                             \
     Schema::Param p;                                                          \
     if (Read(msg, &p)) {                                                      \
-      (obj->*func)(parameter, get<0>(p));                                     \
+      (obj->*func)(parameter, p.a);                                           \
       return true;                                                            \
     }                                                                         \
     return false;                                                             \
@@ -469,7 +469,7 @@
                        void (T::*func)(P*, TA, TB)) {                         \
     Schema::Param p;                                                          \
     if (Read(msg, &p)) {                                                      \
-      (obj->*func)(parameter, get<0>(p), get<1>(p));                          \
+      (obj->*func)(parameter, p.a, p.b);                                      \
       return true;                                                            \
     }                                                                         \
     return false;                                                             \
@@ -481,7 +481,7 @@
                        void (T::*func)(P*, TA, TB, TC)) {                     \
     Schema::Param p;                                                          \
     if (Read(msg, &p)) {                                                      \
-      (obj->*func)(parameter, get<0>(p), get<1>(p), get<2>(p));               \
+      (obj->*func)(parameter, p.a, p.b, p.c);                                 \
       return true;                                                            \
     }                                                                         \
     return false;                                                             \
@@ -494,7 +494,7 @@
                        void (T::*func)(P*, TA, TB, TC, TD)) {                 \
     Schema::Param p;                                                          \
     if (Read(msg, &p)) {                                                      \
-      (obj->*func)(parameter, get<0>(p), get<1>(p), get<2>(p), get<3>(p));    \
+      (obj->*func)(parameter, p.a, p.b, p.c, p.d);                            \
       return true;                                                            \
     }                                                                         \
     return false;                                                             \
@@ -507,8 +507,7 @@
                        void (T::*func)(P*, TA, TB, TC, TD, TE)) {             \
     Schema::Param p;                                                          \
     if (Read(msg, &p)) {                                                      \
-      (obj->*func)(parameter, get<0>(p), get<1>(p), get<2>(p), get<3>(p),     \
-                   get<4>(p));                                                \
+      (obj->*func)(parameter, p.a, p.b, p.c, p.d, p.e);                       \
       return true;                                                            \
     }                                                                         \
     return false;                                                             \
@@ -818,18 +817,18 @@
 #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()                    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()                   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_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_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_NAME_IN_0()                     MakeTuple()
 #define IPC_NAME_IN_1(t1)                   MakeRefTuple(arg1)
diff --git a/ipc/ipc_message_utils.h b/ipc/ipc_message_utils.h
index d4c6268..c78192a 100644
--- a/ipc/ipc_message_utils.h
+++ b/ipc/ipc_message_utils.h
@@ -520,8 +520,8 @@ struct IPC_EXPORT ParamTraits<base::TimeTicks> {
 };
 
 template <>
-struct ParamTraits<Tuple<>> {
-  typedef Tuple<> param_type;
+struct ParamTraits<Tuple0> {
+  typedef Tuple0 param_type;
   static void Write(Message* m, const param_type& p) {
   }
   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
@@ -532,112 +532,112 @@ struct ParamTraits<Tuple<>> {
 };
 
 template <class A>
-struct ParamTraits<Tuple<A>> {
-  typedef Tuple<A> param_type;
+struct ParamTraits< Tuple1<A> > {
+  typedef Tuple1<A> param_type;
   static void Write(Message* m, const param_type& p) {
-    WriteParam(m, get<0>(p));
+    WriteParam(m, p.a);
   }
   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
-    return ReadParam(m, iter, &get<0>(*r));
+    return ReadParam(m, iter, &r->a);
   }
   static void Log(const param_type& p, std::string* l) {
-    LogParam(get<0>(p), l);
+    LogParam(p.a, l);
   }
 };
 
 template <class A, class B>
-struct ParamTraits< Tuple<A, B> > {
-  typedef Tuple<A, B> param_type;
+struct ParamTraits< Tuple2<A, B> > {
+  typedef Tuple2<A, B> param_type;
   static void Write(Message* m, const param_type& p) {
-    WriteParam(m, get<0>(p));
-    WriteParam(m, get<1>(p));
+    WriteParam(m, p.a);
+    WriteParam(m, p.b);
   }
   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
-    return (ReadParam(m, iter, &get<0>(*r)) &&
-            ReadParam(m, iter, &get<1>(*r)));
+    return (ReadParam(m, iter, &r->a) &&
+            ReadParam(m, iter, &r->b));
   }
   static void Log(const param_type& p, std::string* l) {
-    LogParam(get<0>(p), l);
+    LogParam(p.a, l);
     l->append(", ");
-    LogParam(get<1>(p), l);
+    LogParam(p.b, l);
   }
 };
 
 template <class A, class B, class C>
-struct ParamTraits< Tuple<A, B, C> > {
-  typedef Tuple<A, B, C> param_type;
+struct ParamTraits< Tuple3<A, B, C> > {
+  typedef Tuple3<A, B, C> param_type;
   static void Write(Message* m, const param_type& p) {
-    WriteParam(m, get<0>(p));
-    WriteParam(m, get<1>(p));
-    WriteParam(m, get<2>(p));
+    WriteParam(m, p.a);
+    WriteParam(m, p.b);
+    WriteParam(m, p.c);
   }
   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
-    return (ReadParam(m, iter, &get<0>(*r)) &&
-            ReadParam(m, iter, &get<1>(*r)) &&
-            ReadParam(m, iter, &get<2>(*r)));
+    return (ReadParam(m, iter, &r->a) &&
+            ReadParam(m, iter, &r->b) &&
+            ReadParam(m, iter, &r->c));
   }
   static void Log(const param_type& p, std::string* l) {
-    LogParam(get<0>(p), l);
+    LogParam(p.a, l);
     l->append(", ");
-    LogParam(get<1>(p), l);
+    LogParam(p.b, l);
     l->append(", ");
-    LogParam(get<2>(p), l);
+    LogParam(p.c, l);
   }
 };
 
 template <class A, class B, class C, class D>
-struct ParamTraits< Tuple<A, B, C, D> > {
-  typedef Tuple<A, B, C, D> param_type;
+struct ParamTraits< Tuple4<A, B, C, D> > {
+  typedef Tuple4<A, B, C, D> param_type;
   static void Write(Message* m, const param_type& p) {
-    WriteParam(m, get<0>(p));
-    WriteParam(m, get<1>(p));
-    WriteParam(m, get<2>(p));
-    WriteParam(m, get<3>(p));
+    WriteParam(m, p.a);
+    WriteParam(m, p.b);
+    WriteParam(m, p.c);
+    WriteParam(m, p.d);
   }
   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
-    return (ReadParam(m, iter, &get<0>(*r)) &&
-            ReadParam(m, iter, &get<1>(*r)) &&
-            ReadParam(m, iter, &get<2>(*r)) &&
-            ReadParam(m, iter, &get<3>(*r)));
+    return (ReadParam(m, iter, &r->a) &&
+            ReadParam(m, iter, &r->b) &&
+            ReadParam(m, iter, &r->c) &&
+            ReadParam(m, iter, &r->d));
   }
   static void Log(const param_type& p, std::string* l) {
-    LogParam(get<0>(p), l);
+    LogParam(p.a, l);
     l->append(", ");
-    LogParam(get<1>(p), l);
+    LogParam(p.b, l);
     l->append(", ");
-    LogParam(get<2>(p), l);
+    LogParam(p.c, l);
     l->append(", ");
-    LogParam(get<3>(p), l);
+    LogParam(p.d, l);
   }
 };
 
 template <class A, class B, class C, class D, class E>
-struct ParamTraits< Tuple<A, B, C, D, E> > {
-  typedef Tuple<A, B, C, D, E> param_type;
+struct ParamTraits< Tuple5<A, B, C, D, E> > {
+  typedef Tuple5<A, B, C, D, E> param_type;
   static void Write(Message* m, const param_type& p) {
-    WriteParam(m, get<0>(p));
-    WriteParam(m, get<1>(p));
-    WriteParam(m, get<2>(p));
-    WriteParam(m, get<3>(p));
-    WriteParam(m, get<4>(p));
+    WriteParam(m, p.a);
+    WriteParam(m, p.b);
+    WriteParam(m, p.c);
+    WriteParam(m, p.d);
+    WriteParam(m, p.e);
   }
   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
-    return (ReadParam(m, iter, &get<0>(*r)) &&
-            ReadParam(m, iter, &get<1>(*r)) &&
-            ReadParam(m, iter, &get<2>(*r)) &&
-            ReadParam(m, iter, &get<3>(*r)) &&
-            ReadParam(m, iter, &get<4>(*r)));
+    return (ReadParam(m, iter, &r->a) &&
+            ReadParam(m, iter, &r->b) &&
+            ReadParam(m, iter, &r->c) &&
+            ReadParam(m, iter, &r->d) &&
+            ReadParam(m, iter, &r->e));
   }
   static void Log(const param_type& p, std::string* l) {
-    LogParam(get<0>(p), l);
+    LogParam(p.a, l);
     l->append(", ");
-    LogParam(get<1>(p), l);
+    LogParam(p.b, l);
     l->append(", ");
-    LogParam(get<2>(p), l);
+    LogParam(p.c, l);
     l->append(", ");
-    LogParam(get<3>(p), l);
+    LogParam(p.d, l);
     l->append(", ");
-    LogParam(get<4>(p), l);
+    LogParam(p.e, l);
   }
 };
 
@@ -912,7 +912,7 @@ class SyncMessageSchema {
                                                Method func) {
     Message* reply = SyncMessage::GenerateReply(msg);
     if (ok) {
-      Tuple<Message&> t = MakeRefTuple(*reply);
+      Tuple1<Message&> t = MakeRefTuple(*reply);
       ConnectMessageAndReply(msg, reply);
       DispatchToMethod(obj, func, send_params, &t);
     } else {