Replace base::Tuple implementation with std::tuple

ipc/ipc_message_utils.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.
 
 #ifndef IPC_IPC_MESSAGE_UTILS_H_
 #define IPC_IPC_MESSAGE_UTILS_H_
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 617 matching lines @@
   typedef base::TimeTicks 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,
                    base::PickleIterator* iter,
                    param_type* r);
   static void Log(const param_type& p, std::string* l);
 };
 
 template <>
-struct ParamTraits<base::Tuple<>> {
-  typedef base::Tuple<> param_type;
+struct ParamTraits<std::tuple<>> {
+  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,
                    base::PickleIterator* iter,
                    param_type* r) {
     return true;
   }
   static void Log(const param_type& p, std::string* l) {
   }
 };
 
 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));
   }
   static void Write(base::Pickle* m, const param_type& p) {
     WriteParam(m, base::get<0>(p));
   }
   static bool Read(const base::Pickle* m,
                    base::PickleIterator* iter,
                    param_type* r) {
     return ReadParam(m, iter, &base::get<0>(*r));
   }
   static void Log(const param_type& p, std::string* l) {
     LogParam(base::get<0>(p), l);
   }
 };
 
 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));
   }
   static void Write(base::Pickle* m, const param_type& p) {
     WriteParam(m, base::get<0>(p));
     WriteParam(m, base::get<1>(p));
   }
   static bool Read(const base::Pickle* m,
                    base::PickleIterator* iter,
                    param_type* r) {
     return (ReadParam(m, iter, &base::get<0>(*r)) &&
             ReadParam(m, iter, &base::get<1>(*r)));
   }
   static void Log(const param_type& p, std::string* l) {
     LogParam(base::get<0>(p), l);
     l->append(", ");
     LogParam(base::get<1>(p), l);
   }
 };
 
 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));
     GetParamSize(sizer, base::get<2>(p));
   }
   static void Write(base::Pickle* m, const param_type& p) {
     WriteParam(m, base::get<0>(p));
     WriteParam(m, base::get<1>(p));
     WriteParam(m, base::get<2>(p));
   }
   static bool Read(const base::Pickle* m,
                    base::PickleIterator* iter,
                    param_type* r) {
     return (ReadParam(m, iter, &base::get<0>(*r)) &&
             ReadParam(m, iter, &base::get<1>(*r)) &&
             ReadParam(m, iter, &base::get<2>(*r)));
   }
   static void Log(const param_type& p, std::string* l) {
     LogParam(base::get<0>(p), l);
     l->append(", ");
     LogParam(base::get<1>(p), l);
     l->append(", ");
     LogParam(base::get<2>(p), l);
   }
 };
 
 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));
     GetParamSize(sizer, base::get<2>(p));
     GetParamSize(sizer, base::get<3>(p));
   }
   static void Write(base::Pickle* m, const param_type& p) {
     WriteParam(m, base::get<0>(p));
     WriteParam(m, base::get<1>(p));
     WriteParam(m, base::get<2>(p));
@@ skipping 12 matching lines @@
     l->append(", ");
     LogParam(base::get<1>(p), l);
     l->append(", ");
     LogParam(base::get<2>(p), l);
     l->append(", ");
     LogParam(base::get<3>(p), l);
   }
 };
 
 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));
     GetParamSize(sizer, base::get<2>(p));
     GetParamSize(sizer, base::get<3>(p));
     GetParamSize(sizer, base::get<4>(p));
   }
   static void Write(base::Pickle* m, const param_type& p) {
     WriteParam(m, base::get<0>(p));
     WriteParam(m, base::get<1>(p));
@@ skipping 300 matching lines @@
 template <class ReplyParamType>
 inline void LogReplyParamsToMessage(const ReplyParamType& reply_params,
                                     const Message* msg) {}
 
 inline void ConnectMessageAndReply(const Message* msg, Message* reply) {}
 #endif
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_MESSAGE_UTILS_H_