Remove WTF:: prefix from types in messages.in files.
[WebKit-https.git] / Source / WebKit2 / Scripts / webkit2 / messages.py
1 # Copyright (C) 2010, 2011 Apple Inc. All rights reserved.
2 #
3 # Redistribution and use in source and binary forms, with or without
4 # modification, are permitted provided that the following conditions
5 # are met:
6 # 1.  Redistributions of source code must retain the above copyright
7 #     notice, this list of conditions and the following disclaimer.
8 # 2.  Redistributions in binary form must reproduce the above copyright
9 #     notice, this list of conditions and the following disclaimer in the
10 #     documentation and/or other materials provided with the distribution.
11 #
12 # THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
13 # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
14 # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
15 # DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR
16 # ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
17 # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
18 # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
19 # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
20 # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
21 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
22
23 import collections
24 import re
25 import sys
26 from webkit2 import parser
27
28 WANTS_CONNECTION_ATTRIBUTE = 'WantsConnection'
29 LEGACY_RECEIVER_ATTRIBUTE = 'LegacyReceiver'
30 DELAYED_ATTRIBUTE = 'Delayed'
31 VARIADIC_ATTRIBUTE = 'Variadic'
32
33 _license_header = """/*
34  * Copyright (C) 2010 Apple Inc. All rights reserved.
35  *
36  * Redistribution and use in source and binary forms, with or without
37  * modification, are permitted provided that the following conditions
38  * are met:
39  * 1.  Redistributions of source code must retain the above copyright
40  *     notice, this list of conditions and the following disclaimer.
41  * 2.  Redistributions in binary form must reproduce the above copyright
42  *     notice, this list of conditions and the following disclaimer in the
43  *     documentation and/or other materials provided with the distribution.
44  *
45  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
46  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
47  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
48  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR
49  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
50  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
51  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
52  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
53  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
54  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
55  */
56
57 """
58
59
60 def messages_header_filename(receiver):
61     return '%sMessages.h' % receiver.name
62
63
64 def surround_in_condition(string, condition):
65     if not condition:
66         return string
67     return '#if %s\n%s#endif\n' % (condition, string)
68
69
70 def function_parameter_type(type):
71     # Don't use references for built-in types.
72     builtin_types = frozenset([
73         'bool',
74         'float',
75         'double',
76         'uint8_t',
77         'uint16_t',
78         'uint32_t',
79         'uint64_t',
80         'int8_t',
81         'int16_t',
82         'int32_t',
83         'int64_t',
84     ])
85
86     if type in builtin_types:
87         return type
88
89     return 'const %s&' % type
90
91
92 def reply_parameter_type(type):
93     return '%s&' % type
94
95
96 def arguments_type_old(parameters, parameter_type_function):
97     arguments_type = 'CoreIPC::Arguments%d' % len(parameters)
98     if len(parameters):
99         arguments_type = '%s<%s>' % (arguments_type, ', '.join(parameter_type_function(parameter.type) for parameter in parameters))
100     return arguments_type
101
102
103 def arguments_type(message):
104     return 'std::tuple<%s>' % ', '.join(function_parameter_type(parameter.type) for parameter in message.parameters)
105
106 def base_class(message):
107     return arguments_type(message.parameters, function_parameter_type)
108
109
110 def reply_type(message):
111     return arguments_type_old(message.reply_parameters, reply_parameter_type)
112
113
114 def decode_type(message):
115     parameters = message.parameters
116
117     if message.has_attribute(VARIADIC_ATTRIBUTE):
118         parameters = parameters[:-1]
119
120     return 'std::tuple<%s>' % ', '.join(parameter.type for parameter in parameters)
121
122 def delayed_reply_type(message):
123     return arguments_type_old(message.reply_parameters, function_parameter_type)
124
125
126 def message_to_struct_declaration(message):
127     result = []
128     function_parameters = [(function_parameter_type(x.type), x.name) for x in message.parameters]
129     result.append('class %s {\n' % message.name)
130     result.append('public:\n')
131     result.append('    typedef %s DecodeType;\n' % decode_type(message))
132     result.append('\n')
133     result.append('    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }\n')
134     result.append('    static CoreIPC::StringReference name() { return CoreIPC::StringReference("%s"); }\n' % message.name)
135     result.append('    static const bool isSync = %s;\n' % ('false', 'true')[message.reply_parameters != None])
136     result.append('\n')
137     if message.reply_parameters != None:
138         if message.has_attribute(DELAYED_ATTRIBUTE):
139             send_parameters = [(function_parameter_type(x.type), x.name) for x in message.reply_parameters]
140             result.append('    struct DelayedReply : public ThreadSafeRefCounted<DelayedReply> {\n')
141             result.append('        DelayedReply(PassRefPtr<CoreIPC::Connection>, std::unique_ptr<CoreIPC::MessageEncoder>);\n')
142             result.append('        ~DelayedReply();\n')
143             result.append('\n')
144             result.append('        bool send(%s);\n' % ', '.join([' '.join(x) for x in send_parameters]))
145             result.append('\n')
146             result.append('    private:\n')
147             result.append('        RefPtr<CoreIPC::Connection> m_connection;\n')
148             result.append('        std::unique_ptr<CoreIPC::MessageEncoder> m_encoder;\n')
149             result.append('    };\n\n')
150
151         result.append('    typedef %s Reply;\n' % reply_type(message))
152
153     if len(function_parameters):
154         result.append('    %s%s(%s)' % (len(function_parameters) == 1 and 'explicit ' or '', message.name, ', '.join([' '.join(x) for x in function_parameters])))
155         result.append('\n        : m_arguments(%s)\n' % ', '.join([x[1] for x in function_parameters]))
156         result.append('    {\n')
157         result.append('    }\n\n')
158     result.append('    const %s arguments() const\n' % arguments_type(message))
159     result.append('    {\n')
160     result.append('        return m_arguments;\n')
161     result.append('    }\n')
162     result.append('\n')
163     result.append('private:\n')
164     result.append('    %s m_arguments;\n' % arguments_type(message))
165     result.append('};\n')
166     return surround_in_condition(''.join(result), message.condition)
167
168
169 def struct_or_class(namespace, type):
170     structs = frozenset([
171         'WebCore::Animation',
172         'WebCore::EditorCommandsForKeyEvent',
173         'WebCore::CompositionUnderline',
174         'WebCore::Cookie',
175         'WebCore::DragSession',
176         'WebCore::FloatPoint3D',
177         'WebCore::FileChooserSettings',
178         'WebCore::GrammarDetail',
179         'WebCore::IDBDatabaseMetadata',
180         'WebCore::IdentityTransformOperation',
181         'WebCore::KeypressCommand',
182         'WebCore::Length',
183         'WebCore::MatrixTransformOperation',
184         'WebCore::Matrix3DTransformOperation',
185         'WebCore::NotificationContents',
186         'WebCore::PasteboardImage',
187         'WebCore::PasteboardWebContent',
188         'WebCore::PerspectiveTransformOperation',
189         'WebCore::PluginInfo',
190         'WebCore::PrintInfo',
191         'WebCore::RotateTransformOperation',
192         'WebCore::ScaleTransformOperation',
193         'WebCore::SkewTransformOperation',
194         'WebCore::TimingFunction',
195         'WebCore::TransformationMatrix',
196         'WebCore::TransformOperation',
197         'WebCore::TransformOperations',
198         'WebCore::TranslateTransformOperation',
199         'WebCore::ViewportArguments',
200         'WebCore::ViewportAttributes',
201         'WebCore::WindowFeatures',
202         'WebKit::AttributedString',
203         'WebKit::ColorSpaceData',
204         'WebKit::ContextMenuState',
205         'WebKit::DatabaseProcessCreationParameters',
206         'WebKit::DictionaryPopupInfo',
207         'WebKit::DrawingAreaInfo',
208         'WebKit::EditorState',
209         'WebKit::NetworkProcessCreationParameters',
210         'WebKit::PlatformPopupMenuData',
211         'WebKit::PluginCreationParameters',
212         'WebKit::PluginProcessCreationParameters',
213         'WebKit::PrintInfo',
214         'WebKit::SecurityOriginData',
215         'WebKit::StatisticsData',
216         'WebKit::TextCheckerState',
217         'WebKit::WebNavigationDataStore',
218         'WebKit::WebPageCreationParameters',
219         'WebKit::WebPreferencesStore',
220         'WebKit::WebProcessCreationParameters',
221         'WebKit::WindowGeometry',
222     ])
223
224     qualified_name = '%s::%s' % (namespace, type)
225     if qualified_name in structs:
226         return 'struct %s' % type
227
228     return 'class %s' % type
229
230 def forward_declarations_for_namespace(namespace, types):
231     result = []
232     result.append('namespace %s {\n' % namespace)
233     result += ['    %s;\n' % struct_or_class(namespace, x) for x in types]
234     result.append('}\n')
235     return ''.join(result)
236
237
238 def forward_declarations_and_headers(receiver):
239     types_by_namespace = collections.defaultdict(set)
240
241     headers = set([
242         '"Arguments.h"',
243         '"MessageEncoder.h"',
244         '"StringReference.h"',
245     ])
246
247     non_template_wtf_types = frozenset([
248         'String',
249     ])
250
251     for message in receiver.messages:
252         if message.reply_parameters != None and message.has_attribute(DELAYED_ATTRIBUTE):
253             headers.add('<wtf/ThreadSafeRefCounted.h>')
254             types_by_namespace['CoreIPC'].update(['Connection'])
255
256     for parameter in receiver.iterparameters():
257         type = parameter.type
258
259         if type.find('<') != -1:
260             # Don't forward declare class templates.
261             headers.update(headers_for_type(type))
262             continue
263
264         split = type.split('::')
265
266         # Handle WTF types even if the WTF:: prefix is not given
267         if split[0] in non_template_wtf_types:
268             split.insert(0, 'WTF')
269
270         if len(split) == 2:
271             namespace = split[0]
272             inner_type = split[1]
273             types_by_namespace[namespace].add(inner_type)
274         elif len(split) > 2:
275             # We probably have a nested struct, which means we can't forward declare it.
276             # Include its header instead.
277             headers.update(headers_for_type(type))
278
279     forward_declarations = '\n'.join([forward_declarations_for_namespace(namespace, types) for (namespace, types) in sorted(types_by_namespace.items())])
280     headers = ['#include %s\n' % header for header in sorted(headers)]
281
282     return (forward_declarations, headers)
283
284 def generate_messages_header(file):
285     receiver = parser.parse(file)
286     header_guard = messages_header_filename(receiver).replace('.', '_')
287
288     result = []
289
290     result.append(_license_header)
291
292     result.append('#ifndef %s\n' % header_guard)
293     result.append('#define %s\n\n' % header_guard)
294
295     if receiver.condition:
296         result.append('#if %s\n\n' % receiver.condition)
297
298     forward_declarations, headers = forward_declarations_and_headers(receiver)
299
300     result += headers
301     result.append('\n')
302
303     result.append(forward_declarations)
304     result.append('\n')
305
306     result.append('namespace Messages {\nnamespace %s {\n' % receiver.name)
307     result.append('\n')
308     result.append('static inline CoreIPC::StringReference messageReceiverName()\n')
309     result.append('{\n')
310     result.append('    return CoreIPC::StringReference("%s");\n' % receiver.name)
311     result.append('}\n')
312     result.append('\n')
313     result.append('\n'.join([message_to_struct_declaration(x) for x in receiver.messages]))
314     result.append('\n')
315     result.append('} // namespace %s\n} // namespace Messages\n' % receiver.name)
316
317     if receiver.condition:
318         result.append('\n#endif // %s\n' % receiver.condition)
319
320     result.append('\n#endif // %s\n' % header_guard)
321
322     return ''.join(result)
323
324
325 def handler_function(receiver, message):
326     if message.name.find('URL') == 0:
327         return '%s::%s' % (receiver.name, 'url' + message.name[3:])
328     return '%s::%s' % (receiver.name, message.name[0].lower() + message.name[1:])
329
330
331 def async_message_statement(receiver, message):
332     dispatch_function_args = ['decoder', 'this', '&%s' % handler_function(receiver, message)]
333
334     dispatch_function = 'handleMessage'
335     if message.has_attribute(VARIADIC_ATTRIBUTE):
336         dispatch_function += 'Variadic'
337
338     if message.has_attribute(WANTS_CONNECTION_ATTRIBUTE):
339         dispatch_function_args.insert(0, 'connection')
340
341     result = []
342     result.append('    if (decoder.messageName() == Messages::%s::%s::name()) {\n' % (receiver.name, message.name))
343     result.append('        CoreIPC::%s<Messages::%s::%s>(%s);\n' % (dispatch_function, receiver.name, message.name, ', '.join(dispatch_function_args)))
344     result.append('        return;\n')
345     result.append('    }\n')
346     return surround_in_condition(''.join(result), message.condition)
347
348
349 def sync_message_statement(receiver, message):
350     dispatch_function = 'handleMessage'
351     if message.has_attribute(DELAYED_ATTRIBUTE):
352         dispatch_function += 'Delayed'
353     if message.has_attribute(VARIADIC_ATTRIBUTE):
354         dispatch_function += 'Variadic'
355
356     wants_connection = message.has_attribute(DELAYED_ATTRIBUTE) or message.has_attribute(WANTS_CONNECTION_ATTRIBUTE)
357
358     result = []
359     result.append('    if (decoder.messageName() == Messages::%s::%s::name()) {\n' % (receiver.name, message.name))
360     result.append('        CoreIPC::%s<Messages::%s::%s>(%sdecoder, %sreplyEncoder, this, &%s);\n' % (dispatch_function, receiver.name, message.name, 'connection, ' if wants_connection else '', '' if message.has_attribute(DELAYED_ATTRIBUTE) else '*', handler_function(receiver, message)))
361     result.append('        return;\n')
362     result.append('    }\n')
363     return surround_in_condition(''.join(result), message.condition)
364
365
366 def class_template_headers(template_string):
367     template_string = template_string.strip()
368
369     class_template_types = {
370         'Vector': {'headers': ['<wtf/Vector.h>'], 'argument_coder_headers': ['"ArgumentCoders.h"']},
371         'HashMap': {'headers': ['<wtf/HashMap.h>'], 'argument_coder_headers': ['"ArgumentCoders.h"']},
372         'std::pair': {'headers': ['<utility>'], 'argument_coder_headers': ['"ArgumentCoders.h"']},
373     }
374
375     match = re.match('(?P<template_name>.+?)<(?P<parameter_string>.+)>', template_string)
376     if not match:
377         return {'header_infos':[], 'types':[template_string]}
378
379     template_name = match.groupdict()['template_name']
380     if template_name not in class_template_types:
381         sys.stderr.write("Error: no class template type is defined for '%s'\n" % (template_string))
382         sys.exit(1)
383
384     header_infos = [class_template_types[template_name]]
385     types = []
386
387     for parameter in parser.split_parameters_string(match.groupdict()['parameter_string']):
388         parameter_header_infos_and_types = class_template_headers(parameter)
389
390         header_infos += parameter_header_infos_and_types['header_infos'];
391         types += parameter_header_infos_and_types['types']
392
393     return {'header_infos':header_infos, 'types':types}
394
395
396 def argument_coder_headers_for_type(type):
397     header_infos_and_types = class_template_headers(type)
398
399     special_cases = {
400         'String': '"ArgumentCoders.h"',
401         'WebKit::InjectedBundleUserMessageEncoder': '"InjectedBundleUserMessageCoders.h"',
402         'WebKit::WebContextUserMessageEncoder': '"WebContextUserMessageCoders.h"',
403     }
404
405     headers = []
406     for header_info in header_infos_and_types['header_infos']:
407         headers += header_info['argument_coder_headers']
408
409     for type in header_infos_and_types['types']:
410         if type in special_cases:
411             headers.append(special_cases[type])
412             continue
413
414         split = type.split('::')
415         if len(split) < 2:
416             continue
417         if split[0] == 'WebCore':
418             headers.append('"WebCoreArgumentCoders.h"')
419
420     return headers
421
422 def headers_for_type(type):
423     header_infos_and_types = class_template_headers(type)
424
425     special_cases = {
426         'String': ['<wtf/text/WTFString.h>'],
427         'WebCore::CompositionUnderline': ['<WebCore/Editor.h>'],
428         'WebCore::GrammarDetail': ['<WebCore/TextCheckerClient.h>'],
429         'WebCore::GraphicsLayerAnimations': ['<WebCore/GraphicsLayerAnimation.h>'],
430         'WebCore::KeyframeValueList': ['<WebCore/GraphicsLayer.h>'],
431         'WebCore::KeypressCommand': ['<WebCore/KeyboardEvent.h>'],
432         'WebCore::FileChooserSettings': ['<WebCore/FileChooser.h>'],
433         'WebCore::PluginInfo': ['<WebCore/PluginData.h>'],
434         'WebCore::PasteboardImage': ['<WebCore/Pasteboard.h>'],
435         'WebCore::PasteboardWebContent': ['<WebCore/Pasteboard.h>'],
436         'WebCore::TextCheckingRequestData': ['<WebCore/TextChecking.h>'],
437         'WebCore::TextCheckingResult': ['<WebCore/TextCheckerClient.h>'],
438         'WebCore::ViewportAttributes': ['<WebCore/ViewportArguments.h>'],
439         'WebKit::InjectedBundleUserMessageEncoder': [],
440         'WebKit::WebContextUserMessageEncoder': [],
441         'WebKit::WebGestureEvent': ['"WebEvent.h"'],
442         'WebKit::WebKeyboardEvent': ['"WebEvent.h"'],
443         'WebKit::WebMouseEvent': ['"WebEvent.h"'],
444         'WebKit::WebTouchEvent': ['"WebEvent.h"'],
445         'WebKit::WebWheelEvent': ['"WebEvent.h"'],
446     }
447
448     headers = []
449     for header_info in header_infos_and_types['header_infos']:
450         headers += header_info['headers']
451
452     for type in header_infos_and_types['types']:
453         if type in special_cases:
454             headers += special_cases[type]
455             continue
456
457         # We assume that we must include a header for a type iff it has a scope
458         # resolution operator (::).
459         split = type.split('::')
460         if len(split) < 2:
461             continue
462
463         if split[0] == 'WebKit' or split[0] == 'CoreIPC':
464             headers.append('"%s.h"' % split[1])
465         else:
466             headers.append('<%s/%s.h>' % tuple(split))
467
468     return headers
469
470 def generate_message_handler(file):
471     receiver = parser.parse(file)
472     header_conditions = {
473         '"%s"' % messages_header_filename(receiver): [None],
474         '"HandleMessage.h"': [None],
475         '"MessageDecoder.h"': [None],
476     }
477
478     type_conditions = {}
479     for parameter in receiver.iterparameters():
480         if not parameter.type in type_conditions:
481             type_conditions[parameter.type] = []
482
483         if not parameter.condition in type_conditions[parameter.type]:
484             type_conditions[parameter.type].append(parameter.condition)
485
486     for parameter in receiver.iterparameters():
487         type = parameter.type
488         conditions = type_conditions[type]
489
490         argument_encoder_headers = argument_coder_headers_for_type(type)
491         if argument_encoder_headers:
492             for header in argument_encoder_headers:
493                 if header not in header_conditions:
494                     header_conditions[header] = []
495                 header_conditions[header].extend(conditions)
496
497         type_headers = headers_for_type(type)
498         for header in type_headers:
499             if header not in header_conditions:
500                 header_conditions[header] = []
501             header_conditions[header].extend(conditions)
502
503     for message in receiver.messages:
504         if message.reply_parameters is not None:
505             for reply_parameter in message.reply_parameters:
506                 type = reply_parameter.type
507                 argument_encoder_headers = argument_coder_headers_for_type(type)
508                 if argument_encoder_headers:
509                     for header in argument_encoder_headers:
510                         if header not in header_conditions:
511                             header_conditions[header] = []
512                         header_conditions[header].append(message.condition)
513
514                 type_headers = headers_for_type(type)
515                 for header in type_headers:
516                     if header not in header_conditions:
517                         header_conditions[header] = []
518                     header_conditions[header].append(message.condition)
519
520
521     result = []
522
523     result.append(_license_header)
524     result.append('#include "config.h"\n')
525     result.append('\n')
526
527     if receiver.condition:
528         result.append('#if %s\n\n' % receiver.condition)
529
530     result.append('#include "%s.h"\n\n' % receiver.name)
531     for header in sorted(header_conditions):
532         if header_conditions[header] and not None in header_conditions[header]:
533             result.append('#if %s\n' % ' || '.join(set(header_conditions[header])))
534             result += ['#include %s\n' % header]
535             result.append('#endif\n')
536         else:
537             result += ['#include %s\n' % header]
538     result.append('\n')
539
540     sync_delayed_messages = []
541     for message in receiver.messages:
542         if message.reply_parameters != None and message.has_attribute(DELAYED_ATTRIBUTE):
543             sync_delayed_messages.append(message)
544
545     if sync_delayed_messages:
546         result.append('namespace Messages {\n\nnamespace %s {\n\n' % receiver.name)
547
548         for message in sync_delayed_messages:
549             send_parameters = [(function_parameter_type(x.type), x.name) for x in message.reply_parameters]
550
551             if message.condition:
552                 result.append('#if %s\n\n' % message.condition)
553
554             result.append('%s::DelayedReply::DelayedReply(PassRefPtr<CoreIPC::Connection> connection, std::unique_ptr<CoreIPC::MessageEncoder> encoder)\n' % message.name)
555             result.append('    : m_connection(connection)\n')
556             result.append('    , m_encoder(std::move(encoder))\n')
557             result.append('{\n')
558             result.append('}\n')
559             result.append('\n')
560             result.append('%s::DelayedReply::~DelayedReply()\n' % message.name)
561             result.append('{\n')
562             result.append('    ASSERT(!m_connection);\n')
563             result.append('}\n')
564             result.append('\n')
565             result.append('bool %s::DelayedReply::send(%s)\n' % (message.name, ', '.join([' '.join(x) for x in send_parameters])))
566             result.append('{\n')
567             result.append('    ASSERT(m_encoder);\n')
568             result += ['    *m_encoder << %s;\n' % x.name for x in message.reply_parameters]
569             result.append('    bool result = m_connection->sendSyncReply(std::move(m_encoder));\n')
570             result.append('    m_connection = nullptr;\n')
571             result.append('    return result;\n')
572             result.append('}\n')
573             result.append('\n')
574
575             if message.condition:
576                 result.append('#endif\n\n')
577
578         result.append('} // namespace %s\n\n} // namespace Messages\n\n' % receiver.name)
579
580     result.append('namespace WebKit {\n\n')
581
582     async_messages = []
583     sync_messages = []
584     for message in receiver.messages:
585         if message.reply_parameters is not None:
586             sync_messages.append(message)
587         else:
588             async_messages.append(message)
589
590     if async_messages:
591         if receiver.has_attribute(LEGACY_RECEIVER_ATTRIBUTE):
592             result.append('void %s::didReceive%sMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder& decoder)\n' % (receiver.name, receiver.name))
593         else:
594             result.append('void %s::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder)\n' % (receiver.name))
595
596         result.append('{\n')
597         result += [async_message_statement(receiver, message) for message in async_messages]
598         if not receiver.has_attribute(LEGACY_RECEIVER_ATTRIBUTE):
599             result.append('    UNUSED_PARAM(connection);\n')
600         result.append('    ASSERT_NOT_REACHED();\n')
601         result.append('}\n')
602
603     if sync_messages:
604         result.append('\n')
605         if receiver.has_attribute(LEGACY_RECEIVER_ATTRIBUTE):
606             result.append('void %s::didReceiveSync%sMessage(CoreIPC::Connection*%s, CoreIPC::MessageDecoder& decoder, std::unique_ptr<CoreIPC::MessageEncoder>& replyEncoder)\n' % (receiver.name, receiver.name, ' connection' if sync_delayed_messages else ''))
607         else:
608             result.append('void %s::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder, std::unique_ptr<CoreIPC::MessageEncoder>& replyEncoder)\n' % (receiver.name))
609         result.append('{\n')
610         result += [sync_message_statement(receiver, message) for message in sync_messages]
611         if not receiver.has_attribute(LEGACY_RECEIVER_ATTRIBUTE):
612             result.append('    UNUSED_PARAM(connection);\n')
613         result.append('    ASSERT_NOT_REACHED();\n')
614         result.append('}\n')
615
616     result.append('\n} // namespace WebKit\n')
617
618     if receiver.condition:
619         result.append('\n#endif // %s\n' % receiver.condition)
620
621     return ''.join(result)