⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 271237 in webkit


Ignore:
Timestamp:
Jan 7, 2021, 9:04:21 AM (6 years ago)
Author:
commit-queue@webkit.org
Message:

WebKit IPC builtin messages should be part of the model
​https://bugs.webkit.org/show_bug.cgi?id=220318

Patch by Kimmo Kinnunen <​kkinnunen@apple.com> on 2021-01-07
Reviewed by Chris Dumez.

Add IPC and AsyncReply message receivers to the IPC model
so that their messages can be part of the generator dynamic logic instead of
being part of the static textual templates.

IPC receiver is a built-in message receiver that has few async messages.

AsyncReply receiver is a built-in message receiver that has one async message
for each message declared as 'Async' in any receiver.

This helps to refine features such as "is message asynchronous" more easily.

Adds new test case TestWithIfMessage to check a case that went wrong when
making the change.

Moves parsing tests to parser_unittest.py so that TestWithIfMessage does not
need to be added to the parsing tests. The said test is not intended to exercises
anything particular in the parsing.

Adds test logic for asserting MessageNames.{h,cpp} and MessageArgumentDescriptions.cpp
are as expected.

  • Scripts/generate-message-receiver.py:

(main):

  • Scripts/webkit/messages.py:
  • Scripts/webkit/model.py:

(check_global_model_inputs):
(generate_global_model):

  • Scripts/webkit/model_unittest.py:
  • Scripts/webkit/tests/MessageNames.cpp:

(IPC::description):
(IPC::receiverName):
(IPC::isValidMessageName):

  • Scripts/webkit/tests/MessageNames.h:
Location:
trunk/Source/WebKit
Files:
4 added
10 edited
1 copied

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit/ChangeLog

    r271235 r271237  
     12021-01-07  Kimmo Kinnunen  <kkinnunen@apple.com>
     2
     3        WebKit IPC builtin messages should be part of the model
     4        https://bugs.webkit.org/show_bug.cgi?id=220318
     5
     6        Reviewed by Chris Dumez.
     7
     8        Add IPC and AsyncReply message receivers to the IPC model
     9        so that their messages can be part of the generator dynamic logic instead of
     10        being part of the static textual templates.
     11       
     12        IPC receiver is a built-in message receiver that has few async messages.
     13
     14        AsyncReply receiver is a built-in message receiver that has one async message
     15        for each message declared as 'Async' in any receiver.
     16
     17        This helps to refine features such as "is message asynchronous" more easily.
     18
     19        Adds new test case TestWithIfMessage to check a case that went wrong when
     20        making the change.
     21
     22        Moves parsing tests to parser_unittest.py so that TestWithIfMessage does not
     23        need to be added to the parsing tests. The said test is not intended to exercises
     24        anything particular in the parsing.
     25
     26        Adds test logic for asserting MessageNames.{h,cpp} and MessageArgumentDescriptions.cpp
     27        are as expected.
     28
     29        * Scripts/generate-message-receiver.py:
     30        (main):
     31        * Scripts/webkit/messages.py:
     32        * Scripts/webkit/model.py:
     33        (check_global_model_inputs):
     34        (generate_global_model):
     35        * Scripts/webkit/model_unittest.py:
     36        * Scripts/webkit/tests/MessageNames.cpp:
     37        (IPC::description):
     38        (IPC::receiverName):
     39        (IPC::isValidMessageName):
     40        * Scripts/webkit/tests/MessageNames.h:
     41
    1422021-01-07  Lauro Moura  <lmoura@igalia.com>
    243

  • trunk/Source/WebKit/Scripts/generate-message-receiver.py

    r271183 r271237  
    5555            sys.exit(1)
    5656
    57     errors = webkit.model.check_global_model(receivers)
     57    errors = webkit.model.check_global_model_inputs(receivers)
    5858    if errors:
    5959        for e in errors:
    … …  
    6161        sys.exit(1)
    6262
     63    receivers = webkit.model.generate_global_model(receivers)
     64
    6365    for receiver in receivers:
     66        if receiver.has_attribute(webkit.model.BUILTIN_ATTRIBUTE):
     67            continue
    6468        with open('%sMessageReceiver.cpp' % receiver.name, "w+") as implementation_output:
    6569            implementation_output.write(webkit.messages.generate_message_handler(receiver))

  • trunk/Source/WebKit/Scripts/webkit/messages.py

    r271183 r271237  
    2626
    2727from webkit import parser
     28from webkit.model import BUILTIN_ATTRIBUTE, ASYNC_ATTRIBUTE
    2829
    2930_license_header = """/*
    … …  
    5960NOT_REFCOUNTED_RECEIVER_ATTRIBUTE = 'NotRefCounted'
    6061SYNCHRONOUS_ATTRIBUTE = 'Synchronous'
    61 ASYNC_ATTRIBUTE = 'Async'
     62
     63
     64def receiver_enumerator_order_key(receiver_name):
     65    if receiver_name == 'IPC':
     66        return 1
     67    elif receiver_name == 'AsyncReply':
     68        return 2
     69    return 0
     70
     71
     72class MessageEnumerator(object):
     73
     74    def __init__(self, receiver, messages):
     75        self.receiver = receiver
     76        self.messages = messages
     77
     78    def __str__(self):
     79        if self.messages[0].has_attribute(BUILTIN_ATTRIBUTE):
     80            return self.messages[0].name
     81        if self.receiver.name == 'AsyncReply':
     82            return self.messages[0].name
     83        return '%s_%s' % (self.receiver.name, self.messages[0].name)
     84
     85    @classmethod
     86    def sort_key(cls, obj):
     87        return receiver_enumerator_order_key(obj.receiver.name), str(obj)
     88
     89
     90def get_message_enumerators(receivers):
     91    enumerators = []
     92    for receiver in receivers:
     93        receiver_enumerators = {}
     94        for message in receiver.messages:
     95            if message.name not in receiver_enumerators:
     96                receiver_enumerators[message.name] = MessageEnumerator(receiver, messages=[message])
     97            else:
     98                receiver_enumerators[message.name].messages.append(message)
     99        enumerators += receiver_enumerators.values()
     100    assert(len(enumerators) == len(set(enumerators)))
     101    return sorted(enumerators, key=MessageEnumerator.sort_key)
     102
     103
     104def get_receiver_enumerators(receivers):
     105    return sorted((r.name for r in receivers), key=lambda n: (receiver_enumerator_order_key(n), n))
     106
    62107
    63108def messages_header_filename(receiver):
    … …  
    912957    result.append('\n')
    913958    result.append('enum class ReceiverName : uint8_t {')
    914 
    915     enum_value = 1
    916     first_receiver = True
    917     for receiver in receivers:
    918         result.append('\n')
    919         result.append('    ')
    920         if not first_receiver:
    921             result.append(', ')
    922         first_receiver = False
    923         result.append('%s = %d' % (receiver.name, enum_value))
    924         enum_value = enum_value + 1
    925     result.append('\n    , IPC = %d' % enum_value)
    926     enum_value = enum_value + 1
    927     result.append('\n    , AsyncReply = %d' % enum_value)
    928     enum_value = enum_value + 1
    929     result.append('\n    , Invalid = %d' % enum_value)
     959    result.append('\n    ')
     960    enums = ['%s = %d' % (e, v) for v, e in enumerate(get_receiver_enumerators(receivers), 1)]
     961    result.append('\n    , '.join(enums))
     962    result.append('\n    , Invalid = %d' % (len(enums) + 1))
    930963    result.append('\n};\n')
    931964    result.append('\n')
     965
     966    message_enumerators = get_message_enumerators(receivers)
     967
    932968    result.append('enum class MessageName : uint16_t {')
    933 
    934     enum_values = set()
    935     for receiver in receivers:
    936         for message in receiver.messages:
    937             enum_values.add('%s_%s' % (receiver.name, message.name))
    938             if message.has_attribute(ASYNC_ATTRIBUTE):
    939                 enum_values.add('%s_%sReply' % (receiver.name, message.name))
    940 
    941     first_message = True
    942     for enum_value in sorted(enum_values):
    943         result.append('\n    ')
    944         if not first_message:
    945             result.append(', ')
    946         first_message = False
    947         result.append(enum_value)
    948     result.append('\n    , WrappedAsyncMessageForTesting')
    949     result.append('\n    , SyncMessageReply')
    950     result.append('\n    , InitializeConnection')
    951     result.append('\n    , LegacySessionState')
    952     result.append('\n    , Last = LegacySessionState')
     969    result.append('\n    ')
     970    result.append('\n    , '.join(str(e) for e in message_enumerators))
     971    result.append('\n    , Last = %s' % message_enumerators[-1])
    953972    result.append('\n};\n')
    954973    result.append('\n')
    … …  
    9881007    result.append('{\n')
    9891008    result.append('    switch (name) {\n')
    990     enum_values = set()
    991     for receiver in receivers:
    992         for message in receiver.messages:
    993             enum_values.add('%s_%s' % (receiver.name, message.name))
    994             if message.has_attribute(ASYNC_ATTRIBUTE):
    995                 enum_values.add('%s_%sReply' % (receiver.name, message.name))
    996 
    997     for enum_value in sorted(enum_values):
    998         result.append('    case MessageName::%s:\n' % enum_value)
    999         result.append('        return "%s";\n' % enum_value)
    1000     result.append('    case MessageName::WrappedAsyncMessageForTesting:\n')
    1001     result.append('        return "IPC::WrappedAsyncMessageForTesting";\n')
    1002     result.append('    case MessageName::SyncMessageReply:\n')
    1003     result.append('        return "IPC::SyncMessageReply";\n')
    1004     result.append('    case MessageName::InitializeConnection:\n')
    1005     result.append('        return "IPC::InitializeConnection";\n')
    1006     result.append('    case MessageName::LegacySessionState:\n')
    1007     result.append('        return "IPC::LegacySessionState";\n')
     1009
     1010    message_enumerators = get_message_enumerators(receivers)
     1011    for enumerator in message_enumerators:
     1012        result.append('    case MessageName::%s:\n' % enumerator)
     1013        result.append('        return "%s";\n' % enumerator)
    10081014    result.append('    }\n')
    10091015    result.append('    ASSERT_NOT_REACHED();\n')
    … …  
    10141020    result.append('{\n')
    10151021    result.append('    switch (messageName) {\n')
    1016     message_receiver_map = dict()
    1017     async_reply_messages = set()
    1018     for receiver in receivers:
    1019         messages = set()
    1020         for message in receiver.messages:
    1021             messages.add('%s_%s' % (receiver.name, message.name))
    1022             if message.has_attribute(ASYNC_ATTRIBUTE):
    1023                 async_reply_messages.add('%s_%sReply' % (receiver.name, message.name))
    1024         if len(messages):
    1025             message_receiver_map[receiver.name] = messages
    1026 
    1027     for receiver_name, message_names in message_receiver_map.items():
    1028         for message_name in sorted(message_names):
    1029             result.append('    case MessageName::%s:\n' % message_name)
    1030         result.append('        return ReceiverName::%s;\n' % receiver_name)
    1031 
    1032     for async_reply_message in sorted(async_reply_messages):
    1033         result.append('    case MessageName::%s:\n' % async_reply_message)
    1034     result.append('        return ReceiverName::AsyncReply;\n')
    1035     result.append('    case MessageName::WrappedAsyncMessageForTesting:\n')
    1036     result.append('    case MessageName::SyncMessageReply:\n')
    1037     result.append('    case MessageName::InitializeConnection:\n')
    1038     result.append('    case MessageName::LegacySessionState:\n')
    1039     result.append('        return ReceiverName::IPC;\n')
     1022    prev_enumerator = None
     1023    for enumerator in message_enumerators:
     1024        if prev_enumerator and prev_enumerator.receiver != enumerator.receiver:
     1025            result.append('        return ReceiverName::%s;\n' % prev_enumerator.receiver.name)
     1026        result.append('    case MessageName::%s:\n' % enumerator)
     1027        prev_enumerator = enumerator
     1028    if prev_enumerator:
     1029        result.append('        return ReceiverName::%s;\n' % prev_enumerator.receiver.name)
    10401030    result.append('    }\n')
    10411031    result.append('    ASSERT_NOT_REACHED();\n')
    … …  
    10451035    result.append('bool isValidMessageName(MessageName messageName)\n')
    10461036    result.append('{\n')
    1047     for receiver in receivers:
    1048         for message in receiver.messages:
     1037    for enumerator in message_enumerators:
     1038        for message in enumerator.messages:
    10491039            if message.condition:
    10501040                result.append('#if %s\n' % message.condition)
    1051             result.append('    if (messageName == IPC::MessageName::%s_%s)\n' % (receiver.name, message.name))
     1041            result.append('    if (messageName == IPC::MessageName::%s)\n' % enumerator)
    10521042            result.append('        return true;\n')
    1053             if message.has_attribute(ASYNC_ATTRIBUTE):
    1054                 result.append('    if (messageName == IPC::MessageName::%s_%sReply)\n' % (receiver.name, message.name))
    1055                 result.append('        return true;\n')
    10561043            if message.condition:
    10571044                result.append('#endif\n')
    1058     result.append('    if (messageName == IPC::MessageName::WrappedAsyncMessageForTesting)\n')
    1059     result.append('        return true;\n')
    1060     result.append('    if (messageName == IPC::MessageName::SyncMessageReply)\n')
    1061     result.append('        return true;\n')
    1062     result.append('    if (messageName == IPC::MessageName::InitializeConnection)\n')
    1063     result.append('        return true;\n')
    1064     result.append('    if (messageName == IPC::MessageName::LegacySessionState)\n')
    1065     result.append('        return true;\n')
    10661045    result.append('    return false;\n')
    10671046    result.append('};\n')
    … …  
    10761055    result.append('    switch (name) {\n')
    10771056    for receiver in receivers:
     1057        if receiver.has_attribute(BUILTIN_ATTRIBUTE):
     1058            continue
    10781059        if receiver.condition:
    10791060            result.append('#if %s\n' % receiver.condition)
    … …  
    11071088    result.append('    switch (name) {\n')
    11081089    for receiver in receivers:
     1090        if receiver.has_attribute(BUILTIN_ATTRIBUTE):
     1091            continue
    11091092        if receiver.condition:
    11101093            result.append('#if %s\n' % receiver.condition)
    11111094        previous_message_condition = None
    11121095        for message in receiver.messages:
     1096            if message.has_attribute(BUILTIN_ATTRIBUTE):
     1097                continue
    11131098            argument_list = arguments_from_message(message)
    11141099            if argument_list is None:
    … …  
    11561141    }
    11571142    for receiver in receivers:
     1143        if receiver.has_attribute(BUILTIN_ATTRIBUTE):
     1144            continue
    11581145        header_conditions['"%s"' % messages_header_filename(receiver)] = [None]
    11591146        collect_header_conditions_for_receiver(receiver, header_conditions)
    … …  
    12051192                    result.append('#if %s\n' % message.condition)
    12061193            previous_message_condition = message.condition
    1207             result.append('    case MessageName::%s_%s:\n' % (receiver.name, message.name))
     1194            result.append('    case MessageName::%s:\n' % MessageEnumerator(receiver, [message]))
    12081195            result.append('        return true;\n')
    12091196        if previous_message_condition:

  • trunk/Source/WebKit/Scripts/webkit/messages_unittest.py

    r271183 r271237  
    3131import unittest
    3232
    33 if sys.version_info > (3, 0):
    34     from io import StringIO
    35 else:
    36     from StringIO import StringIO
    37 
    3833module_directory = os.path.dirname(os.path.abspath(__file__))
    3934
    4035sys.path.append(os.path.abspath(os.path.join(module_directory, os.path.pardir)))
    41 from webkit import messages
    42 from webkit import parser
     36from webkit import messages, model, parser  # noqa: E402
    4337
    4438tests_directory = os.path.join(module_directory, 'tests')
    … …  
    4640reset_results = False
    4741
    48 with open(os.path.join(tests_directory, 'TestWithoutAttributes.messages.in')) as in_file:
    49     _messages_file_contents = in_file.read()
    50 
    51 with open(os.path.join(tests_directory, 'TestWithLegacyReceiver.messages.in')) as in_file:
    52     _legacy_messages_file_contents = in_file.read()
    53 
    54 with open(os.path.join(tests_directory, 'TestWithSuperclass.messages.in')) as in_file:
    55     _superclass_messages_file_contents = in_file.read()
    56 
    57 _expected_receiver_header_file_name = 'TestWithoutAttributesMessages.h'
    58 _expected_legacy_receiver_header_file_name = 'TestWithLegacyReceiverMessages.h'
    59 _expected_superclass_receiver_header_file_name = 'TestWithSuperclassMessages.h'
    60 
    61 _expected_receiver_implementation_file_name = 'TestWithoutAttributesMessageReceiver.cpp'
    62 _expected_legacy_receiver_implementation_file_name = 'TestWithLegacyReceiverMessageReceiver.cpp'
    63 _expected_superclass_receiver_implementation_file_name = 'TestWithSuperclassMessageReceiver.cpp'
    64 
    65 _base_expected_results = {
    66     'conditions': ('(ENABLE(WEBKIT2) && (NESTED_MASTER_CONDITION || MASTER_OR && MASTER_AND))'),
    67     'messages': (
    68         {
    69             'name': 'LoadURL',
    70             'parameters': (
    71                 ('String', 'url'),
    72             ),
    73             'conditions': (None),
    74         },
    75         {
    76             'name': 'LoadSomething',
    77             'parameters': (
    78                 ('String', 'url'),
    79             ),
    80             'conditions': ('ENABLE(TOUCH_EVENTS)'),
    81         },
    82         {
    83             'name': 'TouchEvent',
    84             'parameters': (
    85                 ('WebKit::WebTouchEvent', 'event'),
    86             ),
    87             'conditions': ('(ENABLE(TOUCH_EVENTS) && (NESTED_MESSAGE_CONDITION || SOME_OTHER_MESSAGE_CONDITION))'),
    88         },
    89         {
    90             'name': 'AddEvent',
    91             'parameters': (
    92                 ('WebKit::WebTouchEvent', 'event'),
    93             ),
    94             'conditions': ('(ENABLE(TOUCH_EVENTS) && (NESTED_MESSAGE_CONDITION && SOME_OTHER_MESSAGE_CONDITION))'),
    95         },
    96         {
    97             'name': 'LoadSomethingElse',
    98             'parameters': (
    99                 ('String', 'url'),
    100             ),
    101             'conditions': ('ENABLE(TOUCH_EVENTS)'),
    102         },
    103         {
    104             'name': 'DidReceivePolicyDecision',
    105             'parameters': (
    106                 ('uint64_t', 'frameID'),
    107                 ('uint64_t', 'listenerID'),
    108                 ('uint32_t', 'policyAction'),
    109             ),
    110             'conditions': (None),
    111         },
    112         {
    113             'name': 'Close',
    114             'parameters': (),
    115             'conditions': (None),
    116         },
    117         {
    118             'name': 'PreferencesDidChange',
    119             'parameters': (
    120                 ('WebKit::WebPreferencesStore', 'store'),
    121             ),
    122             'conditions': (None),
    123         },
    124         {
    125             'name': 'SendDoubleAndFloat',
    126             'parameters': (
    127                 ('double', 'd'),
    128                 ('float', 'f'),
    129             ),
    130             'conditions': (None),
    131         },
    132         {
    133             'name': 'SendInts',
    134             'parameters': (
    135                 ('Vector<uint64_t>', 'ints'),
    136                 ('Vector<Vector<uint64_t>>', 'intVectors')
    137             ),
    138             'conditions': (None),
    139         },
    140         {
    141             'name': 'CreatePlugin',
    142             'parameters': (
    143                 ('uint64_t', 'pluginInstanceID'),
    144                 ('WebKit::Plugin::Parameters', 'parameters')
    145             ),
    146             'reply_parameters': (
    147                 ('bool', 'result'),
    148             ),
    149             'conditions': (None),
    150         },
    151         {
    152             'name': 'RunJavaScriptAlert',
    153             'parameters': (
    154                 ('uint64_t', 'frameID'),
    155                 ('String', 'message')
    156             ),
    157             'reply_parameters': (),
    158             'conditions': (None),
    159         },
    160         {
    161             'name': 'GetPlugins',
    162             'parameters': (
    163                 ('bool', 'refresh'),
    164             ),
    165             'reply_parameters': (
    166                 ('Vector<WebCore::PluginInfo>', 'plugins'),
    167             ),
    168             'conditions': (None),
    169         },
    170         {
    171             'name': 'GetPluginProcessConnection',
    172             'parameters': (
    173                 ('String', 'pluginPath'),
    174             ),
    175             'reply_parameters': (
    176                 ('IPC::Connection::Handle', 'connectionHandle'),
    177             ),
    178             'conditions': (None),
    179         },
    180         {
    181             'name': 'TestMultipleAttributes',
    182             'parameters': (
    183             ),
    184             'reply_parameters': (
    185             ),
    186             'conditions': (None),
    187         },
    188         {
    189             'name': 'TestParameterAttributes',
    190             'parameters': (
    191                 ('uint64_t', 'foo', ('AttributeOne', 'AttributeTwo')),
    192                 ('double', 'bar'),
    193                 ('double', 'baz', ('AttributeThree',)),
    194             ),
    195             'conditions': (None),
    196         },
    197         {
    198             'name': 'TemplateTest',
    199             'parameters': (
    200                 ('HashMap<String, std::pair<String, uint64_t>>', 'a'),
    201             ),
    202             'conditions': (None),
    203         },
    204         {
    205             'name': 'SetVideoLayerID',
    206             'parameters': (
    207                 ('WebCore::GraphicsLayer::PlatformLayerID', 'videoLayerID'),
    208             ),
    209             'conditions': (None),
    210         },
    211         {
    212             'name': 'DidCreateWebProcessConnection',
    213             'parameters': (
    214                 ('IPC::MachPort', 'connectionIdentifier'),
    215                 ('OptionSet<WebKit::SelectionFlags>', 'flags'),
    216             ),
    217             'conditions': ('PLATFORM(MAC)'),
    218         },
    219         {
    220             'name': 'InterpretKeyEvent',
    221             'parameters': (
    222                 ('uint32_t', 'type'),
    223             ),
    224             'reply_parameters': (
    225                 ('Vector<WebCore::KeypressCommand>', 'commandName'),
    226             ),
    227             'conditions': ('PLATFORM(MAC)'),
    228         },
    229         {
    230             'name': 'DeprecatedOperation',
    231             'parameters': (
    232                 ('IPC::DummyType', 'dummy'),
    233             ),
    234             'conditions': ('ENABLE(DEPRECATED_FEATURE)'),
    235         },
    236         {
    237             'name': 'ExperimentalOperation',
    238             'parameters': (
    239                 ('IPC::DummyType', 'dummy'),
    240             ),
    241             'conditions': ('ENABLE(EXPERIMENTAL_FEATURE)'),
    242         }
    243     ),
    244 }
    245 
    246 _expected_results = dict(_base_expected_results, name='TestWithoutAttributes')
    247 
    248 _expected_legacy_results = dict(_base_expected_results, name='TestWithLegacyReceiver')
    249 
    250 _expected_superclass_results = {
    251     'name': 'TestWithSuperclass',
    252     'superclass': 'WebPageBase',
    253     'conditions': None,
    254     'messages': (
    255         {
    256             'name': 'LoadURL',
    257             'parameters': (
    258                 ('String', 'url'),
    259             ),
    260             'conditions': (None),
    261         },
    262         {
    263             'name': 'TestAsyncMessage',
    264             'parameters': (
    265                 ('WebKit::TestTwoStateEnum', 'twoStateEnum'),
    266             ),
    267             'reply_parameters': (
    268                 ('uint64_t', 'result'),
    269             ),
    270             'conditions': ('ENABLE(TEST_FEATURE)'),
    271         },
    272         {
    273             'name': 'TestAsyncMessageWithNoArguments',
    274             'parameters': (),
    275             'reply_parameters': (),
    276             'conditions': ('ENABLE(TEST_FEATURE)'),
    277         },
    278         {
    279             'name': 'TestAsyncMessageWithMultipleArguments',
    280             'parameters': (),
    281             'reply_parameters': (
    282                 ('bool', 'flag'),
    283                 ('uint64_t', 'value'),
    284             ),
    285             'conditions': ('ENABLE(TEST_FEATURE)'),
    286         },
    287         {
    288             'name': 'TestAsyncMessageWithConnection',
    289             'parameters': (
    290                 ('int', 'value'),
    291             ),
    292             'reply_parameters': (
    293                 ('bool', 'flag'),
    294             ),
    295             'conditions': ('ENABLE(TEST_FEATURE)'),
    296         },
    297         {
    298             'name': 'TestSyncMessage',
    299             'parameters': (
    300                 ('uint32_t', 'param'),
    301             ),
    302             'reply_parameters': (
    303                 ('uint8_t', 'reply'),
    304             ),
    305             'conditions': (None),
    306         },
    307         {
    308             'name': 'TestSynchronousMessage',
    309             'parameters': (
    310                 ('bool', 'value'),
    311             ),
    312             'reply_parameters': (
    313                 ('Optional<WebKit::TestClassName>', 'optionalReply'),
    314             ),
    315             'conditions': (None),
    316         },
    317     ),
    318 }
     42_test_receiver_names = ['TestWithSuperclass', 'TestWithLegacyReceiver', 'TestWithoutAttributes', 'TestWithIfMessage']
    31943
    32044
    321 class MessagesTest(unittest.TestCase):
    322     def setUp(self):
    323         self.receiver = parser.parse(StringIO(_messages_file_contents))
    324         self.legacy_receiver = parser.parse(StringIO(_legacy_messages_file_contents))
    325         self.superclass_receiver = parser.parse(StringIO(_superclass_messages_file_contents))
     45def receiver_header_file_name(receiver_name):
     46    return '%sMessages.h' % receiver_name
    32647
    32748
    328 class ParsingTest(MessagesTest):
    329     def check_message(self, message, expected_message):
    330         self.assertEquals(message.name, expected_message['name'])
    331         self.assertEquals(len(message.parameters), len(expected_message['parameters']))
    332         for index, parameter in enumerate(message.parameters):
    333             expected_parameter = expected_message['parameters'][index]
    334             self.assertEquals(parameter.type, expected_parameter[0])
    335             self.assertEquals(parameter.name, expected_parameter[1])
    336             if len(expected_parameter) > 2:
    337                 self.assertEquals(parameter.attributes, frozenset(expected_parameter[2]))
    338                 for attribute in expected_parameter[2]:
    339                     self.assertTrue(parameter.has_attribute(attribute))
    340             else:
    341                 self.assertEquals(parameter.attributes, frozenset())
    342         if message.reply_parameters is not None:
    343             for index, parameter in enumerate(message.reply_parameters):
    344                 self.assertEquals(parameter.type, expected_message['reply_parameters'][index][0])
    345                 self.assertEquals(parameter.name, expected_message['reply_parameters'][index][1])
    346         else:
    347             self.assertFalse('reply_parameters' in expected_message)
    348         self.assertEquals(message.condition, expected_message['conditions'])
     49def receiver_implementation_file_name(receiver_name):
     50    return '%sMessageReceiver.cpp' % receiver_name
    34951
    350     def test_receiver(self):
    351         """Receiver should be parsed as expected"""
    352         self.assertEquals(self.receiver.name, _expected_results['name'])
    353         self.assertEquals(self.receiver.condition, _expected_results['conditions'])
    354         self.assertEquals(len(self.receiver.messages), len(_expected_results['messages']))
    355         for index, message in enumerate(self.receiver.messages):
    356             self.check_message(message, _expected_results['messages'][index])
    35752
    358         self.assertEquals(self.legacy_receiver.name, _expected_legacy_results['name'])
    359         self.assertEquals(self.legacy_receiver.condition, _expected_legacy_results['conditions'])
    360         self.assertEquals(len(self.legacy_receiver.messages), len(_expected_legacy_results['messages']))
    361         for index, message in enumerate(self.legacy_receiver.messages):
    362             self.check_message(message, _expected_legacy_results['messages'][index])
    363 
    364         self.assertEquals(self.superclass_receiver.name, _expected_superclass_results['name'])
    365         self.assertEquals(self.superclass_receiver.superclass, _expected_superclass_results['superclass'])
    366         self.assertEquals(len(self.superclass_receiver.messages), len(_expected_superclass_results['messages']))
    367         for index, message in enumerate(self.superclass_receiver.messages):
    368             self.check_message(message, _expected_superclass_results['messages'][index])
     53def parse_receiver(receiver_name):
     54    with open(os.path.join(tests_directory, '{}.messages.in'.format(receiver_name))) as in_file:
     55        return parser.parse(in_file)
     56    assert(False)
    36957
    37058
    37159class GeneratedFileContentsTest(unittest.TestCase):
     60    def setUp(self):
     61        self.test_receivers = [parse_receiver(receiver_name) for receiver_name in _test_receiver_names]
     62        self.receivers = model.generate_global_model(self.test_receivers)
     63
    37264    def assertGeneratedFileContentsEqual(self, actual_file_contents, expected_file_name):
    37365        try:
    … …  
    38678
    38779            self.assertEquals(len(actual_line_list), len(expected_line_list))
    388         except:
     80        except Exception:
    38981            sys.stderr.write('In expected file %s\n' % expected_file_name)
    39082            raise
    39183
    392     def assertHeaderEqual(self, input_messages_file_contents, expected_file_name):
    393         actual_file_contents = messages.generate_messages_header(parser.parse(StringIO(input_messages_file_contents)))
    394         self.assertGeneratedFileContentsEqual(actual_file_contents, expected_file_name)
     84    def test_receiver(self):
     85        for receiver_name, receiver in zip(_test_receiver_names, self.test_receivers):
     86            header_contents = messages.generate_messages_header(receiver)
     87            self.assertGeneratedFileContentsEqual(header_contents, os.path.join(tests_directory, '{}Messages.h'.format(receiver_name)))
     88            implementation_contents = messages.generate_message_handler(receiver)
     89            self.assertGeneratedFileContentsEqual(implementation_contents, os.path.join(tests_directory, '{}MessageReceiver.cpp'.format(receiver_name)))
    39590
    396     def assertImplementationEqual(self, input_messages_file_contents, expected_file_name):
    397         actual_file_contents = messages.generate_message_handler(parser.parse(StringIO(input_messages_file_contents)))
    398         self.assertGeneratedFileContentsEqual(actual_file_contents, expected_file_name)
     91    def test_message_names(self):
     92        header_contents = messages.generate_message_names_header(self.receivers)
     93        self.assertGeneratedFileContentsEqual(header_contents, os.path.join(tests_directory, 'MessageNames.h'))
     94        implementation_contents = messages.generate_message_names_implementation(self.receivers)
     95        self.assertGeneratedFileContentsEqual(implementation_contents, os.path.join(tests_directory, 'MessageNames.cpp'))
    39996
    400 
    401 class HeaderTest(GeneratedFileContentsTest):
    402     def test_receiver_headers(self):
    403         self.assertHeaderEqual(_messages_file_contents,
    404                                _expected_receiver_header_file_name)
    405         self.assertHeaderEqual(_legacy_messages_file_contents,
    406                                _expected_legacy_receiver_header_file_name)
    407         self.assertHeaderEqual(_superclass_messages_file_contents,
    408                                _expected_superclass_receiver_header_file_name)
    409 
    410 
    411 class ReceiverImplementationTest(GeneratedFileContentsTest):
    412     def test_receiver_implementations(self):
    413         self.assertImplementationEqual(_messages_file_contents,
    414                                        _expected_receiver_implementation_file_name)
    415         self.assertImplementationEqual(_legacy_messages_file_contents,
    416                                        _expected_legacy_receiver_implementation_file_name)
    417         self.assertImplementationEqual(_superclass_messages_file_contents,
    418                                        _expected_superclass_receiver_implementation_file_name)
    419 
    420 
    421 class UnsupportedPrecompilerDirectiveTest(unittest.TestCase):
    422     def test_error_at_else(self):
    423         with self.assertRaisesRegexp(Exception, r"ERROR: '#else.*' is not supported in the \*\.in files"):
    424             messages.generate_message_handler(parser.parse(StringIO("asd\n#else bla\nfoo")))
    425 
    426     def test_error_at_elif(self):
    427         with self.assertRaisesRegexp(Exception, r"ERROR: '#elif.*' is not supported in the \*\.in files"):
    428             messages.generate_message_handler(parser.parse(StringIO("asd\n#elif bla\nfoo")))
    429 
     97    def test_message_argument_description(self):
     98        receiver_header_files = ['{}Messages.h'.format(receiver.name) for receiver in self.receivers]
     99        implementation_contents = messages.generate_message_argument_description_implementation(self.receivers, receiver_header_files)
     100        self.assertGeneratedFileContentsEqual(implementation_contents, os.path.join(tests_directory, 'MessageArgumentDescriptions.cpp'))
    430101
    431102def add_reset_results_to_unittest_help():

  • trunk/Source/WebKit/Scripts/webkit/model.py

    r271183 r271237  
    2424
    2525from collections import Counter
     26
     27BUILTIN_ATTRIBUTE = "Builtin"
     28ASYNC_ATTRIBUTE = "Async"
    2629
    2730class MessageReceiver(object):
    … …  
    6568
    6669
    67 def check_global_model(receivers):
     70ipc_receiver = MessageReceiver(name="IPC", superclass=None, attributes=[BUILTIN_ATTRIBUTE], messages=[
     71    Message('WrappedAsyncMessageForTesting', [], [], attributes=[BUILTIN_ATTRIBUTE], condition=None),
     72    Message('SyncMessageReply', [], [], attributes=[BUILTIN_ATTRIBUTE], condition=None),
     73    Message('InitializeConnection', [], [], attributes=[BUILTIN_ATTRIBUTE], condition="PLATFORM(COCOA)"),
     74    Message('LegacySessionState', [], [], attributes=[BUILTIN_ATTRIBUTE], condition=None)
     75], condition=None)
     76
     77
     78def check_global_model_inputs(receivers):
    6879    errors = []
    6980    receiver_counts = Counter([r.name for r in receivers])
    … …  
    7384
    7485    return errors
     86
     87
     88def generate_global_model(receivers):
     89    async_reply_messages = []
     90    for receiver in receivers:
     91        for message in receiver.messages:
     92            if message.has_attribute(ASYNC_ATTRIBUTE):
     93                async_reply_messages.append(Message(name='%s_%sReply' % (receiver.name, message.name), parameters=message.reply_parameters, reply_parameters=[], attributes=None, condition=message.condition))
     94    async_reply_receiver = MessageReceiver(name='AsyncReply', superclass='None', attributes=[BUILTIN_ATTRIBUTE], messages=async_reply_messages, condition=None)
     95    return [ipc_receiver, async_reply_receiver] + receivers

  • trunk/Source/WebKit/Scripts/webkit/model_unittest.py

    r271183 r271237  
    6060        self.assertEquals(other_receiver.messages[0].name, 'LoadURL')
    6161        self.assertEquals(other_receiver.messages[1].name, 'LoadURL2')
    62         errors = model.check_global_model([receiver, other_receiver])
     62        errors = model.check_global_model_inputs([receiver, other_receiver])
    6363        self.assertEquals(len(errors), 1)
    6464        self.assertTrue("Duplicate" in errors[0])

  • trunk/Source/WebKit/Scripts/webkit/parser_unittest.py

    r271236 r271237  
    2222
    2323# Examples of how to run:
    24 # python Source/WebKit/Scripts/webkit/messages_unittest.py [-r]
    25 # cd Source/WebKit/Scripts && python -m webkit.messages_unittest
     24# python Source/WebKit/Scripts/webkit/parser_unittest.py
     25# cd Source/WebKit/Scripts && python -m webkit.parser_unittest
    2626# cd Source/WebKit/Scripts && python -m unittest discover -p '*_unittest.py'
    2727
    … …  
    3939
    4040sys.path.append(os.path.abspath(os.path.join(module_directory, os.path.pardir)))
    41 from webkit import messages
    42 from webkit import parser
     41from webkit import parser  # noqa: E402
    4342
    4443tests_directory = os.path.join(module_directory, 'tests')
    4544
    46 reset_results = False
    47 
    48 with open(os.path.join(tests_directory, 'TestWithoutAttributes.messages.in')) as in_file:
    49     _messages_file_contents = in_file.read()
    50 
    51 with open(os.path.join(tests_directory, 'TestWithLegacyReceiver.messages.in')) as in_file:
    52     _legacy_messages_file_contents = in_file.read()
    53 
    54 with open(os.path.join(tests_directory, 'TestWithSuperclass.messages.in')) as in_file:
    55     _superclass_messages_file_contents = in_file.read()
    56 
    57 _expected_receiver_header_file_name = 'TestWithoutAttributesMessages.h'
    58 _expected_legacy_receiver_header_file_name = 'TestWithLegacyReceiverMessages.h'
    59 _expected_superclass_receiver_header_file_name = 'TestWithSuperclassMessages.h'
    60 
    61 _expected_receiver_implementation_file_name = 'TestWithoutAttributesMessageReceiver.cpp'
    62 _expected_legacy_receiver_implementation_file_name = 'TestWithLegacyReceiverMessageReceiver.cpp'
    63 _expected_superclass_receiver_implementation_file_name = 'TestWithSuperclassMessageReceiver.cpp'
    64 
    65 _base_expected_results = {
     45_expected_model_base = {
    6646    'conditions': ('(ENABLE(WEBKIT2) && (NESTED_MASTER_CONDITION || MASTER_OR && MASTER_AND))'),
    6747    'messages': (
    … …  
    244224}
    245225
    246 _expected_results = dict(_base_expected_results, name='TestWithoutAttributes')
    247 
    248 _expected_legacy_results = dict(_base_expected_results, name='TestWithLegacyReceiver')
    249 
    250 _expected_superclass_results = {
     226_expected_model_test_without_attributes = dict(_expected_model_base, name='TestWithoutAttributes')
     227
     228_expected_model_test_with_legacy_receiver = dict(_expected_model_base, name='TestWithLegacyReceiver')
     229
     230_expected_model_test_with_superclass = {
    251231    'name': 'TestWithSuperclass',
    252232    'superclass': 'WebPageBase',
    … …  
    319299
    320300
    321 class MessagesTest(unittest.TestCase):
     301_parsing_test_cases = [
     302    _expected_model_test_without_attributes,
     303    _expected_model_test_with_legacy_receiver,
     304    _expected_model_test_with_superclass
     305]
     306
     307
     308def parse_receiver(receiver_name):
     309    with open(os.path.join(tests_directory, '{}.messages.in'.format(receiver_name))) as in_file:
     310        return parser.parse(in_file)
     311    assert(False)
     312
     313
     314class ParsingTest(unittest.TestCase):
    322315    def setUp(self):
    323         self.receiver = parser.parse(StringIO(_messages_file_contents))
    324         self.legacy_receiver = parser.parse(StringIO(_legacy_messages_file_contents))
    325         self.superclass_receiver = parser.parse(StringIO(_superclass_messages_file_contents))
    326 
    327 
    328 class ParsingTest(MessagesTest):
     316        self.receivers = [parse_receiver(expected_model['name']) for expected_model in _parsing_test_cases]
     317
    329318    def check_message(self, message, expected_message):
    330319        self.assertEquals(message.name, expected_message['name'])
    … …  
    350339    def test_receiver(self):
    351340        """Receiver should be parsed as expected"""
    352         self.assertEquals(self.receiver.name, _expected_results['name'])
    353         self.assertEquals(self.receiver.condition, _expected_results['conditions'])
    354         self.assertEquals(len(self.receiver.messages), len(_expected_results['messages']))
    355         for index, message in enumerate(self.receiver.messages):
    356             self.check_message(message, _expected_results['messages'][index])
    357 
    358         self.assertEquals(self.legacy_receiver.name, _expected_legacy_results['name'])
    359         self.assertEquals(self.legacy_receiver.condition, _expected_legacy_results['conditions'])
    360         self.assertEquals(len(self.legacy_receiver.messages), len(_expected_legacy_results['messages']))
    361         for index, message in enumerate(self.legacy_receiver.messages):
    362             self.check_message(message, _expected_legacy_results['messages'][index])
    363 
    364         self.assertEquals(self.superclass_receiver.name, _expected_superclass_results['name'])
    365         self.assertEquals(self.superclass_receiver.superclass, _expected_superclass_results['superclass'])
    366         self.assertEquals(len(self.superclass_receiver.messages), len(_expected_superclass_results['messages']))
    367         for index, message in enumerate(self.superclass_receiver.messages):
    368             self.check_message(message, _expected_superclass_results['messages'][index])
    369 
    370 
    371 class GeneratedFileContentsTest(unittest.TestCase):
    372     def assertGeneratedFileContentsEqual(self, actual_file_contents, expected_file_name):
    373         try:
    374             if reset_results:
    375                 with open(os.path.join(tests_directory, expected_file_name), mode='w') as out_file:
    376                     out_file.write(actual_file_contents)
    377                 return
    378 
    379             with open(os.path.join(tests_directory, expected_file_name), mode='r') as in_file:
    380                 expected_file_contents = in_file.read()
    381             actual_line_list = actual_file_contents.splitlines(False)
    382             expected_line_list = expected_file_contents.splitlines(False)
    383 
    384             for index, actual_line in enumerate(actual_line_list):
    385                 self.assertEquals(actual_line, expected_line_list[index])
    386 
    387             self.assertEquals(len(actual_line_list), len(expected_line_list))
    388         except:
    389             sys.stderr.write('In expected file %s\n' % expected_file_name)
    390             raise
    391 
    392     def assertHeaderEqual(self, input_messages_file_contents, expected_file_name):
    393         actual_file_contents = messages.generate_messages_header(parser.parse(StringIO(input_messages_file_contents)))
    394         self.assertGeneratedFileContentsEqual(actual_file_contents, expected_file_name)
    395 
    396     def assertImplementationEqual(self, input_messages_file_contents, expected_file_name):
    397         actual_file_contents = messages.generate_message_handler(parser.parse(StringIO(input_messages_file_contents)))
    398         self.assertGeneratedFileContentsEqual(actual_file_contents, expected_file_name)
    399 
    400 
    401 class HeaderTest(GeneratedFileContentsTest):
    402     def test_receiver_headers(self):
    403         self.assertHeaderEqual(_messages_file_contents,
    404                                _expected_receiver_header_file_name)
    405         self.assertHeaderEqual(_legacy_messages_file_contents,
    406                                _expected_legacy_receiver_header_file_name)
    407         self.assertHeaderEqual(_superclass_messages_file_contents,
    408                                _expected_superclass_receiver_header_file_name)
    409 
    410 
    411 class ReceiverImplementationTest(GeneratedFileContentsTest):
    412     def test_receiver_implementations(self):
    413         self.assertImplementationEqual(_messages_file_contents,
    414                                        _expected_receiver_implementation_file_name)
    415         self.assertImplementationEqual(_legacy_messages_file_contents,
    416                                        _expected_legacy_receiver_implementation_file_name)
    417         self.assertImplementationEqual(_superclass_messages_file_contents,
    418                                        _expected_superclass_receiver_implementation_file_name)
     341        for receiver, expected_model in zip(self.receivers, _parsing_test_cases):
     342            self.assertEquals(receiver.name, expected_model['name'])
     343            self.assertEquals(receiver.condition, expected_model['conditions'])
     344            self.assertEquals(len(receiver.messages), len(expected_model['messages']))
     345            for index, message in enumerate(receiver.messages):
     346                self.check_message(message, expected_model['messages'][index])
    419347
    420348
    … …  
    422350    def test_error_at_else(self):
    423351        with self.assertRaisesRegexp(Exception, r"ERROR: '#else.*' is not supported in the \*\.in files"):
    424             messages.generate_message_handler(parser.parse(StringIO("asd\n#else bla\nfoo")))
     352            parser.parse(StringIO("asd\n#else bla\nfoo"))
    425353
    426354    def test_error_at_elif(self):
    427355        with self.assertRaisesRegexp(Exception, r"ERROR: '#elif.*' is not supported in the \*\.in files"):
    428             messages.generate_message_handler(parser.parse(StringIO("asd\n#elif bla\nfoo")))
    429 
    430 
    431 def add_reset_results_to_unittest_help():
    432     script_name = os.path.basename(__file__)
    433     reset_results_help = '''
    434 Custom Options:
    435   -r, --reset-results  Reset expected results for {0}
    436 '''.format(script_name)
    437 
    438     options_regex = re.compile('^Usage:')
    439     lines = unittest.TestProgram.USAGE.splitlines(True)
    440     index = 0
    441     for index, line in enumerate(lines):
    442         if options_regex.match(line) and index + 1 < len(lines):
    443             lines.insert(index + 1, reset_results_help)
    444             break
    445 
    446     if index == (len(lines) - 1):
    447         lines.append(reset_results_help)
    448 
    449     unittest.TestProgram.USAGE = ''.join(lines)
    450 
    451 
    452 def parse_sys_argv():
    453     global reset_results
    454     for index, arg in enumerate(sys.argv[1:]):
    455         if arg in ('-r', '--r', '--reset', '--reset-results') or '--reset-results'.startswith(arg):
    456             reset_results = True
    457             del sys.argv[index + 1]
    458             break
    459 
    460 
    461 if __name__ == '__main__':
    462     add_reset_results_to_unittest_help()
    463     parse_sys_argv()
    464     unittest.main()
     356            parser.parse(StringIO("asd\n#elif bla\nfoo"))

  • trunk/Source/WebKit/Scripts/webkit/tests/Makefile

    r271183 r271237  
    11all:
    2         python ../../generate-message-receiver.py . TestWithSuperclass TestWithLegacyReceiver TestWithoutAttributes
     2        python ../../generate-message-receiver.py . TestWithSuperclass TestWithLegacyReceiver TestWithoutAttributes TestWithIfMessage

  • trunk/Source/WebKit/Scripts/webkit/tests/MessageArgumentDescriptions.cpp

    r271183 r271237  
    4545#include "TestTwoStateEnum.h"
    4646#endif
     47#include "TestWithIfMessageMessages.h"
    4748#include "TestWithLegacyReceiverMessages.h"
    4849#include "TestWithSuperclassMessages.h"
    … …  
    208209#endif
    209210#endif
     211#if PLATFORM(COCOA)
     212    case MessageName::TestWithIfMessage_LoadURL:
     213        return jsValueForDecodedArguments<Messages::TestWithIfMessage::LoadURL::Arguments>(globalObject, decoder);
     214#endif
     215#if PLATFORM(GTK)
     216    case MessageName::TestWithIfMessage_LoadURL:
     217        return jsValueForDecodedArguments<Messages::TestWithIfMessage::LoadURL::Arguments>(globalObject, decoder);
     218#endif
    210219    default:
    211220        break;
    … …  
    496505#endif
    497506#endif
     507#if PLATFORM(COCOA)
     508    case MessageName::TestWithIfMessage_LoadURL:
     509        return Vector<ArgumentDescription> {
     510            {"url", "String", nullptr, false},
     511        };
     512#endif
     513#if PLATFORM(GTK)
     514    case MessageName::TestWithIfMessage_LoadURL:
     515        return Vector<ArgumentDescription> {
     516            {"url", "String", nullptr, false},
     517            {"value", "int64_t", nullptr, false},
     518        };
     519#endif
    498520    default:
    499521        break;

  • trunk/Source/WebKit/Scripts/webkit/tests/MessageNames.cpp

    r271183 r271237  
    3131{
    3232    switch (name) {
     33    case MessageName::TestWithIfMessage_LoadURL:
     34        return "TestWithIfMessage_LoadURL";
    3335    case MessageName::TestWithLegacyReceiver_AddEvent:
    3436        return "TestWithLegacyReceiver_AddEvent";
    … …  
    7981    case MessageName::TestWithSuperclass_TestAsyncMessage:
    8082        return "TestWithSuperclass_TestAsyncMessage";
    81     case MessageName::TestWithSuperclass_TestAsyncMessageReply:
    82         return "TestWithSuperclass_TestAsyncMessageReply";
    8383    case MessageName::TestWithSuperclass_TestAsyncMessageWithConnection:
    8484        return "TestWithSuperclass_TestAsyncMessageWithConnection";
    85     case MessageName::TestWithSuperclass_TestAsyncMessageWithConnectionReply:
    86         return "TestWithSuperclass_TestAsyncMessageWithConnectionReply";
    8785    case MessageName::TestWithSuperclass_TestAsyncMessageWithMultipleArguments:
    8886        return "TestWithSuperclass_TestAsyncMessageWithMultipleArguments";
    89     case MessageName::TestWithSuperclass_TestAsyncMessageWithMultipleArgumentsReply:
    90         return "TestWithSuperclass_TestAsyncMessageWithMultipleArgumentsReply";
    9187    case MessageName::TestWithSuperclass_TestAsyncMessageWithNoArguments:
    9288        return "TestWithSuperclass_TestAsyncMessageWithNoArguments";
    93     case MessageName::TestWithSuperclass_TestAsyncMessageWithNoArgumentsReply:
    94         return "TestWithSuperclass_TestAsyncMessageWithNoArgumentsReply";
    9589    case MessageName::TestWithSuperclass_TestSyncMessage:
    9690        return "TestWithSuperclass_TestSyncMessage";
    … …  
    141135    case MessageName::TestWithoutAttributes_TouchEvent:
    142136        return "TestWithoutAttributes_TouchEvent";
     137    case MessageName::InitializeConnection:
     138        return "InitializeConnection";
     139    case MessageName::LegacySessionState:
     140        return "LegacySessionState";
     141    case MessageName::SyncMessageReply:
     142        return "SyncMessageReply";
    143143    case MessageName::WrappedAsyncMessageForTesting:
    144         return "IPC::WrappedAsyncMessageForTesting";
    145     case MessageName::SyncMessageReply:
    146         return "IPC::SyncMessageReply";
    147     case MessageName::InitializeConnection:
    148         return "IPC::InitializeConnection";
    149     case MessageName::LegacySessionState:
    150         return "IPC::LegacySessionState";
     144        return "WrappedAsyncMessageForTesting";
     145    case MessageName::TestWithSuperclass_TestAsyncMessageReply:
     146        return "TestWithSuperclass_TestAsyncMessageReply";
     147    case MessageName::TestWithSuperclass_TestAsyncMessageWithConnectionReply:
     148        return "TestWithSuperclass_TestAsyncMessageWithConnectionReply";
     149    case MessageName::TestWithSuperclass_TestAsyncMessageWithMultipleArgumentsReply:
     150        return "TestWithSuperclass_TestAsyncMessageWithMultipleArgumentsReply";
     151    case MessageName::TestWithSuperclass_TestAsyncMessageWithNoArgumentsReply:
     152        return "TestWithSuperclass_TestAsyncMessageWithNoArgumentsReply";
    151153    }
    152154    ASSERT_NOT_REACHED();
    … …  
    157159{
    158160    switch (messageName) {
    159     case MessageName::TestWithSuperclass_LoadURL:
    160     case MessageName::TestWithSuperclass_TestAsyncMessage:
    161     case MessageName::TestWithSuperclass_TestAsyncMessageWithConnection:
    162     case MessageName::TestWithSuperclass_TestAsyncMessageWithMultipleArguments:
    163     case MessageName::TestWithSuperclass_TestAsyncMessageWithNoArguments:
    164     case MessageName::TestWithSuperclass_TestSyncMessage:
    165     case MessageName::TestWithSuperclass_TestSynchronousMessage:
    166         return ReceiverName::TestWithSuperclass;
     161    case MessageName::TestWithIfMessage_LoadURL:
     162        return ReceiverName::TestWithIfMessage;
    167163    case MessageName::TestWithLegacyReceiver_AddEvent:
    168164    case MessageName::TestWithLegacyReceiver_Close:
    … …  
    188184    case MessageName::TestWithLegacyReceiver_TouchEvent:
    189185        return ReceiverName::TestWithLegacyReceiver;
     186    case MessageName::TestWithSuperclass_LoadURL:
     187    case MessageName::TestWithSuperclass_TestAsyncMessage:
     188    case MessageName::TestWithSuperclass_TestAsyncMessageWithConnection:
     189    case MessageName::TestWithSuperclass_TestAsyncMessageWithMultipleArguments:
     190    case MessageName::TestWithSuperclass_TestAsyncMessageWithNoArguments:
     191    case MessageName::TestWithSuperclass_TestSyncMessage:
     192    case MessageName::TestWithSuperclass_TestSynchronousMessage:
     193        return ReceiverName::TestWithSuperclass;
    190194    case MessageName::TestWithoutAttributes_AddEvent:
    191195    case MessageName::TestWithoutAttributes_Close:
    … …  
    211215    case MessageName::TestWithoutAttributes_TouchEvent:
    212216        return ReceiverName::TestWithoutAttributes;
     217    case MessageName::InitializeConnection:
     218    case MessageName::LegacySessionState:
     219    case MessageName::SyncMessageReply:
     220    case MessageName::WrappedAsyncMessageForTesting:
     221        return ReceiverName::IPC;
    213222    case MessageName::TestWithSuperclass_TestAsyncMessageReply:
    214223    case MessageName::TestWithSuperclass_TestAsyncMessageWithConnectionReply:
    … …  
    216225    case MessageName::TestWithSuperclass_TestAsyncMessageWithNoArgumentsReply:
    217226        return ReceiverName::AsyncReply;
    218     case MessageName::WrappedAsyncMessageForTesting:
    219     case MessageName::SyncMessageReply:
    220     case MessageName::InitializeConnection:
    221     case MessageName::LegacySessionState:
    222         return ReceiverName::IPC;
    223227    }
    224228    ASSERT_NOT_REACHED();
    … …  
    228232bool isValidMessageName(MessageName messageName)
    229233{
    230     if (messageName == IPC::MessageName::TestWithSuperclass_LoadURL)
    231         return true;
    232 #if ENABLE(TEST_FEATURE)
    233     if (messageName == IPC::MessageName::TestWithSuperclass_TestAsyncMessage)
    234         return true;
    235     if (messageName == IPC::MessageName::TestWithSuperclass_TestAsyncMessageReply)
    236         return true;
    237 #endif
    238 #if ENABLE(TEST_FEATURE)
    239     if (messageName == IPC::MessageName::TestWithSuperclass_TestAsyncMessageWithNoArguments)
    240         return true;
    241     if (messageName == IPC::MessageName::TestWithSuperclass_TestAsyncMessageWithNoArgumentsReply)
    242         return true;
    243 #endif
    244 #if ENABLE(TEST_FEATURE)
    245     if (messageName == IPC::MessageName::TestWithSuperclass_TestAsyncMessageWithMultipleArguments)
    246         return true;
    247     if (messageName == IPC::MessageName::TestWithSuperclass_TestAsyncMessageWithMultipleArgumentsReply)
    248         return true;
    249 #endif
    250 #if ENABLE(TEST_FEATURE)
    251     if (messageName == IPC::MessageName::TestWithSuperclass_TestAsyncMessageWithConnection)
    252         return true;
    253     if (messageName == IPC::MessageName::TestWithSuperclass_TestAsyncMessageWithConnectionReply)
    254         return true;
    255 #endif
    256     if (messageName == IPC::MessageName::TestWithSuperclass_TestSyncMessage)
    257         return true;
    258     if (messageName == IPC::MessageName::TestWithSuperclass_TestSynchronousMessage)
    259         return true;
    260     if (messageName == IPC::MessageName::TestWithLegacyReceiver_LoadURL)
    261         return true;
     234#if PLATFORM(COCOA)
     235    if (messageName == IPC::MessageName::TestWithIfMessage_LoadURL)
     236        return true;
     237#endif
     238#if PLATFORM(GTK)
     239    if (messageName == IPC::MessageName::TestWithIfMessage_LoadURL)
     240        return true;
     241#endif
     242#if (ENABLE(TOUCH_EVENTS) && (NESTED_MESSAGE_CONDITION && SOME_OTHER_MESSAGE_CONDITION))
     243    if (messageName == IPC::MessageName::TestWithLegacyReceiver_AddEvent)
     244        return true;
     245#endif
     246    if (messageName == IPC::MessageName::TestWithLegacyReceiver_Close)
     247        return true;
     248    if (messageName == IPC::MessageName::TestWithLegacyReceiver_CreatePlugin)
     249        return true;
     250#if ENABLE(DEPRECATED_FEATURE)
     251    if (messageName == IPC::MessageName::TestWithLegacyReceiver_DeprecatedOperation)
     252        return true;
     253#endif
     254#if PLATFORM(MAC)
     255    if (messageName == IPC::MessageName::TestWithLegacyReceiver_DidCreateWebProcessConnection)
     256        return true;
     257#endif
     258    if (messageName == IPC::MessageName::TestWithLegacyReceiver_DidReceivePolicyDecision)
     259        return true;
     260#if ENABLE(EXPERIMENTAL_FEATURE)
     261    if (messageName == IPC::MessageName::TestWithLegacyReceiver_ExperimentalOperation)
     262        return true;
     263#endif
     264    if (messageName == IPC::MessageName::TestWithLegacyReceiver_GetPluginProcessConnection)
     265        return true;
     266    if (messageName == IPC::MessageName::TestWithLegacyReceiver_GetPlugins)
     267        return true;
     268#if PLATFORM(MAC)
     269    if (messageName == IPC::MessageName::TestWithLegacyReceiver_InterpretKeyEvent)
     270        return true;
     271#endif
    262272#if ENABLE(TOUCH_EVENTS)
    263273    if (messageName == IPC::MessageName::TestWithLegacyReceiver_LoadSomething)
    264274        return true;
    265275#endif
     276#if ENABLE(TOUCH_EVENTS)
     277    if (messageName == IPC::MessageName::TestWithLegacyReceiver_LoadSomethingElse)
     278        return true;
     279#endif
     280    if (messageName == IPC::MessageName::TestWithLegacyReceiver_LoadURL)
     281        return true;
     282    if (messageName == IPC::MessageName::TestWithLegacyReceiver_PreferencesDidChange)
     283        return true;
     284    if (messageName == IPC::MessageName::TestWithLegacyReceiver_RunJavaScriptAlert)
     285        return true;
     286    if (messageName == IPC::MessageName::TestWithLegacyReceiver_SendDoubleAndFloat)
     287        return true;
     288    if (messageName == IPC::MessageName::TestWithLegacyReceiver_SendInts)
     289        return true;
     290    if (messageName == IPC::MessageName::TestWithLegacyReceiver_SetVideoLayerID)
     291        return true;
     292    if (messageName == IPC::MessageName::TestWithLegacyReceiver_TemplateTest)
     293        return true;
     294    if (messageName == IPC::MessageName::TestWithLegacyReceiver_TestMultipleAttributes)
     295        return true;
     296    if (messageName == IPC::MessageName::TestWithLegacyReceiver_TestParameterAttributes)
     297        return true;
    266298#if (ENABLE(TOUCH_EVENTS) && (NESTED_MESSAGE_CONDITION || SOME_OTHER_MESSAGE_CONDITION))
    267299    if (messageName == IPC::MessageName::TestWithLegacyReceiver_TouchEvent)
    268300        return true;
    269301#endif
     302    if (messageName == IPC::MessageName::TestWithSuperclass_LoadURL)
     303        return true;
     304#if ENABLE(TEST_FEATURE)
     305    if (messageName == IPC::MessageName::TestWithSuperclass_TestAsyncMessage)
     306        return true;
     307#endif
     308#if ENABLE(TEST_FEATURE)
     309    if (messageName == IPC::MessageName::TestWithSuperclass_TestAsyncMessageWithConnection)
     310        return true;
     311#endif
     312#if ENABLE(TEST_FEATURE)
     313    if (messageName == IPC::MessageName::TestWithSuperclass_TestAsyncMessageWithMultipleArguments)
     314        return true;
     315#endif
     316#if ENABLE(TEST_FEATURE)
     317    if (messageName == IPC::MessageName::TestWithSuperclass_TestAsyncMessageWithNoArguments)
     318        return true;
     319#endif
     320    if (messageName == IPC::MessageName::TestWithSuperclass_TestSyncMessage)
     321        return true;
     322    if (messageName == IPC::MessageName::TestWithSuperclass_TestSynchronousMessage)
     323        return true;
    270324#if (ENABLE(TOUCH_EVENTS) && (NESTED_MESSAGE_CONDITION && SOME_OTHER_MESSAGE_CONDITION))
    271     if (messageName == IPC::MessageName::TestWithLegacyReceiver_AddEvent)
    272         return true;
    273 #endif
    274 #if ENABLE(TOUCH_EVENTS)
    275     if (messageName == IPC::MessageName::TestWithLegacyReceiver_LoadSomethingElse)
    276         return true;
    277 #endif
    278     if (messageName == IPC::MessageName::TestWithLegacyReceiver_DidReceivePolicyDecision)
    279         return true;
    280     if (messageName == IPC::MessageName::TestWithLegacyReceiver_Close)
    281         return true;
    282     if (messageName == IPC::MessageName::TestWithLegacyReceiver_PreferencesDidChange)
    283         return true;
    284     if (messageName == IPC::MessageName::TestWithLegacyReceiver_SendDoubleAndFloat)
    285         return true;
    286     if (messageName == IPC::MessageName::TestWithLegacyReceiver_SendInts)
    287         return true;
    288     if (messageName == IPC::MessageName::TestWithLegacyReceiver_CreatePlugin)
    289         return true;
    290     if (messageName == IPC::MessageName::TestWithLegacyReceiver_RunJavaScriptAlert)
    291         return true;
    292     if (messageName == IPC::MessageName::TestWithLegacyReceiver_GetPlugins)
    293         return true;
    294     if (messageName == IPC::MessageName::TestWithLegacyReceiver_GetPluginProcessConnection)
    295         return true;
    296     if (messageName == IPC::MessageName::TestWithLegacyReceiver_TestMultipleAttributes)
    297         return true;
    298     if (messageName == IPC::MessageName::TestWithLegacyReceiver_TestParameterAttributes)
    299         return true;
    300     if (messageName == IPC::MessageName::TestWithLegacyReceiver_TemplateTest)
    301         return true;
    302     if (messageName == IPC::MessageName::TestWithLegacyReceiver_SetVideoLayerID)
    303         return true;
     325    if (messageName == IPC::MessageName::TestWithoutAttributes_AddEvent)
     326        return true;
     327#endif
     328    if (messageName == IPC::MessageName::TestWithoutAttributes_Close)
     329        return true;
     330    if (messageName == IPC::MessageName::TestWithoutAttributes_CreatePlugin)
     331        return true;
     332#if ENABLE(DEPRECATED_FEATURE)
     333    if (messageName == IPC::MessageName::TestWithoutAttributes_DeprecatedOperation)
     334        return true;
     335#endif
    304336#if PLATFORM(MAC)
    305     if (messageName == IPC::MessageName::TestWithLegacyReceiver_DidCreateWebProcessConnection)
    306         return true;
    307 #endif
     337    if (messageName == IPC::MessageName::TestWithoutAttributes_DidCreateWebProcessConnection)
     338        return true;
     339#endif
     340    if (messageName == IPC::MessageName::TestWithoutAttributes_DidReceivePolicyDecision)
     341        return true;
     342#if ENABLE(EXPERIMENTAL_FEATURE)
     343    if (messageName == IPC::MessageName::TestWithoutAttributes_ExperimentalOperation)
     344        return true;
     345#endif
     346    if (messageName == IPC::MessageName::TestWithoutAttributes_GetPluginProcessConnection)
     347        return true;
     348    if (messageName == IPC::MessageName::TestWithoutAttributes_GetPlugins)
     349        return true;
    308350#if PLATFORM(MAC)
    309     if (messageName == IPC::MessageName::TestWithLegacyReceiver_InterpretKeyEvent)
    310         return true;
    311 #endif
    312 #if ENABLE(DEPRECATED_FEATURE)
    313     if (messageName == IPC::MessageName::TestWithLegacyReceiver_DeprecatedOperation)
    314         return true;
    315 #endif
    316 #if ENABLE(EXPERIMENTAL_FEATURE)
    317     if (messageName == IPC::MessageName::TestWithLegacyReceiver_ExperimentalOperation)
    318         return true;
    319 #endif
    320     if (messageName == IPC::MessageName::TestWithoutAttributes_LoadURL)
    321         return true;
     351    if (messageName == IPC::MessageName::TestWithoutAttributes_InterpretKeyEvent)
     352        return true;
     353#endif
    322354#if ENABLE(TOUCH_EVENTS)
    323355    if (messageName == IPC::MessageName::TestWithoutAttributes_LoadSomething)
    324356        return true;
    325357#endif
     358#if ENABLE(TOUCH_EVENTS)
     359    if (messageName == IPC::MessageName::TestWithoutAttributes_LoadSomethingElse)
     360        return true;
     361#endif
     362    if (messageName == IPC::MessageName::TestWithoutAttributes_LoadURL)
     363        return true;
     364    if (messageName == IPC::MessageName::TestWithoutAttributes_PreferencesDidChange)
     365        return true;
     366    if (messageName == IPC::MessageName::TestWithoutAttributes_RunJavaScriptAlert)
     367        return true;
     368    if (messageName == IPC::MessageName::TestWithoutAttributes_SendDoubleAndFloat)
     369        return true;
     370    if (messageName == IPC::MessageName::TestWithoutAttributes_SendInts)
     371        return true;
     372    if (messageName == IPC::MessageName::TestWithoutAttributes_SetVideoLayerID)
     373        return true;
     374    if (messageName == IPC::MessageName::TestWithoutAttributes_TemplateTest)
     375        return true;
     376    if (messageName == IPC::MessageName::TestWithoutAttributes_TestMultipleAttributes)
     377        return true;
     378    if (messageName == IPC::MessageName::TestWithoutAttributes_TestParameterAttributes)
     379        return true;
    326380#if (ENABLE(TOUCH_EVENTS) && (NESTED_MESSAGE_CONDITION || SOME_OTHER_MESSAGE_CONDITION))
    327381    if (messageName == IPC::MessageName::TestWithoutAttributes_TouchEvent)
    328382        return true;
    329383#endif
    330 #if (ENABLE(TOUCH_EVENTS) && (NESTED_MESSAGE_CONDITION && SOME_OTHER_MESSAGE_CONDITION))
    331     if (messageName == IPC::MessageName::TestWithoutAttributes_AddEvent)
    332         return true;
    333 #endif
    334 #if ENABLE(TOUCH_EVENTS)
    335     if (messageName == IPC::MessageName::TestWithoutAttributes_LoadSomethingElse)
    336         return true;
    337 #endif
    338     if (messageName == IPC::MessageName::TestWithoutAttributes_DidReceivePolicyDecision)
    339         return true;
    340     if (messageName == IPC::MessageName::TestWithoutAttributes_Close)
    341         return true;
    342     if (messageName == IPC::MessageName::TestWithoutAttributes_PreferencesDidChange)
    343         return true;
    344     if (messageName == IPC::MessageName::TestWithoutAttributes_SendDoubleAndFloat)
    345         return true;
    346     if (messageName == IPC::MessageName::TestWithoutAttributes_SendInts)
    347         return true;
    348     if (messageName == IPC::MessageName::TestWithoutAttributes_CreatePlugin)
    349         return true;
    350     if (messageName == IPC::MessageName::TestWithoutAttributes_RunJavaScriptAlert)
    351         return true;
    352     if (messageName == IPC::MessageName::TestWithoutAttributes_GetPlugins)
    353         return true;
    354     if (messageName == IPC::MessageName::TestWithoutAttributes_GetPluginProcessConnection)
    355         return true;
    356     if (messageName == IPC::MessageName::TestWithoutAttributes_TestMultipleAttributes)
    357         return true;
    358     if (messageName == IPC::MessageName::TestWithoutAttributes_TestParameterAttributes)
    359         return true;
    360     if (messageName == IPC::MessageName::TestWithoutAttributes_TemplateTest)
    361         return true;
    362     if (messageName == IPC::MessageName::TestWithoutAttributes_SetVideoLayerID)
    363         return true;
    364 #if PLATFORM(MAC)
    365     if (messageName == IPC::MessageName::TestWithoutAttributes_DidCreateWebProcessConnection)
    366         return true;
    367 #endif
    368 #if PLATFORM(MAC)
    369     if (messageName == IPC::MessageName::TestWithoutAttributes_InterpretKeyEvent)
    370         return true;
    371 #endif
    372 #if ENABLE(DEPRECATED_FEATURE)
    373     if (messageName == IPC::MessageName::TestWithoutAttributes_DeprecatedOperation)
    374         return true;
    375 #endif
    376 #if ENABLE(EXPERIMENTAL_FEATURE)
    377     if (messageName == IPC::MessageName::TestWithoutAttributes_ExperimentalOperation)
    378         return true;
    379 #endif
     384#if PLATFORM(COCOA)
     385    if (messageName == IPC::MessageName::InitializeConnection)
     386        return true;
     387#endif
     388    if (messageName == IPC::MessageName::LegacySessionState)
     389        return true;
     390    if (messageName == IPC::MessageName::SyncMessageReply)
     391        return true;
    380392    if (messageName == IPC::MessageName::WrappedAsyncMessageForTesting)
    381393        return true;
    382     if (messageName == IPC::MessageName::SyncMessageReply)
    383         return true;
    384     if (messageName == IPC::MessageName::InitializeConnection)
    385         return true;
    386     if (messageName == IPC::MessageName::LegacySessionState)
    387         return true;
     394#if ENABLE(TEST_FEATURE)
     395    if (messageName == IPC::MessageName::TestWithSuperclass_TestAsyncMessageReply)
     396        return true;
     397#endif
     398#if ENABLE(TEST_FEATURE)
     399    if (messageName == IPC::MessageName::TestWithSuperclass_TestAsyncMessageWithConnectionReply)
     400        return true;
     401#endif
     402#if ENABLE(TEST_FEATURE)
     403    if (messageName == IPC::MessageName::TestWithSuperclass_TestAsyncMessageWithMultipleArgumentsReply)
     404        return true;
     405#endif
     406#if ENABLE(TEST_FEATURE)
     407    if (messageName == IPC::MessageName::TestWithSuperclass_TestAsyncMessageWithNoArgumentsReply)
     408        return true;
     409#endif
    388410    return false;
    389411};

  • trunk/Source/WebKit/Scripts/webkit/tests/MessageNames.h

    r271183 r271237  
    3030
    3131enum class ReceiverName : uint8_t {
    32     TestWithSuperclass = 1
     32    TestWithIfMessage = 1
    3333    , TestWithLegacyReceiver = 2
    34     , TestWithoutAttributes = 3
    35     , IPC = 4
    36     , AsyncReply = 5
    37     , Invalid = 6
     34    , TestWithSuperclass = 3
     35    , TestWithoutAttributes = 4
     36    , IPC = 5
     37    , AsyncReply = 6
     38    , Invalid = 7
    3839};
    3940
    4041enum class MessageName : uint16_t {
    41     TestWithLegacyReceiver_AddEvent
     42    TestWithIfMessage_LoadURL
     43    , TestWithLegacyReceiver_AddEvent
    4244    , TestWithLegacyReceiver_Close
    4345    , TestWithLegacyReceiver_CreatePlugin
    … …  
    6365    , TestWithSuperclass_LoadURL
    6466    , TestWithSuperclass_TestAsyncMessage
    65     , TestWithSuperclass_TestAsyncMessageReply
    6667    , TestWithSuperclass_TestAsyncMessageWithConnection
    67     , TestWithSuperclass_TestAsyncMessageWithConnectionReply
    6868    , TestWithSuperclass_TestAsyncMessageWithMultipleArguments
    69     , TestWithSuperclass_TestAsyncMessageWithMultipleArgumentsReply
    7069    , TestWithSuperclass_TestAsyncMessageWithNoArguments
    71     , TestWithSuperclass_TestAsyncMessageWithNoArgumentsReply
    7270    , TestWithSuperclass_TestSyncMessage
    7371    , TestWithSuperclass_TestSynchronousMessage
    … …  
    9492    , TestWithoutAttributes_TestParameterAttributes
    9593    , TestWithoutAttributes_TouchEvent
    96     , WrappedAsyncMessageForTesting
    97     , SyncMessageReply
    9894    , InitializeConnection
    9995    , LegacySessionState
    100     , Last = LegacySessionState
     96    , SyncMessageReply
     97    , WrappedAsyncMessageForTesting
     98    , TestWithSuperclass_TestAsyncMessageReply
     99    , TestWithSuperclass_TestAsyncMessageWithConnectionReply
     100    , TestWithSuperclass_TestAsyncMessageWithMultipleArgumentsReply
     101    , TestWithSuperclass_TestAsyncMessageWithNoArgumentsReply
     102    , Last = TestWithSuperclass_TestAsyncMessageWithNoArgumentsReply
    101103};
    102104
Note: See TracChangeset for help on using the changeset viewer.