Replace base::Tuple implementation with std::tuple

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 d8b660740d8b67d1c739efe44be20c950a1f153b..0f2efcf6f5e9cdb3319198a6f6b3cffc6d28e65a 100644
--- a/ipc/ipc_message_utils.h
+++ b/ipc/ipc_message_utils.h
@@ -658,8 +658,8 @@ struct IPC_EXPORT ParamTraits<base::TimeTicks> {
 };
 
 template <>
-struct ParamTraits<base::Tuple<>> {
-  typedef base::Tuple<> param_type;
+struct ParamTraits<std::tuple<>> {

[Nico, 2016/02/09 12:23:11]

This change is for 2013, right?

[tzik, 2016/02/10 15:10:54]

Yes, it seems failing on the type alias + variadic template + specialization of
class template.

+  typedef std::tuple<> param_type;
   static void GetSize(base::PickleSizer* sizer, const param_type& p) {}
   static void Write(base::Pickle* m, const param_type& p) {}
   static bool Read(const base::Pickle* m,
@@ -672,8 +672,8 @@ struct ParamTraits<base::Tuple<>> {
 };
 
 template <class A>
-struct ParamTraits<base::Tuple<A>> {
-  typedef base::Tuple<A> param_type;
+struct ParamTraits<std::tuple<A>> {
+  typedef std::tuple<A> param_type;
   static void GetSize(base::PickleSizer* sizer, const param_type& p) {
     GetParamSize(sizer, base::get<0>(p));
   }
@@ -691,8 +691,8 @@ struct ParamTraits<base::Tuple<A>> {
 };
 
 template <class A, class B>
-struct ParamTraits<base::Tuple<A, B>> {
-  typedef base::Tuple<A, B> param_type;
+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, base::get<0>(p));
     GetParamSize(sizer, base::get<1>(p));
@@ -715,8 +715,8 @@ struct ParamTraits<base::Tuple<A, B>> {
 };
 
 template <class A, class B, class C>
-struct ParamTraits<base::Tuple<A, B, C>> {
-  typedef base::Tuple<A, B, C> param_type;
+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, base::get<0>(p));
     GetParamSize(sizer, base::get<1>(p));
@@ -744,8 +744,8 @@ struct ParamTraits<base::Tuple<A, B, C>> {
 };
 
 template <class A, class B, class C, class D>
-struct ParamTraits<base::Tuple<A, B, C, D>> {
-  typedef base::Tuple<A, B, C, D> param_type;
+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, base::get<0>(p));
     GetParamSize(sizer, base::get<1>(p));
@@ -778,8 +778,8 @@ struct ParamTraits<base::Tuple<A, B, C, D>> {
 };
 
 template <class A, class B, class C, class D, class E>
-struct ParamTraits<base::Tuple<A, B, C, D, E>> {
-  typedef base::Tuple<A, B, C, D, E> param_type;
+struct ParamTraits<std::tuple<A, B, C, D, E>> {
+  typedef std::tuple<A, B, C, D, E> param_type;
   static void GetSize(base::PickleSizer* sizer, const param_type& p) {
     GetParamSize(sizer, base::get<0>(p));
     GetParamSize(sizer, base::get<1>(p));
@@ -1163,7 +1163,7 @@ class SyncMessageSchema {
                                                Method func) {
     Message* reply = SyncMessage::GenerateReply(msg);
     if (ok) {
-      base::Tuple<Message&> t = base::MakeRefTuple(*reply);
+      std::tuple<Message&> t = base::MakeRefTuple(*reply);
       ConnectMessageAndReply(msg, reply);
       base::DispatchToMethod(obj, func, send_params, &t);
     } else {