def _generate_async_dispatcher_class_for_domain(self, command, domain):
out_parameter_assignments = []
formal_parameters = []
for parameter in command.return_parameters:
param_args = {
'keyedSetMethod': CppGenerator.cpp_setter_method_for_type(parameter.type),
'parameterKey': parameter.parameter_name,
'parameterName': parameter.parameter_name,
'parameterType': CppGenerator.cpp_type_for_stack_in_parameter(parameter),
}
formal_parameters.append('%s %s' % (CppGenerator.cpp_type_for_formal_async_parameter(parameter), parameter.parameter_name))
if parameter.is_optional:
if CppGenerator.should_use_wrapper_for_return_type(parameter.type):
out_parameter_assignments.append(' if (%(parameterName)s.isAssigned())' % param_args)
out_parameter_assignments.append(' jsonMessage->%(keyedSetMethod)s(ASCIILiteral("%(parameterKey)s"), %(parameterName)s.getValue());' % param_args)
else:
out_parameter_assignments.append(' if (%(parameterName)s)' % param_args)
out_parameter_assignments.append(' jsonMessage->%(keyedSetMethod)s(ASCIILiteral("%(parameterKey)s"), %(parameterName)s);' % param_args)
elif parameter.type.is_enum():
out_parameter_assignments.append(' jsonMessage->%(keyedSetMethod)s(ASCIILiteral("%(parameterKey)s"), Inspector::Protocol::getEnumConstantValue(%(parameterName)s));' % param_args)
else:
out_parameter_assignments.append(' jsonMessage->%(keyedSetMethod)s(ASCIILiteral("%(parameterKey)s"), %(parameterName)s);' % param_args)
async_args = {
'domainName': domain.domain_name,
'callbackName': ucfirst(command.command_name) + 'Callback',
'formalParameters': ", ".join(formal_parameters),
'outParameterAssignments': "\n".join(out_parameter_assignments)
}
return Template(CppTemplates.BackendDispatcherImplementationAsyncCommand).substitute(None, **async_args)
def _generate_event_out_parameters(self, domain, event):
lines = []
lines.append(
' Ref<JSON::Object> paramsObject = JSON::Object::create();')
for parameter in event.event_parameters:
keyed_set_method = CppGenerator.cpp_setter_method_for_type(
parameter.type)
var_name = parameter.parameter_name
safe_var_name = '(*%s)' % var_name if parameter.is_optional else var_name
export_expression = self.objc_protocol_export_expression_for_variable(
parameter.type, safe_var_name)
if not parameter.is_optional:
lines.append(' paramsObject->%s(ASCIILiteral("%s"), %s);' %
(keyed_set_method, parameter.parameter_name,
export_expression))
else:
lines.append(' if (%s)' % (parameter.parameter_name))
lines.append(
' paramsObject->%s(ASCIILiteral("%s"), %s);' %
(keyed_set_method, parameter.parameter_name,
export_expression))
lines.append(
' jsonMessage->setObject(ASCIILiteral("params"), WTFMove(paramsObject));'
)
return lines
def _generate_builder_setter_for_member(self, type_member, domain):
setter_args = {
'camelName': ucfirst(type_member.member_name),
'keyedSet':
CppGenerator.cpp_setter_method_for_type(type_member.type),
'name': type_member.member_name,
'parameterType':
CppGenerator.cpp_type_for_type_member(type_member),
'helpersNamespace': self.helpers_namespace(),
}
lines = []
lines.append('')
lines.append(
' Builder<STATE | %(camelName)sSet>& set%(camelName)s(%(parameterType)s value)'
% setter_args)
lines.append(' {')
lines.append(
' COMPILE_ASSERT(!(STATE & %(camelName)sSet), property_%(name)s_already_set);'
% setter_args)
if isinstance(type_member.type, EnumType):
lines.append(
' m_result->%(keyedSet)s("%(name)s"_s, Inspector::Protocol::%(helpersNamespace)s::getEnumConstantValue(value));'
% setter_args)
else:
lines.append(
' m_result->%(keyedSet)s("%(name)s"_s, value);' %
setter_args)
lines.append(' return castState<%(camelName)sSet>();' %
setter_args)
lines.append(' }')
return '\n'.join(lines)
def _generate_unchecked_setter_for_member(self, type_member, domain):
setter_args = {
'camelName': ucfirst(type_member.member_name),
'keyedSet':
CppGenerator.cpp_setter_method_for_type(type_member.type),
'name': type_member.member_name,
'parameterType':
CppGenerator.cpp_type_for_type_member(type_member),
'helpersNamespace': self.helpers_namespace(),
}
lines = []
lines.append('')
lines.append(' void set%(camelName)s(%(parameterType)s value)' %
setter_args)
lines.append(' {')
if isinstance(type_member.type, EnumType):
lines.append(
' JSON::ObjectBase::%(keyedSet)s("%(name)s"_s, Inspector::Protocol::%(helpersNamespace)s::getEnumConstantValue(value));'
% setter_args)
elif CppGenerator.should_use_references_for_type(type_member.type):
lines.append(
' JSON::ObjectBase::%(keyedSet)s("%(name)s"_s, WTFMove(value));'
% setter_args)
else:
lines.append(
' JSON::ObjectBase::%(keyedSet)s("%(name)s"_s, value);'
% setter_args)
lines.append(' }')
return '\n'.join(lines)
def _generate_async_dispatcher_class_for_domain(self, command, domain):
out_parameter_assignments = []
formal_parameters = []
for parameter in command.return_parameters:
param_args = {
'keyedSetMethod': CppGenerator.cpp_setter_method_for_type(parameter.type),
'parameterKey': parameter.parameter_name,
'parameterName': parameter.parameter_name,
'parameterType': CppGenerator.cpp_type_for_stack_in_parameter(parameter),
'helpersNamespace': self.helpers_namespace(),
}
formal_parameters.append('%s %s' % (CppGenerator.cpp_type_for_formal_async_parameter(parameter), parameter.parameter_name))
if parameter.is_optional:
if CppGenerator.should_use_wrapper_for_return_type(parameter.type):
out_parameter_assignments.append(' if (%(parameterName)s.has_value())' % param_args)
out_parameter_assignments.append(' jsonMessage->%(keyedSetMethod)s("%(parameterKey)s"_s, *%(parameterName)s);' % param_args)
else:
out_parameter_assignments.append(' if (%(parameterName)s)' % param_args)
out_parameter_assignments.append(' jsonMessage->%(keyedSetMethod)s("%(parameterKey)s"_s, %(parameterName)s);' % param_args)
elif parameter.type.is_enum():
out_parameter_assignments.append(' jsonMessage->%(keyedSetMethod)s("%(parameterKey)s"_s, Inspector::Protocol::%(helpersNamespace)s::getEnumConstantValue(%(parameterName)s));' % param_args)
else:
out_parameter_assignments.append(' jsonMessage->%(keyedSetMethod)s("%(parameterKey)s"_s, %(parameterName)s);' % param_args)
async_args = {
'domainName': domain.domain_name,
'callbackName': ucfirst(command.command_name) + 'Callback',
'formalParameters': ", ".join(formal_parameters),
'outParameterAssignments': "\n".join(out_parameter_assignments)
}
return Template(CppTemplates.BackendDispatcherImplementationAsyncCommand).substitute(None, **async_args)
def _generate_unchecked_setter_for_member(self, type_member, domain):
setter_args = {
'camelName': ucfirst(type_member.member_name),
'keyedSet':
CppGenerator.cpp_setter_method_for_type(type_member.type),
'name': type_member.member_name,
'parameterType': CppGenerator.cpp_type_for_type_member(type_member)
}
lines = []
lines.append('')
lines.append(' void set%(camelName)s(%(parameterType)s value)' %
setter_args)
lines.append(' {')
if isinstance(type_member.type, EnumType):
lines.append(
' InspectorObjectBase::%(keyedSet)s(ASCIILiteral("%(name)s"), Inspector::Protocol::getEnumConstantValue(static_cast<int>(value)));'
% setter_args)
elif CppGenerator.should_use_references_for_type(type_member.type):
lines.append(
' InspectorObjectBase::%(keyedSet)s(ASCIILiteral("%(name)s"), WTF::move(value));'
% setter_args)
else:
lines.append(
' InspectorObjectBase::%(keyedSet)s(ASCIILiteral("%(name)s"), value);'
% setter_args)
lines.append(' }')
return '\n'.join(lines)
def _generate_success_block_for_command(self, domain, command):
lines = []
if command.return_parameters:
success_block_parameters = []
for parameter in command.return_parameters:
out_param_name = parameter.parameter_name
if parameter.is_optional:
out_param_name = 'opt_' + out_param_name
out_param_name = 'out_' + out_param_name
objc_type = self.objc_type_for_param(domain, command.command_name, parameter)
success_block_parameters.append(join_type_and_name(objc_type, out_param_name))
lines.append(' id successCallback = ^(%s) {' % ', '.join(success_block_parameters))
else:
lines.append(' id successCallback = ^{')
lines.append(' auto protocol_jsonMessage = JSON::Object::create();')
if command.return_parameters:
required_pointer_parameters = [parameter for parameter in command.return_parameters if not parameter.is_optional and ObjCGenerator.is_type_objc_pointer_type(parameter.type)]
for parameter in required_pointer_parameters:
out_param_name = parameter.parameter_name
if parameter.is_optional:
out_param_name = 'opt_' + out_param_name
out_param_name = 'out_' + out_param_name
lines.append(' THROW_EXCEPTION_FOR_REQUIRED_PARAMETER(%s, @"%s");' % (out_param_name, parameter.parameter_name))
objc_array_class = self.objc_class_for_array_type(parameter.type)
if objc_array_class and objc_array_class.startswith(self.objc_prefix()):
lines.append(' THROW_EXCEPTION_FOR_BAD_TYPE_IN_ARRAY(%s, [%s class]);' % (out_param_name, objc_array_class))
optional_pointer_parameters = [parameter for parameter in command.return_parameters if parameter.is_optional and ObjCGenerator.is_type_objc_pointer_type(parameter.type)]
for parameter in optional_pointer_parameters:
out_param_name = parameter.parameter_name
if parameter.is_optional:
out_param_name = 'opt_' + out_param_name
out_param_name = 'out_' + out_param_name
lines.append(' THROW_EXCEPTION_FOR_BAD_OPTIONAL_PARAMETER(%s, @"%s");' % (out_param_name, parameter.parameter_name))
objc_array_class = self.objc_class_for_array_type(parameter.type)
if objc_array_class and objc_array_class.startswith(self.objc_prefix()):
lines.append(' THROW_EXCEPTION_FOR_BAD_TYPE_IN_OPTIONAL_ARRAY(%s, [%s class]);' % (out_param_name, objc_array_class))
for parameter in command.return_parameters:
out_param_name = parameter.parameter_name
if parameter.is_optional:
out_param_name = 'opt_' + out_param_name
out_param_name = 'out_' + out_param_name
keyed_set_method = CppGenerator.cpp_setter_method_for_type(parameter.type)
var_expression = '*%s' % out_param_name if parameter.is_optional else out_param_name
export_expression = self.objc_protocol_export_expression_for_variable(parameter.type, var_expression)
if not parameter.is_optional:
lines.append(' protocol_jsonMessage->%s("%s"_s, %s);' % (keyed_set_method, parameter.parameter_name, export_expression))
else:
lines.append(' if (!!%s)' % out_param_name)
lines.append(' protocol_jsonMessage->%s("%s"_s, %s);' % (keyed_set_method, parameter.parameter_name, export_expression))
lines.append(' backendDispatcher()->sendResponse(protocol_requestId, WTFMove(protocol_jsonMessage), false);')
lines.append(' };')
return '\n'.join(lines)
def _generate_event_out_parameters(self, domain, event):
lines = []
lines.append(' RefPtr<InspectorObject> paramsObject = InspectorObject::create();')
for parameter in event.event_parameters:
keyed_set_method = CppGenerator.cpp_setter_method_for_type(parameter.type)
var_name = parameter.parameter_name
safe_var_name = '(*%s)' % var_name if parameter.is_optional else var_name
export_expression = ObjCGenerator.objc_protocol_export_expression_for_variable(parameter.type, safe_var_name)
if not parameter.is_optional:
lines.append(' paramsObject->%s(ASCIILiteral("%s"), %s);' % (keyed_set_method, parameter.parameter_name, export_expression))
else:
lines.append(' if (%s)' % (parameter.parameter_name))
lines.append(' paramsObject->%s(ASCIILiteral("%s"), %s);' % (keyed_set_method, parameter.parameter_name, export_expression))
lines.append(' jsonMessage->setObject(ASCIILiteral("params"), paramsObject);')
return lines
def _generate_dispatcher_implementation_for_event(self, event, domain):
lines = []
parameter_assignments = []
formal_parameters = []
for parameter in event.event_parameters:
parameter_value = parameter.parameter_name
if parameter.is_optional and not CppGenerator.should_pass_by_copy_for_return_type(parameter.type):
parameter_value = '*' + parameter_value
if parameter.type.is_enum():
parameter_value = 'Inspector::Protocol::%s::getEnumConstantValue(%s)' % (self.helpers_namespace(), parameter_value)
parameter_args = {
'parameterType': CppGenerator.cpp_type_for_stack_out_parameter(parameter),
'parameterName': parameter.parameter_name,
'parameterValue': parameter_value,
'keyedSetMethod': CppGenerator.cpp_setter_method_for_type(parameter.type),
}
if parameter.is_optional:
parameter_assignments.append(' if (%(parameterName)s)' % parameter_args)
parameter_assignments.append(' paramsObject->%(keyedSetMethod)s(ASCIILiteral("%(parameterName)s"), %(parameterValue)s);' % parameter_args)
else:
parameter_assignments.append(' paramsObject->%(keyedSetMethod)s(ASCIILiteral("%(parameterName)s"), %(parameterValue)s);' % parameter_args)
formal_parameters.append('%s %s' % (CppGenerator.cpp_type_for_checked_formal_event_parameter(parameter), parameter.parameter_name))
event_args = {
'domainName': domain.domain_name,
'eventName': event.event_name,
'formalParameters': ", ".join(formal_parameters)
}
lines.append('void %(domainName)sFrontendDispatcher::%(eventName)s(%(formalParameters)s)' % event_args)
lines.append('{')
lines.append(' Ref<InspectorObject> jsonMessage = InspectorObject::create();')
lines.append(' jsonMessage->setString(ASCIILiteral("method"), ASCIILiteral("%(domainName)s.%(eventName)s"));' % event_args)
if len(parameter_assignments) > 0:
lines.append(' Ref<InspectorObject> paramsObject = InspectorObject::create();')
lines.extend(parameter_assignments)
lines.append(' jsonMessage->setObject(ASCIILiteral("params"), WTFMove(paramsObject));')
lines.append('')
lines.append(' m_frontendRouter.sendEvent(jsonMessage->toJSONString());')
lines.append('}')
return "\n".join(lines)
def _generate_dispatcher_implementation_for_event(self, event, domain):
lines = []
parameter_assignments = []
formal_parameters = []
for parameter in event.event_parameters:
parameter_value = parameter.parameter_name
if parameter.is_optional and not CppGenerator.should_pass_by_copy_for_return_type(parameter.type):
parameter_value = '*' + parameter_value
if parameter.type.is_enum():
parameter_value = 'Inspector::Protocol::%s::getEnumConstantValue(%s)' % (self.helpers_namespace(), parameter_value)
parameter_args = {
'parameterType': CppGenerator.cpp_type_for_stack_out_parameter(parameter),
'parameterName': parameter.parameter_name,
'parameterValue': parameter_value,
'keyedSetMethod': CppGenerator.cpp_setter_method_for_type(parameter.type),
}
if parameter.is_optional:
parameter_assignments.append(' if (%(parameterName)s)' % parameter_args)
parameter_assignments.append(' paramsObject->%(keyedSetMethod)s(ASCIILiteral("%(parameterName)s"), %(parameterValue)s);' % parameter_args)
else:
parameter_assignments.append(' paramsObject->%(keyedSetMethod)s(ASCIILiteral("%(parameterName)s"), %(parameterValue)s);' % parameter_args)
formal_parameters.append('%s %s' % (CppGenerator.cpp_type_for_checked_formal_event_parameter(parameter), parameter.parameter_name))
event_args = {
'domainName': domain.domain_name,
'eventName': event.event_name,
'formalParameters': ", ".join(formal_parameters)
}
lines.append('void %(domainName)sFrontendDispatcher::%(eventName)s(%(formalParameters)s)' % event_args)
lines.append('{')
lines.append(' Ref<InspectorObject> jsonMessage = InspectorObject::create();')
lines.append(' jsonMessage->setString(ASCIILiteral("method"), ASCIILiteral("%(domainName)s.%(eventName)s"));' % event_args)
if len(parameter_assignments) > 0:
lines.append(' Ref<InspectorObject> paramsObject = InspectorObject::create();')
lines.extend(parameter_assignments)
lines.append(' jsonMessage->setObject(ASCIILiteral("params"), WTFMove(paramsObject));')
lines.append('')
lines.append(' m_frontendRouter.sendEvent(jsonMessage->toJSONString());')
lines.append('}')
return "\n".join(lines)
def _generate_success_block_for_command(self, domain, command):
lines = []
if command.return_parameters:
success_block_parameters = []
for parameter in command.return_parameters:
objc_type = ObjCGenerator.objc_type_for_param(domain, command.command_name, parameter)
var_name = ObjCGenerator.identifier_to_objc_identifier(parameter.parameter_name)
success_block_parameters.append(join_type_and_name(objc_type, var_name))
lines.append(' id successCallback = ^(%s) {' % ', '.join(success_block_parameters))
else:
lines.append(' id successCallback = ^{')
if command.return_parameters:
lines.append(' Ref<InspectorObject> resultObject = InspectorObject::create();')
required_pointer_parameters = filter(lambda parameter: not parameter.is_optional and ObjCGenerator.is_type_objc_pointer_type(parameter.type), command.return_parameters)
for parameter in required_pointer_parameters:
var_name = ObjCGenerator.identifier_to_objc_identifier(parameter.parameter_name)
lines.append(' THROW_EXCEPTION_FOR_REQUIRED_PARAMETER(%s, @"%s");' % (var_name, var_name))
objc_array_class = ObjCGenerator.objc_class_for_array_type(parameter.type)
if objc_array_class and objc_array_class.startswith(ObjCGenerator.OBJC_PREFIX):
lines.append(' THROW_EXCEPTION_FOR_BAD_TYPE_IN_ARRAY(%s, [%s class]);' % (var_name, objc_array_class))
optional_pointer_parameters = filter(lambda parameter: parameter.is_optional and ObjCGenerator.is_type_objc_pointer_type(parameter.type), command.return_parameters)
for parameter in optional_pointer_parameters:
var_name = ObjCGenerator.identifier_to_objc_identifier(parameter.parameter_name)
lines.append(' THROW_EXCEPTION_FOR_BAD_OPTIONAL_PARAMETER(%s, @"%s");' % (var_name, var_name))
objc_array_class = ObjCGenerator.objc_class_for_array_type(parameter.type)
if objc_array_class and objc_array_class.startswith(ObjCGenerator.OBJC_PREFIX):
lines.append(' THROW_EXCEPTION_FOR_BAD_TYPE_IN_OPTIONAL_ARRAY(%s, [%s class]);' % (var_name, objc_array_class))
for parameter in command.return_parameters:
keyed_set_method = CppGenerator.cpp_setter_method_for_type(parameter.type)
var_name = ObjCGenerator.identifier_to_objc_identifier(parameter.parameter_name)
var_expression = '*%s' % var_name if parameter.is_optional else var_name
export_expression = ObjCGenerator.objc_protocol_export_expression_for_variable(parameter.type, var_expression)
if not parameter.is_optional:
lines.append(' resultObject->%s(ASCIILiteral("%s"), %s);' % (keyed_set_method, parameter.parameter_name, export_expression))
else:
lines.append(' if (%s)' % var_name)
lines.append(' resultObject->%s(ASCIILiteral("%s"), %s);' % (keyed_set_method, parameter.parameter_name, export_expression))
lines.append(' backendDispatcher()->sendResponse(requestId, WTF::move(resultObject));')
else:
lines.append(' backendDispatcher()->sendResponse(requestId, InspectorObject::create());')
lines.append(' };')
return '\n'.join(lines)
def _generate_unchecked_setter_for_member(self, type_member, domain):
setter_args = {
'camelName': ucfirst(type_member.member_name),
'keyedSet': CppGenerator.cpp_setter_method_for_type(type_member.type),
'name': type_member.member_name,
'parameterType': CppGenerator.cpp_type_for_type_member(type_member)
}
lines = []
lines.append('')
lines.append(' void set%(camelName)s(%(parameterType)s value)' % setter_args)
lines.append(' {')
if isinstance(type_member.type, EnumType):
lines.append(' InspectorObjectBase::%(keyedSet)s(ASCIILiteral("%(name)s"), Inspector::Protocol::getEnumConstantValue(static_cast<int>(value)));' % setter_args)
else:
lines.append(' InspectorObjectBase::%(keyedSet)s(ASCIILiteral("%(name)s"), value);' % setter_args)
lines.append(' }')
return '\n'.join(lines)
def _generate_builder_setter_for_member(self, type_member, domain):
member_name = 'in_' + type_member.member_name
member_value = member_name
if type_member.type.is_enum():
member_value = 'Protocol::%s::getEnumConstantValue(%s)' % (
self.helpers_namespace(), member_value)
elif CppGenerator.should_move_argument(type_member.type, False):
member_value = 'WTFMove(%s)' % member_value
setter_args = {
'camelName':
ucfirst(type_member.member_name),
'setter':
CppGenerator.cpp_setter_method_for_type(type_member.type),
'memberType':
CppGenerator.cpp_type_for_type_member_argument(
type_member.type, type_member.member_name),
'memberKey':
type_member.member_name,
'memberName':
member_name,
'memberValue':
member_value,
}
lines = []
lines.append('')
lines.append(
' Builder<STATE | %(camelName)sSet>& set%(camelName)s(%(memberType)s %(memberName)s)'
% setter_args)
lines.append(' {')
lines.append(
' COMPILE_ASSERT(!(STATE & %(camelName)sSet), property_%(memberKey)s_already_set);'
% setter_args)
lines.append(
' m_result->%(setter)s("%(memberKey)s"_s, %(memberValue)s);'
% setter_args)
lines.append(' return castState<%(camelName)sSet>();' %
setter_args)
lines.append(' }')
return '\n'.join(lines)
def _generate_unchecked_setter_for_member(self, type_member, domain):
setter_args = {
'camelName': ucfirst(type_member.member_name),
'keyedSet': CppGenerator.cpp_setter_method_for_type(type_member.type),
'name': type_member.member_name,
'parameterType': CppGenerator.cpp_type_for_type_member(type_member),
'helpersNamespace': self.helpers_namespace(),
}
lines = []
lines.append('')
lines.append(' void set%(camelName)s(%(parameterType)s value)' % setter_args)
lines.append(' {')
if isinstance(type_member.type, EnumType):
lines.append(' JSON::ObjectBase::%(keyedSet)s("%(name)s"_s, Inspector::Protocol::%(helpersNamespace)s::getEnumConstantValue(value));' % setter_args)
elif CppGenerator.should_use_references_for_type(type_member.type):
lines.append(' JSON::ObjectBase::%(keyedSet)s("%(name)s"_s, WTFMove(value));' % setter_args)
else:
lines.append(' JSON::ObjectBase::%(keyedSet)s("%(name)s"_s, value);' % setter_args)
lines.append(' }')
return '\n'.join(lines)
def _generate_builder_setter_for_member(self, type_member, domain):
setter_args = {
'camelName': ucfirst(type_member.member_name),
'keyedSet': CppGenerator.cpp_setter_method_for_type(type_member.type),
'name': type_member.member_name,
'parameterType': CppGenerator.cpp_type_for_type_member(type_member)
}
lines = []
lines.append('')
lines.append(' Builder<STATE | %(camelName)sSet>& set%(camelName)s(%(parameterType)s value)' % setter_args)
lines.append(' {')
lines.append(' COMPILE_ASSERT(!(STATE & %(camelName)sSet), property_%(name)s_already_set);' % setter_args)
if isinstance(type_member.type, EnumType):
lines.append(' m_result->%(keyedSet)s(ASCIILiteral("%(name)s"), Inspector::Protocol::getEnumConstantValue(static_cast<int>(value)));' % setter_args)
else:
lines.append(' m_result->%(keyedSet)s(ASCIILiteral("%(name)s"), value);' % setter_args)
lines.append(' return castState<%(camelName)sSet>();' % setter_args)
lines.append(' }')
return '\n'.join(lines)
def _generate_unchecked_setter_for_member(self, type_member, domain):
member_name = 'in_opt_' + type_member.member_name
member_value = member_name
if type_member.type.is_enum():
member_value = 'Protocol::%s::getEnumConstantValue(%s)' % (
self.helpers_namespace(), member_value)
elif CppGenerator.should_move_argument(type_member.type, False):
member_value = 'WTFMove(%s)' % member_value
setter_args = {
'camelName':
ucfirst(type_member.member_name),
'setter':
CppGenerator.cpp_setter_method_for_type(type_member.type),
'memberKey':
type_member.member_name,
'memberName':
member_name,
'memberValue':
member_value,
'memberType':
CppGenerator.cpp_type_for_type_member_argument(
type_member.type, type_member.member_name),
}
lines = []
lines.append('')
lines.append(
' void set%(camelName)s(%(memberType)s %(memberName)s)' %
setter_args)
lines.append(' {')
lines.append(
' JSON::ObjectBase::%(setter)s("%(memberKey)s"_s, %(memberValue)s);'
% setter_args)
lines.append(' }')
return '\n'.join(lines)
def _generate_dispatcher_implementation_for_command(self, command, domain):
parameter_declarations = []
parameter_enum_resolutions = []
alternate_dispatcher_method_parameters = ['protocol_requestId']
method_parameters = []
for parameter in command.call_parameters:
parameter_name = parameter.parameter_name
if parameter.is_optional:
parameter_name = 'opt_' + parameter_name
parameter_name = 'in_' + parameter_name
variable_name = parameter_name
_type = parameter.type
if isinstance(_type, AliasedType):
_type = _type.aliased_type
if isinstance(_type, EnumType) and _type.is_anonymous:
_type = _type.primitive_type
if _type.is_enum():
parameter_name = parameter_name + '_json'
alternate_dispatcher_method_parameters.append(parameter_name)
enum_args = {
'helpersNamespace': self.helpers_namespace(),
'parameterKey': parameter.parameter_name,
'enumType': CppGenerator.cpp_protocol_type_for_type(_type),
'enumVariableName': variable_name,
'stringVariableName': parameter_name,
}
if len(parameter_enum_resolutions):
parameter_enum_resolutions.append('')
parameter_enum_resolutions.append(
' auto %(enumVariableName)s = Protocol::%(helpersNamespace)s::parseEnumValueFromString<%(enumType)s>(%(stringVariableName)s);'
% enum_args)
if parameter.is_optional:
parameter_expression = 'WTFMove(%s)' % variable_name
else:
parameter_enum_resolutions.append(
' if (!%(enumVariableName)s) {' % enum_args)
parameter_enum_resolutions.append(
' m_backendDispatcher->reportProtocolError(BackendDispatcher::ServerError, makeString("Unknown %(parameterKey)s: "_s, %(stringVariableName)s));'
% enum_args)
parameter_enum_resolutions.append(' return;')
parameter_enum_resolutions.append(' }')
parameter_expression = '*' + variable_name
else:
if _type.raw_name() == 'string':
parameter_expression = variable_name
elif parameter.is_optional:
parameter_expression = 'WTFMove(%s)' % variable_name
elif _type.raw_name() in ['boolean', 'integer', 'number']:
parameter_expression = '*' + variable_name
else:
parameter_expression = variable_name + '.releaseNonNull()'
alternate_dispatcher_method_parameters.append(
parameter_expression)
method_parameters.append(parameter_expression)
param_args = {
'parameterKey': parameter.parameter_name,
'parameterName': parameter_name,
'keyedGetMethod':
CppGenerator.cpp_getter_method_for_type(_type),
'required': 'false' if parameter.is_optional else 'true',
}
parameter_declarations.append(
' auto %(parameterName)s = m_backendDispatcher->%(keyedGetMethod)s(protocol_parameters.get(), "%(parameterKey)s"_s, %(required)s);'
% param_args)
if command.is_async:
method_parameters.append(
'adoptRef(*new %sBackendDispatcherHandler::%s(m_backendDispatcher.copyRef(), protocol_requestId))'
% (domain.domain_name,
'%sCallback' % ucfirst(command.command_name)))
command_args = {
'domainName':
domain.domain_name,
'commandName':
command.command_name,
'parameterDeclarations':
'\n'.join(parameter_declarations),
'invocationParameters':
', '.join(method_parameters),
'alternateInvocationParameters':
', '.join(alternate_dispatcher_method_parameters),
}
lines = []
if len(command.call_parameters) == 0:
lines.append(
'void %(domainName)sBackendDispatcher::%(commandName)s(long protocol_requestId, RefPtr<JSON::Object>&&)'
% command_args)
else:
lines.append(
'void %(domainName)sBackendDispatcher::%(commandName)s(long protocol_requestId, RefPtr<JSON::Object>&& protocol_parameters)'
% command_args)
lines.append('{')
if len(command.call_parameters) > 0:
lines.append(
Template(CppTemplates.
BackendDispatcherImplementationPrepareCommandArguments
).substitute(None, **command_args))
if self.model().framework.setting('alternate_dispatchers', False):
lines.append('#if ENABLE(INSPECTOR_ALTERNATE_DISPATCHERS)')
lines.append(' if (m_alternateDispatcher) {')
lines.append(
' m_alternateDispatcher->%(commandName)s(%(alternateInvocationParameters)s);'
% command_args)
lines.append(' return;')
lines.append(' }')
lines.append('#endif // ENABLE(INSPECTOR_ALTERNATE_DISPATCHERS)')
lines.append('')
if len(parameter_enum_resolutions):
lines.extend(parameter_enum_resolutions)
lines.append('')
if command.is_async:
lines.append(
' m_agent->%(commandName)s(%(invocationParameters)s);' %
command_args)
else:
result_destructured_names = []
result_conversion_lines = []
for parameter in command.return_parameters:
parameter_name = parameter.parameter_name
if parameter.is_optional:
parameter_name = 'opt_' + parameter_name
parameter_name = 'out_' + parameter_name
result_destructured_names.append(parameter_name)
parameter_value = parameter_name
_type = parameter.type
if isinstance(_type, AliasedType):
_type = _type.aliased_type
if isinstance(_type, EnumType) and _type.is_anonymous:
_type = _type.primitive_type
if _type.is_enum():
if parameter.is_optional:
parameter_value = '*' + parameter_value
parameter_value = 'Protocol::%s::getEnumConstantValue(%s)' % (
self.helpers_namespace(), parameter_value)
elif CppGenerator.should_release_argument(
_type, parameter.is_optional):
parameter_value = parameter_value + '.releaseNonNull()'
elif CppGenerator.should_dereference_argument(
_type, parameter.is_optional):
parameter_value = '*' + parameter_value
elif CppGenerator.should_move_argument(_type,
parameter.is_optional):
parameter_value = 'WTFMove(%s)' % parameter_value
param_args = {
'keyedSetMethod':
CppGenerator.cpp_setter_method_for_type(_type),
'parameterKey':
parameter.parameter_name,
'parameterName':
parameter_name,
'parameterValue':
parameter_value,
}
if parameter.is_optional:
result_conversion_lines.append(
' if (!!%(parameterName)s)' % param_args)
result_conversion_lines.append(
' protocol_jsonMessage->%(keyedSetMethod)s("%(parameterKey)s"_s, %(parameterValue)s);'
% param_args)
else:
result_conversion_lines.append(
' protocol_jsonMessage->%(keyedSetMethod)s("%(parameterKey)s"_s, %(parameterValue)s);'
% param_args)
lines.append(
' auto result = m_agent->%(commandName)s(%(invocationParameters)s);'
% command_args)
lines.append(' if (!result) {')
lines.append(' ASSERT(!result.error().isEmpty());')
lines.append(
' m_backendDispatcher->reportProtocolError(BackendDispatcher::ServerError, result.error());'
)
lines.append(' return;')
lines.append(' }')
lines.append('')
if len(result_destructured_names) == 1:
lines.append(' auto %s = WTFMove(result.value());' %
result_destructured_names[0])
lines.append('')
elif len(result_destructured_names) > 1:
lines.append(' auto [%s] = WTFMove(result.value());' %
", ".join(result_destructured_names))
lines.append('')
lines.append(
' auto protocol_jsonMessage = JSON::Object::create();')
lines.extend(result_conversion_lines)
lines.append(
' m_backendDispatcher->sendResponse(protocol_requestId, WTFMove(protocol_jsonMessage), false);'
)
lines.append('}')
return self.wrap_with_guard_for_condition(command.condition,
"\n".join(lines))
def _generate_dispatcher_implementation_for_command(self, command, domain):
in_parameter_declarations = []
out_parameter_declarations = []
out_parameter_assignments = []
alternate_dispatcher_method_parameters = ['requestId']
method_parameters = ['error']
for parameter in command.call_parameters:
parameter_name = 'in_' + parameter.parameter_name
if parameter.is_optional:
parameter_name = 'opt_' + parameter_name
out_success_argument = 'nullptr'
if parameter.is_optional:
out_success_argument = '&%s_valueFound' % parameter_name
in_parameter_declarations.append(
' bool %s_valueFound = false;' % parameter_name)
# Now add appropriate operators.
parameter_expression = parameter_name
if CppGenerator.should_use_references_for_type(parameter.type):
if parameter.is_optional:
parameter_expression = '%s.get()' % parameter_expression
else:
# This assumes that we have already proved the object is non-null.
# If a required property is missing, InspectorBackend::getObject will
# append a protocol error, and the method dispatcher will return without
# invoking the backend method (and dereferencing the object).
parameter_expression = '*%s' % parameter_expression
elif parameter.is_optional:
parameter_expression = '&%s' % parameter_expression
param_args = {
'parameterType':
CppGenerator.cpp_type_for_stack_in_parameter(parameter),
'parameterKey':
parameter.parameter_name,
'parameterName':
parameter_name,
'parameterExpression':
parameter_expression,
'keyedGetMethod':
CppGenerator.cpp_getter_method_for_type(parameter.type),
'successOutParam':
out_success_argument
}
in_parameter_declarations.append(
' %(parameterType)s %(parameterName)s = m_backendDispatcher->%(keyedGetMethod)s(parameters.get(), ASCIILiteral("%(parameterKey)s"), %(successOutParam)s);'
% param_args)
if parameter.is_optional:
optional_in_parameter_string = '%(parameterName)s_valueFound ? %(parameterExpression)s : nullptr' % param_args
alternate_dispatcher_method_parameters.append(
optional_in_parameter_string)
method_parameters.append(optional_in_parameter_string)
else:
alternate_dispatcher_method_parameters.append(
parameter_expression)
method_parameters.append(parameter_expression)
if command.is_async:
async_args = {
'domainName': domain.domain_name,
'callbackName': ucfirst(command.command_name) + 'Callback'
}
out_parameter_assignments.append(' callback->disable();')
out_parameter_assignments.append(
' m_backendDispatcher->reportProtocolError(BackendDispatcher::ServerError, error);'
)
out_parameter_assignments.append(' return;')
method_parameters.append('callback.copyRef()')
else:
for parameter in command.return_parameters:
param_args = {
'parameterType':
CppGenerator.cpp_type_for_stack_out_parameter(parameter),
'parameterKey':
parameter.parameter_name,
'parameterName':
parameter.parameter_name,
'keyedSetMethod':
CppGenerator.cpp_setter_method_for_type(parameter.type),
'helpersNamespace':
self.helpers_namespace(),
}
out_parameter_declarations.append(
' %(parameterType)s out_%(parameterName)s;' %
param_args)
if parameter.is_optional:
if CppGenerator.should_use_wrapper_for_return_type(
parameter.type):
out_parameter_assignments.append(
' if (out_%(parameterName)s.isAssigned())' %
param_args)
out_parameter_assignments.append(
' result->%(keyedSetMethod)s(ASCIILiteral("%(parameterKey)s"), out_%(parameterName)s.getValue());'
% param_args)
else:
out_parameter_assignments.append(
' if (out_%(parameterName)s)' % param_args)
out_parameter_assignments.append(
' result->%(keyedSetMethod)s(ASCIILiteral("%(parameterKey)s"), out_%(parameterName)s);'
% param_args)
elif parameter.type.is_enum():
out_parameter_assignments.append(
' result->%(keyedSetMethod)s(ASCIILiteral("%(parameterKey)s"), Inspector::Protocol::%(helpersNamespace)s::getEnumConstantValue(out_%(parameterName)s));'
% param_args)
else:
out_parameter_assignments.append(
' result->%(keyedSetMethod)s(ASCIILiteral("%(parameterKey)s"), out_%(parameterName)s);'
% param_args)
if CppGenerator.should_pass_by_copy_for_return_type(
parameter.type):
method_parameters.append('out_' + parameter.parameter_name)
else:
method_parameters.append('&out_' +
parameter.parameter_name)
command_args = {
'domainName':
domain.domain_name,
'callbackName':
'%sCallback' % ucfirst(command.command_name),
'commandName':
command.command_name,
'inParameterDeclarations':
'\n'.join(in_parameter_declarations),
'invocationParameters':
', '.join(method_parameters),
'alternateInvocationParameters':
', '.join(alternate_dispatcher_method_parameters),
}
lines = []
if len(command.call_parameters) == 0:
lines.append(
'void %(domainName)sBackendDispatcher::%(commandName)s(long requestId, RefPtr<InspectorObject>&&)'
% command_args)
else:
lines.append(
'void %(domainName)sBackendDispatcher::%(commandName)s(long requestId, RefPtr<InspectorObject>&& parameters)'
% command_args)
lines.append('{')
if len(command.call_parameters) > 0:
lines.append(
Template(CppTemplates.
BackendDispatcherImplementationPrepareCommandArguments
).substitute(None, **command_args))
if self.model().framework.setting('alternate_dispatchers', False):
lines.append('#if ENABLE(INSPECTOR_ALTERNATE_DISPATCHERS)')
lines.append(' if (m_alternateDispatcher) {')
lines.append(
' m_alternateDispatcher->%(commandName)s(%(alternateInvocationParameters)s);'
% command_args)
lines.append(' return;')
lines.append(' }')
lines.append('#endif')
lines.append('')
lines.append(' ErrorString error;')
lines.append(
' Ref<InspectorObject> result = InspectorObject::create();')
if command.is_async:
lines.append(
' Ref<%(domainName)sBackendDispatcherHandler::%(callbackName)s> callback = adoptRef(*new %(domainName)sBackendDispatcherHandler::%(callbackName)s(m_backendDispatcher.copyRef(), requestId));'
% command_args)
if len(command.return_parameters) > 0:
lines.extend(out_parameter_declarations)
lines.append(
' m_agent->%(commandName)s(%(invocationParameters)s);' %
command_args)
lines.append('')
if command.is_async:
lines.append(' if (error.length()) {')
lines.extend(out_parameter_assignments)
lines.append(' }')
elif len(command.return_parameters) > 1:
lines.append(' if (!error.length()) {')
lines.extend(out_parameter_assignments)
lines.append(' }')
elif len(command.return_parameters) == 1:
lines.append(' if (!error.length())')
lines.extend(out_parameter_assignments)
lines.append('')
if not command.is_async:
lines.append(' if (!error.length())')
lines.append(
' m_backendDispatcher->sendResponse(requestId, WTFMove(result));'
)
lines.append(' else')
lines.append(
' m_backendDispatcher->reportProtocolError(BackendDispatcher::ServerError, WTFMove(error));'
)
lines.append('}')
return "\n".join(lines)
def _generate_dispatcher_implementation_for_command(self, command, domain):
in_parameter_declarations = []
out_parameter_declarations = []
out_parameter_assignments = []
alternate_dispatcher_method_parameters = ['callId']
method_parameters = ['error']
for parameter in command.call_parameters:
out_success_argument = 'nullptr'
if parameter.is_optional:
out_success_argument = '&%s_valueFound' % parameter.parameter_name
in_parameter_declarations.append(' bool %s_valueFound = false;' % parameter.parameter_name)
param_args = {
'parameterType': CppGenerator.cpp_type_for_stack_in_parameter(parameter),
'parameterName': parameter.parameter_name,
'keyedGetMethod': CppGenerator.cpp_getter_method_for_type(parameter.type),
'successOutParam': out_success_argument
}
in_parameter_declarations.append(' %(parameterType)s in_%(parameterName)s = InspectorBackendDispatcher::%(keyedGetMethod)s(paramsContainerPtr, ASCIILiteral("%(parameterName)s"), %(successOutParam)s, protocolErrorsPtr);' % param_args)
if parameter.is_optional:
optional_in_parameter_string = '%(parameterName)s_valueFound ? &in_%(parameterName)s : nullptr' % param_args
alternate_dispatcher_method_parameters.append(optional_in_parameter_string)
method_parameters.append(optional_in_parameter_string)
else:
alternate_dispatcher_method_parameters.append('in_' + parameter.parameter_name)
method_parameters.append('in_' + parameter.parameter_name)
if command.is_async:
async_args = {
'domainName': domain.domain_name,
'callbackName': ucfirst(command.command_name) + 'Callback'
}
out_parameter_assignments.append(' callback->disable();')
out_parameter_assignments.append(' m_backendDispatcher->reportProtocolError(&callId, Inspector::InspectorBackendDispatcher::ServerError, error);')
out_parameter_assignments.append(' return;')
method_parameters.append('callback')
else:
for parameter in command.return_parameters:
param_args = {
'parameterType': CppGenerator.cpp_type_for_stack_out_parameter(parameter),
'parameterName': parameter.parameter_name,
'keyedSetMethod': CppGenerator.cpp_setter_method_for_type(parameter.type),
}
out_parameter_declarations.append(' %(parameterType)s out_%(parameterName)s;' % param_args)
if parameter.is_optional:
if CppGenerator.should_use_wrapper_for_return_type(parameter.type):
out_parameter_assignments.append(' if (out_%(parameterName)s.isAssigned())' % param_args)
out_parameter_assignments.append(' result->%(keyedSetMethod)s(ASCIILiteral("%(parameterName)s"), out_%(parameterName)s.getValue());' % param_args)
else:
out_parameter_assignments.append(' if (out_%(parameterName)s)' % param_args)
out_parameter_assignments.append(' result->%(keyedSetMethod)s(ASCIILiteral("%(parameterName)s"), out_%(parameterName)s);' % param_args)
elif parameter.type.is_enum():
out_parameter_assignments.append(' result->%(keyedSetMethod)s(ASCIILiteral("%(parameterName)s"), Inspector::Protocol::getEnumConstantValue(out_%(parameterName)s));' % param_args)
else:
out_parameter_assignments.append(' result->%(keyedSetMethod)s(ASCIILiteral("%(parameterName)s"), out_%(parameterName)s);' % param_args)
if CppGenerator.should_pass_by_copy_for_return_type(parameter.type):
method_parameters.append('out_' + parameter.parameter_name)
else:
method_parameters.append('&out_' + parameter.parameter_name)
command_args = {
'domainName': domain.domain_name,
'callbackName': '%sCallback' % ucfirst(command.command_name),
'commandName': command.command_name,
'inParameterDeclarations': '\n'.join(in_parameter_declarations),
'invocationParameters': ', '.join(method_parameters),
'alternateInvocationParameters': ', '.join(alternate_dispatcher_method_parameters),
}
lines = []
if len(command.call_parameters) == 0:
lines.append('void Inspector%(domainName)sBackendDispatcher::%(commandName)s(long callId, const InspectorObject&)' % command_args)
else:
lines.append('void Inspector%(domainName)sBackendDispatcher::%(commandName)s(long callId, const InspectorObject& message)' % command_args)
lines.append('{')
if len(command.call_parameters) > 0:
lines.append(Template(CppTemplates.BackendDispatcherImplementationPrepareCommandArguments).substitute(None, **command_args))
lines.append('#if ENABLE(INSPECTOR_ALTERNATE_DISPATCHERS)')
lines.append(' if (m_alternateDispatcher) {')
lines.append(' m_alternateDispatcher->%(commandName)s(%(alternateInvocationParameters)s);' % command_args)
lines.append(' return;')
lines.append(' }')
lines.append('#endif')
lines.append('')
lines.append(' ErrorString error;')
lines.append(' RefPtr<InspectorObject> result = InspectorObject::create();')
if command.is_async:
lines.append(' RefPtr<Inspector%(domainName)sBackendDispatcherHandler::%(callbackName)s> callback = adoptRef(new Inspector%(domainName)sBackendDispatcherHandler::%(callbackName)s(m_backendDispatcher,callId));' % command_args)
if len(command.return_parameters) > 0:
lines.extend(out_parameter_declarations)
lines.append(' m_agent->%(commandName)s(%(invocationParameters)s);' % command_args)
lines.append('')
if command.is_async:
lines.append(' if (error.length()) {')
lines.extend(out_parameter_assignments)
lines.append(' }')
elif len(command.return_parameters) > 1:
lines.append(' if (!error.length()) {')
lines.extend(out_parameter_assignments)
lines.append(' }')
elif len(command.return_parameters) == 1:
lines.append(' if (!error.length())')
lines.extend(out_parameter_assignments)
lines.append('')
if not command.is_async:
lines.append(' m_backendDispatcher->sendResponse(callId, result.release(), error);')
lines.append('}')
return "\n".join(lines)
def _generate_dispatcher_implementation_for_command(self, command, domain):
in_parameter_declarations = []
out_parameter_declarations = []
out_parameter_assignments = []
alternate_dispatcher_method_parameters = ['callId']
method_parameters = ['error']
for parameter in command.call_parameters:
out_success_argument = 'nullptr'
if parameter.is_optional:
out_success_argument = '&%s_valueFound' % parameter.parameter_name
in_parameter_declarations.append(
' bool %s_valueFound = false;' %
parameter.parameter_name)
parameter_expression = 'in_' + parameter.parameter_name
if CppGenerator.should_use_references_for_type(parameter.type):
parameter_expression = '%s.copyRef()' % parameter_expression
elif parameter.is_optional:
parameter_expression = '&%s' % parameter_expression
param_args = {
'parameterType':
CppGenerator.cpp_type_for_stack_in_parameter(parameter),
'parameterName':
parameter.parameter_name,
'parameterExpression':
parameter_expression,
'keyedGetMethod':
CppGenerator.cpp_getter_method_for_type(parameter.type),
'successOutParam':
out_success_argument
}
in_parameter_declarations.append(
' %(parameterType)s in_%(parameterName)s = InspectorBackendDispatcher::%(keyedGetMethod)s(paramsContainer.get(), ASCIILiteral("%(parameterName)s"), %(successOutParam)s, protocolErrors.get());'
% param_args)
if parameter.is_optional:
optional_in_parameter_string = '%(parameterName)s_valueFound ? %(parameterExpression)s : nullptr' % param_args
alternate_dispatcher_method_parameters.append(
optional_in_parameter_string)
method_parameters.append(optional_in_parameter_string)
else:
alternate_dispatcher_method_parameters.append(
parameter_expression)
method_parameters.append(parameter_expression)
if command.is_async:
async_args = {
'domainName': domain.domain_name,
'callbackName': ucfirst(command.command_name) + 'Callback'
}
out_parameter_assignments.append(' callback->disable();')
out_parameter_assignments.append(
' m_backendDispatcher->reportProtocolError(&callId, Inspector::InspectorBackendDispatcher::ServerError, error);'
)
out_parameter_assignments.append(' return;')
method_parameters.append('callback.copyRef()')
else:
for parameter in command.return_parameters:
param_args = {
'parameterType':
CppGenerator.cpp_type_for_stack_out_parameter(parameter),
'parameterName':
parameter.parameter_name,
'keyedSetMethod':
CppGenerator.cpp_setter_method_for_type(parameter.type),
}
out_parameter_declarations.append(
' %(parameterType)s out_%(parameterName)s;' %
param_args)
if parameter.is_optional:
if CppGenerator.should_use_wrapper_for_return_type(
parameter.type):
out_parameter_assignments.append(
' if (out_%(parameterName)s.isAssigned())' %
param_args)
out_parameter_assignments.append(
' result->%(keyedSetMethod)s(ASCIILiteral("%(parameterName)s"), out_%(parameterName)s.getValue());'
% param_args)
else:
out_parameter_assignments.append(
' if (out_%(parameterName)s)' % param_args)
out_parameter_assignments.append(
' result->%(keyedSetMethod)s(ASCIILiteral("%(parameterName)s"), out_%(parameterName)s);'
% param_args)
elif parameter.type.is_enum():
out_parameter_assignments.append(
' result->%(keyedSetMethod)s(ASCIILiteral("%(parameterName)s"), Inspector::Protocol::getEnumConstantValue(out_%(parameterName)s));'
% param_args)
else:
out_parameter_assignments.append(
' result->%(keyedSetMethod)s(ASCIILiteral("%(parameterName)s"), out_%(parameterName)s);'
% param_args)
if CppGenerator.should_pass_by_copy_for_return_type(
parameter.type):
method_parameters.append('out_' + parameter.parameter_name)
else:
method_parameters.append('&out_' +
parameter.parameter_name)
command_args = {
'domainName':
domain.domain_name,
'callbackName':
'%sCallback' % ucfirst(command.command_name),
'commandName':
command.command_name,
'inParameterDeclarations':
'\n'.join(in_parameter_declarations),
'invocationParameters':
', '.join(method_parameters),
'alternateInvocationParameters':
', '.join(alternate_dispatcher_method_parameters),
}
lines = []
if len(command.call_parameters) == 0:
lines.append(
'void Inspector%(domainName)sBackendDispatcher::%(commandName)s(long callId, const InspectorObject&)'
% command_args)
else:
lines.append(
'void Inspector%(domainName)sBackendDispatcher::%(commandName)s(long callId, const InspectorObject& message)'
% command_args)
lines.append('{')
if len(command.call_parameters) > 0:
lines.append(
Template(CppTemplates.
BackendDispatcherImplementationPrepareCommandArguments
).substitute(None, **command_args))
lines.append('#if ENABLE(INSPECTOR_ALTERNATE_DISPATCHERS)')
lines.append(' if (m_alternateDispatcher) {')
lines.append(
' m_alternateDispatcher->%(commandName)s(%(alternateInvocationParameters)s);'
% command_args)
lines.append(' return;')
lines.append(' }')
lines.append('#endif')
lines.append('')
lines.append(' ErrorString error;')
lines.append(
' Ref<InspectorObject> result = InspectorObject::create();')
if command.is_async:
lines.append(
' Ref<Inspector%(domainName)sBackendDispatcherHandler::%(callbackName)s> callback = adoptRef(*new Inspector%(domainName)sBackendDispatcherHandler::%(callbackName)s(m_backendDispatcher.copyRef(), callId));'
% command_args)
if len(command.return_parameters) > 0:
lines.extend(out_parameter_declarations)
lines.append(
' m_agent->%(commandName)s(%(invocationParameters)s);' %
command_args)
lines.append('')
if command.is_async:
lines.append(' if (error.length()) {')
lines.extend(out_parameter_assignments)
lines.append(' }')
elif len(command.return_parameters) > 1:
lines.append(' if (!error.length()) {')
lines.extend(out_parameter_assignments)
lines.append(' }')
elif len(command.return_parameters) == 1:
lines.append(' if (!error.length())')
lines.extend(out_parameter_assignments)
lines.append('')
if not command.is_async:
lines.append(
' m_backendDispatcher->sendResponse(callId, WTF::move(result), error);'
)
lines.append('}')
return "\n".join(lines)
def _generate_dispatcher_implementation_for_command(self, command, domain):
in_parameter_declarations = []
out_parameter_declarations = []
out_parameter_assignments = []
alternate_dispatcher_method_parameters = ['requestId']
method_parameters = ['error']
for parameter in command.call_parameters:
parameter_name = 'in_' + parameter.parameter_name
if parameter.is_optional:
parameter_name = 'opt_' + parameter_name
out_success_argument = 'nullptr'
if parameter.is_optional:
out_success_argument = '&%s_valueFound' % parameter_name
in_parameter_declarations.append(' bool %s_valueFound = false;' % parameter_name)
# Now add appropriate operators.
parameter_expression = parameter_name
if CppGenerator.should_use_references_for_type(parameter.type):
if parameter.is_optional:
parameter_expression = '%s.get()' % parameter_expression
else:
# This assumes that we have already proved the object is non-null.
# If a required property is missing, InspectorBackend::getObject will
# append a protocol error, and the method dispatcher will return without
# invoking the backend method (and dereferencing the object).
parameter_expression = '*%s' % parameter_expression
elif parameter.is_optional:
parameter_expression = '&%s' % parameter_expression
param_args = {
'parameterType': CppGenerator.cpp_type_for_stack_in_parameter(parameter),
'parameterKey': parameter.parameter_name,
'parameterName': parameter_name,
'parameterExpression': parameter_expression,
'keyedGetMethod': CppGenerator.cpp_getter_method_for_type(parameter.type),
'successOutParam': out_success_argument
}
in_parameter_declarations.append(' %(parameterType)s %(parameterName)s = m_backendDispatcher->%(keyedGetMethod)s(parameters.get(), ASCIILiteral("%(parameterKey)s"), %(successOutParam)s);' % param_args)
if parameter.is_optional:
optional_in_parameter_string = '%(parameterName)s_valueFound ? %(parameterExpression)s : nullptr' % param_args
alternate_dispatcher_method_parameters.append(optional_in_parameter_string)
method_parameters.append(optional_in_parameter_string)
else:
alternate_dispatcher_method_parameters.append(parameter_expression)
method_parameters.append(parameter_expression)
if command.is_async:
async_args = {
'domainName': domain.domain_name,
'callbackName': ucfirst(command.command_name) + 'Callback'
}
out_parameter_assignments.append(' callback->disable();')
out_parameter_assignments.append(' m_backendDispatcher->reportProtocolError(BackendDispatcher::ServerError, error);')
out_parameter_assignments.append(' return;')
method_parameters.append('callback.copyRef()')
else:
for parameter in command.return_parameters:
param_args = {
'parameterType': CppGenerator.cpp_type_for_stack_out_parameter(parameter),
'parameterKey': parameter.parameter_name,
'parameterName': parameter.parameter_name,
'keyedSetMethod': CppGenerator.cpp_setter_method_for_type(parameter.type),
}
out_parameter_declarations.append(' %(parameterType)s out_%(parameterName)s;' % param_args)
if parameter.is_optional:
if CppGenerator.should_use_wrapper_for_return_type(parameter.type):
out_parameter_assignments.append(' if (out_%(parameterName)s.isAssigned())' % param_args)
out_parameter_assignments.append(' result->%(keyedSetMethod)s(ASCIILiteral("%(parameterKey)s"), out_%(parameterName)s.getValue());' % param_args)
else:
out_parameter_assignments.append(' if (out_%(parameterName)s)' % param_args)
out_parameter_assignments.append(' result->%(keyedSetMethod)s(ASCIILiteral("%(parameterKey)s"), out_%(parameterName)s);' % param_args)
elif parameter.type.is_enum():
out_parameter_assignments.append(' result->%(keyedSetMethod)s(ASCIILiteral("%(parameterKey)s"), Inspector::Protocol::getEnumConstantValue(out_%(parameterName)s));' % param_args)
else:
out_parameter_assignments.append(' result->%(keyedSetMethod)s(ASCIILiteral("%(parameterKey)s"), out_%(parameterName)s);' % param_args)
if CppGenerator.should_pass_by_copy_for_return_type(parameter.type):
method_parameters.append('out_' + parameter.parameter_name)
else:
method_parameters.append('&out_' + parameter.parameter_name)
command_args = {
'domainName': domain.domain_name,
'callbackName': '%sCallback' % ucfirst(command.command_name),
'commandName': command.command_name,
'inParameterDeclarations': '\n'.join(in_parameter_declarations),
'invocationParameters': ', '.join(method_parameters),
'alternateInvocationParameters': ', '.join(alternate_dispatcher_method_parameters),
}
lines = []
if len(command.call_parameters) == 0:
lines.append('void %(domainName)sBackendDispatcher::%(commandName)s(long requestId, RefPtr<InspectorObject>&&)' % command_args)
else:
lines.append('void %(domainName)sBackendDispatcher::%(commandName)s(long requestId, RefPtr<InspectorObject>&& parameters)' % command_args)
lines.append('{')
if len(command.call_parameters) > 0:
lines.append(Template(CppTemplates.BackendDispatcherImplementationPrepareCommandArguments).substitute(None, **command_args))
lines.append('#if ENABLE(INSPECTOR_ALTERNATE_DISPATCHERS)')
lines.append(' if (m_alternateDispatcher) {')
lines.append(' m_alternateDispatcher->%(commandName)s(%(alternateInvocationParameters)s);' % command_args)
lines.append(' return;')
lines.append(' }')
lines.append('#endif')
lines.append('')
lines.append(' ErrorString error;')
lines.append(' Ref<InspectorObject> result = InspectorObject::create();')
if command.is_async:
lines.append(' Ref<%(domainName)sBackendDispatcherHandler::%(callbackName)s> callback = adoptRef(*new %(domainName)sBackendDispatcherHandler::%(callbackName)s(m_backendDispatcher.copyRef(), requestId));' % command_args)
if len(command.return_parameters) > 0:
lines.extend(out_parameter_declarations)
lines.append(' m_agent->%(commandName)s(%(invocationParameters)s);' % command_args)
lines.append('')
if command.is_async:
lines.append(' if (error.length()) {')
lines.extend(out_parameter_assignments)
lines.append(' }')
elif len(command.return_parameters) > 1:
lines.append(' if (!error.length()) {')
lines.extend(out_parameter_assignments)
lines.append(' }')
elif len(command.return_parameters) == 1:
lines.append(' if (!error.length())')
lines.extend(out_parameter_assignments)
lines.append('')
if not command.is_async:
lines.append(' if (!error.length())')
lines.append(' m_backendDispatcher->sendResponse(requestId, WTF::move(result));')
lines.append(' else')
lines.append(' m_backendDispatcher->reportProtocolError(BackendDispatcher::ServerError, WTF::move(error));')
lines.append('}')
return "\n".join(lines)
def _generate_success_block_for_command(self, domain, command):
lines = []
if command.return_parameters:
success_block_parameters = []
for parameter in command.return_parameters:
objc_type = ObjCGenerator.objc_type_for_param(
domain, command.command_name, parameter)
var_name = ObjCGenerator.identifier_to_objc_identifier(
parameter.parameter_name)
success_block_parameters.append(
join_type_and_name(objc_type, var_name))
lines.append(' id successCallback = ^(%s) {' %
', '.join(success_block_parameters))
else:
lines.append(' id successCallback = ^{')
if command.return_parameters:
lines.append(
' Ref<InspectorObject> resultObject = InspectorObject::create();'
)
required_pointer_parameters = filter(
lambda parameter: not parameter.is_optional and ObjCGenerator.
is_type_objc_pointer_type(parameter.type),
command.return_parameters)
for parameter in required_pointer_parameters:
var_name = ObjCGenerator.identifier_to_objc_identifier(
parameter.parameter_name)
lines.append(
' THROW_EXCEPTION_FOR_REQUIRED_PARAMETER(%s, @"%s");'
% (var_name, var_name))
objc_array_class = ObjCGenerator.objc_class_for_array_type(
parameter.type)
if objc_array_class and objc_array_class.startswith(
ObjCGenerator.OBJC_PREFIX):
lines.append(
' THROW_EXCEPTION_FOR_BAD_TYPE_IN_ARRAY(%s, [%s class]);'
% (var_name, objc_array_class))
optional_pointer_parameters = filter(
lambda parameter: parameter.is_optional and ObjCGenerator.
is_type_objc_pointer_type(parameter.type),
command.return_parameters)
for parameter in optional_pointer_parameters:
var_name = ObjCGenerator.identifier_to_objc_identifier(
parameter.parameter_name)
lines.append(
' THROW_EXCEPTION_FOR_BAD_OPTIONAL_PARAMETER(%s, @"%s");'
% (var_name, var_name))
objc_array_class = ObjCGenerator.objc_class_for_array_type(
parameter.type)
if objc_array_class and objc_array_class.startswith(
ObjCGenerator.OBJC_PREFIX):
lines.append(
' THROW_EXCEPTION_FOR_BAD_TYPE_IN_OPTIONAL_ARRAY(%s, [%s class]);'
% (var_name, objc_array_class))
for parameter in command.return_parameters:
keyed_set_method = CppGenerator.cpp_setter_method_for_type(
parameter.type)
var_name = ObjCGenerator.identifier_to_objc_identifier(
parameter.parameter_name)
var_expression = '*%s' % var_name if parameter.is_optional else var_name
export_expression = ObjCGenerator.objc_protocol_export_expression_for_variable(
parameter.type, var_expression)
if not parameter.is_optional:
lines.append(
' resultObject->%s(ASCIILiteral("%s"), %s);' %
(keyed_set_method, parameter.parameter_name,
export_expression))
else:
lines.append(' if (%s)' % var_name)
lines.append(
' resultObject->%s(ASCIILiteral("%s"), %s);'
% (keyed_set_method, parameter.parameter_name,
export_expression))
lines.append(
' backendDispatcher()->sendResponse(callId, WTF::move(resultObject), String());'
)
else:
lines.append(
' backendDispatcher()->sendResponse(callId, InspectorObject::create(), String());'
)
lines.append(' };')
return '\n'.join(lines)
def _generate_async_dispatcher_class_for_domain(self, command, domain):
return_assignments = []
callback_parameters = []
for parameter in command.return_parameters:
parameter_name = parameter.parameter_name
if parameter.is_optional:
parameter_name = 'opt_' + parameter_name
parameter_value = parameter_name
_type = parameter.type
if isinstance(_type, AliasedType):
_type = _type.aliased_type
if isinstance(_type, EnumType) and _type.is_anonymous:
_type = _type.primitive_type
if _type.is_enum():
if parameter.is_optional:
parameter_value = '*' + parameter_value
parameter_value = 'Protocol::%s::getEnumConstantValue(%s)' % (
self.helpers_namespace(), parameter_value)
elif CppGenerator.should_release_argument(_type,
parameter.is_optional):
parameter_value = parameter_value + '.releaseNonNull()'
elif CppGenerator.should_dereference_argument(
_type, parameter.is_optional):
parameter_value = '*' + parameter_value
elif CppGenerator.should_move_argument(_type,
parameter.is_optional):
parameter_value = 'WTFMove(%s)' % parameter_value
param_args = {
'keyedSetMethod':
CppGenerator.cpp_setter_method_for_type(_type),
'parameterKey': parameter.parameter_name,
'parameterName': parameter_name,
'parameterValue': parameter_value,
}
callback_parameters.append(
'%s %s' % (CppGenerator.cpp_type_for_command_return_argument(
_type, parameter.is_optional), parameter_name))
if parameter.is_optional:
return_assignments.append(' if (!!%(parameterName)s)' %
param_args)
return_assignments.append(
' protocol_jsonMessage->%(keyedSetMethod)s("%(parameterKey)s"_s, %(parameterValue)s);'
% param_args)
else:
return_assignments.append(
' protocol_jsonMessage->%(keyedSetMethod)s("%(parameterKey)s"_s, %(parameterValue)s);'
% param_args)
async_args = {
'domainName': domain.domain_name,
'callbackName': ucfirst(command.command_name) + 'Callback',
'callbackParameters': ", ".join(callback_parameters),
'returnAssignments': "\n".join(return_assignments)
}
return self.wrap_with_guard_for_condition(
command.condition,
Template(CppTemplates.BackendDispatcherImplementationAsyncCommand).
substitute(None, **async_args))
def _generate_dispatcher_implementation_for_event(self, event, domain):
lines = []
parameter_assignments = []
formal_parameters = []
for parameter in event.event_parameters:
parameter_name = parameter.parameter_name
if parameter.is_optional:
parameter_name = 'opt_' + parameter_name
parameter_value = parameter_name
_type = parameter.type
if isinstance(_type, AliasedType):
_type = _type.aliased_type
if isinstance(_type, EnumType) and _type.is_anonymous:
_type = _type.primitive_type
if _type.is_enum():
if parameter.is_optional:
parameter_value = '*' + parameter_value
parameter_value = 'Protocol::%s::getEnumConstantValue(%s)' % (
self.helpers_namespace(), parameter_value)
elif CppGenerator.should_release_argument(_type,
parameter.is_optional):
parameter_value = parameter_value + '.releaseNonNull()'
elif CppGenerator.should_dereference_argument(
_type, parameter.is_optional):
parameter_value = '*' + parameter_value
elif CppGenerator.should_move_argument(_type,
parameter.is_optional):
parameter_value = 'WTFMove(%s)' % parameter_value
parameter_args = {
'parameterKey': parameter.parameter_name,
'parameterName': parameter_name,
'parameterValue': parameter_value,
'keyedSetMethod':
CppGenerator.cpp_setter_method_for_type(_type),
}
if parameter.is_optional:
parameter_assignments.append(' if (!!%(parameterName)s)' %
parameter_args)
parameter_assignments.append(
' protocol_paramsObject->%(keyedSetMethod)s("%(parameterKey)s"_s, %(parameterValue)s);'
% parameter_args)
else:
parameter_assignments.append(
' protocol_paramsObject->%(keyedSetMethod)s("%(parameterKey)s"_s, %(parameterValue)s);'
% parameter_args)
formal_parameters.append(
'%s %s' % (CppGenerator.cpp_type_for_event_parameter(
_type, parameter.is_optional), parameter_name))
event_args = {
'domainName': domain.domain_name,
'eventName': event.event_name,
'formalParameters': ", ".join(formal_parameters)
}
lines.append(
'void %(domainName)sFrontendDispatcher::%(eventName)s(%(formalParameters)s)'
% event_args)
lines.append('{')
lines.append(' auto protocol_jsonMessage = JSON::Object::create();')
lines.append(
' protocol_jsonMessage->setString("method"_s, "%(domainName)s.%(eventName)s"_s);'
% event_args)
if len(parameter_assignments) > 0:
lines.append(
' auto protocol_paramsObject = JSON::Object::create();')
lines.extend(parameter_assignments)
lines.append(
' protocol_jsonMessage->setObject("params"_s, WTFMove(protocol_paramsObject));'
)
lines.append('')
lines.append(
' m_frontendRouter.sendEvent(protocol_jsonMessage->toJSONString());'
)
lines.append('}')
return self.wrap_with_guard_for_condition(event.condition,
"\n".join(lines))
