def GetStructClassDeclarations(self):
struct_decls = map(
lambda s: self.GetStructDeclaration(
s.name, mojom_pack.PackedStruct(s),
self.GetTemplate("struct_declaration"), {}),
self.module.structs)
return '\n'.join(struct_decls)
def TestBools():
errors = 0
struct = mojom.Struct('test')
struct.AddField('bit0', mojom.BOOL)
struct.AddField('bit1', mojom.BOOL)
struct.AddField('int', mojom.INT32)
struct.AddField('bit2', mojom.BOOL)
struct.AddField('bit3', mojom.BOOL)
struct.AddField('bit4', mojom.BOOL)
struct.AddField('bit5', mojom.BOOL)
struct.AddField('bit6', mojom.BOOL)
struct.AddField('bit7', mojom.BOOL)
struct.AddField('bit8', mojom.BOOL)
ps = mojom_pack.PackedStruct(struct)
errors += EXPECT_EQ(10, len(ps.packed_fields))
# First 8 bits packed together.
for i in xrange(8):
pf = ps.packed_fields[i]
errors += EXPECT_EQ(0, pf.offset)
errors += EXPECT_EQ("bit%d" % i, pf.field.name)
errors += EXPECT_EQ(i, pf.bit)
# Ninth bit goes into second byte.
errors += EXPECT_EQ("bit8", ps.packed_fields[8].field.name)
errors += EXPECT_EQ(1, ps.packed_fields[8].offset)
errors += EXPECT_EQ(0, ps.packed_fields[8].bit)
# int comes last.
errors += EXPECT_EQ("int", ps.packed_fields[9].field.name)
errors += EXPECT_EQ(4, ps.packed_fields[9].offset)
return errors
def TestOneField():
errors = 0
struct = mojom.Struct('test')
struct.AddField('testfield1', mojom.INT8)
ps = mojom_pack.PackedStruct(struct)
errors += EXPECT_EQ(1, len(ps.packed_fields))
return errors
def GetWrapperClassDeclarations(self):
wrapper_decls = map(
lambda s: self.GetWrapperDeclaration(
s.name, mojom_pack.PackedStruct(s),
self.GetTemplate("wrapper_class_declaration"), {}),
self.module.structs)
return '\n'.join(wrapper_decls)
def GetStructFromMethod(interface, method):
"""Converts a method's parameters into the fields of a struct."""
params_class = "%s_%s_Params" % (interface.name, method.name)
struct = mojom.Struct(params_class)
for param in method.parameters:
struct.AddField(param.name, param.kind, param.ordinal)
struct.packed = mojom_pack.PackedStruct(struct)
return struct
def GetStructInfo(exported, struct):
packed_struct = mojom_pack.PackedStruct(struct)
return {
"name": struct.name,
"packed": packed_struct,
"bytes": mojom_pack.GetByteLayout(packed_struct),
"exported": exported,
}
def GetInterfaceSerializationDefinitions(self):
serializations = []
for interface in self.module.interfaces:
for method in interface.methods:
struct = mojom_generator.GetStructFromMethod(interface, method)
ps = mojom_pack.PackedStruct(struct)
serializations.append(
self.GetStructSerialization(
struct.name, "params", ps,
self.GetTemplate("params_serialization"), 2))
return '\n'.join(serializations)
def GetParamsDefinition(self, interface, method):
struct = mojom_generator.GetStructFromMethod(interface, method)
method_name = "k%s_%s_Name" % (interface.name, method.name)
assert method.ordinal is not None
params_def = self.GetStructDeclaration(
struct.name, mojom_pack.PackedStruct(struct),
self.GetTemplate("params_definition"), {
'METHOD_NAME': method_name,
'METHOD_ID': method.ordinal
})
return params_def
def TestOrdinalOrder():
errors = 0
struct = mojom.Struct('test')
struct.AddField('testfield1', mojom.INT32, 2)
struct.AddField('testfield2', mojom.INT32, 1)
ps = mojom_pack.PackedStruct(struct)
errors += EXPECT_EQ(2, len(ps.packed_fields))
errors += EXPECT_EQ('testfield2', ps.packed_fields[0].field.name)
errors += EXPECT_EQ('testfield1', ps.packed_fields[1].field.name)
return errors
def GetParamsDefinition(self, interface, method, next_id):
struct = GetStructFromMethod(interface, method)
method_name = "k%s_%s_Name" % (interface.name, method.name)
if method.ordinal is not None:
next_id = method.ordinal
params_def = self.GetStructDeclaration(
struct.name, mojom_pack.PackedStruct(struct),
self.GetTemplate("params_definition"), {
'METHOD_NAME': method_name,
'METHOD_ID': next_id
})
return params_def, next_id + 1
def GenerateFiles(self):
for struct in self.module.structs:
ps = mojom_pack.PackedStruct(struct)
self.GenerateStructHeader(ps)
self.GenerateStructSource(ps)
self.GenerateStructSerializationHeader(ps)
self.GenerateStructSerializationSource(ps)
for interface in self.module.interfaces:
self.GenerateInterfaceHeader(interface)
self.GenerateInterfaceStubHeader(interface)
self.GenerateInterfaceStubSource(interface)
self.GenerateInterfaceSerializationHeader(interface)
self.GenerateInterfaceSerializationSource(interface)
self.GenerateInterfaceProxyHeader(interface)
self.GenerateInterfaceProxySource(interface)
def TestSequence(kinds, fields, offsets):
errors = 0
struct = mojom.Struct('test')
index = 1
for kind in kinds:
struct.AddField("%d" % index, kind)
index += 1
ps = mojom_pack.PackedStruct(struct)
num_fields = len(ps.packed_fields)
errors += EXPECT_EQ(len(kinds), num_fields)
for i in xrange(num_fields):
EXPECT_EQ("%d" % fields[i], ps.packed_fields[i].field.name)
EXPECT_EQ(offsets[i], ps.packed_fields[i].offset)
return errors
def GenerateInterfaceSerializationSource(self, interface):
implementations = []
serializations = []
for method in interface.methods:
struct = GetStructFromMethod(interface, method)
ps = mojom_pack.PackedStruct(struct)
implementations.append(
self.GetStructImplementation(struct.name, ps))
serializations.append(
self.GetStructSerialization("internal::" + struct.name,
"params", ps))
self.WriteTemplateToFile("interface_serialization.cc",
interface.name,
HEADER=self.GetHeaderFile(
interface.name.lower(), "serialization"),
IMPLEMENTATIONS='\n'.join(implementations),
SERIALIZATIONS='\n'.join(serializations))
def TestPaddingPackedOutOfOrderByOrdinal():
errors = 0
struct = mojom.Struct('test')
struct.AddField('testfield1', mojom.INT8)
struct.AddField('testfield3', mojom.UINT8, 3)
struct.AddField('testfield2', mojom.INT32, 2)
ps = mojom_pack.PackedStruct(struct)
errors += EXPECT_EQ(3, len(ps.packed_fields))
# Second byte should be packed in behind first, altering order.
errors += EXPECT_EQ('testfield1', ps.packed_fields[0].field.name)
errors += EXPECT_EQ('testfield3', ps.packed_fields[1].field.name)
errors += EXPECT_EQ('testfield2', ps.packed_fields[2].field.name)
# Second byte should be packed with first.
errors += EXPECT_EQ(0, ps.packed_fields[0].offset)
errors += EXPECT_EQ(1, ps.packed_fields[1].offset)
errors += EXPECT_EQ(4, ps.packed_fields[2].offset)
return errors
def GenerateInterfaceSerializationHeader(self, interface):
kinds = DependentKinds()
for method in interface.methods:
for param in method.parameters:
kinds.AddKind(param.kind)
headers = \
map(lambda kind: self.GetHeaderFile(kind.name, "serialization"), kinds)
headers.append(self.GetHeaderFile(interface.name))
headers.append("mojo/public/bindings/lib/bindings_serialization.h")
includes = map(lambda header: "#include \"%s\"" % header,
sorted(headers))
names = []
name = 1
param_classes = []
param_templates = []
template_declaration = self.GetTemplate("template_declaration")
for method in interface.methods:
names.append(
self.name_template.substitute(
INTERFACE=interface.name.capitalize(),
METHOD=method.name.capitalize(),
NAME=name))
name += 1
struct = GetStructFromMethod(interface, method)
ps = mojom_pack.PackedStruct(struct)
param_classes.append(self.GetStructDeclaration(struct.name, ps))
param_templates.append(
template_declaration.substitute(CLASS=struct.name))
self.WriteTemplateToFile(
"interface_serialization.h",
interface.name,
HEADER_GUARD=self.GetHeaderGuard(interface.name +
"_SERIALIZATION"),
INCLUDES='\n'.join(includes),
NAMES='\n'.join(names),
PARAM_CLASSES='\n'.join(param_classes),
PARAM_TEMPLATES='\n'.join(param_templates))
def GetStructSerializationDefinition(self, struct):
ps = mojom_pack.PackedStruct(struct)
param_name = CamelToUnderscores(struct.name)
clones = Lines(self.struct_serialization_clone_template)
sizes = " return sizeof(*%s)" % param_name
fields = self.GetSerializedFields(ps)
for field in fields:
substitutions = {'NAME': param_name, 'FIELD': field.name}
sizes += \
self.struct_serialization_compute_template.substitute(substitutions)
clones.Add(substitutions)
sizes += ";"
serialization = self.GetStructSerialization(
struct.name, param_name, ps,
self.GetTemplate("struct_serialization"))
return self.GetTemplate("struct_serialization_definition").substitute(
NAME=param_name,
CLASS="%s::%s" % (self.module.namespace, struct.name),
SIZES=sizes,
CLONES=clones,
SERIALIZATION=serialization)
def GetStructSerializationDefinition(self, struct):
ps = mojom_pack.PackedStruct(struct)
param_name = mojom_generator.CamelToUnderscores(struct.name)
dtor = ''
closes = Lines(self.close_handles_template)
clones = Lines(self.struct_serialization_clone_template)
handle_releases = Lines(
self.struct_serialization_handle_release_template)
sizes = " return sizeof(*%s)" % param_name
fields = self.GetSerializedFields(ps)
for field in fields:
substitutions = {'NAME': param_name, 'FIELD': field.name}
sizes += \
self.struct_serialization_compute_template.substitute(substitutions)
clones.Add(substitutions)
closes.Add(substitutions)
handle_fields = self.GetHandleFields(ps)
for field in handle_fields:
substitutions = {'NAME': param_name, 'FIELD': field.name}
handle_releases.Add(substitutions)
if len(handle_fields) > 0:
dtor = " %s_Data_Destructor(%s);" % (struct.name, param_name)
sizes += ";"
serialization = self.GetStructSerialization(
struct.name, param_name, ps,
self.GetTemplate("struct_serialization"))
return self.GetTemplate("struct_serialization_definition").substitute(
NAME=param_name,
CLASS="%s::internal::%s_Data" %
(self.module.namespace, struct.name),
SIZES=sizes,
CLONES=clones,
HANDLE_RELEASES=handle_releases,
CLOSES=closes,
DTOR=dtor,
SERIALIZATION=serialization)
def GetStructInfo(exported, struct): struct.packed = mojom_pack.PackedStruct(struct) struct.bytes = mojom_pack.GetByteLayout(struct.packed) struct.exported = exported return struct
def TestZeroFields():
errors = 0
struct = mojom.Struct('test')
ps = mojom_pack.PackedStruct(struct)
errors += EXPECT_EQ(0, len(ps.packed_fields))
return errors
