Revert of Revert "Update legacy Tuple-using code." (patchset #1 id:1 of...

Revert of Revert "Update legacy Tuple-using code." (patchset #1 id:1 of https://codereview.chromium.org/826573002/)

Reason for revert:
The tests should have failed with this. Undoing the revert.

Original issue's description:
> Revert "Update legacy Tuple-using code."
>
> This reverts commit 12f4b983
>
> BUG=440675, 444827
>
> Committed: https://chromium.googlesource.com/chromium/src/+/85748694f2a119a057088f77f70b97f11607473c

TBR=
NOTREECHECKS=true
NOTRY=true
BUG=440675, 444827

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

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

base/tuple.h

@@ -124,71 +124,6 @@ struct TupleLeaf {
   T x;
 };
 
-// For legacy compatibility, we name the first 8 tuple elements "a", "b", ...
-// TODO(mdempsky): Update users to use get<N>() (crbug.com/440675).
-
-#define DEFINE_TUPLE_LEAF(N, x)                                        \
-  template <typename T>                                                \
-  struct TupleLeaf<N, T> {                                             \
-    TupleLeaf() {}                                                     \
-    explicit TupleLeaf(typename TupleTraits<T>::ParamType x) : x(x) {} \
-                                                                       \
-    T& get() { return x; }                                             \
-    const T& get() const { return x; }                                 \
-                                                                       \
-    T x;                                                               \
-  }
-
-DEFINE_TUPLE_LEAF(0, a);
-DEFINE_TUPLE_LEAF(1, b);
-DEFINE_TUPLE_LEAF(2, c);
-DEFINE_TUPLE_LEAF(3, d);
-DEFINE_TUPLE_LEAF(4, e);
-DEFINE_TUPLE_LEAF(5, f);
-DEFINE_TUPLE_LEAF(6, g);
-DEFINE_TUPLE_LEAF(7, h);
-
-#undef DEFINE_TUPLE_LEAF
-
-// Deprecated compat aliases
-// TODO(mdempsky): Update users to just use Tuple instead (crbug.com/440675).
-
-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 getters --------------------------------------------------------------
 //
 // Allows accessing an arbitrary tuple element by index.

chrome/common/chrome_utility_messages.h

@@ -26,7 +26,7 @@
 #ifndef CHROME_COMMON_CHROME_UTILITY_MESSAGES_H_
 #define CHROME_COMMON_CHROME_UTILITY_MESSAGES_H_
 
-typedef std::vector<Tuple2<SkBitmap, base::FilePath> > DecodedImages;
+typedef std::vector<Tuple<SkBitmap, base::FilePath>> DecodedImages;
 
 #endif  // CHROME_COMMON_CHROME_UTILITY_MESSAGES_H_
 
@@ -38,9 +38,9 @@ IPC_STRUCT_TRAITS_END()
 
 #if defined(OS_WIN)
 
-// A vector of filters, each being a Tuple2 containing a display string (i.e.
+// A vector of filters, each being a Tuple containing a display string (i.e.
 // "Text Files") and a filter pattern (i.e. "*.txt").
-typedef std::vector<Tuple2<base::string16, base::string16> >
+typedef std::vector<Tuple<base::string16, base::string16>>
     GetOpenFileNameFilter;
 
 IPC_STRUCT_BEGIN(ChromeUtilityMsg_GetSaveFileName_Params)

ipc/ipc_message_macros.h

@@ -457,7 +457,7 @@
                        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;                                                             \
@@ -469,7 +469,7 @@
                        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;                                                             \
@@ -481,7 +481,7 @@
                        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;                                                             \
@@ -494,7 +494,7 @@
                        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;                                                             \
@@ -507,7 +507,8 @@
                        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;                                                             \
@@ -817,18 +818,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()                    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_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_NAME_IN_0()                     MakeTuple()
 #define IPC_NAME_IN_1(t1)                   MakeRefTuple(arg1)

ipc/ipc_message_utils.h

@@ -520,8 +520,8 @@ struct IPC_EXPORT ParamTraits<base::TimeTicks> {
 };
 
 template <>
-struct ParamTraits<Tuple0> {
-  typedef Tuple0 param_type;
+struct ParamTraits<Tuple<>> {
+  typedef Tuple<> 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<Tuple0> {
 };
 
 template <class A>
-struct ParamTraits< Tuple1<A> > {
-  typedef Tuple1<A> param_type;
+struct ParamTraits<Tuple<A>> {
+  typedef Tuple<A> param_type;
   static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.a);
+    WriteParam(m, get<0>(p));
   }
   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
-    return ReadParam(m, iter, &r->a);
+    return ReadParam(m, iter, &get<0>(*r));
   }
   static void Log(const param_type& p, std::string* l) {
-    LogParam(p.a, l);
+    LogParam(get<0>(p), l);
   }
 };
 
 template <class A, class B>
-struct ParamTraits< Tuple2<A, B> > {
-  typedef Tuple2<A, B> param_type;
+struct ParamTraits< Tuple<A, B> > {
+  typedef Tuple<A, B> param_type;
   static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.a);
-    WriteParam(m, p.b);
+    WriteParam(m, get<0>(p));
+    WriteParam(m, get<1>(p));
   }
   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
-    return (ReadParam(m, iter, &r->a) &&
-            ReadParam(m, iter, &r->b));
+    return (ReadParam(m, iter, &get<0>(*r)) &&
+            ReadParam(m, iter, &get<1>(*r)));
   }
   static void Log(const param_type& p, std::string* l) {
-    LogParam(p.a, l);
+    LogParam(get<0>(p), l);
     l->append(", ");
-    LogParam(p.b, l);
+    LogParam(get<1>(p), l);
   }
 };
 
 template <class A, class B, class C>
-struct ParamTraits< Tuple3<A, B, C> > {
-  typedef Tuple3<A, B, C> param_type;
+struct ParamTraits< Tuple<A, B, C> > {
+  typedef Tuple<A, B, C> param_type;
   static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.a);
-    WriteParam(m, p.b);
-    WriteParam(m, p.c);
+    WriteParam(m, get<0>(p));
+    WriteParam(m, get<1>(p));
+    WriteParam(m, get<2>(p));
   }
   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
-    return (ReadParam(m, iter, &r->a) &&
-            ReadParam(m, iter, &r->b) &&
-            ReadParam(m, iter, &r->c));
+    return (ReadParam(m, iter, &get<0>(*r)) &&
+            ReadParam(m, iter, &get<1>(*r)) &&
+            ReadParam(m, iter, &get<2>(*r)));
   }
   static void Log(const param_type& p, std::string* l) {
-    LogParam(p.a, l);
+    LogParam(get<0>(p), l);
     l->append(", ");
-    LogParam(p.b, l);
+    LogParam(get<1>(p), l);
     l->append(", ");
-    LogParam(p.c, l);
+    LogParam(get<2>(p), l);
   }
 };
 
 template <class A, class B, class C, class D>
-struct ParamTraits< Tuple4<A, B, C, D> > {
-  typedef Tuple4<A, B, C, D> param_type;
+struct ParamTraits< Tuple<A, B, C, D> > {
+  typedef Tuple<A, B, C, D> param_type;
   static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.a);
-    WriteParam(m, p.b);
-    WriteParam(m, p.c);
-    WriteParam(m, p.d);
+    WriteParam(m, get<0>(p));
+    WriteParam(m, get<1>(p));
+    WriteParam(m, get<2>(p));
+    WriteParam(m, get<3>(p));
   }
   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
-    return (ReadParam(m, iter, &r->a) &&
-            ReadParam(m, iter, &r->b) &&
-            ReadParam(m, iter, &r->c) &&
-            ReadParam(m, iter, &r->d));
+    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)));
   }
   static void Log(const param_type& p, std::string* l) {
-    LogParam(p.a, l);
+    LogParam(get<0>(p), l);
     l->append(", ");
-    LogParam(p.b, l);
+    LogParam(get<1>(p), l);
     l->append(", ");
-    LogParam(p.c, l);
+    LogParam(get<2>(p), l);
     l->append(", ");
-    LogParam(p.d, l);
+    LogParam(get<3>(p), l);
   }
 };
 
 template <class A, class B, class C, class D, class E>
-struct ParamTraits< Tuple5<A, B, C, D, E> > {
-  typedef Tuple5<A, B, C, D, E> param_type;
+struct ParamTraits< Tuple<A, B, C, D, E> > {
+  typedef Tuple<A, B, C, D, E> param_type;
   static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.a);
-    WriteParam(m, p.b);
-    WriteParam(m, p.c);
-    WriteParam(m, p.d);
-    WriteParam(m, p.e);
+    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));
   }
   static bool Read(const Message* m, PickleIterator* iter, param_type* 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));
+    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)));
   }
   static void Log(const param_type& p, std::string* l) {
-    LogParam(p.a, l);
+    LogParam(get<0>(p), l);
     l->append(", ");
-    LogParam(p.b, l);
+    LogParam(get<1>(p), l);
     l->append(", ");
-    LogParam(p.c, l);
+    LogParam(get<2>(p), l);
     l->append(", ");
-    LogParam(p.d, l);
+    LogParam(get<3>(p), l);
     l->append(", ");
-    LogParam(p.e, l);
+    LogParam(get<4>(p), l);
   }
 };
 
@@ -912,7 +912,7 @@ class SyncMessageSchema {
                                                Method func) {
     Message* reply = SyncMessage::GenerateReply(msg);
     if (ok) {
-      Tuple1<Message&> t = MakeRefTuple(*reply);
+      Tuple<Message&> t = MakeRefTuple(*reply);
       ConnectMessageAndReply(msg, reply);
       DispatchToMethod(obj, func, send_params, &t);
     } else {

sandbox/linux/seccomp-bpf/codegen.cc

@@ -145,14 +145,14 @@ size_t CodeGen::Offset(Node target) const {
 // TODO(mdempsky): Move into a general base::Tuple helper library.
 bool CodeGen::MemoKeyLess::operator()(const MemoKey& lhs,
                                       const MemoKey& rhs) const {
-  if (lhs.a != rhs.a)
-    return lhs.a < rhs.a;
-  if (lhs.b != rhs.b)
-    return lhs.b < rhs.b;
-  if (lhs.c != rhs.c)
-    return lhs.c < rhs.c;
-  if (lhs.d != rhs.d)
-    return lhs.d < rhs.d;
+  if (get<0>(lhs) != get<0>(rhs))
+    return get<0>(lhs) < get<0>(rhs);
+  if (get<1>(lhs) != get<1>(rhs))
+    return get<1>(lhs) < get<1>(rhs);
+  if (get<2>(lhs) != get<2>(rhs))
+    return get<2>(lhs) < get<2>(rhs);
+  if (get<3>(lhs) != get<3>(rhs))
+    return get<3>(lhs) < get<3>(rhs);
   return false;
 }
 

sandbox/linux/seccomp-bpf/codegen.h

@@ -81,7 +81,7 @@ class SANDBOX_EXPORT CodeGen {
   void Compile(Node head, Program* program);
 
  private:
-  using MemoKey = Tuple4<uint16_t, uint32_t, Node, Node>;
+  using MemoKey = Tuple<uint16_t, uint32_t, Node, Node>;
   struct MemoKeyLess {
     bool operator()(const MemoKey& lhs, const MemoKey& rhs) const;
   };

testing/generate_gmock_mutant.py

@@ -56,8 +56,8 @@ HEADER = """\
 //   }
 //
 //   void QuitMessageLoop(int seconds) {
-//     MessageLoop* loop = MessageLoop::current();
-//     loop->PostDelayedTask(FROM_HERE, MessageLoop::QuitClosure(),
+//     base::MessageLoop* loop = base::MessageLoop::current();
+//     loop->PostDelayedTask(FROM_HERE, base::MessageLoop::QuitClosure(),
 //                           1000 * seconds);
 //   }
 // };
@@ -202,7 +202,7 @@ struct MutantFunctor {
   }
 
   inline R operator()() {
-    return impl_->RunWithParams(Tuple0());
+    return impl_->RunWithParams(Tuple<>());
   }
 
   template <typename Arg1>
@@ -241,8 +241,8 @@ FOOTER = """\
 
 # Templates for DispatchToMethod/DispatchToFunction functions.
 # template_params - typename P1, typename P2.. typename C1..
-# prebound - TupleN<P1, .. PN>
-# calltime - TupleN<C1, .. CN>
+# prebound - Tuple<P1, .. PN>
+# calltime - Tuple<C1, .. CN>
 # args - p.a, p.b.., c.a, c.b..
 DISPATCH_TO_METHOD_TEMPLATE = """\
 template <typename R, typename T, typename Method, %(template_params)s>
@@ -264,8 +264,8 @@ inline R DispatchToFunction(Function function,
 
 # Templates for CreateFunctor functions.
 # template_params - typename P1, typename P2.. typename C1.. typename X1..
-# prebound - TupleN<P1, .. PN>
-# calltime - TupleN<A1, .. AN>
+# prebound - Tuple<P1, .. PN>
+# calltime - Tuple<A1, .. AN>
 # params - X1,.. , A1, ..
 # args - const P1& p1 ..
 # call_args - p1, p2, p3..
@@ -305,7 +305,7 @@ def SplitLine(line, width):
   return (line[:n], line[n + 1:])
 
 
-def Wrap(s, width, subsequent_offset=4):
+def Wrap(s, width, subsequent_offset):
   """Wraps a single line |s| at commas so every line is at most |width|
      characters long.
   """
@@ -324,10 +324,8 @@ def Clean(s):
 
   Our simple string formatting/concatenation may introduce extra commas.
   """
-  s = s.replace("<>", "")
   s = s.replace(", >", ">")
   s = s.replace(", )", ")")
-  s = s.replace(">>", "> >")
   return s
 
 
@@ -339,23 +337,13 @@ def ExpandPattern(pattern, it):
   return [pattern.replace("%", x) for x in it]
 
 
-def Gen(pattern, n):
-  """Expands pattern replacing '%' with sequential integers.
+def Gen(pattern, n, start):
+  """Expands pattern replacing '%' with sequential integers starting with start.
 
   Expanded patterns will be joined with comma separator.
-  GenAlphs("X%", 3) will return "X1, X2, X3".
+  Gen("X%", 3, 1) will return "X1, X2, X3".
   """
-  it = string.hexdigits[1:n + 1]
-  return ", ".join(ExpandPattern(pattern, it))
-
-
-def GenAlpha(pattern, n):
-  """Expands pattern replacing '%' with sequential small ASCII letters.
-
-  Expanded patterns will be joined with comma separator.
-  GenAlphs("X%", 3) will return "Xa, Xb, Xc".
-  """
-  it = string.ascii_lowercase[0:n]
+  it = string.hexdigits[start:n + start]
   return ", ".join(ExpandPattern(pattern, it))
 
 
@@ -364,7 +352,7 @@ def Merge(a):
 
 
 def GenTuple(pattern, n):
-  return Clean("Tuple%d<%s>" % (n, Gen(pattern, n)))
+  return Clean("Tuple<%s>" % (Gen(pattern, n, 1)))
 
 
 def FixCode(s):
@@ -378,11 +366,12 @@ def FixCode(s):
 def GenerateDispatch(prebound, calltime):
   print "\n// %d - %d" % (prebound, calltime)
   args = {
-      "template_params": Merge([Gen("typename P%", prebound),
-                                Gen("typename C%", calltime)]),
+      "template_params": Merge([Gen("typename P%", prebound, 1),
+                                Gen("typename C%", calltime, 1)]),
       "prebound": GenTuple("P%", prebound),
       "calltime": GenTuple("C%", calltime),
-      "args": Merge([GenAlpha("p.%", prebound), GenAlpha("c.%", calltime)]),
+      "args": Merge([Gen("get<%>(p)", prebound, 0),
+                     Gen("get<%>(c)", calltime, 0)]),
   }
 
   print FixCode(DISPATCH_TO_METHOD_TEMPLATE % args)
@@ -394,12 +383,12 @@ def GenerateCreateFunctor(prebound, calltime):
   args = {
       "calltime": GenTuple("A%", calltime),
       "prebound": GenTuple("P%", prebound),
-      "params": Merge([Gen("X%", prebound), Gen("A%", calltime)]),
-      "args": Gen("const P%& p%", prebound),
-      "call_args": Gen("p%", prebound),
-      "template_params": Merge([Gen("typename P%", prebound),
-                                Gen("typename A%", calltime),
-                                Gen("typename X%", prebound)])
+      "params": Merge([Gen("X%", prebound, 1), Gen("A%", calltime, 1)]),
+      "args": Gen("const P%& p%", prebound, 1),
+      "call_args": Gen("p%", prebound, 1),
+      "template_params": Merge([Gen("typename P%", prebound, 1),
+                                Gen("typename A%", calltime, 1),
+                                Gen("typename X%", prebound, 1)])
   }
 
   mutant = FixCode(CREATE_METHOD_FUNCTOR_TEMPLATE % args)