Add a variadic version of ParamTraits, to allow for >5 IPC parameters.

ipc/ipc_message_utils.h

Index: ipc/ipc_message_utils.h
diff --git a/ipc/ipc_message_utils.h b/ipc/ipc_message_utils.h
index 84324ebaf417f5aee89cdfb33b60d513ac19c7c5..3f429b66539d0a0ae9e6782d11426b27e45ef55a 100644
--- a/ipc/ipc_message_utils.h
+++ b/ipc/ipc_message_utils.h
@@ -724,149 +724,63 @@ struct ParamTraits<std::tuple<>> {
   }
 };
 
-template <class A>
-struct ParamTraits<std::tuple<A>> {
-  typedef std::tuple<A> param_type;
-  static void GetSize(base::PickleSizer* sizer, const param_type& p) {
-    GetParamSize(sizer, std::get<0>(p));
-  }
-  static void Write(base::Pickle* m, const param_type& p) {
-    WriteParam(m, std::get<0>(p));
-  }
-  static bool Read(const base::Pickle* m,
-                   base::PickleIterator* iter,
-                   param_type* r) {
-    return ReadParam(m, iter, &std::get<0>(*r));
-  }
-  static void Log(const param_type& p, std::string* l) {
-    LogParam(std::get<0>(p), l);
-  }
-};
+template <typename T, int index, int count>
+struct TupleParamTraitsHelper {
+  using Next = TupleParamTraitsHelper<T, index + 1, count>;
 
-template <class A, class B>
-struct ParamTraits<std::tuple<A, B>> {
-  typedef std::tuple<A, B> param_type;
-  static void GetSize(base::PickleSizer* sizer, const param_type& p) {
-    GetParamSize(sizer, std::get<0>(p));
-    GetParamSize(sizer, std::get<1>(p));
-  }
-  static void Write(base::Pickle* m, const param_type& p) {
-    WriteParam(m, std::get<0>(p));
-    WriteParam(m, std::get<1>(p));
+  static void GetSize(base::PickleSizer* sizer, const T& p) {
+    GetParamSize(sizer, std::get<index>(p));
+    Next::GetSize(sizer, p);
   }
-  static bool Read(const base::Pickle* m,
-                   base::PickleIterator* iter,
-                   param_type* r) {
-    return (ReadParam(m, iter, &std::get<0>(*r)) &&
-            ReadParam(m, iter, &std::get<1>(*r)));
-  }
-  static void Log(const param_type& p, std::string* l) {
-    LogParam(std::get<0>(p), l);
-    l->append(", ");
-    LogParam(std::get<1>(p), l);
-  }
-};
 
-template <class A, class B, class C>
-struct ParamTraits<std::tuple<A, B, C>> {
-  typedef std::tuple<A, B, C> param_type;
-  static void GetSize(base::PickleSizer* sizer, const param_type& p) {
-    GetParamSize(sizer, std::get<0>(p));
-    GetParamSize(sizer, std::get<1>(p));
-    GetParamSize(sizer, std::get<2>(p));
-  }
-  static void Write(base::Pickle* m, const param_type& p) {
-    WriteParam(m, std::get<0>(p));
-    WriteParam(m, std::get<1>(p));
-    WriteParam(m, std::get<2>(p));
+  static void Write(base::Pickle* m, const T& p) {
+    WriteParam(m, std::get<index>(p));
+    Next::Write(m, p);
   }
-  static bool Read(const base::Pickle* m,
-                   base::PickleIterator* iter,
-                   param_type* r) {
-    return (ReadParam(m, iter, &std::get<0>(*r)) &&
-            ReadParam(m, iter, &std::get<1>(*r)) &&
-            ReadParam(m, iter, &std::get<2>(*r)));
+
+  static bool Read(const base::Pickle* m, base::PickleIterator* iter, T* r) {
+    return ReadParam(m, iter, &std::get<index>(*r)) && Next::Read(m, iter, r);
   }
-  static void Log(const param_type& p, std::string* l) {
-    LogParam(std::get<0>(p), l);
-    l->append(", ");
-    LogParam(std::get<1>(p), l);
-    l->append(", ");
-    LogParam(std::get<2>(p), l);
+
+  static void Log(const T& p, std::string* l) {
+    LogParam(std::get<index>(p), l);
+    if (index < count - 1)
+      l->append(", ");
+    Next::Log(p, l);
   }
 };
 
-template <class A, class B, class C, class D>
-struct ParamTraits<std::tuple<A, B, C, D>> {
-  typedef std::tuple<A, B, C, D> param_type;
-  static void GetSize(base::PickleSizer* sizer, const param_type& p) {
-    GetParamSize(sizer, std::get<0>(p));
-    GetParamSize(sizer, std::get<1>(p));
-    GetParamSize(sizer, std::get<2>(p));
-    GetParamSize(sizer, std::get<3>(p));
-  }
-  static void Write(base::Pickle* m, const param_type& p) {
-    WriteParam(m, std::get<0>(p));
-    WriteParam(m, std::get<1>(p));
-    WriteParam(m, std::get<2>(p));
-    WriteParam(m, std::get<3>(p));
-  }
-  static bool Read(const base::Pickle* m,
-                   base::PickleIterator* iter,
-                   param_type* r) {
-    return (ReadParam(m, iter, &std::get<0>(*r)) &&
-            ReadParam(m, iter, &std::get<1>(*r)) &&
-            ReadParam(m, iter, &std::get<2>(*r)) &&
-            ReadParam(m, iter, &std::get<3>(*r)));
-  }
-  static void Log(const param_type& p, std::string* l) {
-    LogParam(std::get<0>(p), l);
-    l->append(", ");
-    LogParam(std::get<1>(p), l);
-    l->append(", ");
-    LogParam(std::get<2>(p), l);
-    l->append(", ");
-    LogParam(std::get<3>(p), l);
+template <typename T, int index>
+struct TupleParamTraitsHelper<T, index, index> {
+  static void GetSize(base::PickleSizer* sizer, const T& p) {}
+  static void Write(base::Pickle* m, const T& p) {}
+  static bool Read(const base::Pickle* m, base::PickleIterator* iter, T* r) {
+    return true;
   }
+  static void Log(const T& p, std::string* l) {}
 };
 
-template <class A, class B, class C, class D, class E>
-struct ParamTraits<std::tuple<A, B, C, D, E>> {
-  typedef std::tuple<A, B, C, D, E> param_type;
+template <typename... Args>
+struct ParamTraits<std::tuple<Args...>> {
+  using param_type = std::tuple<Args...>;
+  using Helper =
+      TupleParamTraitsHelper<param_type, 0, std::tuple_size<param_type>::value>;
+
   static void GetSize(base::PickleSizer* sizer, const param_type& p) {
-    GetParamSize(sizer, std::get<0>(p));
-    GetParamSize(sizer, std::get<1>(p));
-    GetParamSize(sizer, std::get<2>(p));
-    GetParamSize(sizer, std::get<3>(p));
-    GetParamSize(sizer, std::get<4>(p));
+    Helper::GetSize(sizer, p);
   }
+
   static void Write(base::Pickle* m, const param_type& p) {
-    WriteParam(m, std::get<0>(p));
-    WriteParam(m, std::get<1>(p));
-    WriteParam(m, std::get<2>(p));
-    WriteParam(m, std::get<3>(p));
-    WriteParam(m, std::get<4>(p));
+    Helper::Write(m, p);
   }
+
   static bool Read(const base::Pickle* m,
                    base::PickleIterator* iter,
                    param_type* r) {
-    return (ReadParam(m, iter, &std::get<0>(*r)) &&
-            ReadParam(m, iter, &std::get<1>(*r)) &&
-            ReadParam(m, iter, &std::get<2>(*r)) &&
-            ReadParam(m, iter, &std::get<3>(*r)) &&
-            ReadParam(m, iter, &std::get<4>(*r)));
-  }
-  static void Log(const param_type& p, std::string* l) {
-    LogParam(std::get<0>(p), l);
-    l->append(", ");
-    LogParam(std::get<1>(p), l);
-    l->append(", ");
-    LogParam(std::get<2>(p), l);
-    l->append(", ");
-    LogParam(std::get<3>(p), l);
-    l->append(", ");
-    LogParam(std::get<4>(p), l);
+    return Helper::Read(m, iter, r);
   }
+
+  static void Log(const param_type& p, std::string* l) { Helper::Log(p, l); }
 };
 
 template <class P, size_t stack_capacity>