| OLD | NEW |
|---|
| 1 // Copyright (c) 2010 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2010 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
| 4 | 4 |
| 5 // The file ipc_messsage_macros.h defines the classes for individual | 5 // The file ipc_messsage_macros.h defines the classes for individual |
| 6 // messages. This file works similarly, except that it defines the | 6 // messages. This file works similarly, except that it defines the |
| 7 // implementations of the constructors and the logging methods. (These only | 7 // implementations of the constructors and the logging methods. (These only |
| 8 // have to be generated once). It is meant to be included in a XXX_messages.cc | 8 // have to be generated once). It is meant to be included in a XXX_messages.cc |
| 9 // file. | 9 // file. |
| 10 // | 10 |
| 11 // Unlike ipc_message_macros.h, this file is only included once; it uses one | |
| 12 // pass. But we *still* can't use normal include guards because we still need | |
| 13 // to use the MESSAGES_INTERNAL_FILE dispatch system. Because that #define is | |
| 14 // unset, we use the different name MESSAGES_INTERNAL_IMPL_FILE to tell this | |
| 15 // file what to do. | |
| 16 #ifndef IPC_IPC_MESSAGE_IMPL_MACROS_H_ | 11 #ifndef IPC_IPC_MESSAGE_IMPL_MACROS_H_ |
| 17 #define IPC_IPC_MESSAGE_IMPL_MACROS_H_ | 12 #define IPC_IPC_MESSAGE_IMPL_MACROS_H_ |
| 18 | 13 |
| 19 #include "ipc/ipc_message_utils.h" | 14 #include "ipc/ipc_message_utils.h" |
| 20 #include "ipc/ipc_message_utils_impl.h" | 15 #include "ipc/ipc_message_utils_impl.h" |
| 21 | 16 |
| 22 #ifndef MESSAGES_INTERNAL_IMPL_FILE | 17 #ifndef MESSAGES_INTERNAL_IMPL_FILE |
| 23 #error This file should only be included by X_messages.cc, which needs to define
MESSAGES_INTERNAL_IMPL_FILE first. | 18 #error This file should only be included by X_messages.cc, which needs to define
MESSAGES_INTERNAL_IMPL_FILE first. |
| 24 #endif | 19 #endif |
| 25 | 20 |
| (...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 90 #undef IPC_SYNC_MESSAGE_ROUTED4_3 | 85 #undef IPC_SYNC_MESSAGE_ROUTED4_3 |
| 91 #undef IPC_SYNC_MESSAGE_ROUTED5_0 | 86 #undef IPC_SYNC_MESSAGE_ROUTED5_0 |
| 92 #undef IPC_SYNC_MESSAGE_ROUTED5_1 | 87 #undef IPC_SYNC_MESSAGE_ROUTED5_1 |
| 93 #undef IPC_SYNC_MESSAGE_ROUTED5_2 | 88 #undef IPC_SYNC_MESSAGE_ROUTED5_2 |
| 94 #undef IPC_SYNC_MESSAGE_ROUTED5_3 | 89 #undef IPC_SYNC_MESSAGE_ROUTED5_3 |
| 95 | 90 |
| 96 // These don't do anything during this pass. | 91 // These don't do anything during this pass. |
| 97 #define IPC_BEGIN_MESSAGES(label) | 92 #define IPC_BEGIN_MESSAGES(label) |
| 98 #define IPC_END_MESSAGES(label) | 93 #define IPC_END_MESSAGES(label) |
| 99 | 94 |
| 95 // Every class must include a destructor and a log method that is keyed to the |
| 96 // specific types. |
| 97 #define IPC_ASYNC_MESSAGE_DTOR_AND_LOG(msg_class) \ |
| 98 msg_class::~msg_class() {} \ |
| 99 \ |
| 100 void msg_class::Log(const Message* msg, std::wstring* l) { \ |
| 101 Param p; \ |
| 102 if (Read(msg, &p)) \ |
| 103 IPC::LogParam(p, l); \ |
| 104 } |
| 105 |
| 100 // This derives from IPC::Message and thus doesn't need us to keep the | 106 // This derives from IPC::Message and thus doesn't need us to keep the |
| 101 // implementations in this impl file. | 107 // implementations in this impl file. |
| 102 #define IPC_MESSAGE_CONTROL0(msg_class) | 108 #define IPC_MESSAGE_CONTROL0(msg_class) |
| 103 | 109 |
| 104 #define IPC_MESSAGE_CONTROL1(msg_class, type1) \ | 110 #define IPC_MESSAGE_CONTROL1(msg_class, type1) \ |
| 105 msg_class::msg_class(const type1& arg1) \ | 111 msg_class::msg_class(const type1& arg1) \ |
| 106 : IPC::MessageWithTuple< Tuple1<type1> >( \ | 112 : IPC::MessageWithTuple< Tuple1<type1> >( \ |
| 107 MSG_ROUTING_CONTROL, ID, MakeRefTuple(arg1)) {} \ | 113 MSG_ROUTING_CONTROL, ID, MakeRefTuple(arg1)) {} \ |
| 108 \ | 114 \ |
| 109 msg_class::~msg_class() {} \ | 115 IPC_ASYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 110 \ | |
| 111 void msg_class::Log(const Message* msg, std::wstring* l) { \ | |
| 112 Param p; \ | |
| 113 if (Read(msg, &p)) \ | |
| 114 IPC::LogParam(p, l); \ | |
| 115 } | |
| 116 | 116 |
| 117 #define IPC_MESSAGE_CONTROL2(msg_class, type1, type2) \ | 117 #define IPC_MESSAGE_CONTROL2(msg_class, type1, type2) \ |
| 118 msg_class::msg_class(const type1& arg1, const type2& arg2) \ | 118 msg_class::msg_class(const type1& arg1, const type2& arg2) \ |
| 119 : IPC::MessageWithTuple< Tuple2<type1, type2> >( \ | 119 : IPC::MessageWithTuple< Tuple2<type1, type2> >( \ |
| 120 MSG_ROUTING_CONTROL, ID, MakeRefTuple(arg1, arg2)) {} \ | 120 MSG_ROUTING_CONTROL, ID, MakeRefTuple(arg1, arg2)) {} \ |
| 121 \ | 121 \ |
| 122 msg_class::~msg_class() {} \ | 122 IPC_ASYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 123 \ | |
| 124 void msg_class::Log(const Message* msg, std::wstring* l) { \ | |
| 125 Param p; \ | |
| 126 if (Read(msg, &p)) \ | |
| 127 IPC::LogParam(p, l); \ | |
| 128 } | |
| 129 | 123 |
| 130 #define IPC_MESSAGE_CONTROL3(msg_class, type1, type2, type3) \ | 124 #define IPC_MESSAGE_CONTROL3(msg_class, type1, type2, type3) \ |
| 131 msg_class::msg_class(const type1& arg1, const type2& arg2, \ | 125 msg_class::msg_class(const type1& arg1, const type2& arg2, \ |
| 132 const type3& arg3) \ | 126 const type3& arg3) \ |
| 133 : IPC::MessageWithTuple< Tuple3<type1, type2, type3> >( \ | 127 : IPC::MessageWithTuple< Tuple3<type1, type2, type3> >( \ |
| 134 MSG_ROUTING_CONTROL, ID, MakeRefTuple(arg1, arg2, arg3)) {} \ | 128 MSG_ROUTING_CONTROL, ID, MakeRefTuple(arg1, arg2, arg3)) {} \ |
| 135 \ | 129 \ |
| 136 msg_class::~msg_class() {} \ | 130 IPC_ASYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 137 \ | |
| 138 void msg_class::Log(const Message* msg, std::wstring* l) { \ | |
| 139 Param p; \ | |
| 140 if (Read(msg, &p)) \ | |
| 141 IPC::LogParam(p, l); \ | |
| 142 } | |
| 143 | 131 |
| 144 #define IPC_MESSAGE_CONTROL4(msg_class, type1, type2, type3, type4) \ | 132 #define IPC_MESSAGE_CONTROL4(msg_class, type1, type2, type3, type4) \ |
| 145 msg_class::msg_class(const type1& arg1, const type2& arg2, \ | 133 msg_class::msg_class(const type1& arg1, const type2& arg2, \ |
| 146 const type3& arg3, const type4& arg4) \ | 134 const type3& arg3, const type4& arg4) \ |
| 147 : IPC::MessageWithTuple< Tuple4<type1, type2, type3, type4> >( \ | 135 : IPC::MessageWithTuple< Tuple4<type1, type2, type3, type4> >( \ |
| 148 MSG_ROUTING_CONTROL, ID, MakeRefTuple(arg1, arg2, arg3, arg4)) {} \ | 136 MSG_ROUTING_CONTROL, ID, MakeRefTuple(arg1, arg2, arg3, arg4)) {} \ |
| 149 \ | 137 \ |
| 150 msg_class::~msg_class() {} \ | 138 IPC_ASYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 151 \ | |
| 152 void msg_class::Log(const Message* msg, std::wstring* l) { \ | |
| 153 Param p; \ | |
| 154 if (Read(msg, &p)) \ | |
| 155 IPC::LogParam(p, l); \ | |
| 156 } | |
| 157 | 139 |
| 158 #define IPC_MESSAGE_CONTROL5(msg_class, type1, type2, type3, type4, type5) \ | 140 #define IPC_MESSAGE_CONTROL5(msg_class, type1, type2, type3, type4, type5) \ |
| 159 msg_class::msg_class(const type1& arg1, const type2& arg2, \ | 141 msg_class::msg_class(const type1& arg1, const type2& arg2, \ |
| 160 const type3& arg3, const type4& arg4, \ | 142 const type3& arg3, const type4& arg4, \ |
| 161 const type5& arg5) \ | 143 const type5& arg5) \ |
| 162 : IPC::MessageWithTuple< Tuple5<type1, type2, type3, type4, type5> >( \ | 144 : IPC::MessageWithTuple< Tuple5<type1, type2, type3, type4, type5> >( \ |
| 163 MSG_ROUTING_CONTROL, ID, \ | 145 MSG_ROUTING_CONTROL, ID, \ |
| 164 MakeRefTuple(arg1, arg2, arg3, arg4, arg5)) {} \ | 146 MakeRefTuple(arg1, arg2, arg3, arg4, arg5)) {} \ |
| 165 \ | 147 \ |
| 166 msg_class::~msg_class() {} \ | 148 IPC_ASYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 167 \ | |
| 168 void msg_class::Log(const Message* msg, std::wstring* l) { \ | |
| 169 Param p; \ | |
| 170 if (Read(msg, &p)) \ | |
| 171 IPC::LogParam(p, l); \ | |
| 172 } | |
| 173 | 149 |
| 174 // This derives from IPC::Message and thus doesn't need us to keep the | 150 // This derives from IPC::Message and thus doesn't need us to keep the |
| 175 // implementations in this impl file. | 151 // implementations in this impl file. |
| 176 #define IPC_MESSAGE_ROUTED0(msg_class) | 152 #define IPC_MESSAGE_ROUTED0(msg_class) |
| 177 | 153 |
| 178 #define IPC_MESSAGE_ROUTED1(msg_class, type1) \ | 154 #define IPC_MESSAGE_ROUTED1(msg_class, type1) \ |
| 179 msg_class::msg_class(int32 routing_id, const type1& arg1) \ | 155 msg_class::msg_class(int32 routing_id, const type1& arg1) \ |
| 180 : IPC::MessageWithTuple< Tuple1<type1> >( \ | 156 : IPC::MessageWithTuple< Tuple1<type1> >( \ |
| 181 routing_id, ID, MakeRefTuple(arg1)) {} \ | 157 routing_id, ID, MakeRefTuple(arg1)) {} \ |
| 182 \ | 158 \ |
| 183 msg_class::~msg_class() {} \ | 159 IPC_ASYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 184 \ | |
| 185 void msg_class::Log(const Message* msg, std::wstring* l) { \ | |
| 186 Param p; \ | |
| 187 if (Read(msg, &p)) \ | |
| 188 IPC::LogParam(p, l); \ | |
| 189 } | |
| 190 | 160 |
| 191 #define IPC_MESSAGE_ROUTED2(msg_class, type1, type2) \ | 161 #define IPC_MESSAGE_ROUTED2(msg_class, type1, type2) \ |
| 192 msg_class::msg_class(int32 routing_id, const type1& arg1, const type2& arg2) \ | 162 msg_class::msg_class(int32 routing_id, const type1& arg1, const type2& arg2) \ |
| 193 : IPC::MessageWithTuple< Tuple2<type1, type2> >( \ | 163 : IPC::MessageWithTuple< Tuple2<type1, type2> >( \ |
| 194 routing_id, ID, MakeRefTuple(arg1, arg2)) {} \ | 164 routing_id, ID, MakeRefTuple(arg1, arg2)) {} \ |
| 195 \ | 165 \ |
| 196 msg_class::~msg_class() {} \ | 166 IPC_ASYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 197 \ | |
| 198 void msg_class::Log(const Message* msg, std::wstring* l) { \ | |
| 199 Param p; \ | |
| 200 if (Read(msg, &p)) \ | |
| 201 IPC::LogParam(p, l); \ | |
| 202 } | |
| 203 | 167 |
| 204 | 168 |
| 205 #define IPC_MESSAGE_ROUTED3(msg_class, type1, type2, type3) \ | 169 #define IPC_MESSAGE_ROUTED3(msg_class, type1, type2, type3) \ |
| 206 msg_class::msg_class(int32 routing_id, const type1& arg1, \ | 170 msg_class::msg_class(int32 routing_id, const type1& arg1, \ |
| 207 const type2& arg2, const type3& arg3) \ | 171 const type2& arg2, const type3& arg3) \ |
| 208 : IPC::MessageWithTuple< Tuple3<type1, type2, type3> >( \ | 172 : IPC::MessageWithTuple< Tuple3<type1, type2, type3> >( \ |
| 209 routing_id, ID, MakeRefTuple(arg1, arg2, arg3)) {} \ | 173 routing_id, ID, MakeRefTuple(arg1, arg2, arg3)) {} \ |
| 210 \ | 174 \ |
| 211 msg_class::~msg_class() {} \ | 175 IPC_ASYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 212 \ | |
| 213 void msg_class::Log(const Message* msg, std::wstring* l) { \ | |
| 214 Param p; \ | |
| 215 if (Read(msg, &p)) \ | |
| 216 IPC::LogParam(p, l); \ | |
| 217 } | |
| 218 | 176 |
| 219 #define IPC_MESSAGE_ROUTED4(msg_class, type1, type2, type3, type4) \ | 177 #define IPC_MESSAGE_ROUTED4(msg_class, type1, type2, type3, type4) \ |
| 220 msg_class::msg_class(int32 routing_id, const type1& arg1, const type2& arg2, \ | 178 msg_class::msg_class(int32 routing_id, const type1& arg1, const type2& arg2, \ |
| 221 const type3& arg3, const type4& arg4) \ | 179 const type3& arg3, const type4& arg4) \ |
| 222 : IPC::MessageWithTuple< Tuple4<type1, type2, type3, type4> >( \ | 180 : IPC::MessageWithTuple< Tuple4<type1, type2, type3, type4> >( \ |
| 223 routing_id, ID, MakeRefTuple(arg1, arg2, arg3, arg4)) {} \ | 181 routing_id, ID, MakeRefTuple(arg1, arg2, arg3, arg4)) {} \ |
| 224 \ | 182 \ |
| 225 msg_class::~msg_class() {} \ | 183 IPC_ASYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 226 \ | |
| 227 void msg_class::Log(const Message* msg, std::wstring* l) { \ | |
| 228 Param p; \ | |
| 229 if (Read(msg, &p)) \ | |
| 230 IPC::LogParam(p, l); \ | |
| 231 } | |
| 232 | 184 |
| 233 #define IPC_MESSAGE_ROUTED5(msg_class, type1, type2, type3, type4, type5) \ | 185 #define IPC_MESSAGE_ROUTED5(msg_class, type1, type2, type3, type4, type5) \ |
| 234 msg_class::msg_class(int32 routing_id, const type1& arg1, \ | 186 msg_class::msg_class(int32 routing_id, const type1& arg1, \ |
| 235 const type2& arg2, const type3& arg3, \ | 187 const type2& arg2, const type3& arg3, \ |
| 236 const type4& arg4, const type5& arg5) \ | 188 const type4& arg4, const type5& arg5) \ |
| 237 : IPC::MessageWithTuple< Tuple5<type1, type2, type3, type4, type5> >( \ | 189 : IPC::MessageWithTuple< Tuple5<type1, type2, type3, type4, type5> >( \ |
| 238 routing_id, ID, MakeRefTuple(arg1, arg2, arg3, arg4, arg5)) {} \ | 190 routing_id, ID, MakeRefTuple(arg1, arg2, arg3, arg4, arg5)) {} \ |
| 239 \ | 191 \ |
| 240 msg_class::~msg_class() { } \ | 192 IPC_ASYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 193 |
| 194 // ----------------------------------------------------------------------------- |
| 195 |
| 196 // Every class must include a destructor and a log method that is keyed to the |
| 197 // specific types. |
| 198 #define IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) \ |
| 199 msg_class::~msg_class() {} \ |
| 241 \ | 200 \ |
| 242 void msg_class::Log(const Message* msg, std::wstring* l) { \ | 201 void msg_class::Log(const Message* msg, std::wstring* l) { \ |
| 243 Param p; \ | 202 if (msg->is_sync()) { \ |
| 244 if (Read(msg, &p)) \ | 203 SendParam p; \ |
| 245 IPC::LogParam(p, l); \ | 204 if (ReadSendParam(msg, &p)) \ |
| 205 IPC::LogParam(p, l); \ |
| 206 \ |
| 207 AddOutputParamsToLog(msg, l); \ |
| 208 } else { \ |
| 209 TupleTypes<ReplyParam>::ValueTuple p; \ |
| 210 if (ReadReplyParam(msg, &p)) \ |
| 211 IPC::LogParam(p, l); \ |
| 212 } \ |
| 246 } | 213 } |
| 247 | 214 |
| 248 // TODO(erg): Fill these in as I go along. | 215 #define IPC_SYNC_MESSAGE_CONTROL0_0(msg_class) \ |
| 249 #define IPC_SYNC_MESSAGE_CONTROL0_0(msg_class) | 216 msg_class::msg_class() \ |
| 250 #define IPC_SYNC_MESSAGE_CONTROL0_1(msg_class, type1_out) | 217 : IPC::MessageWithReply<Tuple0, Tuple0 >( \ |
| 251 #define IPC_SYNC_MESSAGE_CONTROL0_2(msg_class, type1_out, type2_out) | 218 MSG_ROUTING_CONTROL, ID, \ |
| 252 #define IPC_SYNC_MESSAGE_CONTROL0_3(msg_class, type1_out, type2_out, type3_out) | 219 MakeTuple(), MakeTuple()) {} \ |
| 253 #define IPC_SYNC_MESSAGE_CONTROL1_0(msg_class, type1_in) | 220 \ |
| 254 #define IPC_SYNC_MESSAGE_CONTROL1_1(msg_class, type1_in, type1_out) | 221 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 255 #define IPC_SYNC_MESSAGE_CONTROL1_2(msg_class, type1_in, type1_out, type2_out) | 222 |
| 256 #define IPC_SYNC_MESSAGE_CONTROL1_3(msg_class, type1_in, type1_out, type2_out, t
ype3_out) | 223 #define IPC_SYNC_MESSAGE_CONTROL0_1(msg_class, type1_out) \ |
| 257 #define IPC_SYNC_MESSAGE_CONTROL2_0(msg_class, type1_in, type2_in) | 224 msg_class::msg_class(type1_out* arg1) \ |
| 258 #define IPC_SYNC_MESSAGE_CONTROL2_1(msg_class, type1_in, type2_in, type1_out) | 225 : IPC::MessageWithReply<Tuple0, Tuple1<type1_out&> >( \ |
| 259 #define IPC_SYNC_MESSAGE_CONTROL2_2(msg_class, type1_in, type2_in, type1_out, ty
pe2_out) | 226 MSG_ROUTING_CONTROL, ID, \ |
| 260 #define IPC_SYNC_MESSAGE_CONTROL2_3(msg_class, type1_in, type2_in, type1_out, ty
pe2_out, type3_out) | 227 MakeTuple(), MakeRefTuple(*arg1)) {} \ |
| 261 #define IPC_SYNC_MESSAGE_CONTROL3_1(msg_class, type1_in, type2_in, type3_in, typ
e1_out) | 228 \ |
| 262 #define IPC_SYNC_MESSAGE_CONTROL3_2(msg_class, type1_in, type2_in, type3_in, typ
e1_out, type2_out) | 229 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 263 #define IPC_SYNC_MESSAGE_CONTROL3_3(msg_class, type1_in, type2_in, type3_in, typ
e1_out, type2_out, type3_out) | 230 |
| 264 #define IPC_SYNC_MESSAGE_CONTROL4_1(msg_class, type1_in, type2_in, type3_in, typ
e4_in, type1_out) | 231 #define IPC_SYNC_MESSAGE_CONTROL0_2(msg_class, type1_out, type2_out) \ |
| 265 #define IPC_SYNC_MESSAGE_CONTROL4_2(msg_class, type1_in, type2_in, type3_in, typ
e4_in, type1_out, type2_out) | 232 msg_class::msg_class(type1_out* arg1, type2_out* arg2) \ |
| 266 #define IPC_SYNC_MESSAGE_ROUTED0_0(msg_class) | 233 : IPC::MessageWithReply<Tuple0, Tuple2<type1_out&, type2_out&> >( \ |
| 267 #define IPC_SYNC_MESSAGE_ROUTED0_1(msg_class, type1_out) | 234 MSG_ROUTING_CONTROL, ID, \ |
| 268 #define IPC_SYNC_MESSAGE_ROUTED0_2(msg_class, type1_out, type2_out) | 235 MakeTuple(), MakeRefTuple(*arg1, *arg2)) {} \ |
| 269 #define IPC_SYNC_MESSAGE_ROUTED0_3(msg_class, type1_out, type2_out, type3_out) | 236 \ |
| 270 #define IPC_SYNC_MESSAGE_ROUTED1_0(msg_class, type1_in) | 237 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 271 #define IPC_SYNC_MESSAGE_ROUTED1_1(msg_class, type1_in, type1_out) | 238 |
| 272 #define IPC_SYNC_MESSAGE_ROUTED1_2(msg_class, type1_in, type1_out, type2_out) | 239 #define IPC_SYNC_MESSAGE_CONTROL0_3(msg_class, type1_out, type2_out, \ |
| 273 #define IPC_SYNC_MESSAGE_ROUTED1_3(msg_class, type1_in, type1_out, type2_out, ty
pe3_out) | 240 type3_out) \ |
| 274 #define IPC_SYNC_MESSAGE_ROUTED1_4(msg_class, type1_in, type1_out, type2_out, ty
pe3_out, type4_out) | 241 msg_class::msg_class(type1_out* arg1, type2_out* arg2, type3_out* arg3) \ |
| 275 #define IPC_SYNC_MESSAGE_ROUTED2_0(msg_class, type1_in, type2_in) | 242 : IPC::MessageWithReply<Tuple0, Tuple3<type1_out&, type2_out&, \ |
| 276 #define IPC_SYNC_MESSAGE_ROUTED2_1(msg_class, type1_in, type2_in, type1_out) | 243 type3_out&> >( \ |
| 277 #define IPC_SYNC_MESSAGE_ROUTED2_2(msg_class, type1_in, type2_in, type1_out, typ
e2_out) | 244 MSG_ROUTING_CONTROL, ID, \ |
| 278 #define IPC_SYNC_MESSAGE_ROUTED2_3(msg_class, type1_in, type2_in, type1_out, typ
e2_out, type3_out) | 245 MakeTuple(), MakeRefTuple(*arg1, *arg2, *arg3)) {} \ |
| 279 #define IPC_SYNC_MESSAGE_ROUTED3_0(msg_class, type1_in, type2_in, type3_in) | 246 \ |
| 280 #define IPC_SYNC_MESSAGE_ROUTED3_1(msg_class, type1_in, type2_in, type3_in, type
1_out) | 247 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 281 #define IPC_SYNC_MESSAGE_ROUTED3_2(msg_class, type1_in, type2_in, type3_in, type
1_out, type2_out) | 248 |
| 282 #define IPC_SYNC_MESSAGE_ROUTED3_3(msg_class, type1_in, type2_in, type3_in, type
1_out, type2_out, type3_out) | 249 |
| 283 #define IPC_SYNC_MESSAGE_ROUTED4_0(msg_class, type1_in, type2_in, type3_in, type
4_in) | 250 #define IPC_SYNC_MESSAGE_CONTROL1_0(msg_class, type1_in) \ |
| 284 #define IPC_SYNC_MESSAGE_ROUTED4_1(msg_class, type1_in, type2_in, type3_in, type
4_in, type1_out) | 251 msg_class::msg_class(const type1_in& arg1) \ |
| 285 #define IPC_SYNC_MESSAGE_ROUTED4_2(msg_class, type1_in, type2_in, type3_in, type
4_in, type1_out, type2_out) | 252 : IPC::MessageWithReply<Tuple1<type1_in>, Tuple0 >( \ |
| 286 #define IPC_SYNC_MESSAGE_ROUTED4_3(msg_class, type1_in, type2_in, type3_in, type
4_in, type1_out, type2_out, type3_out) | 253 MSG_ROUTING_CONTROL, ID, \ |
| 287 #define IPC_SYNC_MESSAGE_ROUTED5_0(msg_class, type1_in, type2_in, type3_in, type
4_in, type5_in) | 254 MakeRefTuple(arg1), MakeTuple()) {} \ |
| 288 #define IPC_SYNC_MESSAGE_ROUTED5_1(msg_class, type1_in, type2_in, type3_in, type
4_in, type5_in, type1_out) | 255 \ |
| 289 #define IPC_SYNC_MESSAGE_ROUTED5_2(msg_class, type1_in, type2_in, type3_in, type
4_in, type5_in, type1_out, type2_out) | 256 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 290 #define IPC_SYNC_MESSAGE_ROUTED5_3(msg_class, type1_in, type2_in, type3_in, type
4_in, type5_in, type1_out, type2_out, type3_out) | 257 |
| 258 #define IPC_SYNC_MESSAGE_CONTROL1_1(msg_class, type1_in, type1_out) \ |
| 259 msg_class::msg_class(const type1_in& arg1, type1_out* arg2) \ |
| 260 : IPC::MessageWithReply<Tuple1<type1_in>, Tuple1<type1_out&> >( \ |
| 261 MSG_ROUTING_CONTROL, ID, \ |
| 262 MakeRefTuple(arg1), MakeRefTuple(*arg2)) {} \ |
| 263 \ |
| 264 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 265 |
| 266 #define IPC_SYNC_MESSAGE_CONTROL1_2(msg_class, type1_in, type1_out, type2_out) \ |
| 267 msg_class::msg_class(const type1_in& arg1, type1_out* arg2, type2_out* arg3) \ |
| 268 : IPC::MessageWithReply<Tuple1<type1_in>, \ |
| 269 Tuple2<type1_out&, type2_out&> >( \ |
| 270 MSG_ROUTING_CONTROL, ID, \ |
| 271 MakeRefTuple(arg1), MakeRefTuple(*arg2, *arg3)) {} \ |
| 272 \ |
| 273 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 274 |
| 275 #define IPC_SYNC_MESSAGE_CONTROL1_3(msg_class, type1_in, type1_out, \ |
| 276 type2_out, type3_out) \ |
| 277 msg_class::msg_class(const type1_in& arg1, type1_out* arg2, \ |
| 278 type2_out* arg3, type3_out* arg4) \ |
| 279 : IPC::MessageWithReply<Tuple1<type1_in>, \ |
| 280 Tuple3<type1_out&, type2_out&, type3_out&> >( \ |
| 281 MSG_ROUTING_CONTROL, ID, \ |
| 282 MakeRefTuple(arg1), MakeRefTuple(*arg2, *arg3, *arg4)) {} \ |
| 283 \ |
| 284 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 285 |
| 286 #define IPC_SYNC_MESSAGE_CONTROL2_0(msg_class, type1_in, type2_in) \ |
| 287 msg_class::msg_class(const type1_in& arg1, const type2_in& arg2) \ |
| 288 : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple0 >( \ |
| 289 MSG_ROUTING_CONTROL, ID, \ |
| 290 MakeRefTuple(arg1, arg2), MakeTuple()) {} \ |
| 291 \ |
| 292 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 293 |
| 294 #define IPC_SYNC_MESSAGE_CONTROL2_1(msg_class, type1_in, type2_in, type1_out) \ |
| 295 msg_class::msg_class(const type1_in& arg1, const type2_in& arg2, \ |
| 296 type1_out* arg3) \ |
| 297 : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \ |
| 298 Tuple1<type1_out&> >( \ |
| 299 MSG_ROUTING_CONTROL, ID, \ |
| 300 MakeRefTuple(arg1, arg2), MakeRefTuple(*arg3)) {} \ |
| 301 \ |
| 302 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 303 |
| 304 |
| 305 #define IPC_SYNC_MESSAGE_CONTROL2_2(msg_class, type1_in, type2_in, \ |
| 306 type1_out, type2_out) \ |
| 307 msg_class::msg_class(const type1_in& arg1, const type2_in& arg2, \ |
| 308 type1_out* arg3, type2_out* arg4) \ |
| 309 : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \ |
| 310 Tuple2<type1_out&, type2_out&> >(MSG_ROUTING_CONTROL, ID, \ |
| 311 MakeRefTuple(arg1, arg2), MakeRefTuple(*arg3, *arg4)) {} \ |
| 312 \ |
| 313 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 314 |
| 315 |
| 316 #define IPC_SYNC_MESSAGE_CONTROL2_3(msg_class, type1_in, type2_in, \ |
| 317 type1_out, type2_out, type3_out) \ |
| 318 msg_class::msg_class(const type1_in& arg1, const type2_in& arg2, \ |
| 319 type1_out* arg3, type2_out* arg4, type3_out* arg5) \ |
| 320 : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \ |
| 321 Tuple3<type1_out&, type2_out&, type3_out&> >(MSG_ROUTING_CONTROL, \ |
| 322 ID, \ |
| 323 MakeRefTuple(arg1, arg2), MakeRefTuple(*arg3, *arg4, *arg5)) {} \ |
| 324 \ |
| 325 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 326 |
| 327 |
| 328 #define IPC_SYNC_MESSAGE_CONTROL3_1(msg_class, type1_in, type2_in, \ |
| 329 type3_in, type1_out) \ |
| 330 msg_class::msg_class(const type1_in& arg1, const type2_in& arg2, \ |
| 331 const type3_in& arg3, type1_out* arg4) \ |
| 332 : IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ |
| 333 Tuple1<type1_out&> >(MSG_ROUTING_CONTROL, ID, \ |
| 334 MakeRefTuple(arg1, arg2, arg3), MakeRefTuple(*arg4)) {} \ |
| 335 \ |
| 336 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 337 |
| 338 #define IPC_SYNC_MESSAGE_CONTROL3_2(msg_class, type1_in, type2_in, \ |
| 339 type3_in, type1_out, type2_out) \ |
| 340 msg_class::msg_class(const type1_in& arg1, const type2_in& arg2, \ |
| 341 const type3_in& arg3, type1_out* arg4, type2_out* arg5) \ |
| 342 : IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ |
| 343 Tuple2<type1_out&, type2_out&> >(MSG_ROUTING_CONTROL, ID, \ |
| 344 MakeRefTuple(arg1, arg2, arg3), MakeRefTuple(*arg4, *arg5)) {} \ |
| 345 \ |
| 346 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 347 |
| 348 |
| 349 #define IPC_SYNC_MESSAGE_CONTROL3_3(msg_class, type1_in, type2_in, \ |
| 350 type3_in, type1_out, type2_out, \ |
| 351 type3_out) \ |
| 352 msg_class::msg_class(const type1_in& arg1, const type2_in& arg2, \ |
| 353 const type3_in& arg3, type1_out* arg4, \ |
| 354 type2_out* arg5, type3_out* arg6) \ |
| 355 : IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ |
| 356 Tuple3<type1_out&, type2_out&, type3_out&> >(MSG_ROUTING_CONTROL, \ |
| 357 ID, \ |
| 358 MakeRefTuple(arg1, arg2, arg3), \ |
| 359 MakeRefTuple(*arg4, *arg5, *arg6)) {} \ |
| 360 \ |
| 361 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 362 |
| 363 #define IPC_SYNC_MESSAGE_CONTROL4_1(msg_class, type1_in, type2_in, \ |
| 364 type3_in, type4_in, type1_out) \ |
| 365 msg_class::msg_class(const type1_in& arg1, const type2_in& arg2, \ |
| 366 const type3_in& arg3, const type4_in& arg4, \ |
| 367 type1_out* arg6) \ |
| 368 : IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>, \ |
| 369 Tuple1<type1_out&> >(MSG_ROUTING_CONTROL, ID, \ |
| 370 MakeRefTuple(arg1, arg2, arg3, arg4), MakeRefTuple(*arg6)) {} \ |
| 371 \ |
| 372 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 373 |
| 374 |
| 375 #define IPC_SYNC_MESSAGE_CONTROL4_2(msg_class, type1_in, type2_in, \ |
| 376 type3_in, type4_in, type1_out, \ |
| 377 type2_out) \ |
| 378 msg_class::msg_class(const type1_in& arg1, const type2_in& arg2, \ |
| 379 const type3_in& arg3, const type4_in& arg4, \ |
| 380 type1_out* arg5, type2_out* arg6) \ |
| 381 : IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, \ |
| 382 type4_in>, \ |
| 383 Tuple2<type1_out&, type2_out&> >(MSG_ROUTING_CONTROL, ID, \ |
| 384 MakeRefTuple(arg1, arg2, arg3, arg4), \ |
| 385 MakeRefTuple(*arg5, *arg6)) {} \ |
| 386 \ |
| 387 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 388 |
| 389 #define IPC_SYNC_MESSAGE_ROUTED0_0(msg_class) \ |
| 390 msg_class::msg_class(int routing_id) \ |
| 391 : IPC::MessageWithReply<Tuple0, Tuple0>( \ |
| 392 routing_id, ID, \ |
| 393 MakeTuple(), MakeTuple()) {} \ |
| 394 \ |
| 395 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 396 |
| 397 #define IPC_SYNC_MESSAGE_ROUTED0_1(msg_class, type1_out) \ |
| 398 msg_class::msg_class(int routing_id, type1_out* arg1) \ |
| 399 : IPC::MessageWithReply<Tuple0, Tuple1<type1_out&> >( \ |
| 400 routing_id, ID, \ |
| 401 MakeTuple(), MakeRefTuple(*arg1)) {} \ |
| 402 \ |
| 403 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 404 |
| 405 #define IPC_SYNC_MESSAGE_ROUTED0_2(msg_class, type1_out, type2_out) \ |
| 406 msg_class::msg_class(int routing_id, type1_out* arg1, type2_out* arg2) \ |
| 407 : IPC::MessageWithReply<Tuple0, Tuple2<type1_out&, type2_out&> >( \ |
| 408 routing_id, ID, \ |
| 409 MakeTuple(), MakeRefTuple(*arg1, *arg2)) {} \ |
| 410 \ |
| 411 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 412 |
| 413 #define IPC_SYNC_MESSAGE_ROUTED0_3(msg_class, type1_out, type2_out, \ |
| 414 type3_out) \ |
| 415 msg_class::msg_class(int routing_id, type1_out* arg1, type2_out* arg2, \ |
| 416 type3_out* arg3) \ |
| 417 : IPC::MessageWithReply<Tuple0, \ |
| 418 Tuple3<type1_out&, type2_out&, type3_out&> >(routing_id, ID, \ |
| 419 MakeTuple(), MakeRefTuple(*arg1, *arg2, *arg3)) {} \ |
| 420 \ |
| 421 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 422 |
| 423 #define IPC_SYNC_MESSAGE_ROUTED1_0(msg_class, type1_in) \ |
| 424 msg_class::msg_class(int routing_id, const type1_in& arg1) \ |
| 425 : IPC::MessageWithReply<Tuple1<type1_in>, Tuple0 >( \ |
| 426 routing_id, ID, \ |
| 427 MakeRefTuple(arg1), MakeTuple()) {} \ |
| 428 \ |
| 429 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 430 |
| 431 #define IPC_SYNC_MESSAGE_ROUTED1_1(msg_class, type1_in, type1_out) \ |
| 432 msg_class::msg_class(int routing_id, const type1_in& arg1, \ |
| 433 type1_out* arg2) \ |
| 434 : IPC::MessageWithReply<Tuple1<type1_in>, Tuple1<type1_out&> >( \ |
| 435 routing_id, ID, \ |
| 436 MakeRefTuple(arg1), MakeRefTuple(*arg2)) {} \ |
| 437 \ |
| 438 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 439 |
| 440 #define IPC_SYNC_MESSAGE_ROUTED1_2(msg_class, type1_in, type1_out, \ |
| 441 type2_out) \ |
| 442 msg_class::msg_class(int routing_id, const type1_in& arg1, \ |
| 443 type1_out* arg2, type2_out* arg3) \ |
| 444 : IPC::MessageWithReply<Tuple1<type1_in>, \ |
| 445 Tuple2<type1_out&, type2_out&> >( \ |
| 446 routing_id, ID, \ |
| 447 MakeRefTuple(arg1), MakeRefTuple(*arg2, *arg3)) {} \ |
| 448 \ |
| 449 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 450 |
| 451 #define IPC_SYNC_MESSAGE_ROUTED1_3(msg_class, type1_in, type1_out, \ |
| 452 type2_out, type3_out) \ |
| 453 msg_class::msg_class(int routing_id, const type1_in& arg1, \ |
| 454 type1_out* arg2, type2_out* arg3, type3_out* arg4) \ |
| 455 : IPC::MessageWithReply<Tuple1<type1_in>, \ |
| 456 Tuple3<type1_out&, type2_out&, type3_out&> >(routing_id, ID, \ |
| 457 MakeRefTuple(arg1), MakeRefTuple(*arg2, *arg3, *arg4)) {} \ |
| 458 \ |
| 459 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 460 |
| 461 #define IPC_SYNC_MESSAGE_ROUTED1_4(msg_class, type1_in, type1_out, \ |
| 462 type2_out, type3_out, type4_out) \ |
| 463 msg_class::msg_class(int routing_id, const type1_in& arg1, \ |
| 464 type1_out* arg2, type2_out* arg3, \ |
| 465 type3_out* arg4, type4_out* arg5) \ |
| 466 : IPC::MessageWithReply<Tuple1<type1_in>, \ |
| 467 Tuple4<type1_out&, type2_out&, type3_out&, type4_out&> >( \ |
| 468 routing_id, ID, MakeRefTuple(arg1), \ |
| 469 MakeRefTuple(*arg2, *arg3, *arg4, *arg5)) {} \ |
| 470 \ |
| 471 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 472 |
| 473 #define IPC_SYNC_MESSAGE_ROUTED2_0(msg_class, type1_in, type2_in) \ |
| 474 msg_class::msg_class(int routing_id, const type1_in& arg1, \ |
| 475 const type2_in& arg2) \ |
| 476 : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple0 >( \ |
| 477 routing_id, ID, MakeRefTuple(arg1, arg2), MakeTuple()) {} \ |
| 478 \ |
| 479 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 480 |
| 481 #define IPC_SYNC_MESSAGE_ROUTED2_1(msg_class, type1_in, type2_in, \ |
| 482 type1_out) \ |
| 483 msg_class::msg_class(int routing_id, const type1_in& arg1, \ |
| 484 const type2_in& arg2, type1_out* arg3) \ |
| 485 : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \ |
| 486 Tuple1<type1_out&> >(routing_id, ID, \ |
| 487 MakeRefTuple(arg1, arg2), MakeRefTuple(*arg3)) {} \ |
| 488 \ |
| 489 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 490 |
| 491 #define IPC_SYNC_MESSAGE_ROUTED2_2(msg_class, type1_in, type2_in, \ |
| 492 type1_out, type2_out) \ |
| 493 msg_class::msg_class(int routing_id, const type1_in& arg1, \ |
| 494 const type2_in& arg2, type1_out* arg3, \ |
| 495 type2_out* arg4) \ |
| 496 : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \ |
| 497 Tuple2<type1_out&, type2_out&> >(routing_id, ID, \ |
| 498 MakeRefTuple(arg1, arg2), MakeRefTuple(*arg3, *arg4)) {} \ |
| 499 \ |
| 500 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 501 |
| 502 #define IPC_SYNC_MESSAGE_ROUTED2_3(msg_class, type1_in, type2_in, \ |
| 503 type1_out, type2_out, type3_out) \ |
| 504 msg_class::msg_class(int routing_id, const type1_in& arg1, \ |
| 505 const type2_in& arg2, type1_out* arg3, \ |
| 506 type2_out* arg4, type3_out* arg5) \ |
| 507 : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \ |
| 508 Tuple3<type1_out&, type2_out&, type3_out&> >(routing_id, ID, \ |
| 509 MakeRefTuple(arg1, arg2), MakeRefTuple(*arg3, *arg4, *arg5)) {} \ |
| 510 \ |
| 511 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 512 |
| 513 #define IPC_SYNC_MESSAGE_ROUTED3_0(msg_class, type1_in, type2_in, \ |
| 514 type3_in) \ |
| 515 msg_class::msg_class(int routing_id, const type1_in& arg1, \ |
| 516 const type2_in& arg2, const type3_in& arg3) \ |
| 517 : IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, Tuple0>( \ |
| 518 routing_id, ID, \ |
| 519 MakeRefTuple(arg1, arg2, arg3), MakeTuple()) {} \ |
| 520 \ |
| 521 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 522 |
| 523 #define IPC_SYNC_MESSAGE_ROUTED3_1(msg_class, type1_in, type2_in, \ |
| 524 type3_in, type1_out) \ |
| 525 msg_class::msg_class(int routing_id, const type1_in& arg1, \ |
| 526 const type2_in& arg2, const type3_in& arg3, \ |
| 527 type1_out* arg4) \ |
| 528 : IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ |
| 529 Tuple1<type1_out&> >(routing_id, ID, \ |
| 530 MakeRefTuple(arg1, arg2, arg3), MakeRefTuple(*arg4)) {} \ |
| 531 \ |
| 532 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 533 |
| 534 #define IPC_SYNC_MESSAGE_ROUTED3_2(msg_class, type1_in, type2_in, \ |
| 535 type3_in, type1_out, type2_out) \ |
| 536 msg_class::msg_class(int routing_id, const type1_in& arg1, \ |
| 537 const type2_in& arg2, const type3_in& arg3, \ |
| 538 type1_out* arg4, type2_out* arg5) \ |
| 539 : IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ |
| 540 Tuple2<type1_out&, type2_out&> >(routing_id, ID, \ |
| 541 MakeRefTuple(arg1, arg2, arg3), MakeRefTuple(*arg4, *arg5)) {} \ |
| 542 \ |
| 543 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 544 |
| 545 #define IPC_SYNC_MESSAGE_ROUTED3_3(msg_class, type1_in, type2_in, \ |
| 546 type3_in, type1_out, type2_out, \ |
| 547 type3_out) \ |
| 548 msg_class::msg_class(int routing_id, const type1_in& arg1, \ |
| 549 const type2_in& arg2, const type3_in& arg3, \ |
| 550 type1_out* arg4, type2_out* arg5, type3_out* arg6) \ |
| 551 : IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ |
| 552 Tuple3<type1_out&, type2_out&, type3_out&> >(routing_id, ID, \ |
| 553 MakeRefTuple(arg1, arg2, arg3), MakeRefTuple(*arg4, *arg5, \ |
| 554 *arg6)) {} \ |
| 555 \ |
| 556 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 557 |
| 558 #define IPC_SYNC_MESSAGE_ROUTED4_0(msg_class, type1_in, type2_in, \ |
| 559 type3_in, type4_in) \ |
| 560 msg_class::msg_class(int routing_id, const type1_in& arg1, \ |
| 561 const type2_in& arg2, const type3_in& arg3, \ |
| 562 const type4_in& arg4) \ |
| 563 : IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, \ |
| 564 type4_in>, Tuple0 >(routing_id, ID, \ |
| 565 MakeRefTuple(arg1, arg2, arg3, arg4), MakeTuple()) {} \ |
| 566 \ |
| 567 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 568 |
| 569 #define IPC_SYNC_MESSAGE_ROUTED4_1(msg_class, type1_in, type2_in, \ |
| 570 type3_in, type4_in, type1_out) \ |
| 571 msg_class::msg_class(int routing_id, const type1_in& arg1, \ |
| 572 const type2_in& arg2, const type3_in& arg3, \ |
| 573 const type4_in& arg4, type1_out* arg6) \ |
| 574 : IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>,
\ |
| 575 Tuple1<type1_out&> >(routing_id, ID, \ |
| 576 MakeRefTuple(arg1, arg2, arg3, arg4), MakeRefTuple(*arg6)) {} \ |
| 577 \ |
| 578 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 579 |
| 580 |
| 581 #define IPC_SYNC_MESSAGE_ROUTED4_2(msg_class, type1_in, type2_in, \ |
| 582 type3_in, type4_in, type1_out, \ |
| 583 type2_out) \ |
| 584 msg_class::msg_class(int routing_id, const type1_in& arg1, \ |
| 585 const type2_in& arg2, const type3_in& arg3, \ |
| 586 const type4_in& arg4, type1_out* arg5, type2_out* arg6) \ |
| 587 : IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>, \ |
| 588 Tuple2<type1_out&, type2_out&> >(routing_id, ID, \ |
| 589 MakeRefTuple(arg1, arg2, arg3, arg4), MakeRefTuple(*arg5, *arg6)) {} \ |
| 590 \ |
| 591 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 592 |
| 593 |
| 594 #define IPC_SYNC_MESSAGE_ROUTED4_3(msg_class, type1_in, type2_in, \ |
| 595 type3_in, type4_in, type1_out, \ |
| 596 type2_out, type3_out) \ |
| 597 msg_class::msg_class(int routing_id, const type1_in& arg1, \ |
| 598 const type2_in& arg2, const type3_in& arg3, \ |
| 599 const type4_in& arg4, type1_out* arg5, \ |
| 600 type2_out* arg6, type3_out* arg7) \ |
| 601 : IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>, \ |
| 602 Tuple3<type1_out&, type2_out&, type3_out&> >(routing_id, ID, \ |
| 603 MakeRefTuple(arg1, arg2, arg3, arg4), \ |
| 604 MakeRefTuple(*arg5, *arg6, *arg7)) {} \ |
| 605 \ |
| 606 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 607 |
| 608 #define IPC_SYNC_MESSAGE_ROUTED5_0(msg_class, type1_in, type2_in, \ |
| 609 type3_in, type4_in, type5_in) \ |
| 610 msg_class::msg_class(int routing_id, const type1_in& arg1, \ |
| 611 const type2_in& arg2, const type3_in& arg3, \ |
| 612 const type4_in& arg4, const type5_in& arg5) \ |
| 613 : IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, \ |
| 614 type4_in, type5_in>, Tuple0 >(routing_id, ID, \ |
| 615 MakeRefTuple(arg1, arg2, arg3, arg4, arg5), MakeTuple()) {} \ |
| 616 \ |
| 617 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 618 |
| 619 #define IPC_SYNC_MESSAGE_ROUTED5_1(msg_class, type1_in, type2_in, \ |
| 620 type3_in, type4_in, type5_in, type1_out) \ |
| 621 msg_class::msg_class(int routing_id, const type1_in& arg1, \ |
| 622 const type2_in& arg2, const type3_in& arg3, \ |
| 623 const type4_in& arg4, const type5_in& arg5, \ |
| 624 type1_out* arg6) \ |
| 625 : IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, \ |
| 626 type4_in, type5_in>, Tuple1<type1_out&> >(routing_id, ID, \ |
| 627 MakeRefTuple(arg1, arg2, arg3, arg4, arg5), \ |
| 628 MakeRefTuple(*arg6)) {} \ |
| 629 \ |
| 630 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 631 |
| 632 #define IPC_SYNC_MESSAGE_ROUTED5_2(msg_class, type1_in, type2_in, \ |
| 633 type3_in, type4_in, type5_in, \ |
| 634 type1_out, type2_out) \ |
| 635 msg_class::msg_class(int routing_id, const type1_in& arg1, \ |
| 636 const type2_in& arg2, const type3_in& arg3, \ |
| 637 const type4_in& arg4, const type4_in& arg5, \ |
| 638 type1_out* arg6, type2_out* arg7) \ |
| 639 : IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, \ |
| 640 type4_in, type5_in>, Tuple2<type1_out&, type2_out&> >( \ |
| 641 routing_id, ID, MakeRefTuple(arg1, arg2, arg3, arg4, arg5), \ |
| 642 MakeRefTuple(*arg6, *arg7)) {} \ |
| 643 \ |
| 644 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 645 |
| 646 #define IPC_SYNC_MESSAGE_ROUTED5_3(msg_class, type1_in, type2_in, \ |
| 647 type3_in, type4_in, type5_in, \ |
| 648 type1_out, type2_out, type3_out) \ |
| 649 msg_class::msg_class(int routing_id, const type1_in& arg1, \ |
| 650 const type2_in& arg2, const type3_in& arg3, \ |
| 651 const type4_in& arg4, const type4_in& arg5, \ |
| 652 type1_out* arg6, type2_out* arg7, \ |
| 653 type3_out* arg8) \ |
| 654 : IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, \ |
| 655 type4_in, type5_in>, \ |
| 656 Tuple3<type1_out&, type2_out&, type3_out&> >(routing_id, ID, \ |
| 657 MakeRefTuple(arg1, arg2, arg3, arg4, arg5), \ |
| 658 MakeRefTuple(*arg6, *arg7, *arg8)) {} \ |
| 659 \ |
| 660 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) |
| 291 | 661 |
| 292 // Trigger the header guard define in ipc_message_macros.h so we don't get | 662 // Trigger the header guard define in ipc_message_macros.h so we don't get |
| 293 // duplicate including when we include MESSAGES_INTERNAL_FILE again at the end | 663 // duplicate including when we include MESSAGES_INTERNAL_FILE again at the end |
| 294 // of this file. | 664 // of this file. |
| 295 #define IPC_MESSAGE_MACROS_INCLUDE_BLOCK | 665 #define IPC_MESSAGE_MACROS_INCLUDE_BLOCK |
| 296 | 666 |
| 297 // Redefine MESSAGES_INTERNAL_FILE just for the header check in | 667 // Redefine MESSAGES_INTERNAL_FILE just for the header check in |
| 298 // ipc_messages_macros.h that happens before it breaks on the header guard. | 668 // ipc_messages_macros.h that happens before it breaks on the header guard. |
| 299 #define MESSAGES_INTERNAL_FILE MESSAGES_INTERNAL_IMPL_FILE | 669 #define MESSAGES_INTERNAL_FILE MESSAGES_INTERNAL_IMPL_FILE |
| 300 | 670 |
| 301 // Include our INTERNAL file first to get the normal expansion. | 671 // Include our INTERNAL file first to get the normal expansion. |
| 302 #include MESSAGES_INTERNAL_IMPL_FILE | 672 #include MESSAGES_INTERNAL_IMPL_FILE |
| 303 | 673 |
| 304 #endif // IPC_IPC_MESSAGE_IMPL_MACROS_H_ | 674 #endif // IPC_IPC_MESSAGE_IMPL_MACROS_H_ |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 3018045:
FBTF: Allow forward declaration of classes passed to sync IPC messages. (Closed)
