Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(413)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: ipc/ipc_message_impl_macros.h

Issue 3152007: Revert "FBTF: Allow forward declaration of classes passed to sync IPC messages." (Closed) Base URL: http://src.chromium.org/git/chromium.git
Patch Set: Created 10 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « chrome/renderer/render_view.cc ('k') | ipc/ipc_message_macros.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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.
11 #ifndef IPC_IPC_MESSAGE_IMPL_MACROS_H_ 16 #ifndef IPC_IPC_MESSAGE_IMPL_MACROS_H_
12 #define IPC_IPC_MESSAGE_IMPL_MACROS_H_ 17 #define IPC_IPC_MESSAGE_IMPL_MACROS_H_
13 18
14 #include "ipc/ipc_message_utils.h" 19 #include "ipc/ipc_message_utils.h"
15 #include "ipc/ipc_message_utils_impl.h" 20 #include "ipc/ipc_message_utils_impl.h"
16 21
17 #ifndef MESSAGES_INTERNAL_IMPL_FILE 22 #ifndef MESSAGES_INTERNAL_IMPL_FILE
18 #error This file should only be included by X_messages.cc, which needs to define MESSAGES_INTERNAL_IMPL_FILE first. 23 #error This file should only be included by X_messages.cc, which needs to define MESSAGES_INTERNAL_IMPL_FILE first.
19 #endif 24 #endif
20 25
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after
85 #undef IPC_SYNC_MESSAGE_ROUTED4_3 90 #undef IPC_SYNC_MESSAGE_ROUTED4_3
86 #undef IPC_SYNC_MESSAGE_ROUTED5_0 91 #undef IPC_SYNC_MESSAGE_ROUTED5_0
87 #undef IPC_SYNC_MESSAGE_ROUTED5_1 92 #undef IPC_SYNC_MESSAGE_ROUTED5_1
88 #undef IPC_SYNC_MESSAGE_ROUTED5_2 93 #undef IPC_SYNC_MESSAGE_ROUTED5_2
89 #undef IPC_SYNC_MESSAGE_ROUTED5_3 94 #undef IPC_SYNC_MESSAGE_ROUTED5_3
90 95
91 // These don't do anything during this pass. 96 // These don't do anything during this pass.
92 #define IPC_BEGIN_MESSAGES(label) 97 #define IPC_BEGIN_MESSAGES(label)
93 #define IPC_END_MESSAGES(label) 98 #define IPC_END_MESSAGES(label)
94 99
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
106 // This derives from IPC::Message and thus doesn't need us to keep the 100 // This derives from IPC::Message and thus doesn't need us to keep the
107 // implementations in this impl file. 101 // implementations in this impl file.
108 #define IPC_MESSAGE_CONTROL0(msg_class) 102 #define IPC_MESSAGE_CONTROL0(msg_class)
109 103
110 #define IPC_MESSAGE_CONTROL1(msg_class, type1) \ 104 #define IPC_MESSAGE_CONTROL1(msg_class, type1) \
111 msg_class::msg_class(const type1& arg1) \ 105 msg_class::msg_class(const type1& arg1) \
112 : IPC::MessageWithTuple< Tuple1<type1> >( \ 106 : IPC::MessageWithTuple< Tuple1<type1> >( \
113 MSG_ROUTING_CONTROL, ID, MakeRefTuple(arg1)) {} \ 107 MSG_ROUTING_CONTROL, ID, MakeRefTuple(arg1)) {} \
114 \ 108 \
115 IPC_ASYNC_MESSAGE_DTOR_AND_LOG(msg_class) 109 msg_class::~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 IPC_ASYNC_MESSAGE_DTOR_AND_LOG(msg_class) 122 msg_class::~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 }
123 129
124 #define IPC_MESSAGE_CONTROL3(msg_class, type1, type2, type3) \ 130 #define IPC_MESSAGE_CONTROL3(msg_class, type1, type2, type3) \
125 msg_class::msg_class(const type1& arg1, const type2& arg2, \ 131 msg_class::msg_class(const type1& arg1, const type2& arg2, \
126 const type3& arg3) \ 132 const type3& arg3) \
127 : IPC::MessageWithTuple< Tuple3<type1, type2, type3> >( \ 133 : IPC::MessageWithTuple< Tuple3<type1, type2, type3> >( \
128 MSG_ROUTING_CONTROL, ID, MakeRefTuple(arg1, arg2, arg3)) {} \ 134 MSG_ROUTING_CONTROL, ID, MakeRefTuple(arg1, arg2, arg3)) {} \
129 \ 135 \
130 IPC_ASYNC_MESSAGE_DTOR_AND_LOG(msg_class) 136 msg_class::~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 }
131 143
132 #define IPC_MESSAGE_CONTROL4(msg_class, type1, type2, type3, type4) \ 144 #define IPC_MESSAGE_CONTROL4(msg_class, type1, type2, type3, type4) \
133 msg_class::msg_class(const type1& arg1, const type2& arg2, \ 145 msg_class::msg_class(const type1& arg1, const type2& arg2, \
134 const type3& arg3, const type4& arg4) \ 146 const type3& arg3, const type4& arg4) \
135 : IPC::MessageWithTuple< Tuple4<type1, type2, type3, type4> >( \ 147 : IPC::MessageWithTuple< Tuple4<type1, type2, type3, type4> >( \
136 MSG_ROUTING_CONTROL, ID, MakeRefTuple(arg1, arg2, arg3, arg4)) {} \ 148 MSG_ROUTING_CONTROL, ID, MakeRefTuple(arg1, arg2, arg3, arg4)) {} \
137 \ 149 \
138 IPC_ASYNC_MESSAGE_DTOR_AND_LOG(msg_class) 150 msg_class::~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 }
139 157
140 #define IPC_MESSAGE_CONTROL5(msg_class, type1, type2, type3, type4, type5) \ 158 #define IPC_MESSAGE_CONTROL5(msg_class, type1, type2, type3, type4, type5) \
141 msg_class::msg_class(const type1& arg1, const type2& arg2, \ 159 msg_class::msg_class(const type1& arg1, const type2& arg2, \
142 const type3& arg3, const type4& arg4, \ 160 const type3& arg3, const type4& arg4, \
143 const type5& arg5) \ 161 const type5& arg5) \
144 : IPC::MessageWithTuple< Tuple5<type1, type2, type3, type4, type5> >( \ 162 : IPC::MessageWithTuple< Tuple5<type1, type2, type3, type4, type5> >( \
145 MSG_ROUTING_CONTROL, ID, \ 163 MSG_ROUTING_CONTROL, ID, \
146 MakeRefTuple(arg1, arg2, arg3, arg4, arg5)) {} \ 164 MakeRefTuple(arg1, arg2, arg3, arg4, arg5)) {} \
147 \ 165 \
148 IPC_ASYNC_MESSAGE_DTOR_AND_LOG(msg_class) 166 msg_class::~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 }
149 173
150 // This derives from IPC::Message and thus doesn't need us to keep the 174 // This derives from IPC::Message and thus doesn't need us to keep the
151 // implementations in this impl file. 175 // implementations in this impl file.
152 #define IPC_MESSAGE_ROUTED0(msg_class) 176 #define IPC_MESSAGE_ROUTED0(msg_class)
153 177
154 #define IPC_MESSAGE_ROUTED1(msg_class, type1) \ 178 #define IPC_MESSAGE_ROUTED1(msg_class, type1) \
155 msg_class::msg_class(int32 routing_id, const type1& arg1) \ 179 msg_class::msg_class(int32 routing_id, const type1& arg1) \
156 : IPC::MessageWithTuple< Tuple1<type1> >( \ 180 : IPC::MessageWithTuple< Tuple1<type1> >( \
157 routing_id, ID, MakeRefTuple(arg1)) {} \ 181 routing_id, ID, MakeRefTuple(arg1)) {} \
158 \ 182 \
159 IPC_ASYNC_MESSAGE_DTOR_AND_LOG(msg_class) 183 msg_class::~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 }
160 190
161 #define IPC_MESSAGE_ROUTED2(msg_class, type1, type2) \ 191 #define IPC_MESSAGE_ROUTED2(msg_class, type1, type2) \
162 msg_class::msg_class(int32 routing_id, const type1& arg1, const type2& arg2) \ 192 msg_class::msg_class(int32 routing_id, const type1& arg1, const type2& arg2) \
163 : IPC::MessageWithTuple< Tuple2<type1, type2> >( \ 193 : IPC::MessageWithTuple< Tuple2<type1, type2> >( \
164 routing_id, ID, MakeRefTuple(arg1, arg2)) {} \ 194 routing_id, ID, MakeRefTuple(arg1, arg2)) {} \
165 \ 195 \
166 IPC_ASYNC_MESSAGE_DTOR_AND_LOG(msg_class) 196 msg_class::~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 }
167 203
168 204
169 #define IPC_MESSAGE_ROUTED3(msg_class, type1, type2, type3) \ 205 #define IPC_MESSAGE_ROUTED3(msg_class, type1, type2, type3) \
170 msg_class::msg_class(int32 routing_id, const type1& arg1, \ 206 msg_class::msg_class(int32 routing_id, const type1& arg1, \
171 const type2& arg2, const type3& arg3) \ 207 const type2& arg2, const type3& arg3) \
172 : IPC::MessageWithTuple< Tuple3<type1, type2, type3> >( \ 208 : IPC::MessageWithTuple< Tuple3<type1, type2, type3> >( \
173 routing_id, ID, MakeRefTuple(arg1, arg2, arg3)) {} \ 209 routing_id, ID, MakeRefTuple(arg1, arg2, arg3)) {} \
174 \ 210 \
175 IPC_ASYNC_MESSAGE_DTOR_AND_LOG(msg_class) 211 msg_class::~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 }
176 218
177 #define IPC_MESSAGE_ROUTED4(msg_class, type1, type2, type3, type4) \ 219 #define IPC_MESSAGE_ROUTED4(msg_class, type1, type2, type3, type4) \
178 msg_class::msg_class(int32 routing_id, const type1& arg1, const type2& arg2, \ 220 msg_class::msg_class(int32 routing_id, const type1& arg1, const type2& arg2, \
179 const type3& arg3, const type4& arg4) \ 221 const type3& arg3, const type4& arg4) \
180 : IPC::MessageWithTuple< Tuple4<type1, type2, type3, type4> >( \ 222 : IPC::MessageWithTuple< Tuple4<type1, type2, type3, type4> >( \
181 routing_id, ID, MakeRefTuple(arg1, arg2, arg3, arg4)) {} \ 223 routing_id, ID, MakeRefTuple(arg1, arg2, arg3, arg4)) {} \
182 \ 224 \
183 IPC_ASYNC_MESSAGE_DTOR_AND_LOG(msg_class) 225 msg_class::~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 }
184 232
185 #define IPC_MESSAGE_ROUTED5(msg_class, type1, type2, type3, type4, type5) \ 233 #define IPC_MESSAGE_ROUTED5(msg_class, type1, type2, type3, type4, type5) \
186 msg_class::msg_class(int32 routing_id, const type1& arg1, \ 234 msg_class::msg_class(int32 routing_id, const type1& arg1, \
187 const type2& arg2, const type3& arg3, \ 235 const type2& arg2, const type3& arg3, \
188 const type4& arg4, const type5& arg5) \ 236 const type4& arg4, const type5& arg5) \
189 : IPC::MessageWithTuple< Tuple5<type1, type2, type3, type4, type5> >( \ 237 : IPC::MessageWithTuple< Tuple5<type1, type2, type3, type4, type5> >( \
190 routing_id, ID, MakeRefTuple(arg1, arg2, arg3, arg4, arg5)) {} \ 238 routing_id, ID, MakeRefTuple(arg1, arg2, arg3, arg4, arg5)) {} \
191 \ 239 \
192 IPC_ASYNC_MESSAGE_DTOR_AND_LOG(msg_class) 240 msg_class::~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() {} \
200 \ 241 \
201 void msg_class::Log(const Message* msg, std::wstring* l) { \ 242 void msg_class::Log(const Message* msg, std::wstring* l) { \
202 if (msg->is_sync()) { \ 243 Param p; \
203 SendParam p; \ 244 if (Read(msg, &p)) \
204 if (ReadSendParam(msg, &p)) \ 245 IPC::LogParam(p, l); \
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 } \
213 } 246 }
214 247
215 #define IPC_SYNC_MESSAGE_CONTROL0_0(msg_class) \ 248 // TODO(erg): Fill these in as I go along.
216 msg_class::msg_class() \ 249 #define IPC_SYNC_MESSAGE_CONTROL0_0(msg_class)
217 : IPC::MessageWithReply<Tuple0, Tuple0 >( \ 250 #define IPC_SYNC_MESSAGE_CONTROL0_1(msg_class, type1_out)
218 MSG_ROUTING_CONTROL, ID, \ 251 #define IPC_SYNC_MESSAGE_CONTROL0_2(msg_class, type1_out, type2_out)
219 MakeTuple(), MakeTuple()) {} \ 252 #define IPC_SYNC_MESSAGE_CONTROL0_3(msg_class, type1_out, type2_out, type3_out)
220 \ 253 #define IPC_SYNC_MESSAGE_CONTROL1_0(msg_class, type1_in)
221 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) 254 #define IPC_SYNC_MESSAGE_CONTROL1_1(msg_class, type1_in, type1_out)
222 255 #define IPC_SYNC_MESSAGE_CONTROL1_2(msg_class, type1_in, type1_out, type2_out)
223 #define IPC_SYNC_MESSAGE_CONTROL0_1(msg_class, type1_out) \ 256 #define IPC_SYNC_MESSAGE_CONTROL1_3(msg_class, type1_in, type1_out, type2_out, t ype3_out)
224 msg_class::msg_class(type1_out* arg1) \ 257 #define IPC_SYNC_MESSAGE_CONTROL2_0(msg_class, type1_in, type2_in)
225 : IPC::MessageWithReply<Tuple0, Tuple1<type1_out&> >( \ 258 #define IPC_SYNC_MESSAGE_CONTROL2_1(msg_class, type1_in, type2_in, type1_out)
226 MSG_ROUTING_CONTROL, ID, \ 259 #define IPC_SYNC_MESSAGE_CONTROL2_2(msg_class, type1_in, type2_in, type1_out, ty pe2_out)
227 MakeTuple(), MakeRefTuple(*arg1)) {} \ 260 #define IPC_SYNC_MESSAGE_CONTROL2_3(msg_class, type1_in, type2_in, type1_out, ty pe2_out, type3_out)
228 \ 261 #define IPC_SYNC_MESSAGE_CONTROL3_1(msg_class, type1_in, type2_in, type3_in, typ e1_out)
229 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) 262 #define IPC_SYNC_MESSAGE_CONTROL3_2(msg_class, type1_in, type2_in, type3_in, typ e1_out, type2_out)
230 263 #define IPC_SYNC_MESSAGE_CONTROL3_3(msg_class, type1_in, type2_in, type3_in, typ e1_out, type2_out, type3_out)
231 #define IPC_SYNC_MESSAGE_CONTROL0_2(msg_class, type1_out, type2_out) \ 264 #define IPC_SYNC_MESSAGE_CONTROL4_1(msg_class, type1_in, type2_in, type3_in, typ e4_in, type1_out)
232 msg_class::msg_class(type1_out* arg1, type2_out* arg2) \ 265 #define IPC_SYNC_MESSAGE_CONTROL4_2(msg_class, type1_in, type2_in, type3_in, typ e4_in, type1_out, type2_out)
233 : IPC::MessageWithReply<Tuple0, Tuple2<type1_out&, type2_out&> >( \ 266 #define IPC_SYNC_MESSAGE_ROUTED0_0(msg_class)
234 MSG_ROUTING_CONTROL, ID, \ 267 #define IPC_SYNC_MESSAGE_ROUTED0_1(msg_class, type1_out)
235 MakeTuple(), MakeRefTuple(*arg1, *arg2)) {} \ 268 #define IPC_SYNC_MESSAGE_ROUTED0_2(msg_class, type1_out, type2_out)
236 \ 269 #define IPC_SYNC_MESSAGE_ROUTED0_3(msg_class, type1_out, type2_out, type3_out)
237 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) 270 #define IPC_SYNC_MESSAGE_ROUTED1_0(msg_class, type1_in)
238 271 #define IPC_SYNC_MESSAGE_ROUTED1_1(msg_class, type1_in, type1_out)
239 #define IPC_SYNC_MESSAGE_CONTROL0_3(msg_class, type1_out, type2_out, \ 272 #define IPC_SYNC_MESSAGE_ROUTED1_2(msg_class, type1_in, type1_out, type2_out)
240 type3_out) \ 273 #define IPC_SYNC_MESSAGE_ROUTED1_3(msg_class, type1_in, type1_out, type2_out, ty pe3_out)
241 msg_class::msg_class(type1_out* arg1, type2_out* arg2, type3_out* arg3) \ 274 #define IPC_SYNC_MESSAGE_ROUTED1_4(msg_class, type1_in, type1_out, type2_out, ty pe3_out, type4_out)
242 : IPC::MessageWithReply<Tuple0, Tuple3<type1_out&, type2_out&, \ 275 #define IPC_SYNC_MESSAGE_ROUTED2_0(msg_class, type1_in, type2_in)
243 type3_out&> >( \ 276 #define IPC_SYNC_MESSAGE_ROUTED2_1(msg_class, type1_in, type2_in, type1_out)
244 MSG_ROUTING_CONTROL, ID, \ 277 #define IPC_SYNC_MESSAGE_ROUTED2_2(msg_class, type1_in, type2_in, type1_out, typ e2_out)
245 MakeTuple(), MakeRefTuple(*arg1, *arg2, *arg3)) {} \ 278 #define IPC_SYNC_MESSAGE_ROUTED2_3(msg_class, type1_in, type2_in, type1_out, typ e2_out, type3_out)
246 \ 279 #define IPC_SYNC_MESSAGE_ROUTED3_0(msg_class, type1_in, type2_in, type3_in)
247 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) 280 #define IPC_SYNC_MESSAGE_ROUTED3_1(msg_class, type1_in, type2_in, type3_in, type 1_out)
248 281 #define IPC_SYNC_MESSAGE_ROUTED3_2(msg_class, type1_in, type2_in, type3_in, type 1_out, type2_out)
249 282 #define IPC_SYNC_MESSAGE_ROUTED3_3(msg_class, type1_in, type2_in, type3_in, type 1_out, type2_out, type3_out)
250 #define IPC_SYNC_MESSAGE_CONTROL1_0(msg_class, type1_in) \ 283 #define IPC_SYNC_MESSAGE_ROUTED4_0(msg_class, type1_in, type2_in, type3_in, type 4_in)
251 msg_class::msg_class(const type1_in& arg1) \ 284 #define IPC_SYNC_MESSAGE_ROUTED4_1(msg_class, type1_in, type2_in, type3_in, type 4_in, type1_out)
252 : IPC::MessageWithReply<Tuple1<type1_in>, Tuple0 >( \ 285 #define IPC_SYNC_MESSAGE_ROUTED4_2(msg_class, type1_in, type2_in, type3_in, type 4_in, type1_out, type2_out)
253 MSG_ROUTING_CONTROL, ID, \ 286 #define IPC_SYNC_MESSAGE_ROUTED4_3(msg_class, type1_in, type2_in, type3_in, type 4_in, type1_out, type2_out, type3_out)
254 MakeRefTuple(arg1), MakeTuple()) {} \ 287 #define IPC_SYNC_MESSAGE_ROUTED5_0(msg_class, type1_in, type2_in, type3_in, type 4_in, type5_in)
255 \ 288 #define IPC_SYNC_MESSAGE_ROUTED5_1(msg_class, type1_in, type2_in, type3_in, type 4_in, type5_in, type1_out)
256 IPC_SYNC_MESSAGE_DTOR_AND_LOG(msg_class) 289 #define IPC_SYNC_MESSAGE_ROUTED5_2(msg_class, type1_in, type2_in, type3_in, type 4_in, type5_in, type1_out, type2_out)
257 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)
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)
661 291
662 // Trigger the header guard define in ipc_message_macros.h so we don't get 292 // Trigger the header guard define in ipc_message_macros.h so we don't get
663 // duplicate including when we include MESSAGES_INTERNAL_FILE again at the end 293 // duplicate including when we include MESSAGES_INTERNAL_FILE again at the end
664 // of this file. 294 // of this file.
665 #define IPC_MESSAGE_MACROS_INCLUDE_BLOCK 295 #define IPC_MESSAGE_MACROS_INCLUDE_BLOCK
666 296
667 // Redefine MESSAGES_INTERNAL_FILE just for the header check in 297 // Redefine MESSAGES_INTERNAL_FILE just for the header check in
668 // ipc_messages_macros.h that happens before it breaks on the header guard. 298 // ipc_messages_macros.h that happens before it breaks on the header guard.
669 #define MESSAGES_INTERNAL_FILE MESSAGES_INTERNAL_IMPL_FILE 299 #define MESSAGES_INTERNAL_FILE MESSAGES_INTERNAL_IMPL_FILE
670 300
671 // Include our INTERNAL file first to get the normal expansion. 301 // Include our INTERNAL file first to get the normal expansion.
672 #include MESSAGES_INTERNAL_IMPL_FILE 302 #include MESSAGES_INTERNAL_IMPL_FILE
673 303
674 #endif // IPC_IPC_MESSAGE_IMPL_MACROS_H_ 304 #endif // IPC_IPC_MESSAGE_IMPL_MACROS_H_
OLDNEW
« no previous file with comments | « chrome/renderer/render_view.cc ('k') | ipc/ipc_message_macros.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698