},
],
},
+ 'MatrixValuesCHROMIUM': {
+ 'type': 'NamedParameter',
+ 'func': 'MatrixLoadfEXT',
+ 'states': [
+ { 'enum': 'GL_PATH_MODELVIEW_MATRIX_CHROMIUM',
+ 'enum_set': 'GL_PATH_MODELVIEW_CHROMIUM',
+ 'name': 'modelview_matrix',
+ 'type': 'GLfloat',
+ 'default': [
+ '1.0f', '0.0f','0.0f','0.0f',
+ '0.0f', '1.0f','0.0f','0.0f',
+ '0.0f', '0.0f','1.0f','0.0f',
+ '0.0f', '0.0f','0.0f','1.0f',
+ ],
+ 'extension_flag': 'chromium_path_rendering',
+ },
+ { 'enum': 'GL_PATH_PROJECTION_MATRIX_CHROMIUM',
+ 'enum_set': 'GL_PATH_PROJECTION_CHROMIUM',
+ 'name': 'projection_matrix',
+ 'type': 'GLfloat',
+ 'default': [
+ '1.0f', '0.0f','0.0f','0.0f',
+ '0.0f', '1.0f','0.0f','0.0f',
+ '0.0f', '0.0f','1.0f','0.0f',
+ '0.0f', '0.0f','0.0f','1.0f',
+ ],
+ 'extension_flag': 'chromium_path_rendering',
+ },
+ ],
+ },
}
# Named type info object represents a named type that is used in OpenGL call
'GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE',
],
},
+ 'MatrixMode': {
+ 'type': 'GLenum',
+ 'valid': [
+ 'GL_PATH_PROJECTION_CHROMIUM',
+ 'GL_PATH_MODELVIEW_CHROMIUM',
+ ],
+ },
'ProgramParameter': {
'type': 'GLenum',
'valid': [
'extension': True,
'chromium': True,
},
+ 'MatrixLoadfCHROMIUM': {
+ 'type': 'PUT',
+ 'count': 16,
+ 'data_type': 'GLfloat',
+ 'decoder_func': 'DoMatrixLoadfCHROMIUM',
+ 'gl_test_func': 'glMatrixLoadfEXT',
+ 'chromium': True,
+ 'extension': True,
+ 'extension_flag': 'chromium_path_rendering',
+ },
+ 'MatrixLoadIdentityCHROMIUM': {
+ 'decoder_func': 'DoMatrixLoadIdentityCHROMIUM',
+ 'gl_test_func': 'glMatrixLoadIdentityEXT',
+ 'chromium': True,
+ 'extension': True,
+ 'extension_flag': 'chromium_path_rendering',
+ },
}
return 'cached_' + item['name']
return item['name']
+def ToGLExtensionString(extension_flag):
+ """Returns GL-type extension string of a extension flag."""
+ if extension_flag == "oes_compressed_etc1_rgb8_texture":
+ return "OES_compressed_ETC1_RGB8_texture" # Fixup inconsitency with rgb8,
+ # unfortunate.
+ uppercase_words = [ 'img', 'ext', 'arb', 'chromium', 'oes', 'amd', 'bgra8888',
+ 'egl', 'atc', 'etc1', 'angle']
+ parts = extension_flag.split('_')
+ return "_".join(
+ [part.upper() if part in uppercase_words else part for part in parts])
+
+def ToCamelCase(input_string):
+ """converts ABC_underscore_case to ABCUnderscoreCase."""
+ return ''.join(w[0].upper() + w[1:] for w in input_string.split('_'))
+
+def GetGLGetTypeConversion(result_type, value_type, value):
+ """Makes a gl compatible type conversion string for accessing state variables.
+
+ Useful when accessing state variables through glGetXXX calls.
+ glGet documetation (for example, the manual pages):
+ [...] If glGetIntegerv is called, [...] most floating-point values are
+ rounded to the nearest integer value. [...]
+
+ Args:
+ result_type: the gl type to be obtained
+ value_type: the GL type of the state variable
+ value: the name of the state variable
+
+ Returns:
+ String that converts the state variable to desired GL type according to GL
+ rules.
+ """
+
+ if result_type == 'GLint':
+ if value_type == 'GLfloat':
+ return 'static_cast<GLint>(round(%s))' % value
+ return 'static_cast<%s>(%s)' % (result_type, value)
class CWriter(object):
"""Writes to a file formatting it for Google's style guidelines."""
def __init__(self, filename):
self.filename = filename
- self.file_num = 0
self.content = []
- def SetFileNum(self, num):
- """Used to help write number files and tests."""
- self.file_num = num
-
def Write(self, string):
"""Writes a string to a file spliting if it's > 80 characters."""
lines = string.splitlines()
file.Write(" %s(%s);\n" %
(func.GetGLFunctionName(), func.MakeOriginalArgString("")))
+ def WriteServiceHandlerFunctionHeader(self, func, file):
+ """Writes function header for service implementation handlers."""
+ file.Write("""error::Error GLES2DecoderImpl::Handle%(name)s(
+ uint32_t immediate_data_size, const void* cmd_data) {
+ const gles2::cmds::%(name)s& c =
+ *static_cast<const gles2::cmds::%(name)s*>(cmd_data);
+ (void)c;
+ """ % {'name': func.name})
+
def WriteServiceImplementation(self, func, file):
"""Writes the service implementation for a command."""
- file.Write(
- "error::Error GLES2DecoderImpl::Handle%s(\n" % func.name)
- file.Write(
- " uint32_t immediate_data_size, const gles2::cmds::%s& c) {\n" %
- func.name)
+ self.WriteServiceHandlerFunctionHeader(func, file)
self.WriteHandlerExtensionCheck(func, file)
self.WriteHandlerDeferReadWrite(func, file);
if len(func.GetOriginalArgs()) > 0:
def WriteImmediateServiceImplementation(self, func, file):
"""Writes the service implementation for an immediate version of command."""
- file.Write(
- "error::Error GLES2DecoderImpl::Handle%s(\n" % func.name)
- file.Write(
- " uint32_t immediate_data_size, const gles2::cmds::%s& c) {\n" %
- func.name)
+ self.WriteServiceHandlerFunctionHeader(func, file)
self.WriteHandlerExtensionCheck(func, file)
self.WriteHandlerDeferReadWrite(func, file);
last_arg = func.GetLastOriginalArg()
def WriteBucketServiceImplementation(self, func, file):
"""Writes the service implementation for a bucket version of command."""
- file.Write(
- "error::Error GLES2DecoderImpl::Handle%s(\n" % func.name)
- file.Write(
- " uint32_t immediate_data_size, const gles2::cmds::%s& c) {\n" %
- func.name)
+ self.WriteServiceHandlerFunctionHeader(func, file)
self.WriteHandlerExtensionCheck(func, file)
self.WriteHandlerDeferReadWrite(func, file);
last_arg = func.GetLastOriginalArg()
file.Write(" if (error != error::kNoError)\n")
file.Write(" return error;\n")
- def WriteValidUnitTest(self, func, file, test, extra = {}):
+ def WriteValidUnitTest(self, func, file, test, *extras):
"""Writes a valid unit test for the service implementation."""
if func.GetInfo('expectation') == False:
test = self._remove_expected_call_re.sub('', test)
]
gl_func_name = func.GetGLTestFunctionName()
vars = {
- 'test_name': 'GLES2DecoderTest%d' % file.file_num,
'name':name,
'gl_func_name': gl_func_name,
'args': ", ".join(arg_strings),
'gl_args': ", ".join(gl_arg_strings),
}
- vars.update(extra)
+ for extra in extras:
+ vars.update(extra)
old_test = ""
while (old_test != test):
old_test = test
test = test % vars
file.Write(test % vars)
- def WriteInvalidUnitTest(self, func, file, test, extra = {}):
+ def WriteInvalidUnitTest(self, func, file, test, *extras):
"""Writes an invalid unit test for the service implementation."""
for invalid_arg_index, invalid_arg in enumerate(func.GetOriginalArgs()):
# Service implementation does not test constants, as they are not part of
gl_error_test = '\n EXPECT_EQ(%s, GetGLError());' % gl_error
vars = {
- 'test_name': 'GLES2DecoderTest%d' % file.file_num ,
'name': func.name,
'arg_index': invalid_arg_index,
'value_index': value_index,
'parse_result': parse_result,
'gl_error_test': gl_error_test,
}
- vars.update(extra)
+ for extra in extras:
+ vars.update(extra)
file.Write(test % vars)
- def WriteServiceUnitTest(self, func, file):
+ def WriteServiceUnitTest(self, func, file, *extras):
"""Writes the service unit test for a command."""
if func.name == 'Enable':
EXPECT_EQ(GL_NO_ERROR, GetGLError());
}
"""
- self.WriteValidUnitTest(func, file, valid_test)
+ self.WriteValidUnitTest(func, file, valid_test, *extras)
invalid_test = """
TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
EXPECT_EQ(error::%(parse_result)s, ExecuteCmd(cmd));%(gl_error_test)s
}
"""
- self.WriteInvalidUnitTest(func, file, invalid_test)
+ self.WriteInvalidUnitTest(func, file, invalid_test, *extras)
- def WriteImmediateServiceUnitTest(self, func, file):
+ def WriteImmediateServiceUnitTest(self, func, file, *extras):
"""Writes the service unit test for an immediate command."""
file.Write("// TODO(gman): %s\n" % func.name)
"""Writes the validation code for an immediate version of a command."""
pass
- def WriteBucketServiceUnitTest(self, func, file):
+ def WriteBucketServiceUnitTest(self, func, file, *extras):
"""Writes the service unit test for a bucket command."""
file.Write("// TODO(gman): %s\n" % func.name)
(func.GetGLFunctionName(), func.MakeOriginalArgString("")))
file.Write(" }\n")
- def WriteServiceUnitTest(self, func, file):
+ def WriteServiceUnitTest(self, func, file, *extras):
"""Overrriden from TypeHandler."""
- TypeHandler.WriteServiceUnitTest(self, func, file)
+ TypeHandler.WriteServiceUnitTest(self, func, file, *extras)
state_name = func.GetInfo('state')
state = _STATES[state_name]
states = state['states']
arg_strings[ndx] = range_check['test_value']
vars = {
- 'test_name': 'GLES2DecoderTest%d' % file.file_num,
'name': name,
'ndx': ndx,
'check_ndx': check_ndx,
'args': ", ".join(arg_strings),
}
+ for extra in extras:
+ vars.update(extra)
file.Write(valid_test % vars)
if 'nan_check' in item:
valid_test = """
arg_strings[ndx] = 'nanf("")'
vars = {
- 'test_name': 'GLES2DecoderTest%d' % file.file_num,
'name': name,
'ndx': ndx,
'args': ", ".join(arg_strings),
}
+ for extra in extras:
+ vars.update(extra)
file.Write(valid_test % vars)
"""Overrriden from TypeHandler."""
pass
- def WriteServiceUnitTest(self, func, file):
+ def WriteServiceUnitTest(self, func, file, *extras):
"""Overrriden from TypeHandler."""
file.Write("// TODO(gman): %s\n\n" % func.name)
- def WriteImmediateServiceUnitTest(self, func, file):
+ def WriteImmediateServiceUnitTest(self, func, file, *extras):
"""Overrriden from TypeHandler."""
file.Write("// TODO(gman): %s\n\n" % func.name)
def WriteServiceImplementation(self, func, file):
"""Overrriden from TypeHandler."""
- file.Write(
- "error::Error GLES2DecoderImpl::Handle%s(\n" % func.name)
- file.Write(
- " uint32_t immediate_data_size, const gles2::cmds::%s& c) {\n" %
- func.name)
+ self.WriteServiceHandlerFunctionHeader(func, file)
file.Write(" // TODO: for now this is a no-op\n")
file.Write(
" LOCAL_SET_GL_ERROR("
"""Overrriden from TypeHandler."""
pass
- def WriteServiceUnitTest(self, func, file):
+ def WriteServiceUnitTest(self, func, file, *extras):
"""Overrriden from TypeHandler."""
file.Write("// TODO(gman): %s\n\n" % func.name)
- def WriteImmediateServiceUnitTest(self, func, file):
+ def WriteImmediateServiceUnitTest(self, func, file, *extras):
"""Overrriden from TypeHandler."""
file.Write("// TODO(gman): %s\n\n" % func.name)
- def WriteBucketServiceUnitTest(self, func, file):
+ def WriteBucketServiceUnitTest(self, func, file, *extras):
"""Overrriden from TypeHandler."""
file.Write("// TODO(gman): %s\n\n" % func.name)
"""Overrriden from TypeHandler."""
pass
- def WriteServiceUnitTest(self, func, file):
+ def WriteServiceUnitTest(self, func, file, *extras):
"""Overrriden from TypeHandler."""
file.Write("// TODO(gman): %s\n\n" % func.name)
- def WriteImmediateServiceUnitTest(self, func, file):
+ def WriteImmediateServiceUnitTest(self, func, file, *extras):
"""Overrriden from TypeHandler."""
file.Write("// TODO(gman): %s\n\n" % func.name)
file.Write("// TODO(gman): Implement test for %s\n" % func.name)
return
- def WriteServiceUnitTest(self, func, file):
+ def WriteServiceUnitTest(self, func, file, *extras):
"""Overrriden from TypeHandler."""
file.Write("// TODO(gman): %s\n\n" % func.name)
- def WriteImmediateServiceUnitTest(self, func, file):
+ def WriteImmediateServiceUnitTest(self, func, file, *extras):
"""Overrriden from TypeHandler."""
file.Write("// TODO(gman): %s\n\n" % func.name)
def __init__(self):
TypeHandler.__init__(self)
- def WriteServiceUnitTest(self, func, file):
+ def WriteServiceUnitTest(self, func, file, *extras):
"""Overrriden from TypeHandler."""
if len(func.GetOriginalArgs()) == 1:
self.WriteValidUnitTest(func, file, valid_test, {
'resource_type': func.GetOriginalArgs()[0].resource_type,
'gl_gen_func_name': func.GetInfo("gen_func"),
- })
+ }, *extras)
else:
valid_test = """
TEST_P(%(test_name)s, %(name)sValidArgs) {
'first_gl_arg': func.GetOriginalArgs()[0].GetValidGLArg(func),
'resource_type': func.GetOriginalArgs()[1].resource_type,
'gl_gen_func_name': func.GetInfo("gen_func"),
- })
+ }, *extras)
invalid_test = """
TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
EXPECT_EQ(error::%(parse_result)s, ExecuteCmd(cmd));%(gl_error_test)s
}
"""
- self.WriteInvalidUnitTest(func, file, invalid_test)
+ self.WriteInvalidUnitTest(func, file, invalid_test, *extras)
def WriteGLES2Implementation(self, func, file):
"""Writes the GLES2 Implemention."""
'types': func.GetInfo('resource_types'),
})
- def WriteServiceUnitTest(self, func, file):
+ def WriteServiceUnitTest(self, func, file, *extras):
"""Overrriden from TypeHandler."""
valid_test = """
TEST_P(%(test_name)s, %(name)sValidArgs) {
"""
self.WriteValidUnitTest(func, file, valid_test, {
'resource_name': func.GetInfo('resource_type'),
- })
+ }, *extras)
invalid_test = """
TEST_P(%(test_name)s, %(name)sInvalidArgs) {
EXPECT_CALL(*gl_, %(gl_func_name)s(_, _)).Times(0);
"""
self.WriteValidUnitTest(func, file, invalid_test, {
'resource_name': func.GetInfo('resource_type').lower(),
- })
+ }, *extras)
- def WriteImmediateServiceUnitTest(self, func, file):
+ def WriteImmediateServiceUnitTest(self, func, file, *extras):
"""Overrriden from TypeHandler."""
valid_test = """
TEST_P(%(test_name)s, %(name)sValidArgs) {
"""
self.WriteValidUnitTest(func, file, valid_test, {
'resource_name': func.GetInfo('resource_type'),
- })
+ }, *extras)
invalid_test = """
TEST_P(%(test_name)s, %(name)sInvalidArgs) {
EXPECT_CALL(*gl_, %(gl_func_name)s(_, _)).Times(0);
"""
self.WriteValidUnitTest(func, file, invalid_test, {
'resource_name': func.GetInfo('resource_type').lower(),
- })
+ }, *extras)
def WriteImmediateCmdComputeSize(self, func, file):
"""Overrriden from TypeHandler."""
"""Overrriden from TypeHandler."""
func.AddCmdArg(Argument("client_id", 'uint32_t'))
- def WriteServiceUnitTest(self, func, file):
+ def WriteServiceUnitTest(self, func, file, *extras):
"""Overrriden from TypeHandler."""
valid_test = """
TEST_P(%(test_name)s, %(name)sValidArgs) {
self.WriteValidUnitTest(func, file, valid_test, {
'comma': comma,
'resource_type': func.name[6:],
- })
+ }, *extras)
invalid_test = """
TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s)).Times(0);
"""
self.WriteInvalidUnitTest(func, file, invalid_test, {
'comma': comma,
- })
+ }, *extras)
def WriteHandlerImplementation (self, func, file):
"""Overrriden from TypeHandler."""
'types': func.GetInfo('resource_types'),
})
- def WriteServiceUnitTest(self, func, file):
+ def WriteServiceUnitTest(self, func, file, *extras):
"""Overrriden from TypeHandler."""
valid_test = """
TEST_P(%(test_name)s, %(name)sValidArgs) {
self.WriteValidUnitTest(func, file, valid_test, {
'resource_name': func.GetInfo('resource_type').lower(),
'upper_resource_name': func.GetInfo('resource_type'),
- })
+ }, *extras)
invalid_test = """
TEST_P(%(test_name)s, %(name)sInvalidArgs) {
GetSharedMemoryAs<GLuint*>()[0] = kInvalidClientId;
EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
}
"""
- self.WriteValidUnitTest(func, file, invalid_test)
+ self.WriteValidUnitTest(func, file, invalid_test, *extras)
- def WriteImmediateServiceUnitTest(self, func, file):
+ def WriteImmediateServiceUnitTest(self, func, file, *extras):
"""Overrriden from TypeHandler."""
valid_test = """
TEST_P(%(test_name)s, %(name)sValidArgs) {
self.WriteValidUnitTest(func, file, valid_test, {
'resource_name': func.GetInfo('resource_type').lower(),
'upper_resource_name': func.GetInfo('resource_type'),
- })
+ }, *extras)
invalid_test = """
TEST_P(%(test_name)s, %(name)sInvalidArgs) {
cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();
ExecuteImmediateCmd(cmd, sizeof(temp)));
}
"""
- self.WriteValidUnitTest(func, file, invalid_test)
+ self.WriteValidUnitTest(func, file, invalid_test, *extras)
def WriteHandlerImplementation (self, func, file):
"""Overrriden from TypeHandler."""
def WriteServiceImplementation(self, func, file):
"""Overrriden from TypeHandler."""
- file.Write(
- "error::Error GLES2DecoderImpl::Handle%s(\n" % func.name)
- file.Write(
- " uint32_t immediate_data_size, const gles2::cmds::%s& c) {\n" %
- func.name)
+ self.WriteServiceHandlerFunctionHeader(func, file)
last_arg = func.GetLastOriginalArg()
all_but_last_args = func.GetOriginalArgs()[:-1]
'cmd_args': ", ".join(cmd_arg_strings),
})
- def WriteServiceUnitTest(self, func, file):
+ def WriteServiceUnitTest(self, func, file, *extras):
"""Overrriden from TypeHandler."""
valid_test = """
TEST_P(%(test_name)s, %(name)sValidArgs) {
self.WriteValidUnitTest(func, file, valid_test, {
'local_gl_args': ", ".join(gl_arg_strings),
'valid_pname': valid_pname,
- })
+ }, *extras)
invalid_test = """
TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
EXPECT_EQ(0u, result->size);%(gl_error_test)s
}
"""
- self.WriteInvalidUnitTest(func, file, invalid_test)
+ self.WriteInvalidUnitTest(func, file, invalid_test, *extras)
class ArrayArgTypeHandler(TypeHandler):
"""Base class for type handlers that handle args that are arrays"""
def __init__(self):
ArrayArgTypeHandler.__init__(self)
- def WriteServiceUnitTest(self, func, file):
+ def WriteServiceUnitTest(self, func, file, *extras):
"""Writes the service unit test for a command."""
expected_call = "EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s));"
if func.GetInfo("first_element_only"):
'data_value': func.GetInfo('data_value') or '0',
'expected_call': expected_call,
}
- self.WriteValidUnitTest(func, file, valid_test, extra)
+ self.WriteValidUnitTest(func, file, valid_test, extra, *extras)
invalid_test = """
TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
EXPECT_EQ(error::%(parse_result)s, ExecuteCmd(cmd));%(gl_error_test)s
}
"""
- self.WriteInvalidUnitTest(func, file, invalid_test, extra)
+ self.WriteInvalidUnitTest(func, file, invalid_test, extra, *extras)
- def WriteImmediateServiceUnitTest(self, func, file):
+ def WriteImmediateServiceUnitTest(self, func, file, *extras):
"""Writes the service unit test for a command."""
valid_test = """
TEST_P(%(test_name)s, %(name)sValidArgs) {
'gl_args': ", ".join(gl_arg_strings),
'gl_any_args': ", ".join(gl_any_strings),
}
- self.WriteValidUnitTest(func, file, valid_test, extra)
+ self.WriteValidUnitTest(func, file, valid_test, extra, *extras)
invalid_test = """
TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
ExecuteImmediateCmd(cmd, sizeof(temp)));%(gl_error_test)s
}
"""
- self.WriteInvalidUnitTest(func, file, invalid_test, extra)
+ self.WriteInvalidUnitTest(func, file, invalid_test, extra, *extras)
def WriteGetDataSizeCode(self, func, file):
"""Overrriden from TypeHandler."""
def __init__(self):
ArrayArgTypeHandler.__init__(self)
- def WriteServiceUnitTest(self, func, file):
+ def WriteServiceUnitTest(self, func, file, *extras):
"""Overridden from TypeHandler."""
- ArrayArgTypeHandler.WriteServiceUnitTest(self, func, file)
+ ArrayArgTypeHandler.WriteServiceUnitTest(self, func, file, *extras)
valid_test = """
TEST_P(%(test_name)s, %(name)sValidArgsCountTooLarge) {
'gl_args': ", ".join(gl_arg_strings),
'args': ", ".join(arg_strings),
}
- self.WriteValidUnitTest(func, file, valid_test, extra)
+ self.WriteValidUnitTest(func, file, valid_test, extra, *extras)
- def WriteImmediateServiceUnitTest(self, func, file):
+ def WriteImmediateServiceUnitTest(self, func, file, *extras):
"""Overridden from TypeHandler."""
valid_test = """
TEST_P(%(test_name)s, %(name)sValidArgs) {
'gl_args': ", ".join(gl_arg_strings),
'gl_any_args': ", ".join(gl_any_strings),
}
- self.WriteValidUnitTest(func, file, valid_test, extra)
+ self.WriteValidUnitTest(func, file, valid_test, extra, *extras)
invalid_test = """
TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
ExecuteImmediateCmd(cmd, sizeof(temp)));%(gl_error_test)s
}
"""
- self.WriteInvalidUnitTest(func, file, invalid_test, extra)
+ self.WriteInvalidUnitTest(func, file, invalid_test, extra, *extras)
def WriteGetDataSizeCode(self, func, file):
"""Overrriden from TypeHandler."""
'values': values,
})
- def WriteServiceUnitTest(self, func, file):
+ def WriteServiceUnitTest(self, func, file, *extras):
"""Overrriden from TypeHandler."""
valid_test = """
TEST_P(%(test_name)s, %(name)sValidArgs) {
'name': func.name,
'count': self.GetArrayCount(func),
'local_args': local_args,
- })
+ }, *extras)
invalid_test = """
TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
def WriteServiceImplementation(self, func, file):
"""Overrriden from TypeHandler."""
- file.Write("""error::Error GLES2DecoderImpl::Handle%(name)s(
- uint32_t immediate_data_size, const gles2::cmds::%(name)s& c) {
+ self.WriteServiceHandlerFunctionHeader(func, file)
+ file.Write("""
GLuint bucket_id = static_cast<GLuint>(c.%(bucket_id)s);
Bucket* bucket = GetBucket(bucket_id);
if (!bucket || bucket->size() == 0) {
if func.GetInfo('result') == None:
func.AddInfo('result', ['uint32_t'])
- def WriteServiceUnitTest(self, func, file):
+ def WriteServiceUnitTest(self, func, file, *extras):
"""Overrriden from TypeHandler."""
valid_test = """
TEST_P(%(test_name)s, %(name)sValidArgs) {
comma =", "
self.WriteValidUnitTest(func, file, valid_test, {
'comma': comma,
- })
+ }, *extras)
invalid_test = """
TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
"""
self.WriteInvalidUnitTest(func, file, invalid_test, {
'comma': comma,
- })
+ }, *extras)
invalid_test = """
TEST_P(%(test_name)s, %(name)sInvalidArgsBadSharedMemoryId) {
"""
self.WriteValidUnitTest(func, file, invalid_test, {
'comma': comma,
- })
+ }, *extras)
def WriteServiceImplementation(self, func, file):
"""Overrriden from TypeHandler."""
- file.Write(
- "error::Error GLES2DecoderImpl::Handle%s(\n" % func.name)
- file.Write(
- " uint32_t immediate_data_size, const gles2::cmds::%s& c) {\n" %
- func.name)
+ self.WriteServiceHandlerFunctionHeader(func, file)
args = func.GetOriginalArgs()
for arg in args:
arg.WriteGetCode(file)
func.WriteDestinationInitalizationValidation(file)
file.Write(code_2 % str_args)
- def WriteServiceUnitTest(self, func, file):
+ def WriteServiceUnitTest(self, func, file, *extras):
"""Overrriden from TypeHandler."""
valid_test = """
TEST_P(%(test_name)s, %(name)sValidArgs) {
" EXPECT_CALL(*gl_, %s(%s, %s, _))\n"
" .WillOnce(SetArgumentPointee<2>(strlen(kInfo) + 1));") % (
get_len_func[2:], id_name, get_len_enum)
- self.WriteValidUnitTest(func, file, valid_test, sub)
+ self.WriteValidUnitTest(func, file, valid_test, sub, *extras)
invalid_test = """
TEST_P(%(test_name)s, %(name)sInvalidArgs) {
EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
}
"""
- self.WriteValidUnitTest(func, file, invalid_test)
+ self.WriteValidUnitTest(func, file, invalid_test, *extras)
def WriteServiceImplementation(self, func, file):
"""Overrriden from TypeHandler."""
else:
return self.MakeTypedOriginalArgString(prefix, False)
+ def MapCTypeToPepperIdlType(self, ctype, is_for_return_type=False):
+ """Converts a C type name to the corresponding Pepper IDL type."""
+ idltype = {
+ 'char*': '[out] str_t',
+ 'const GLchar* const*': '[out] cstr_t',
+ 'const char*': 'cstr_t',
+ 'const void*': 'mem_t',
+ 'void*': '[out] mem_t',
+ 'void**': '[out] mem_ptr_t',
+ }.get(ctype, ctype)
+ # We use "GLxxx_ptr_t" for "GLxxx*".
+ matched = re.match(r'(const )?(GL\w+)\*$', ctype)
+ if matched:
+ idltype = matched.group(2) + '_ptr_t'
+ if not matched.group(1):
+ idltype = '[out] ' + idltype
+ # If an in/out specifier is not specified yet, prepend [in].
+ if idltype[0] != '[':
+ idltype = '[in] ' + idltype
+ # Strip the in/out specifier for a return type.
+ if is_for_return_type:
+ idltype = re.sub(r'\[\w+\] ', '', idltype)
+ return idltype
+
+ def MakeTypedPepperIdlArgStrings(self):
+ """Gets a list of arguments as they need to be for Pepper IDL."""
+ args = self.GetOriginalArgs()
+ return ["%s %s" % (self.MapCTypeToPepperIdlType(arg.type), arg.name)
+ for arg in args]
+
def GetPepperName(self):
if self.GetInfo("pepper_name"):
return self.GetInfo("pepper_name")
"""Writes the service implementation for a command."""
self.type_handler.WriteServiceImplementation(self, file)
- def WriteServiceUnitTest(self, file):
+ def WriteServiceUnitTest(self, file, *extras):
"""Writes the service implementation for a command."""
- self.type_handler.WriteServiceUnitTest(self, file)
+ self.type_handler.WriteServiceUnitTest(self, file, *extras)
def WriteGLES2CLibImplementation(self, file):
"""Writes the GLES2 C Lib Implemention."""
"""Overridden from Function"""
self.type_handler.WriteImmediateHandlerImplementation(self, file)
- def WriteServiceUnitTest(self, file):
+ def WriteServiceUnitTest(self, file, *extras):
"""Writes the service implementation for a command."""
- self.type_handler.WriteImmediateServiceUnitTest(self, file)
+ self.type_handler.WriteImmediateServiceUnitTest(self, file, *extras)
def WriteValidationCode(self, file):
"""Overridden from Function"""
"""Overridden from Function"""
self.type_handler.WriteBucketHandlerImplementation(self, file)
- def WriteServiceUnitTest(self, file):
+ def WriteServiceUnitTest(self, file, *extras):
"""Writes the service implementation for a command."""
- self.type_handler.WriteBucketServiceUnitTest(self, file)
+ self.type_handler.WriteBucketServiceUnitTest(self, file, *extras)
def CreateArg(arg_string):
for state_name in sorted(_STATES.keys()):
state = _STATES[state_name]
for item in state['states']:
- file.Write("%s %s;\n" % (item['type'], item['name']))
+ if isinstance(item['default'], list):
+ file.Write("%s %s[%d];\n" % (item['type'], item['name'],
+ len(item['default'])))
+ else:
+ file.Write("%s %s;\n" % (item['type'], item['name']))
+
if item.get('cached', False):
- file.Write("%s cached_%s;\n" % (item['type'], item['name']))
+ if isinstance(item['default'], list):
+ file.Write("%s cached_%s[%d];\n" % (item['type'], item['name'],
+ len(item['default'])))
+ else:
+ file.Write("%s cached_%s;\n" % (item['type'], item['name']))
+
file.Write("\n")
file.Write("""
else:
for item in state['states']:
file.Write(" case %s:\n" % item['enum'])
- file.Write(" *num_written = 1;\n")
- file.Write(" if (params) {\n")
- file.Write(" params[0] = static_cast<%s>(%s);\n" %
- (gl_type, item['name']))
+ if isinstance(item['default'], list):
+ item_len = len(item['default'])
+ file.Write(" *num_written = %d;\n" % item_len)
+ file.Write(" if (params) {\n")
+ if item['type'] == gl_type:
+ file.Write(" memcpy(params, %s, sizeof(%s) * %d);\n" %
+ (item['name'], item['type'], item_len))
+ else:
+ file.Write(" for (size_t i = 0; i < %s; ++i) {\n" %
+ item_len)
+ file.Write(" params[i] = %s;\n" %
+ (GetGLGetTypeConversion(gl_type, item['type'],
+ "%s[i]" % item['name'])))
+ file.Write(" }\n");
+ else:
+ file.Write(" *num_written = 1;\n")
+ file.Write(" if (params) {\n")
+ file.Write(" params[0] = %s;\n" %
+ (GetGLGetTypeConversion(gl_type, item['type'],
+ item['name'])))
file.Write(" }\n")
file.Write(" return true;\n")
for capability in _CAPABILITY_FLAGS:
for state_name in sorted(_STATES.keys()):
state = _STATES[state_name]
for item in state['states']:
- file.Write(" %s = %s;\n" % (item['name'], item['default']))
+ if isinstance(item['default'], list):
+ for ndx, value in enumerate(item['default']):
+ file.Write(" %s[%d] = %s;\n" % (item['name'], ndx, value))
+ else:
+ file.Write(" %s = %s;\n" % (item['name'], item['default']))
if item.get('cached', False):
- file.Write(" cached_%s = %s;\n" % (item['name'], item['default']))
+ if isinstance(item['default'], list):
+ for ndx, value in enumerate(item['default']):
+ file.Write(" cached_%s[%d] = %s;\n" % (item['name'], ndx, value))
+ else:
+ file.Write(" cached_%s = %s;\n" % (item['name'], item['default']))
file.Write("}\n")
file.Write("""
item_name = CachedStateName(item)
if 'extension_flag' in item:
- file.Write(" if (feature_info_->feature_flags().%s)\n " %
+ file.Write(" if (feature_info_->feature_flags().%s) {\n " %
item['extension_flag'])
if test_prev:
- file.Write(" if (prev_state->%s != %s)\n" %
- (item_name, item_name))
+ if isinstance(item['default'], list):
+ file.Write(" if (memcmp(prev_state->%s, %s, "
+ "sizeof(%s) * %d)) {\n" %
+ (item_name, item_name, item['type'],
+ len(item['default'])))
+ else:
+ file.Write(" if (prev_state->%s != %s) {\n " %
+ (item_name, item_name))
file.Write(" gl%s(%s, %s);\n" %
- (state['func'], item['enum'], item_name))
+ (state['func'],
+ (item['enum_set']
+ if 'enum_set' in item else item['enum']),
+ item['name']))
+ if test_prev:
+ if 'extension_flag' in item:
+ file.Write(" ")
+ file.Write(" }")
+ if 'extension_flag' in item:
+ file.Write(" }")
else:
+ if 'extension_flag' in state:
+ file.Write(" if (feature_info_->feature_flags().%s)\n " %
+ state['extension_flag'])
if test_prev:
file.Write(" if (")
args = []
file.Write(" } else {")
WriteStates(False)
file.Write(" }")
-
file.Write("}\n")
file.Write("""bool ContextState::GetEnabled(GLenum cap) const {
file = CHeaderWriter(
name,
"// It is included by gles2_cmd_decoder_unittest_%d.cc\n" % count)
- file.SetFileNum(count)
+ test_name = 'GLES2DecoderTest%d' % count
end = test_num + FUNCTIONS_PER_FILE
if end > num_tests:
end = num_tests
for idx in range(test_num, end):
func = self.functions[idx]
+
+ # Do any filtering of the functions here, so that the functions
+ # will not move between the numbered files if filtering properties
+ # are changed.
+ if func.GetInfo('extension_flag'):
+ continue
+
if True:
#gen_cmd = func.GetInfo('gen_cmd')
#if gen_cmd == True or gen_cmd == None:
if func.GetInfo('unit_test') == False:
file.Write("// TODO(gman): %s\n" % func.name)
else:
- func.WriteServiceUnitTest(file)
+ func.WriteServiceUnitTest(file, {
+ 'test_name': test_name
+ })
file.Close()
file = CHeaderWriter(
elif state['type'] == 'NamedParameter':
for item in state['states']:
if 'extension_flag' in item:
- continue
+ file.Write(" if (group_->feature_info()->feature_flags().%s) {\n" %
+ item['extension_flag'])
+ file.Write(" ")
+ expect_value = item['default']
+ if isinstance(expect_value, list):
+ # TODO: Currently we do not check array values.
+ expect_value = "_"
+
file.Write(
" EXPECT_CALL(*gl_, %s(%s, %s))\n" %
- (state['func'], item['enum'], item['default']))
+ (state['func'],
+ (item['enum_set']
+ if 'enum_set' in item else item['enum']),
+ expect_value))
file.Write(" .Times(1)\n")
file.Write(" .RetiresOnSaturation();\n")
+ if 'extension_flag' in item:
+ file.Write(" }\n")
else:
+ if 'extension_flag' in state:
+ file.Write(" if (group_->feature_info()->feature_flags().%s) {\n" %
+ state['extension_flag'])
+ file.Write(" ")
args = []
for item in state['states']:
if 'expected' in item:
args.append(item['expected'])
else:
args.append(item['default'])
+ # TODO: Currently we do not check array values.
+ args = ["_" if isinstance(arg, list) else arg for arg in args]
file.Write(" EXPECT_CALL(*gl_, %s(%s))\n" %
(state['func'], ", ".join(args)))
file.Write(" .Times(1)\n")
file.Write(" .RetiresOnSaturation();\n")
+ if 'extension_flag' in state:
+ file.Write(" }\n")
file.Write("""}
""")
file.Close()
+ def WriteServiceUnitTestsForExtensions(self, filename):
+ """Writes the service decorder unit tests for functions with extension_flag.
+
+ The functions are special in that they need a specific unit test
+ baseclass to turn on the extension.
+ """
+ functions = [f for f in self.functions if f.GetInfo('extension_flag')]
+ file = CHeaderWriter(
+ filename,
+ "// It is included by gles2_cmd_decoder_unittest_extensions.cc\n")
+ for func in functions:
+ if True:
+ if func.GetInfo('unit_test') == False:
+ file.Write("// TODO(gman): %s\n" % func.name)
+ else:
+ extension = ToCamelCase(
+ ToGLExtensionString(func.GetInfo('extension_flag')))
+ func.WriteServiceUnitTest(file, {
+ 'test_name': 'GLES2DecoderTestWith%s' % extension
+ })
+
+ file.Close()
+
def WriteGLES2Header(self, filename):
"""Writes the GLES2 header."""
file = CHeaderWriter(
def WritePepperGLES2Interface(self, filename, dev):
"""Writes the Pepper OpenGLES interface definition."""
- file = CHeaderWriter(
- filename,
- "// OpenGL ES interface.\n")
+ file = CWriter(filename)
+ file.Write(_LICENSE)
+ file.Write(_DO_NOT_EDIT_WARNING)
+ file.Write("label Chrome {\n")
+ file.Write(" M39 = 1.0\n")
+ file.Write("};\n\n")
+
+ if not dev:
+ # Declare GL types.
+ file.Write("[version=1.0]\n")
+ file.Write("describe {\n")
+ for gltype in ['GLbitfield', 'GLboolean', 'GLbyte', 'GLclampf',
+ 'GLclampx', 'GLenum', 'GLfixed', 'GLfloat', 'GLint',
+ 'GLintptr', 'GLshort', 'GLsizei', 'GLsizeiptr',
+ 'GLubyte', 'GLuint', 'GLushort']:
+ file.Write(" %s;\n" % gltype)
+ file.Write(" %s_ptr_t;\n" % gltype)
+ file.Write("};\n\n")
+
+ # C level typedefs.
+ file.Write("#inline c\n")
file.Write("#include \"ppapi/c/pp_resource.h\"\n")
if dev:
file.Write("#include \"ppapi/c/ppb_opengles2.h\"\n\n")
file.Write("typedef %s %s;\n" % (v, k))
file.Write("#endif // _WIN64\n")
file.Write("#endif // __gl2_h_\n\n")
+ file.Write("#endinl\n")
for interface in self.pepper_interfaces:
if interface.dev != dev:
continue
- file.Write("#define %s_1_0 \"%s;1.0\"\n" %
- (interface.GetInterfaceName(), interface.GetInterfaceString()))
- file.Write("#define %s %s_1_0\n" %
- (interface.GetInterfaceName(), interface.GetInterfaceName()))
-
- file.Write("\nstruct %s {\n" % interface.GetStructName())
+ # Historically, we provide OpenGLES2 interfaces with struct
+ # namespace. Not to break code which uses the interface as
+ # "struct OpenGLES2", we put it in struct namespace.
+ file.Write('\n[macro="%s", force_struct_namespace]\n' %
+ interface.GetInterfaceName())
+ file.Write("interface %s {\n" % interface.GetStructName())
for func in self.original_functions:
if not func.InPepperInterface(interface):
continue
- original_arg = func.MakeTypedPepperArgString("")
- context_arg = "PP_Resource context"
- if len(original_arg):
- arg = context_arg + ", " + original_arg
- else:
- arg = context_arg
- file.Write(" %s (*%s)(%s);\n" %
- (func.return_type, func.GetPepperName(), arg))
+ ret_type = func.MapCTypeToPepperIdlType(func.return_type,
+ is_for_return_type=True)
+ func_prefix = " %s %s(" % (ret_type, func.GetPepperName())
+ file.Write(func_prefix)
+ file.Write("[in] PP_Resource context")
+ for arg in func.MakeTypedPepperIdlArgStrings():
+ file.Write(",\n" + " " * len(func_prefix) + arg)
+ file.Write(");\n")
file.Write("};\n\n")
gl_state_valid = _NAMED_TYPE_INFO['GLState']['valid']
for state_name in sorted(_STATES.keys()):
state = _STATES[state_name]
+ if 'extension_flag' in state:
+ continue
if 'enum' in state:
if not state['enum'] in gl_state_valid:
gl_state_valid.append(state['enum'])
if options.output_dir != None:
os.chdir(options.output_dir)
- gen.WritePepperGLES2Interface("ppapi/c/ppb_opengles2.h", False)
- gen.WritePepperGLES2Interface("ppapi/c/dev/ppb_opengles2ext_dev.h", True)
+ gen.WritePepperGLES2Interface("ppapi/api/ppb_opengles2.idl", False)
+ gen.WritePepperGLES2Interface("ppapi/api/dev/ppb_opengles2ext_dev.idl", True)
gen.WriteGLES2ToPPAPIBridge("ppapi/lib/gl/gles2/gles2.c")
gen.WritePepperGLES2Implementation(
"ppapi/shared_impl/ppb_opengles2_shared.cc")
gen.WriteClientContextStateImpl(
"client/client_context_state_impl_autogen.h")
gen.WriteServiceUnitTests("service/gles2_cmd_decoder_unittest_%d_autogen.h")
+ gen.WriteServiceUnitTestsForExtensions(
+ "service/gles2_cmd_decoder_unittest_extensions_autogen.h")
gen.WriteServiceUtilsHeader("service/gles2_cmd_validation_autogen.h")
gen.WriteServiceUtilsImplementation(
"service/gles2_cmd_validation_implementation_autogen.h")
mojo_gles2_prefix + "_autogen.h",
mojo_gles2_prefix + "_chromium_texture_mailbox_autogen.h",
mojo_gles2_prefix + "_chromium_sync_point_autogen.h",
- "ppapi/c/dev/ppb_opengles2ext_dev.h",
- "ppapi/c/ppb_opengles2.h",
"ppapi/lib/gl/gles2/gles2.c",
"ppapi/shared_impl/ppb_opengles2_shared.cc"])
projects / platform / framework / web / crosswalk.git / blobdiff