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