Move Tuple to base namespace.

ipc/ipc_message_macros.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.
 
 // Defining IPC Messages
 //
 // Your IPC messages will be defined by macros inside of an XXX_messages.h
 // header file.  Most of the time, the system can automatically generate all
 // of messaging mechanism from these definitions, but sometimes some manual
 // coding is required.  In these cases, you will also have an XXX_messages.cc
@@ skipping 439 matching lines @@
 
 // The following macros are for for async IPCs which have a dispatcher with an
 // extra parameter specified using IPC_BEGIN_MESSAGE_MAP_WITH_PARAM.
 #define IPC_ASYNC_MESSAGE_METHODS_1                                           \
   IPC_ASYNC_MESSAGE_METHODS_GENERIC                                           \
   template<class T, class S, class P, typename TA>                            \
   static bool Dispatch(const Message* msg, T* obj, S* sender, P* parameter,   \
                        void (T::*func)(P*, TA)) {                             \
     Schema::Param p;                                                          \
     if (Read(msg, &p)) {                                                      \
-      (obj->*func)(parameter, get<0>(p));                                     \
+      (obj->*func)(parameter, base::get<0>(p));                               \
       return true;                                                            \
     }                                                                         \
     return false;                                                             \
   }
 #define IPC_ASYNC_MESSAGE_METHODS_2                                           \
   IPC_ASYNC_MESSAGE_METHODS_GENERIC                                           \
   template<class T, class S, class P, typename TA, typename TB>               \
   static bool Dispatch(const Message* msg, T* obj, S* sender, P* parameter,   \
                        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, base::get<0>(p), base::get<1>(p));              \
       return true;                                                            \
     }                                                                         \
     return false;                                                             \
   }
 #define IPC_ASYNC_MESSAGE_METHODS_3                                           \
   IPC_ASYNC_MESSAGE_METHODS_GENERIC                                           \
   template<class T, class S, class P, typename TA, typename TB, typename TC>  \
   static bool Dispatch(const Message* msg, T* obj, S* sender, P* parameter,   \
                        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, base::get<0>(p), base::get<1>(p),               \
+                   base::get<2>(p));                                          \
       return true;                                                            \
     }                                                                         \
     return false;                                                             \
   }
 #define IPC_ASYNC_MESSAGE_METHODS_4                                           \
   IPC_ASYNC_MESSAGE_METHODS_GENERIC                                           \
   template<class T, class S, class P, typename TA, typename TB, typename TC,  \
            typename TD>                                                       \
   static bool Dispatch(const Message* msg, T* obj, S* sender, P* parameter,   \
                        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, base::get<0>(p), base::get<1>(p),               \
+                   base::get<2>(p), base::get<3>(p));                         \
       return true;                                                            \
     }                                                                         \
     return false;                                                             \
   }
 #define IPC_ASYNC_MESSAGE_METHODS_5                                           \
   IPC_ASYNC_MESSAGE_METHODS_GENERIC                                           \
   template<class T, class S, class P, typename TA, typename TB, typename TC,  \
            typename TD, typename TE>                                          \
   static bool Dispatch(const Message* msg, T* obj, S* sender, P* parameter,   \
                        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, base::get<0>(p), base::get<1>(p),               \
+                   base::get<2>(p), base::get<3>(p), base::get<4>(p));        \
       return true;                                                            \
     }                                                                         \
     return false;                                                             \
   }
 
 // The following macros define the common set of methods provided by SYNC
 // message classes.
 #define IPC_SYNC_MESSAGE_METHODS_GENERIC                                      \
   template<class T, class S, class P, class Method>                           \
   static bool Dispatch(const Message* msg, T* obj, S* sender, P* parameter,   \
@@ skipping 107 matching lines @@
     typedef Schema::ReplyParam ReplyParam;                                    \
     typedef Schema::SendParam SendParam;                                      \
     enum { ID = IPC_MESSAGE_ID() };                                           \
     msg_class(IPC_TYPE_IN_##in_cnt in_list                                    \
               IPC_COMMA_AND_##in_cnt(IPC_COMMA_##out_cnt)                     \
               IPC_TYPE_OUT_##out_cnt out_list);                               \
     ~msg_class() override;                                                    \
     static bool ReadSendParam(const Message* msg, Schema::SendParam* p);      \
     static bool ReadReplyParam(                                               \
         const Message* msg,                                                   \
-        TupleTypes<ReplyParam>::ValueTuple* p);                               \
+        base::TupleTypes<ReplyParam>::ValueTuple* p);                         \
     static void Log(std::string* name, const Message* msg, std::string* l);   \
     IPC_SYNC_MESSAGE_METHODS_##out_cnt                                        \
   };
 
 #define IPC_SYNC_ROUTED_DECL(msg_class, in_cnt, out_cnt, in_list, out_list)   \
   class IPC_MESSAGE_EXPORT msg_class : public IPC::SyncMessage {              \
    public:                                                                    \
     typedef IPC::SyncMessageSchema<IPC_TUPLE_IN_##in_cnt in_list,             \
                                    IPC_TUPLE_OUT_##out_cnt out_list> Schema;  \
     typedef Schema::ReplyParam ReplyParam;                                    \
     typedef Schema::SendParam SendParam;                                      \
     enum { ID = IPC_MESSAGE_ID() };                                           \
     msg_class(int32 routing_id                                                \
               IPC_COMMA_OR_##in_cnt(IPC_COMMA_##out_cnt)                      \
               IPC_TYPE_IN_##in_cnt in_list                                    \
               IPC_COMMA_AND_##in_cnt(IPC_COMMA_##out_cnt)                     \
               IPC_TYPE_OUT_##out_cnt out_list);                               \
     ~msg_class() override;                                                    \
     static bool ReadSendParam(const Message* msg, Schema::SendParam* p);      \
     static bool ReadReplyParam(                                               \
         const Message* msg,                                                   \
-        TupleTypes<ReplyParam>::ValueTuple* p);                               \
+        base::TupleTypes<ReplyParam>::ValueTuple* p);                         \
     static void Log(std::string* name, const Message* msg, std::string* l);   \
     IPC_SYNC_MESSAGE_METHODS_##out_cnt                                        \
   };
 
 #if defined(IPC_MESSAGE_IMPL)
 
 // "Implementation" inclusion produces constructors, destructors, and
 // logging functions, except for the no-arg special cases, where the
 // implementation occurs in the declaration, and there is no special
 // logging function.
@@ skipping 32 matching lines @@
                        IPC_TYPE_OUT_##out_cnt out_list) :                     \
       IPC::SyncMessage(MSG_ROUTING_CONTROL, ID, PRIORITY_NORMAL,              \
                        new IPC::ParamDeserializer<Schema::ReplyParam>(        \
                            IPC_NAME_OUT_##out_cnt out_list)) {                \
         Schema::Write(this, IPC_NAME_IN_##in_cnt in_list);                    \
       }                                                                       \
   msg_class::~msg_class() {}                                                  \
   bool msg_class::ReadSendParam(const Message* msg, Schema::SendParam* p) {   \
     return Schema::ReadSendParam(msg, p);                                     \
   }                                                                           \
-  bool msg_class::ReadReplyParam(const Message* msg,                          \
-                                 TupleTypes<ReplyParam>::ValueTuple* p) {     \
+  bool msg_class::ReadReplyParam(                                             \
+      const Message* msg,                                                     \
+      base::TupleTypes<ReplyParam>::ValueTuple* p) {                          \
     return Schema::ReadReplyParam(msg, p);                                    \
   }
 
 #define IPC_SYNC_ROUTED_IMPL(msg_class, in_cnt, out_cnt, in_list, out_list)   \
   msg_class::msg_class(int32 routing_id                                       \
                        IPC_COMMA_OR_##in_cnt(IPC_COMMA_##out_cnt)             \
                        IPC_TYPE_IN_##in_cnt in_list                           \
                        IPC_COMMA_AND_##in_cnt(IPC_COMMA_##out_cnt)            \
                        IPC_TYPE_OUT_##out_cnt out_list) :                     \
       IPC::SyncMessage(routing_id, ID, PRIORITY_NORMAL,                       \
                        new IPC::ParamDeserializer<Schema::ReplyParam>(        \
                            IPC_NAME_OUT_##out_cnt out_list)) {                \
         Schema::Write(this, IPC_NAME_IN_##in_cnt in_list);                    \
       }                                                                       \
   msg_class::~msg_class() {}                                                  \
   bool msg_class::ReadSendParam(const Message* msg, Schema::SendParam* p) {   \
     return Schema::ReadSendParam(msg, p);                                     \
   }                                                                           \
-  bool msg_class::ReadReplyParam(const Message* msg,                          \
-                                 TupleTypes<ReplyParam>::ValueTuple* p) {     \
+  bool msg_class::ReadReplyParam(                                             \
+      const Message* msg,                                                     \
+      base::TupleTypes<ReplyParam>::ValueTuple* p) {                          \
     return Schema::ReadReplyParam(msg, p);                                    \
   }
 
 #define IPC_EMPTY_MESSAGE_LOG(msg_class)                                \
   void msg_class::Log(std::string* name,                                \
                       const Message* msg,                               \
                       std::string* l) {                                 \
     if (name)                                                           \
       *name = #msg_class;                                               \
   }
@@ skipping 13 matching lines @@
 
 #define IPC_SYNC_MESSAGE_LOG(msg_class)                                 \
   void msg_class::Log(std::string* name,                                \
                       const Message* msg,                               \
                       std::string* l) {                                 \
     if (name)                                                           \
       *name = #msg_class;                                               \
     if (!msg || !l)                                                     \
       return;                                                           \
     if (msg->is_sync()) {                                               \
-      TupleTypes<Schema::SendParam>::ValueTuple p;                      \
+      base::TupleTypes<Schema::SendParam>::ValueTuple p;                \
       if (Schema::ReadSendParam(msg, &p))                               \
         IPC::LogParam(p, l);                                            \
       AddOutputParamsToLog(msg, l);                                     \
     } else {                                                            \
-      TupleTypes<Schema::ReplyParam>::ValueTuple p;                     \
+      base::TupleTypes<Schema::ReplyParam>::ValueTuple p;               \
       if (Schema::ReadReplyParam(msg, &p))                              \
         IPC::LogParam(p, l);                                            \
     }                                                                   \
   }
 
 #elif defined(IPC_MESSAGE_MACROS_LOG_ENABLED)
 
 #ifndef IPC_LOG_TABLE_ADD_ENTRY
 #error You need to define IPC_LOG_TABLE_ADD_ENTRY(msg_id, logger)
 #endif
@@ skipping 24 matching lines @@
 #define IPC_TYPE_IN_1(t1)                   const t1& arg1
 #define IPC_TYPE_IN_2(t1, t2)               const t1& arg1, const t2& arg2
 #define IPC_TYPE_IN_3(t1, t2, t3)           const t1& arg1, const t2& arg2, const t3& arg3
 #define IPC_TYPE_IN_4(t1, t2, t3, t4)       const t1& arg1, const t2& arg2, const t3& arg3, const t4& arg4
 #define IPC_TYPE_IN_5(t1, t2, t3, t4, t5)   const t1& arg1, const t2& arg2, const t3& arg3, const t4& arg4, const t5& arg5
 
 #define IPC_TYPE_OUT_0()
 #define IPC_TYPE_OUT_1(t1)                  t1* arg6
 #define IPC_TYPE_OUT_2(t1, t2)              t1* arg6, t2* arg7
 #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_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_IN_0()                    base::Tuple<>
+#define IPC_TUPLE_IN_1(t1)                  base::Tuple<t1>
+#define IPC_TUPLE_IN_2(t1, t2)              base::Tuple<t1, t2>
+#define IPC_TUPLE_IN_3(t1, t2, t3)          base::Tuple<t1, t2, t3>
+#define IPC_TUPLE_IN_4(t1, t2, t3, t4)      base::Tuple<t1, t2, t3, t4>
+#define IPC_TUPLE_IN_5(t1, t2, t3, t4, t5)  base::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_OUT_0()                   base::Tuple<>
+#define IPC_TUPLE_OUT_1(t1)                 base::Tuple<t1&>
+#define IPC_TUPLE_OUT_2(t1, t2)             base::Tuple<t1&, t2&>
+#define IPC_TUPLE_OUT_3(t1, t2, t3)         base::Tuple<t1&, t2&, t3&>
+#define IPC_TUPLE_OUT_4(t1, t2, t3, t4)     base::Tuple<t1&, t2&, t3&, t4&>
 
-#define IPC_NAME_IN_0()                     MakeTuple()
-#define IPC_NAME_IN_1(t1)                   MakeRefTuple(arg1)
-#define IPC_NAME_IN_2(t1, t2)               MakeRefTuple(arg1, arg2)
-#define IPC_NAME_IN_3(t1, t2, t3)           MakeRefTuple(arg1, arg2, arg3)
-#define IPC_NAME_IN_4(t1, t2, t3, t4)       MakeRefTuple(arg1, arg2, arg3, arg4)
-#define IPC_NAME_IN_5(t1, t2, t3, t4, t5)   MakeRefTuple(arg1, arg2, arg3, arg4, arg5)
+#define IPC_NAME_IN_0()                     base::MakeTuple()
+#define IPC_NAME_IN_1(t1)                   base::MakeRefTuple(arg1)
+#define IPC_NAME_IN_2(t1, t2)               base::MakeRefTuple(arg1, arg2)
+#define IPC_NAME_IN_3(t1, t2, t3)           base::MakeRefTuple(arg1, arg2, arg3)
+#define IPC_NAME_IN_4(t1, t2, t3, t4)       base::MakeRefTuple(arg1, arg2, \
+                                                               arg3, arg4)
+#define IPC_NAME_IN_5(t1, t2, t3, t4, t5)   base::MakeRefTuple(arg1, arg2, \
+                                                               arg3, arg4, arg5)
 
-#define IPC_NAME_OUT_0()                    MakeTuple()
-#define IPC_NAME_OUT_1(t1)                  MakeRefTuple(*arg6)
-#define IPC_NAME_OUT_2(t1, t2)              MakeRefTuple(*arg6, *arg7)
-#define IPC_NAME_OUT_3(t1, t2, t3)          MakeRefTuple(*arg6, *arg7, *arg8)
-#define IPC_NAME_OUT_4(t1, t2, t3, t4)      MakeRefTuple(*arg6, *arg7, *arg8, *arg9)
+#define IPC_NAME_OUT_0()                    base::MakeTuple()
+#define IPC_NAME_OUT_1(t1)                  base::MakeRefTuple(*arg6)
+#define IPC_NAME_OUT_2(t1, t2)              base::MakeRefTuple(*arg6, *arg7)
+#define IPC_NAME_OUT_3(t1, t2, t3)          base::MakeRefTuple(*arg6, *arg7, \
+                                                               *arg8)
+#define IPC_NAME_OUT_4(t1, t2, t3, t4)      base::MakeRefTuple(*arg6, *arg7, \
+                                                               *arg8, *arg9)
 
 // There are places where the syntax requires a comma if there are input args,
 // if there are input args and output args, or if there are input args or
 // output args.  These macros allow generation of the comma as needed; invoke
 // by token pasting against the argument counts.
 #define IPC_COMMA_0
 #define IPC_COMMA_1 ,
 #define IPC_COMMA_2 ,
 #define IPC_COMMA_3 ,
 #define IPC_COMMA_4 ,
@@ skipping 108 matching lines @@
 // This corresponds to an enum value from IPCMessageStart.
 #define IPC_MESSAGE_CLASS(message) \
   IPC_MESSAGE_ID_CLASS(message.type())
 
 #endif  // IPC_IPC_MESSAGE_MACROS_H_
 
 // Clean up IPC_MESSAGE_START in this unguarded section so that the
 // XXX_messages.h files need not do so themselves.  This makes the
 // XXX_messages.h files easier to write.
 #undef IPC_MESSAGE_START