chromium/src
0
Fork 0
Code Activity

Add Sync related APIs to GPU command buffer.

Browse Source 
glFenceSync
glIsFence
glDeleteFence

Most of the work is to deal with the fact that GLsync is not like any other ID types (GLuint).

BUG=429053
TEST=gpu_unittests

Review URL: https://codereview.chromium.org/859043005

Cr-Commit-Position: refs/heads/master@{#312544}
This commit is contained in:
zmo
2015-01-21 18:50:24 -08:00
committed by Commit bot
parent 2eff74b542
commit b5e2c68d25
32 changed files with 1093 additions and 455 deletions

3
gpu/GLES2/gl2chromium_autogen.h

@ -55,6 +55,7 @@
#define glDeleteProgram GLES2_GET_FUN(DeleteProgram)
#define glDeleteRenderbuffers GLES2_GET_FUN(DeleteRenderbuffers)
#define glDeleteSamplers GLES2_GET_FUN(DeleteSamplers)
#define glDeleteSync GLES2_GET_FUN(DeleteSync)
#define glDeleteShader GLES2_GET_FUN(DeleteShader)
#define glDeleteTextures GLES2_GET_FUN(DeleteTextures)
#define glDeleteTransformFeedbacks GLES2_GET_FUN(DeleteTransformFeedbacks)
@ -68,6 +69,7 @@
#define glDrawElements GLES2_GET_FUN(DrawElements)
#define glEnable GLES2_GET_FUN(Enable)
#define glEnableVertexAttribArray GLES2_GET_FUN(EnableVertexAttribArray)
#define glFenceSync GLES2_GET_FUN(FenceSync)
#define glFinish GLES2_GET_FUN(Finish)
#define glFlush GLES2_GET_FUN(Flush)
#define glFramebufferRenderbuffer GLES2_GET_FUN(FramebufferRenderbuffer)
@ -121,6 +123,7 @@
#define glIsRenderbuffer GLES2_GET_FUN(IsRenderbuffer)
#define glIsSampler GLES2_GET_FUN(IsSampler)
#define glIsShader GLES2_GET_FUN(IsShader)
#define glIsSync GLES2_GET_FUN(IsSync)
#define glIsTexture GLES2_GET_FUN(IsTexture)
#define glIsTransformFeedback GLES2_GET_FUN(IsTransformFeedback)
#define glLineWidth GLES2_GET_FUN(LineWidth)

240
gpu/command_buffer/build_gles2_cmd_buffer.py

@ -1368,6 +1368,27 @@ _NAMED_TYPE_INFO = {
'GL_UNKNOWN_CONTEXT_RESET_ARB',
],
},
'SyncCondition': {
'type': 'GLenum',
'is_complete': True,
'valid': [
#TODO(zmo): avoid using the direct number.
'0x9117', # GL_SYNC_GPU_COMMANDS_COMPLETE
],
'invalid': [
'0',
],
},
'SyncFlags': {
'type': 'GLbitfield',
'is_complete': True,
'valid': [
'0',
],
'invalid': [
'1',
],
},
}
# This table specifies the different pepper interfaces that are supported for
@ -1815,7 +1836,7 @@ _FUNCTION_INFO = {
'resource_type': 'Framebuffer',
'resource_types': 'Framebuffers',
},
'DeleteProgram': {'type': 'Delete', 'decoder_func': 'DoDeleteProgram'},
'DeleteProgram': { 'type': 'Delete' },
'DeleteRenderbuffers': {
'type': 'DELn',
'gl_test_func': 'glDeleteRenderbuffersEXT',
@ -1828,7 +1849,13 @@ _FUNCTION_INFO = {
'resource_types': 'Samplers',
'unsafe': True,
},
'DeleteShader': {'type': 'Delete', 'decoder_func': 'DoDeleteShader'},
'DeleteShader': { 'type': 'Delete' },
'DeleteSync': {
'type': 'Delete',
'cmd_args': 'GLuint sync',
'resource_type': 'Sync',
'unsafe': True,
},
'DeleteTextures': {
'type': 'DELn',
'resource_type': 'Texture',
@ -1883,6 +1910,11 @@ _FUNCTION_INFO = {
'decoder_func': 'DoEnableVertexAttribArray',
'impl_decl': False,
},
'FenceSync': {
'type': 'Create',
'client_test': False,
'unsafe': True,
},
'Finish': {
'impl_func': False,
'client_test': False,
@ -2209,6 +2241,7 @@ _FUNCTION_INFO = {
'IsEnabled': {
'type': 'Is',
'decoder_func': 'DoIsEnabled',
'client_test': False,
'impl_func': False,
'expectation': False,
},
@ -2238,6 +2271,13 @@ _FUNCTION_INFO = {
'expectation': False,
'unsafe': True,
},
'IsSync': {
'type': 'Is',
'id_mapping': [ 'Sync' ],
'cmd_args': 'GLuint sync',
'expectation': False,
'unsafe': True,
},
'IsTexture': {
'type': 'Is',
'decoder_func': 'DoIsTexture',
@ -4942,26 +4982,61 @@ class CreateHandler(TypeHandler):
"""Overrriden from TypeHandler."""
func.AddCmdArg(Argument("client_id", 'uint32_t'))
def __GetResourceType(self, func):
if func.return_type == "GLsync":
return "Sync"
else:
return func.name[6:] # Create*
def WriteServiceUnitTest(self, func, file, *extras):
"""Overrriden from TypeHandler."""
valid_test = """
TEST_P(%(test_name)s, %(name)sValidArgs) {
EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s))
.WillOnce(Return(kNewServiceId));
%(id_type_cast)sEXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s))
.WillOnce(Return(%(const_service_id)s));
SpecializedSetup<cmds::%(name)s, 0>(true);
cmds::%(name)s cmd;
cmd.Init(%(args)s%(comma)skNewClientId);
cmd.Init(%(args)s%(comma)skNewClientId);"""
if func.IsUnsafe():
valid_test += """
decoder_->set_unsafe_es3_apis_enabled(true);"""
valid_test += """
EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
EXPECT_EQ(GL_NO_ERROR, GetGLError());
EXPECT_TRUE(Get%(resource_type)s(kNewClientId) != NULL);
EXPECT_EQ(GL_NO_ERROR, GetGLError());"""
if func.IsUnsafe():
valid_test += """
%(return_type)s service_id = 0;
EXPECT_TRUE(Get%(resource_type)sServiceId(kNewClientId, &service_id));
EXPECT_EQ(%(const_service_id)s, service_id);
decoder_->set_unsafe_es3_apis_enabled(false);
EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
}
"""
else:
valid_test += """
EXPECT_TRUE(Get%(resource_type)s(kNewClientId));
}
"""
comma = ""
if len(func.GetOriginalArgs()):
comma =", "
cmd_arg_count = 0
for arg in func.GetOriginalArgs():
if not arg.IsConstant():
cmd_arg_count += 1
if cmd_arg_count:
comma = ", "
if func.return_type == 'GLsync':
id_type_cast = ("const GLsync kNewServiceIdGLuint = reinterpret_cast"
"<GLsync>(kNewServiceId);\n ")
const_service_id = "kNewServiceIdGLuint"
else:
id_type_cast = ""
const_service_id = "kNewServiceId"
self.WriteValidUnitTest(func, file, valid_test, {
'comma': comma,
'resource_type': func.name[6:],
'resource_type': self.__GetResourceType(func),
'return_type': func.return_type,
'id_type_cast': id_type_cast,
'const_service_id': const_service_id,
}, *extras)
invalid_test = """
TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
@ -4978,11 +5053,33 @@ TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
def WriteHandlerImplementation (self, func, file):
"""Overrriden from TypeHandler."""
file.Write(" uint32_t client_id = c.client_id;\n")
file.Write(" if (!%sHelper(%s)) {\n" %
(func.name, func.MakeCmdArgString("")))
file.Write(" return error::kInvalidArguments;\n")
file.Write(" }\n")
if func.IsUnsafe():
code = """ uint32_t client_id = c.client_id;
%(return_type)s service_id = 0;
if (group_->Get%(resource_name)sServiceId(client_id, &service_id)) {
return error::kInvalidArguments;
}
service_id = %(gl_func_name)s(%(gl_args)s);
if (service_id) {
group_->Add%(resource_name)sId(client_id, service_id);
}
"""
else:
code = """ uint32_t client_id = c.client_id;
if (Get%(resource_name)s(client_id)) {
return error::kInvalidArguments;
}
%(return_type)s service_id = %(gl_func_name)s(%(gl_args)s);
if (service_id) {
Create%(resource_name)s(client_id, service_id%(gl_args_with_comma)s);
}
"""
file.Write(code % {
'resource_name': self.__GetResourceType(func),
'return_type': func.return_type,
'gl_func_name': func.GetGLFunctionName(),
'gl_args': func.MakeOriginalArgString(""),
'gl_args_with_comma': func.MakeOriginalArgString("", True) })
def WriteGLES2Implementation(self, func, file):
"""Overrriden from TypeHandler."""
@ -4995,14 +5092,21 @@ TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
for arg in func.GetOriginalArgs():
arg.WriteClientSideValidationCode(file, func)
file.Write(" GLuint client_id;\n")
file.Write(
" GetIdHandler(id_namespaces::kProgramsAndShaders)->\n")
if func.return_type == "GLsync":
file.Write(
" GetIdHandler(id_namespaces::kSyncs)->\n")
else:
file.Write(
" GetIdHandler(id_namespaces::kProgramsAndShaders)->\n")
file.Write(" MakeIds(this, 0, 1, &client_id);\n")
file.Write(" helper_->%s(%s);\n" %
(func.name, func.MakeCmdArgString("")))
file.Write(' GPU_CLIENT_LOG("returned " << client_id);\n')
file.Write(" CheckGLError();\n")
file.Write(" return client_id;\n")
if func.return_type == "GLsync":
file.Write(" return reinterpret_cast<GLsync>(client_id);\n")
else:
file.Write(" return client_id;\n")
file.Write("}\n")
file.Write("\n")
@ -5015,6 +5119,9 @@ class DeleteHandler(TypeHandler):
def WriteServiceImplementation(self, func, file):
"""Overrriden from TypeHandler."""
if func.IsUnsafe():
TypeHandler.WriteServiceImplementation(self, func, file)
# HandleDeleteShader and HandleDeleteProgram are manually written.
pass
def WriteGLES2Implementation(self, func, file):
@ -5035,6 +5142,25 @@ class DeleteHandler(TypeHandler):
file.Write("}\n")
file.Write("\n")
def WriteHandlerImplementation (self, func, file):
"""Overrriden from TypeHandler."""
assert len(func.GetOriginalArgs()) == 1
arg = func.GetOriginalArgs()[0]
if func.IsUnsafe():
file.Write(""" %(arg_type)s service_id = 0;
if (group_->Get%(resource_type)sServiceId(%(arg_name)s, &service_id)) {
glDelete%(resource_type)s(service_id);
group_->Remove%(resource_type)sId(%(arg_name)s);
} else {
LOCAL_SET_GL_ERROR(
GL_INVALID_VALUE, "gl%(func_name)s", "unknown %(arg_name)s");
}
""" % { 'resource_type': func.GetInfo('resource_type'),
'arg_name': arg.name,
'arg_type': arg.type,
'func_name': func.original_name })
else:
file.Write(" %sHelper(%s);\n" % (func.original_name, arg.name))
class DELnHandler(TypeHandler):
"""Handler for glDelete___ type functions."""
@ -6715,8 +6841,10 @@ TEST_P(%(test_name)s, %(name)sInvalidArgsBadSharedMemoryId) {
if func.IsUnsafe():
assert func.GetInfo('id_mapping')
assert len(func.GetInfo('id_mapping')) == 1
assert len(args) == 1
id_type = func.GetInfo('id_mapping')[0]
file.Write(" *result_dst = group_->Get%sServiceId(%s, &%s);\n" %
file.Write(" %s service_%s = 0;\n" % (args[0].type, id_type.lower()))
file.Write(" *result_dst = group_->Get%sServiceId(%s, &service_%s);\n" %
(id_type, id_type.lower(), id_type.lower()))
else:
file.Write(" *result_dst = %s(%s);\n" %
@ -6743,13 +6871,15 @@ TEST_P(%(test_name)s, %(name)sInvalidArgsBadSharedMemoryId) {
file.Write(" return %s;\n" % error_value)
file.Write(" }\n")
file.Write(" *result = 0;\n")
arg_string = func.MakeOriginalArgString("")
comma = ""
if len(arg_string) > 0:
comma = ", "
assert len(func.GetOriginalArgs()) == 1
id_arg = func.GetOriginalArgs()[0]
if id_arg.type == 'GLsync':
arg_string = "ToGLuint(%s)" % func.MakeOriginalArgString("")
else:
arg_string = func.MakeOriginalArgString("")
file.Write(
" helper_->%s(%s%sGetResultShmId(), GetResultShmOffset());\n" %
(func.name, arg_string, comma))
" helper_->%s(%s, GetResultShmId(), GetResultShmOffset());\n" %
(func.name, arg_string))
file.Write(" WaitForCmd();\n")
file.Write(" %s result_value = *result" % func.return_type)
if func.return_type == "GLboolean":
@ -6773,20 +6903,23 @@ TEST_F(GLES2ImplementationTest, %(name)s) {
Cmds expected;
ExpectedMemoryInfo result1 =
GetExpectedResultMemory(sizeof(cmds::%(name)s::Result));
expected.cmd.Init(1, result1.id, result1.offset);
expected.cmd.Init(%(cmd_id_value)s, result1.id, result1.offset);
EXPECT_CALL(*command_buffer(), OnFlush())
.WillOnce(SetMemory(result1.ptr, uint32_t(1)))
.WillOnce(SetMemory(result1.ptr, uint32_t(GL_TRUE)))
.RetiresOnSaturation();
GLboolean result = gl_->%(name)s(1);
GLboolean result = gl_->%(name)s(%(gl_id_value)s);
EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
EXPECT_TRUE(result);
}
"""
args = func.GetOriginalArgs()
assert len(args) == 1
file.Write(code % {
'name': func.name,
})
'name': func.name,
'cmd_id_value': args[0].GetValidClientSideCmdArg(func),
'gl_id_value': args[0].GetValidClientSideArg(func) })
class STRnHandler(TypeHandler):
@ -7011,6 +7144,8 @@ class Argument(object):
return valid_arg
index = func.GetOriginalArgs().index(self)
if self.type == 'GLsync':
return ("reinterpret_cast<GLsync>(%d)" % (index + 1))
return str(index + 1)
def GetValidClientSideCmdArg(self, func):
@ -7028,7 +7163,10 @@ class Argument(object):
def GetValidGLArg(self, func):
"""Gets a valid GL value for this argument."""
return self.GetValidArg(func)
value = self.GetValidArg(func)
if self.type == 'GLsync':
return ("reinterpret_cast<GLsync>(%s)" % value)
return value
def GetValidNonCachedClientSideArg(self, func):
"""Returns a valid value for this argument in a GL call.
@ -7061,8 +7199,12 @@ class Argument(object):
def WriteGetCode(self, file):
"""Writes the code to get an argument from a command structure."""
if self.type == 'GLsync':
my_type = 'GLuint'
else:
my_type = self.type
file.Write(" %s %s = static_cast<%s>(c.%s);\n" %
(self.type, self.name, self.type, self.name))
(my_type, self.name, my_type, self.name))
def WriteValidationCode(self, file, func):
"""Writes the validation code for an argument."""
@ -7196,7 +7338,8 @@ class SizeNotNegativeArgument(SizeArgument):
class EnumBaseArgument(Argument):
"""Base class for EnumArgument, IntArgument and ValidatedBoolArgument"""
"""Base class for EnumArgument, IntArgument, BitfieldArgument, and
ValidatedBoolArgument."""
def __init__(self, name, gl_type, type, gl_error):
Argument.__init__(self, name, gl_type)
@ -7312,7 +7455,7 @@ class EnumArgument(EnumBaseArgument):
class IntArgument(EnumBaseArgument):
"""A class for a GLint argument that can only except specific values.
"""A class for a GLint argument that can only accept specific values.
For example glTexImage2D takes a GLint for its internalformat
argument instead of a GLenum.
@ -7323,7 +7466,7 @@ class IntArgument(EnumBaseArgument):
class ValidatedBoolArgument(EnumBaseArgument):
"""A class for a GLboolean argument that can only except specific values.
"""A class for a GLboolean argument that can only accept specific values.
For example glUniformMatrix takes a GLboolean for it's transpose but it
must be false.
@ -7337,6 +7480,18 @@ class ValidatedBoolArgument(EnumBaseArgument):
return 'GLES2Util::GetStringBool(%s)' % self.name
class BitFieldArgument(EnumBaseArgument):
"""A class for a GLbitfield argument that can only accept specific values.
For example glFenceSync takes a GLbitfield for its flags argument bit it
must be 0.
"""
def __init__(self, name, type):
EnumBaseArgument.__init__(self, name, "GLbitfield", type,
"GL_INVALID_VALUE")
class ImmediatePointerArgument(Argument):
"""A class that represents an immediate argument to a function.
@ -7584,17 +7739,26 @@ class ResourceIdArgument(Argument):
def __init__(self, name, type):
match = re.match("(GLid\w+)", type)
self.resource_type = match.group(1)[4:]
type = type.replace(match.group(1), "GLuint")
if self.resource_type == "Sync":
type = type.replace(match.group(1), "GLsync")
else:
type = type.replace(match.group(1), "GLuint")
Argument.__init__(self, name, type)
def WriteGetCode(self, file):
"""Overridden from Argument."""
file.Write(" %s %s = c.%s;\n" % (self.type, self.name, self.name))
if self.type == "GLsync":
my_type = "GLuint"
else:
my_type = self.type
file.Write(" %s %s = c.%s;\n" % (my_type, self.name, self.name))
def GetValidArg(self, func):
return "client_%s_id_" % self.resource_type.lower()
def GetValidGLArg(self, func):
if self.resource_type == "Sync":
return "reinterpret_cast<GLsync>(kService%sId)" % self.resource_type
return "kService%sId" % self.resource_type
@ -8307,6 +8471,8 @@ def CreateArg(arg_string):
return ResourceIdArgument(arg_parts[-1], " ".join(arg_parts[0:-1]))
elif arg_parts[0].startswith('GLenum') and len(arg_parts[0]) > 6:
return EnumArgument(arg_parts[-1], " ".join(arg_parts[0:-1]))
elif arg_parts[0].startswith('GLbitfield') and len(arg_parts[0]) > 10:
return BitFieldArgument(arg_parts[-1], " ".join(arg_parts[0:-1]))
elif arg_parts[0].startswith('GLboolean') and len(arg_parts[0]) > 9:
return ValidatedBoolArgument(arg_parts[-1], " ".join(arg_parts[0:-1]))
elif arg_parts[0].startswith('GLboolean'):

21
gpu/command_buffer/client/gles2_c_lib_autogen.h

@ -205,6 +205,9 @@ void GLES2DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) {
void GLES2DeleteSamplers(GLsizei n, const GLuint* samplers) {
gles2::GetGLContext()->DeleteSamplers(n, samplers);
}
void GLES2DeleteSync(GLsync sync) {
gles2::GetGLContext()->DeleteSync(sync);
}
void GLES2DeleteShader(GLuint shader) {
gles2::GetGLContext()->DeleteShader(shader);
}
@ -247,6 +250,9 @@ void GLES2Enable(GLenum cap) {
void GLES2EnableVertexAttribArray(GLuint index) {
gles2::GetGLContext()->EnableVertexAttribArray(index);
}
GLsync GLES2FenceSync(GLenum condition, GLbitfield flags) {
return gles2::GetGLContext()->FenceSync(condition, flags);
}
void GLES2Finish() {
gles2::GetGLContext()->Finish();
}
@ -467,6 +473,9 @@ GLboolean GLES2IsSampler(GLuint sampler) {
GLboolean GLES2IsShader(GLuint shader) {
return gles2::GetGLContext()->IsShader(shader);
}
GLboolean GLES2IsSync(GLsync sync) {
return gles2::GetGLContext()->IsSync(sync);
}
GLboolean GLES2IsTexture(GLuint texture) {
return gles2::GetGLContext()->IsTexture(texture);
}
@ -1383,6 +1392,10 @@ extern const NameToFunc g_gles2_function_table[] = {
"glDeleteSamplers",
reinterpret_cast<GLES2FunctionPointer>(glDeleteSamplers),
},
{
"glDeleteSync",
reinterpret_cast<GLES2FunctionPointer>(glDeleteSync),
},
{
"glDeleteShader",
reinterpret_cast<GLES2FunctionPointer>(glDeleteShader),
@ -1435,6 +1448,10 @@ extern const NameToFunc g_gles2_function_table[] = {
"glEnableVertexAttribArray",
reinterpret_cast<GLES2FunctionPointer>(glEnableVertexAttribArray),
},
{
"glFenceSync",
reinterpret_cast<GLES2FunctionPointer>(glFenceSync),
},
{
"glFinish",
reinterpret_cast<GLES2FunctionPointer>(glFinish),
@ -1644,6 +1661,10 @@ extern const NameToFunc g_gles2_function_table[] = {
"glIsShader",
reinterpret_cast<GLES2FunctionPointer>(glIsShader),
},
{
"glIsSync",
reinterpret_cast<GLES2FunctionPointer>(glIsSync),
},
{
"glIsTexture",
reinterpret_cast<GLES2FunctionPointer>(glIsTexture),

21
gpu/command_buffer/client/gles2_cmd_helper_autogen.h

@ -427,6 +427,13 @@ void DeleteSamplersImmediate(GLsizei n, const GLuint* samplers) {
}
}
void DeleteSync(GLuint sync) {
gles2::cmds::DeleteSync* c = GetCmdSpace<gles2::cmds::DeleteSync>();
if (c) {
c->Init(sync);
}
}
void DeleteShader(GLuint shader) {
gles2::cmds::DeleteShader* c = GetCmdSpace<gles2::cmds::DeleteShader>();
if (c) {
@ -529,6 +536,13 @@ void EnableVertexAttribArray(GLuint index) {
}
}
void FenceSync(uint32_t client_id) {
gles2::cmds::FenceSync* c = GetCmdSpace<gles2::cmds::FenceSync>();
if (c) {
c->Init(client_id);
}
}
void Finish() {
gles2::cmds::Finish* c = GetCmdSpace<gles2::cmds::Finish>();
if (c) {
@ -1042,6 +1056,13 @@ void IsShader(GLuint shader,
}
}
void IsSync(GLuint sync, uint32_t result_shm_id, uint32_t result_shm_offset) {
gles2::cmds::IsSync* c = GetCmdSpace<gles2::cmds::IsSync>();
if (c) {
c->Init(sync, result_shm_id, result_shm_offset);
}
}
void IsTexture(GLuint texture,
uint32_t result_shm_id,
uint32_t result_shm_offset) {

14
gpu/command_buffer/client/gles2_implementation.cc

@ -976,6 +976,20 @@ void GLES2Implementation::DeleteShaderStub(
helper_->DeleteShader(shaders[0]);
}
void GLES2Implementation::DeleteSyncHelper(GLsync sync) {
GLuint sync_uint = ToGLuint(sync);
if (!GetIdHandler(id_namespaces::kSyncs)->FreeIds(
this, 1, &sync_uint, &GLES2Implementation::DeleteSyncStub)) {
SetGLError(
GL_INVALID_VALUE,
"glDeleteSync", "id not created by this context.");
}
}
void GLES2Implementation::DeleteSyncStub(GLsizei n, const GLuint* syncs) {
DCHECK_EQ(1, n);
helper_->DeleteSync(syncs[0]);
}
GLint GLES2Implementation::GetAttribLocationHelper(
GLuint program, const char* name) {

2
gpu/command_buffer/client/gles2_implementation.h

@ -478,6 +478,7 @@ class GLES2_IMPL_EXPORT GLES2Implementation
void DeleteSamplersHelper(GLsizei n, const GLuint* samplers);
void DeleteTransformFeedbacksHelper(
GLsizei n, const GLuint* transformfeedbacks);
void DeleteSyncHelper(GLsync sync);
void DeleteBuffersStub(GLsizei n, const GLuint* buffers);
void DeleteFramebuffersStub(GLsizei n, const GLuint* framebuffers);
@ -490,6 +491,7 @@ class GLES2_IMPL_EXPORT GLES2Implementation
void DeleteSamplersStub(GLsizei n, const GLuint* samplers);
void DeleteTransformFeedbacksStub(
GLsizei n, const GLuint* transformfeedbacks);
void DeleteSyncStub(GLsizei n, const GLuint* syncs);
void BufferDataHelper(
GLenum target, GLsizeiptr size, const void* data, GLenum usage);

6
gpu/command_buffer/client/gles2_implementation_autogen.h

@ -163,6 +163,8 @@ void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) override;
void DeleteSamplers(GLsizei n, const GLuint* samplers) override;
void DeleteSync(GLsync sync) override;
void DeleteShader(GLuint shader) override;
void DeleteTextures(GLsizei n, const GLuint* textures) override;
@ -188,6 +190,8 @@ void DrawElements(GLenum mode,
void Enable(GLenum cap) override;
GLsync FenceSync(GLenum condition, GLbitfield flags) override;
void Finish() override;
void Flush() override;
@ -349,6 +353,8 @@ GLboolean IsSampler(GLuint sampler) override;
GLboolean IsShader(GLuint shader) override;
GLboolean IsSync(GLsync sync) override;
GLboolean IsTexture(GLuint texture) override;
GLboolean IsTransformFeedback(GLuint transformfeedback) override;

47
gpu/command_buffer/client/gles2_implementation_impl_autogen.h

@ -546,6 +546,14 @@ void GLES2Implementation::DeleteSamplers(GLsizei n, const GLuint* samplers) {
CheckGLError();
}
void GLES2Implementation::DeleteSync(GLsync sync) {
GPU_CLIENT_SINGLE_THREAD_CHECK();
GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDeleteSync(" << sync << ")");
GPU_CLIENT_DCHECK(sync != 0);
DeleteSyncHelper(sync);
CheckGLError();
}
void GLES2Implementation::DeleteShader(GLuint shader) {
GPU_CLIENT_SINGLE_THREAD_CHECK();
GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDeleteShader(" << shader << ")");
@ -631,6 +639,27 @@ void GLES2Implementation::DetachShader(GLuint program, GLuint shader) {
CheckGLError();
}
GLsync GLES2Implementation::FenceSync(GLenum condition, GLbitfield flags) {
GPU_CLIENT_SINGLE_THREAD_CHECK();
GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glFenceSync("
<< GLES2Util::GetStringSyncCondition(condition) << ", "
<< flags << ")");
if (condition != 0x9117) {
SetGLError(GL_INVALID_ENUM, "glFenceSync", "condition GL_INVALID_ENUM");
return 0;
}
if (flags != 0) {
SetGLError(GL_INVALID_VALUE, "glFenceSync", "flags GL_INVALID_VALUE");
return 0;
}
GLuint client_id;
GetIdHandler(id_namespaces::kSyncs)->MakeIds(this, 0, 1, &client_id);
helper_->FenceSync(client_id);
GPU_CLIENT_LOG("returned " << client_id);
CheckGLError();
return reinterpret_cast<GLsync>(client_id);
}
void GLES2Implementation::FramebufferRenderbuffer(GLenum target,
GLenum attachment,
GLenum renderbuffertarget,
@ -1463,6 +1492,24 @@ GLboolean GLES2Implementation::IsShader(GLuint shader) {
return result_value;
}
GLboolean GLES2Implementation::IsSync(GLsync sync) {
GPU_CLIENT_SINGLE_THREAD_CHECK();
TRACE_EVENT0("gpu", "GLES2Implementation::IsSync");
GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glIsSync(" << sync << ")");
typedef cmds::IsSync::Result Result;
Result* result = GetResultAs<Result*>();
if (!result) {
return GL_FALSE;
}
*result = 0;
helper_->IsSync(ToGLuint(sync), GetResultShmId(), GetResultShmOffset());
WaitForCmd();
GLboolean result_value = *result != 0;
GPU_CLIENT_LOG("returned " << result_value);
CheckGLError();
return result_value;
}
GLboolean GLES2Implementation::IsTexture(GLuint texture) {
GPU_CLIENT_SINGLE_THREAD_CHECK();
TRACE_EVENT0("gpu", "GLES2Implementation::IsTexture");

23
gpu/command_buffer/client/gles2_implementation_unittest.cc

@ -3555,6 +3555,29 @@ TEST_F(GLES2ImplementationTest, AllowNestedTracesCHROMIUM) {
EXPECT_EQ(GL_INVALID_OPERATION, CheckError());
}
TEST_F(GLES2ImplementationTest, IsEnabled) {
// If we use a valid enum, its state is cached on client side, so no command
// is actually generated, and this test will fail.
// TODO(zmo): it seems we never need the command. Maybe remove it.
GLenum kCap = 1;
struct Cmds {
cmds::IsEnabled cmd;
};
Cmds expected;
ExpectedMemoryInfo result1 =
GetExpectedResultMemory(sizeof(cmds::IsEnabled::Result));
expected.cmd.Init(kCap, result1.id, result1.offset);
EXPECT_CALL(*command_buffer(), OnFlush())
.WillOnce(SetMemory(result1.ptr, uint32_t(kCap)))
.RetiresOnSaturation();
GLboolean result = gl_->IsEnabled(kCap);
EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
EXPECT_TRUE(result);
}
TEST_F(GLES2ImplementationManualInitTest, LoseContextOnOOM) {
ContextInitOptions init_options;
init_options.lose_context_when_out_of_memory = true;

75
gpu/command_buffer/client/gles2_implementation_unittest_autogen.h

@ -174,13 +174,13 @@ TEST_F(GLES2ImplementationTest, CheckFramebufferStatus) {
Cmds expected;
ExpectedMemoryInfo result1 =
GetExpectedResultMemory(sizeof(cmds::CheckFramebufferStatus::Result));
expected.cmd.Init(1, result1.id, result1.offset);
expected.cmd.Init(GL_FRAMEBUFFER, result1.id, result1.offset);
EXPECT_CALL(*command_buffer(), OnFlush())
.WillOnce(SetMemory(result1.ptr, uint32_t(1)))
.WillOnce(SetMemory(result1.ptr, uint32_t(GL_TRUE)))
.RetiresOnSaturation();
GLboolean result = gl_->CheckFramebufferStatus(1);
GLboolean result = gl_->CheckFramebufferStatus(GL_FRAMEBUFFER);
EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
EXPECT_TRUE(result);
}
@ -429,6 +429,17 @@ TEST_F(GLES2ImplementationTest, DeleteSamplers) {
EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
}
TEST_F(GLES2ImplementationTest, DeleteSync) {
struct Cmds {
cmds::DeleteSync cmd;
};
Cmds expected;
expected.cmd.Init(1);
gl_->DeleteSync(reinterpret_cast<GLsync>(1));
EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
}
TEST_F(GLES2ImplementationTest, DeleteShader) {
struct Cmds {
cmds::DeleteShader cmd;
@ -1058,7 +1069,7 @@ TEST_F(GLES2ImplementationTest, IsBuffer) {
expected.cmd.Init(1, result1.id, result1.offset);
EXPECT_CALL(*command_buffer(), OnFlush())
.WillOnce(SetMemory(result1.ptr, uint32_t(1)))
.WillOnce(SetMemory(result1.ptr, uint32_t(GL_TRUE)))
.RetiresOnSaturation();
GLboolean result = gl_->IsBuffer(1);
@ -1066,25 +1077,6 @@ TEST_F(GLES2ImplementationTest, IsBuffer) {
EXPECT_TRUE(result);
}
TEST_F(GLES2ImplementationTest, IsEnabled) {
struct Cmds {
cmds::IsEnabled cmd;
};
Cmds expected;
ExpectedMemoryInfo result1 =
GetExpectedResultMemory(sizeof(cmds::IsEnabled::Result));
expected.cmd.Init(1, result1.id, result1.offset);
EXPECT_CALL(*command_buffer(), OnFlush())
.WillOnce(SetMemory(result1.ptr, uint32_t(1)))
.RetiresOnSaturation();
GLboolean result = gl_->IsEnabled(1);
EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
EXPECT_TRUE(result);
}
TEST_F(GLES2ImplementationTest, IsFramebuffer) {
struct Cmds {
cmds::IsFramebuffer cmd;
@ -1096,7 +1088,7 @@ TEST_F(GLES2ImplementationTest, IsFramebuffer) {
expected.cmd.Init(1, result1.id, result1.offset);
EXPECT_CALL(*command_buffer(), OnFlush())
.WillOnce(SetMemory(result1.ptr, uint32_t(1)))
.WillOnce(SetMemory(result1.ptr, uint32_t(GL_TRUE)))
.RetiresOnSaturation();
GLboolean result = gl_->IsFramebuffer(1);
@ -1115,7 +1107,7 @@ TEST_F(GLES2ImplementationTest, IsProgram) {
expected.cmd.Init(1, result1.id, result1.offset);
EXPECT_CALL(*command_buffer(), OnFlush())
.WillOnce(SetMemory(result1.ptr, uint32_t(1)))
.WillOnce(SetMemory(result1.ptr, uint32_t(GL_TRUE)))
.RetiresOnSaturation();
GLboolean result = gl_->IsProgram(1);
@ -1134,7 +1126,7 @@ TEST_F(GLES2ImplementationTest, IsRenderbuffer) {
expected.cmd.Init(1, result1.id, result1.offset);
EXPECT_CALL(*command_buffer(), OnFlush())
.WillOnce(SetMemory(result1.ptr, uint32_t(1)))
.WillOnce(SetMemory(result1.ptr, uint32_t(GL_TRUE)))
.RetiresOnSaturation();
GLboolean result = gl_->IsRenderbuffer(1);
@ -1153,7 +1145,7 @@ TEST_F(GLES2ImplementationTest, IsSampler) {
expected.cmd.Init(1, result1.id, result1.offset);
EXPECT_CALL(*command_buffer(), OnFlush())
.WillOnce(SetMemory(result1.ptr, uint32_t(1)))
.WillOnce(SetMemory(result1.ptr, uint32_t(GL_TRUE)))
.RetiresOnSaturation();
GLboolean result = gl_->IsSampler(1);
@ -1172,7 +1164,7 @@ TEST_F(GLES2ImplementationTest, IsShader) {
expected.cmd.Init(1, result1.id, result1.offset);
EXPECT_CALL(*command_buffer(), OnFlush())
.WillOnce(SetMemory(result1.ptr, uint32_t(1)))
.WillOnce(SetMemory(result1.ptr, uint32_t(GL_TRUE)))
.RetiresOnSaturation();
GLboolean result = gl_->IsShader(1);
@ -1180,6 +1172,25 @@ TEST_F(GLES2ImplementationTest, IsShader) {
EXPECT_TRUE(result);
}
TEST_F(GLES2ImplementationTest, IsSync) {
struct Cmds {
cmds::IsSync cmd;
};
Cmds expected;
ExpectedMemoryInfo result1 =
GetExpectedResultMemory(sizeof(cmds::IsSync::Result));
expected.cmd.Init(1, result1.id, result1.offset);
EXPECT_CALL(*command_buffer(), OnFlush())
.WillOnce(SetMemory(result1.ptr, uint32_t(GL_TRUE)))
.RetiresOnSaturation();
GLboolean result = gl_->IsSync(reinterpret_cast<GLsync>(1));
EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
EXPECT_TRUE(result);
}
TEST_F(GLES2ImplementationTest, IsTexture) {
struct Cmds {
cmds::IsTexture cmd;
@ -1191,7 +1202,7 @@ TEST_F(GLES2ImplementationTest, IsTexture) {
expected.cmd.Init(1, result1.id, result1.offset);
EXPECT_CALL(*command_buffer(), OnFlush())
.WillOnce(SetMemory(result1.ptr, uint32_t(1)))
.WillOnce(SetMemory(result1.ptr, uint32_t(GL_TRUE)))
.RetiresOnSaturation();
GLboolean result = gl_->IsTexture(1);
@ -1210,7 +1221,7 @@ TEST_F(GLES2ImplementationTest, IsTransformFeedback) {
expected.cmd.Init(1, result1.id, result1.offset);
EXPECT_CALL(*command_buffer(), OnFlush())
.WillOnce(SetMemory(result1.ptr, uint32_t(1)))
.WillOnce(SetMemory(result1.ptr, uint32_t(GL_TRUE)))
.RetiresOnSaturation();
GLboolean result = gl_->IsTransformFeedback(1);
@ -2516,7 +2527,7 @@ TEST_F(GLES2ImplementationTest, IsVertexArrayOES) {
expected.cmd.Init(1, result1.id, result1.offset);
EXPECT_CALL(*command_buffer(), OnFlush())
.WillOnce(SetMemory(result1.ptr, uint32_t(1)))
.WillOnce(SetMemory(result1.ptr, uint32_t(GL_TRUE)))
.RetiresOnSaturation();
GLboolean result = gl_->IsVertexArrayOES(1);
@ -2628,7 +2639,7 @@ TEST_F(GLES2ImplementationTest, IsValuebufferCHROMIUM) {
expected.cmd.Init(1, result1.id, result1.offset);
EXPECT_CALL(*command_buffer(), OnFlush())
.WillOnce(SetMemory(result1.ptr, uint32_t(1)))
.WillOnce(SetMemory(result1.ptr, uint32_t(GL_TRUE)))
.RetiresOnSaturation();
GLboolean result = gl_->IsValuebufferCHROMIUM(1);

3
gpu/command_buffer/client/gles2_interface_autogen.h

@ -121,6 +121,7 @@ virtual void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) = 0;
virtual void DeleteProgram(GLuint program) = 0;
virtual void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) = 0;
virtual void DeleteSamplers(GLsizei n, const GLuint* samplers) = 0;
virtual void DeleteSync(GLsync sync) = 0;
virtual void DeleteShader(GLuint shader) = 0;
virtual void DeleteTextures(GLsizei n, const GLuint* textures) = 0;
virtual void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) = 0;
@ -137,6 +138,7 @@ virtual void DrawElements(GLenum mode,
const void* indices) = 0;
virtual void Enable(GLenum cap) = 0;
virtual void EnableVertexAttribArray(GLuint index) = 0;
virtual GLsync FenceSync(GLenum condition, GLbitfield flags) = 0;
virtual void Finish() = 0;
virtual void Flush() = 0;
virtual void FramebufferRenderbuffer(GLenum target,
@ -254,6 +256,7 @@ virtual GLboolean IsProgram(GLuint program) = 0;
virtual GLboolean IsRenderbuffer(GLuint renderbuffer) = 0;
virtual GLboolean IsSampler(GLuint sampler) = 0;
virtual GLboolean IsShader(GLuint shader) = 0;
virtual GLboolean IsSync(GLsync sync) = 0;
virtual GLboolean IsTexture(GLuint texture) = 0;
virtual GLboolean IsTransformFeedback(GLuint transformfeedback) = 0;
virtual void LineWidth(GLfloat width) = 0;

3
gpu/command_buffer/client/gles2_interface_stub_autogen.h

@ -120,6 +120,7 @@ void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) override;
void DeleteProgram(GLuint program) override;
void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) override;
void DeleteSamplers(GLsizei n, const GLuint* samplers) override;
void DeleteSync(GLsync sync) override;
void DeleteShader(GLuint shader) override;
void DeleteTextures(GLsizei n, const GLuint* textures) override;
void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override;
@ -136,6 +137,7 @@ void DrawElements(GLenum mode,
const void* indices) override;
void Enable(GLenum cap) override;
void EnableVertexAttribArray(GLuint index) override;
GLsync FenceSync(GLenum condition, GLbitfield flags) override;
void Finish() override;
void Flush() override;
void FramebufferRenderbuffer(GLenum target,
@ -249,6 +251,7 @@ GLboolean IsProgram(GLuint program) override;
GLboolean IsRenderbuffer(GLuint renderbuffer) override;
GLboolean IsSampler(GLuint sampler) override;
GLboolean IsShader(GLuint shader) override;
GLboolean IsSync(GLsync sync) override;
GLboolean IsTexture(GLuint texture) override;
GLboolean IsTransformFeedback(GLuint transformfeedback) override;
void LineWidth(GLfloat width) override;

9
gpu/command_buffer/client/gles2_interface_stub_impl_autogen.h

@ -178,6 +178,8 @@ void GLES2InterfaceStub::DeleteRenderbuffers(
void GLES2InterfaceStub::DeleteSamplers(GLsizei /* n */,
const GLuint* /* samplers */) {
}
void GLES2InterfaceStub::DeleteSync(GLsync /* sync */) {
}
void GLES2InterfaceStub::DeleteShader(GLuint /* shader */) {
}
void GLES2InterfaceStub::DeleteTextures(GLsizei /* n */,
@ -213,6 +215,10 @@ void GLES2InterfaceStub::Enable(GLenum /* cap */) {
}
void GLES2InterfaceStub::EnableVertexAttribArray(GLuint /* index */) {
}
GLsync GLES2InterfaceStub::FenceSync(GLenum /* condition */,
GLbitfield /* flags */) {
return 0;
}
void GLES2InterfaceStub::Finish() {
}
void GLES2InterfaceStub::Flush() {
@ -417,6 +423,9 @@ GLboolean GLES2InterfaceStub::IsSampler(GLuint /* sampler */) {
GLboolean GLES2InterfaceStub::IsShader(GLuint /* shader */) {
return 0;
}
GLboolean GLES2InterfaceStub::IsSync(GLsync /* sync */) {
return 0;
}
GLboolean GLES2InterfaceStub::IsTexture(GLuint /* texture */) {
return 0;
}

3
gpu/command_buffer/client/gles2_trace_implementation_autogen.h

@ -120,6 +120,7 @@ void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) override;
void DeleteProgram(GLuint program) override;
void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) override;
void DeleteSamplers(GLsizei n, const GLuint* samplers) override;
void DeleteSync(GLsync sync) override;
void DeleteShader(GLuint shader) override;
void DeleteTextures(GLsizei n, const GLuint* textures) override;
void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override;
@ -136,6 +137,7 @@ void DrawElements(GLenum mode,
const void* indices) override;
void Enable(GLenum cap) override;
void EnableVertexAttribArray(GLuint index) override;
GLsync FenceSync(GLenum condition, GLbitfield flags) override;
void Finish() override;
void Flush() override;
void FramebufferRenderbuffer(GLenum target,
@ -249,6 +251,7 @@ GLboolean IsProgram(GLuint program) override;
GLboolean IsRenderbuffer(GLuint renderbuffer) override;
GLboolean IsSampler(GLuint sampler) override;
GLboolean IsShader(GLuint shader) override;
GLboolean IsSync(GLsync sync) override;
GLboolean IsTexture(GLuint texture) override;
GLboolean IsTransformFeedback(GLuint transformfeedback) override;
void LineWidth(GLfloat width) override;

15
gpu/command_buffer/client/gles2_trace_implementation_impl_autogen.h

@ -302,6 +302,11 @@ void GLES2TraceImplementation::DeleteSamplers(GLsizei n,
gl_->DeleteSamplers(n, samplers);
}
void GLES2TraceImplementation::DeleteSync(GLsync sync) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteSync");
gl_->DeleteSync(sync);
}
void GLES2TraceImplementation::DeleteShader(GLuint shader) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteShader");
gl_->DeleteShader(shader);
@ -374,6 +379,11 @@ void GLES2TraceImplementation::EnableVertexAttribArray(GLuint index) {
gl_->EnableVertexAttribArray(index);
}
GLsync GLES2TraceImplementation::FenceSync(GLenum condition, GLbitfield flags) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::FenceSync");
return gl_->FenceSync(condition, flags);
}
void GLES2TraceImplementation::Finish() {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Finish");
gl_->Finish();
@ -725,6 +735,11 @@ GLboolean GLES2TraceImplementation::IsShader(GLuint shader) {
return gl_->IsShader(shader);
}
GLboolean GLES2TraceImplementation::IsSync(GLsync sync) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsSync");
return gl_->IsSync(sync);
}
GLboolean GLES2TraceImplementation::IsTexture(GLuint texture) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsTexture");
return gl_->IsTexture(texture);

3
gpu/command_buffer/cmd_buffer_functions.txt

@ -46,6 +46,7 @@ GL_APICALL void GL_APIENTRY glDeleteFramebuffers (GLsizeiNotNegative n,
GL_APICALL void GL_APIENTRY glDeleteProgram (GLidProgram program);
GL_APICALL void GL_APIENTRY glDeleteRenderbuffers (GLsizeiNotNegative n, const GLuint* renderbuffers);
GL_APICALL void GL_APIENTRY glDeleteSamplers (GLsizeiNotNegative n, const GLuint* samplers);
GL_APICALL void GL_APIENTRY glDeleteSync (GLidSync sync);
GL_APICALL void GL_APIENTRY glDeleteShader (GLidShader shader);
GL_APICALL void GL_APIENTRY glDeleteTextures (GLsizeiNotNegative n, const GLuint* textures);
GL_APICALL void GL_APIENTRY glDeleteTransformFeedbacks (GLsizeiNotNegative n, const GLuint* ids);
@ -59,6 +60,7 @@ GL_APICALL void GL_APIENTRY glDrawArrays (GLenumDrawMode mode, GLint fir
GL_APICALL void GL_APIENTRY glDrawElements (GLenumDrawMode mode, GLsizei count, GLenumIndexType type, const void* indices);
GL_APICALL void GL_APIENTRY glEnable (GLenumCapability cap);
GL_APICALL void GL_APIENTRY glEnableVertexAttribArray (GLuint index);
GL_APICALL GLsync GL_APIENTRY glFenceSync (GLenumSyncCondition condition, GLbitfieldSyncFlags flags);
GL_APICALL void GL_APIENTRY glFinish (void);
GL_APICALL void GL_APIENTRY glFlush (void);
GL_APICALL void GL_APIENTRY glFramebufferRenderbuffer (GLenumFrameBufferTarget target, GLenumAttachment attachment, GLenumRenderBufferTarget renderbuffertarget, GLidRenderbuffer renderbuffer);
@ -111,6 +113,7 @@ GL_APICALL GLboolean GL_APIENTRY glIsProgram (GLidProgram program);
GL_APICALL GLboolean GL_APIENTRY glIsRenderbuffer (GLidRenderbuffer renderbuffer);
GL_APICALL GLboolean GL_APIENTRY glIsSampler (GLidSampler sampler);
GL_APICALL GLboolean GL_APIENTRY glIsShader (GLidShader shader);
GL_APICALL GLboolean GL_APIENTRY glIsSync (GLidSync sync);
GL_APICALL GLboolean GL_APIENTRY glIsTexture (GLidTexture texture);
GL_APICALL GLboolean GL_APIENTRY glIsTransformFeedback (GLidTransformFeedback transformfeedback);
GL_APICALL void GL_APIENTRY glLineWidth (GLfloat width);

2
gpu/command_buffer/common/gles2_cmd_format.h

@ -42,6 +42,7 @@ typedef double GLclampd;
typedef void GLvoid;
typedef khronos_intptr_t GLintptr;
typedef khronos_ssize_t GLsizeiptr;
typedef struct __GLsync *GLsync;
namespace gpu {
namespace gles2 {
@ -63,6 +64,7 @@ enum IdNamespaces {
kValuebuffers,
kSamplers,
kTransformFeedbacks,
kSyncs,
kNumIdNamespaces
};

113
gpu/command_buffer/common/gles2_cmd_format_autogen.h

@ -2071,6 +2071,38 @@ static_assert(offsetof(DeleteSamplersImmediate, header) == 0,
static_assert(offsetof(DeleteSamplersImmediate, n) == 4,
"offset of DeleteSamplersImmediate n should be 4");
struct DeleteSync {
typedef DeleteSync ValueType;
static const CommandId kCmdId = kDeleteSync;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _sync) {
SetHeader();
sync = _sync;
}
void* Set(void* cmd, GLuint _sync) {
static_cast<ValueType*>(cmd)->Init(_sync);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t sync;
};
static_assert(sizeof(DeleteSync) == 8, "size of DeleteSync should be 8");
static_assert(offsetof(DeleteSync, header) == 0,
"offset of DeleteSync header should be 0");
static_assert(offsetof(DeleteSync, sync) == 4,
"offset of DeleteSync sync should be 4");
struct DeleteShader {
typedef DeleteShader ValueType;
static const CommandId kCmdId = kDeleteShader;
@ -2539,6 +2571,40 @@ static_assert(offsetof(EnableVertexAttribArray, header) == 0,
static_assert(offsetof(EnableVertexAttribArray, index) == 4,
"offset of EnableVertexAttribArray index should be 4");
struct FenceSync {
typedef FenceSync ValueType;
static const CommandId kCmdId = kFenceSync;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(uint32_t _client_id) {
SetHeader();
client_id = _client_id;
}
void* Set(void* cmd, uint32_t _client_id) {
static_cast<ValueType*>(cmd)->Init(_client_id);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t client_id;
static const uint32_t condition = 0x9117;
static const uint32_t flags = 0;
};
static_assert(sizeof(FenceSync) == 8, "size of FenceSync should be 8");
static_assert(offsetof(FenceSync, header) == 0,
"offset of FenceSync header should be 0");
static_assert(offsetof(FenceSync, client_id) == 4,
"offset of FenceSync client_id should be 4");
struct Finish {
typedef Finish ValueType;
static const CommandId kCmdId = kFinish;
@ -5134,6 +5200,53 @@ static_assert(offsetof(IsShader, result_shm_id) == 8,
static_assert(offsetof(IsShader, result_shm_offset) == 12,
"offset of IsShader result_shm_offset should be 12");
struct IsSync {
typedef IsSync ValueType;
static const CommandId kCmdId = kIsSync;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
typedef uint32_t Result;
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _sync,
uint32_t _result_shm_id,
uint32_t _result_shm_offset) {
SetHeader();
sync = _sync;
result_shm_id = _result_shm_id;
result_shm_offset = _result_shm_offset;
}
void* Set(void* cmd,
GLuint _sync,
uint32_t _result_shm_id,
uint32_t _result_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_sync, _result_shm_id, _result_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t sync;
uint32_t result_shm_id;
uint32_t result_shm_offset;
};
static_assert(sizeof(IsSync) == 16, "size of IsSync should be 16");
static_assert(offsetof(IsSync, header) == 0,
"offset of IsSync header should be 0");
static_assert(offsetof(IsSync, sync) == 4, "offset of IsSync sync should be 4");
static_assert(offsetof(IsSync, result_shm_id) == 8,
"offset of IsSync result_shm_id should be 8");
static_assert(offsetof(IsSync, result_shm_offset) == 12,
"offset of IsSync result_shm_offset should be 12");
struct IsTexture {
typedef IsTexture ValueType;
static const CommandId kCmdId = kIsTexture;

32
gpu/command_buffer/common/gles2_cmd_format_test_autogen.h

@ -675,6 +675,16 @@ TEST_F(GLES2FormatTest, DeleteSamplersImmediate) {
// TODO(gman): Check that ids were inserted;
}
TEST_F(GLES2FormatTest, DeleteSync) {
cmds::DeleteSync& cmd = *GetBufferAs<cmds::DeleteSync>();
void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteSync::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
EXPECT_EQ(static_cast<GLuint>(11), cmd.sync);
CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
}
TEST_F(GLES2FormatTest, DeleteShader) {
cmds::DeleteShader& cmd = *GetBufferAs<cmds::DeleteShader>();
void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
@ -832,6 +842,15 @@ TEST_F(GLES2FormatTest, EnableVertexAttribArray) {
CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
}
TEST_F(GLES2FormatTest, FenceSync) {
cmds::FenceSync& cmd = *GetBufferAs<cmds::FenceSync>();
void* next_cmd = cmd.Set(&cmd, static_cast<uint32_t>(11));
EXPECT_EQ(static_cast<uint32_t>(cmds::FenceSync::kCmdId), cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
EXPECT_EQ(static_cast<uint32_t>(11), cmd.client_id);
CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
}
TEST_F(GLES2FormatTest, Finish) {
cmds::Finish& cmd = *GetBufferAs<cmds::Finish>();
void* next_cmd = cmd.Set(&cmd);
@ -1607,6 +1626,19 @@ TEST_F(GLES2FormatTest, IsShader) {
CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
}
TEST_F(GLES2FormatTest, IsSync) {
cmds::IsSync& cmd = *GetBufferAs<cmds::IsSync>();
void* next_cmd =
cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<uint32_t>(12),
static_cast<uint32_t>(13));
EXPECT_EQ(static_cast<uint32_t>(cmds::IsSync::kCmdId), cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
EXPECT_EQ(static_cast<GLuint>(11), cmd.sync);
EXPECT_EQ(static_cast<uint32_t>(12), cmd.result_shm_id);
EXPECT_EQ(static_cast<uint32_t>(13), cmd.result_shm_offset);
CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
}
TEST_F(GLES2FormatTest, IsTexture) {
cmds::IsTexture& cmd = *GetBufferAs<cmds::IsTexture>();
void* next_cmd =

431
gpu/command_buffer/common/gles2_cmd_ids_autogen.h

@ -56,220 +56,223 @@
OP(DeleteProgram) /* 297 */ \
OP(DeleteRenderbuffersImmediate) /* 298 */ \
OP(DeleteSamplersImmediate) /* 299 */ \
OP(DeleteShader) /* 300 */ \
OP(DeleteTexturesImmediate) /* 301 */ \
OP(DeleteTransformFeedbacksImmediate) /* 302 */ \
OP(DepthFunc) /* 303 */ \
OP(DepthMask) /* 304 */ \
OP(DepthRangef) /* 305 */ \
OP(DetachShader) /* 306 */ \
OP(Disable) /* 307 */ \
OP(DisableVertexAttribArray) /* 308 */ \
OP(DrawArrays) /* 309 */ \
OP(DrawElements) /* 310 */ \
OP(Enable) /* 311 */ \
OP(EnableVertexAttribArray) /* 312 */ \
OP(Finish) /* 313 */ \
OP(Flush) /* 314 */ \
OP(FramebufferRenderbuffer) /* 315 */ \
OP(FramebufferTexture2D) /* 316 */ \
OP(FramebufferTextureLayer) /* 317 */ \
OP(FrontFace) /* 318 */ \
OP(GenBuffersImmediate) /* 319 */ \
OP(GenerateMipmap) /* 320 */ \
OP(GenFramebuffersImmediate) /* 321 */ \
OP(GenRenderbuffersImmediate) /* 322 */ \
OP(GenSamplersImmediate) /* 323 */ \
OP(GenTexturesImmediate) /* 324 */ \
OP(GenTransformFeedbacksImmediate) /* 325 */ \
OP(GetActiveAttrib) /* 326 */ \
OP(GetActiveUniform) /* 327 */ \
OP(GetAttachedShaders) /* 328 */ \
OP(GetAttribLocation) /* 329 */ \
OP(GetBooleanv) /* 330 */ \
OP(GetBufferParameteriv) /* 331 */ \
OP(GetError) /* 332 */ \
OP(GetFloatv) /* 333 */ \
OP(GetFramebufferAttachmentParameteriv) /* 334 */ \
OP(GetIntegerv) /* 335 */ \
OP(GetInternalformativ) /* 336 */ \
OP(GetProgramiv) /* 337 */ \
OP(GetProgramInfoLog) /* 338 */ \
OP(GetRenderbufferParameteriv) /* 339 */ \
OP(GetSamplerParameterfv) /* 340 */ \
OP(GetSamplerParameteriv) /* 341 */ \
OP(GetShaderiv) /* 342 */ \
OP(GetShaderInfoLog) /* 343 */ \
OP(GetShaderPrecisionFormat) /* 344 */ \
OP(GetShaderSource) /* 345 */ \
OP(GetString) /* 346 */ \
OP(GetTexParameterfv) /* 347 */ \
OP(GetTexParameteriv) /* 348 */ \
OP(GetUniformfv) /* 349 */ \
OP(GetUniformiv) /* 350 */ \
OP(GetUniformLocation) /* 351 */ \
OP(GetVertexAttribfv) /* 352 */ \
OP(GetVertexAttribiv) /* 353 */ \
OP(GetVertexAttribPointerv) /* 354 */ \
OP(Hint) /* 355 */ \
OP(InvalidateFramebufferImmediate) /* 356 */ \
OP(InvalidateSubFramebufferImmediate) /* 357 */ \
OP(IsBuffer) /* 358 */ \
OP(IsEnabled) /* 359 */ \
OP(IsFramebuffer) /* 360 */ \
OP(IsProgram) /* 361 */ \
OP(IsRenderbuffer) /* 362 */ \
OP(IsSampler) /* 363 */ \
OP(IsShader) /* 364 */ \
OP(IsTexture) /* 365 */ \
OP(IsTransformFeedback) /* 366 */ \
OP(LineWidth) /* 367 */ \
OP(LinkProgram) /* 368 */ \
OP(PauseTransformFeedback) /* 369 */ \
OP(PixelStorei) /* 370 */ \
OP(PolygonOffset) /* 371 */ \
OP(ReadBuffer) /* 372 */ \
OP(ReadPixels) /* 373 */ \
OP(ReleaseShaderCompiler) /* 374 */ \
OP(RenderbufferStorage) /* 375 */ \
OP(ResumeTransformFeedback) /* 376 */ \
OP(SampleCoverage) /* 377 */ \
OP(SamplerParameterf) /* 378 */ \
OP(SamplerParameterfvImmediate) /* 379 */ \
OP(SamplerParameteri) /* 380 */ \
OP(SamplerParameterivImmediate) /* 381 */ \
OP(Scissor) /* 382 */ \
OP(ShaderBinary) /* 383 */ \
OP(ShaderSourceBucket) /* 384 */ \
OP(StencilFunc) /* 385 */ \
OP(StencilFuncSeparate) /* 386 */ \
OP(StencilMask) /* 387 */ \
OP(StencilMaskSeparate) /* 388 */ \
OP(StencilOp) /* 389 */ \
OP(StencilOpSeparate) /* 390 */ \
OP(TexImage2D) /* 391 */ \
OP(TexImage3D) /* 392 */ \
OP(TexParameterf) /* 393 */ \
OP(TexParameterfvImmediate) /* 394 */ \
OP(TexParameteri) /* 395 */ \
OP(TexParameterivImmediate) /* 396 */ \
OP(TexStorage3D) /* 397 */ \
OP(TexSubImage2D) /* 398 */ \
OP(TexSubImage3D) /* 399 */ \
OP(Uniform1f) /* 400 */ \
OP(Uniform1fvImmediate) /* 401 */ \
OP(Uniform1i) /* 402 */ \
OP(Uniform1ivImmediate) /* 403 */ \
OP(Uniform1ui) /* 404 */ \
OP(Uniform1uivImmediate) /* 405 */ \
OP(Uniform2f) /* 406 */ \
OP(Uniform2fvImmediate) /* 407 */ \
OP(Uniform2i) /* 408 */ \
OP(Uniform2ivImmediate) /* 409 */ \
OP(Uniform2ui) /* 410 */ \
OP(Uniform2uivImmediate) /* 411 */ \
OP(Uniform3f) /* 412 */ \
OP(Uniform3fvImmediate) /* 413 */ \
OP(Uniform3i) /* 414 */ \
OP(Uniform3ivImmediate) /* 415 */ \
OP(Uniform3ui) /* 416 */ \
OP(Uniform3uivImmediate) /* 417 */ \
OP(Uniform4f) /* 418 */ \
OP(Uniform4fvImmediate) /* 419 */ \
OP(Uniform4i) /* 420 */ \
OP(Uniform4ivImmediate) /* 421 */ \
OP(Uniform4ui) /* 422 */ \
OP(Uniform4uivImmediate) /* 423 */ \
OP(UniformMatrix2fvImmediate) /* 424 */ \
OP(UniformMatrix2x3fvImmediate) /* 425 */ \
OP(UniformMatrix2x4fvImmediate) /* 426 */ \
OP(UniformMatrix3fvImmediate) /* 427 */ \
OP(UniformMatrix3x2fvImmediate) /* 428 */ \
OP(UniformMatrix3x4fvImmediate) /* 429 */ \
OP(UniformMatrix4fvImmediate) /* 430 */ \
OP(UniformMatrix4x2fvImmediate) /* 431 */ \
OP(UniformMatrix4x3fvImmediate) /* 432 */ \
OP(UseProgram) /* 433 */ \
OP(ValidateProgram) /* 434 */ \
OP(VertexAttrib1f) /* 435 */ \
OP(VertexAttrib1fvImmediate) /* 436 */ \
OP(VertexAttrib2f) /* 437 */ \
OP(VertexAttrib2fvImmediate) /* 438 */ \
OP(VertexAttrib3f) /* 439 */ \
OP(VertexAttrib3fvImmediate) /* 440 */ \
OP(VertexAttrib4f) /* 441 */ \
OP(VertexAttrib4fvImmediate) /* 442 */ \
OP(VertexAttribI4i) /* 443 */ \
OP(VertexAttribI4ivImmediate) /* 444 */ \
OP(VertexAttribI4ui) /* 445 */ \
OP(VertexAttribI4uivImmediate) /* 446 */ \
OP(VertexAttribIPointer) /* 447 */ \
OP(VertexAttribPointer) /* 448 */ \
OP(Viewport) /* 449 */ \
OP(BlitFramebufferCHROMIUM) /* 450 */ \
OP(RenderbufferStorageMultisampleCHROMIUM) /* 451 */ \
OP(RenderbufferStorageMultisampleEXT) /* 452 */ \
OP(FramebufferTexture2DMultisampleEXT) /* 453 */ \
OP(TexStorage2DEXT) /* 454 */ \
OP(GenQueriesEXTImmediate) /* 455 */ \
OP(DeleteQueriesEXTImmediate) /* 456 */ \
OP(BeginQueryEXT) /* 457 */ \
OP(BeginTransformFeedback) /* 458 */ \
OP(EndQueryEXT) /* 459 */ \
OP(EndTransformFeedback) /* 460 */ \
OP(InsertEventMarkerEXT) /* 461 */ \
OP(PushGroupMarkerEXT) /* 462 */ \
OP(PopGroupMarkerEXT) /* 463 */ \
OP(GenVertexArraysOESImmediate) /* 464 */ \
OP(DeleteVertexArraysOESImmediate) /* 465 */ \
OP(IsVertexArrayOES) /* 466 */ \
OP(BindVertexArrayOES) /* 467 */ \
OP(SwapBuffers) /* 468 */ \
OP(GetMaxValueInBufferCHROMIUM) /* 469 */ \
OP(EnableFeatureCHROMIUM) /* 470 */ \
OP(ResizeCHROMIUM) /* 471 */ \
OP(GetRequestableExtensionsCHROMIUM) /* 472 */ \
OP(RequestExtensionCHROMIUM) /* 473 */ \
OP(GetProgramInfoCHROMIUM) /* 474 */ \
OP(GetTranslatedShaderSourceANGLE) /* 475 */ \
OP(PostSubBufferCHROMIUM) /* 476 */ \
OP(TexImageIOSurface2DCHROMIUM) /* 477 */ \
OP(CopyTextureCHROMIUM) /* 478 */ \
OP(DrawArraysInstancedANGLE) /* 479 */ \
OP(DrawElementsInstancedANGLE) /* 480 */ \
OP(VertexAttribDivisorANGLE) /* 481 */ \
OP(GenMailboxCHROMIUM) /* 482 */ \
OP(ProduceTextureCHROMIUMImmediate) /* 483 */ \
OP(ProduceTextureDirectCHROMIUMImmediate) /* 484 */ \
OP(ConsumeTextureCHROMIUMImmediate) /* 485 */ \
OP(CreateAndConsumeTextureCHROMIUMImmediate) /* 486 */ \
OP(BindUniformLocationCHROMIUMBucket) /* 487 */ \
OP(GenValuebuffersCHROMIUMImmediate) /* 488 */ \
OP(DeleteValuebuffersCHROMIUMImmediate) /* 489 */ \
OP(IsValuebufferCHROMIUM) /* 490 */ \
OP(BindValuebufferCHROMIUM) /* 491 */ \
OP(SubscribeValueCHROMIUM) /* 492 */ \
OP(PopulateSubscribedValuesCHROMIUM) /* 493 */ \
OP(UniformValuebufferCHROMIUM) /* 494 */ \
OP(BindTexImage2DCHROMIUM) /* 495 */ \
OP(ReleaseTexImage2DCHROMIUM) /* 496 */ \
OP(TraceBeginCHROMIUM) /* 497 */ \
OP(TraceEndCHROMIUM) /* 498 */ \
OP(AsyncTexSubImage2DCHROMIUM) /* 499 */ \
OP(AsyncTexImage2DCHROMIUM) /* 500 */ \
OP(WaitAsyncTexImage2DCHROMIUM) /* 501 */ \
OP(WaitAllAsyncTexImage2DCHROMIUM) /* 502 */ \
OP(DiscardFramebufferEXTImmediate) /* 503 */ \
OP(LoseContextCHROMIUM) /* 504 */ \
OP(InsertSyncPointCHROMIUM) /* 505 */ \
OP(WaitSyncPointCHROMIUM) /* 506 */ \
OP(DrawBuffersEXTImmediate) /* 507 */ \
OP(DiscardBackbufferCHROMIUM) /* 508 */ \
OP(ScheduleOverlayPlaneCHROMIUM) /* 509 */ \
OP(SwapInterval) /* 510 */ \
OP(MatrixLoadfCHROMIUMImmediate) /* 511 */ \
OP(MatrixLoadIdentityCHROMIUM) /* 512 */ \
OP(BlendBarrierKHR) /* 513 */
OP(DeleteSync) /* 300 */ \
OP(DeleteShader) /* 301 */ \
OP(DeleteTexturesImmediate) /* 302 */ \
OP(DeleteTransformFeedbacksImmediate) /* 303 */ \
OP(DepthFunc) /* 304 */ \
OP(DepthMask) /* 305 */ \
OP(DepthRangef) /* 306 */ \
OP(DetachShader) /* 307 */ \
OP(Disable) /* 308 */ \
OP(DisableVertexAttribArray) /* 309 */ \
OP(DrawArrays) /* 310 */ \
OP(DrawElements) /* 311 */ \
OP(Enable) /* 312 */ \
OP(EnableVertexAttribArray) /* 313 */ \
OP(FenceSync) /* 314 */ \
OP(Finish) /* 315 */ \
OP(Flush) /* 316 */ \
OP(FramebufferRenderbuffer) /* 317 */ \
OP(FramebufferTexture2D) /* 318 */ \
OP(FramebufferTextureLayer) /* 319 */ \
OP(FrontFace) /* 320 */ \
OP(GenBuffersImmediate) /* 321 */ \
OP(GenerateMipmap) /* 322 */ \
OP(GenFramebuffersImmediate) /* 323 */ \
OP(GenRenderbuffersImmediate) /* 324 */ \
OP(GenSamplersImmediate) /* 325 */ \
OP(GenTexturesImmediate) /* 326 */ \
OP(GenTransformFeedbacksImmediate) /* 327 */ \
OP(GetActiveAttrib) /* 328 */ \
OP(GetActiveUniform) /* 329 */ \
OP(GetAttachedShaders) /* 330 */ \
OP(GetAttribLocation) /* 331 */ \
OP(GetBooleanv) /* 332 */ \
OP(GetBufferParameteriv) /* 333 */ \
OP(GetError) /* 334 */ \
OP(GetFloatv) /* 335 */ \
OP(GetFramebufferAttachmentParameteriv) /* 336 */ \
OP(GetIntegerv) /* 337 */ \
OP(GetInternalformativ) /* 338 */ \
OP(GetProgramiv) /* 339 */ \
OP(GetProgramInfoLog) /* 340 */ \
OP(GetRenderbufferParameteriv) /* 341 */ \
OP(GetSamplerParameterfv) /* 342 */ \
OP(GetSamplerParameteriv) /* 343 */ \
OP(GetShaderiv) /* 344 */ \
OP(GetShaderInfoLog) /* 345 */ \
OP(GetShaderPrecisionFormat) /* 346 */ \
OP(GetShaderSource) /* 347 */ \
OP(GetString) /* 348 */ \
OP(GetTexParameterfv) /* 349 */ \
OP(GetTexParameteriv) /* 350 */ \
OP(GetUniformfv) /* 351 */ \
OP(GetUniformiv) /* 352 */ \
OP(GetUniformLocation) /* 353 */ \
OP(GetVertexAttribfv) /* 354 */ \
OP(GetVertexAttribiv) /* 355 */ \
OP(GetVertexAttribPointerv) /* 356 */ \
OP(Hint) /* 357 */ \
OP(InvalidateFramebufferImmediate) /* 358 */ \
OP(InvalidateSubFramebufferImmediate) /* 359 */ \
OP(IsBuffer) /* 360 */ \
OP(IsEnabled) /* 361 */ \
OP(IsFramebuffer) /* 362 */ \
OP(IsProgram) /* 363 */ \
OP(IsRenderbuffer) /* 364 */ \
OP(IsSampler) /* 365 */ \
OP(IsShader) /* 366 */ \
OP(IsSync) /* 367 */ \
OP(IsTexture) /* 368 */ \
OP(IsTransformFeedback) /* 369 */ \
OP(LineWidth) /* 370 */ \
OP(LinkProgram) /* 371 */ \
OP(PauseTransformFeedback) /* 372 */ \
OP(PixelStorei) /* 373 */ \
OP(PolygonOffset) /* 374 */ \
OP(ReadBuffer) /* 375 */ \
OP(ReadPixels) /* 376 */ \
OP(ReleaseShaderCompiler) /* 377 */ \
OP(RenderbufferStorage) /* 378 */ \
OP(ResumeTransformFeedback) /* 379 */ \
OP(SampleCoverage) /* 380 */ \
OP(SamplerParameterf) /* 381 */ \
OP(SamplerParameterfvImmediate) /* 382 */ \
OP(SamplerParameteri) /* 383 */ \
OP(SamplerParameterivImmediate) /* 384 */ \
OP(Scissor) /* 385 */ \
OP(ShaderBinary) /* 386 */ \
OP(ShaderSourceBucket) /* 387 */ \
OP(StencilFunc) /* 388 */ \
OP(StencilFuncSeparate) /* 389 */ \
OP(StencilMask) /* 390 */ \
OP(StencilMaskSeparate) /* 391 */ \
OP(StencilOp) /* 392 */ \
OP(StencilOpSeparate) /* 393 */ \
OP(TexImage2D) /* 394 */ \
OP(TexImage3D) /* 395 */ \
OP(TexParameterf) /* 396 */ \
OP(TexParameterfvImmediate) /* 397 */ \
OP(TexParameteri) /* 398 */ \
OP(TexParameterivImmediate) /* 399 */ \
OP(TexStorage3D) /* 400 */ \
OP(TexSubImage2D) /* 401 */ \
OP(TexSubImage3D) /* 402 */ \
OP(Uniform1f) /* 403 */ \
OP(Uniform1fvImmediate) /* 404 */ \
OP(Uniform1i) /* 405 */ \
OP(Uniform1ivImmediate) /* 406 */ \
OP(Uniform1ui) /* 407 */ \
OP(Uniform1uivImmediate) /* 408 */ \
OP(Uniform2f) /* 409 */ \
OP(Uniform2fvImmediate) /* 410 */ \
OP(Uniform2i) /* 411 */ \
OP(Uniform2ivImmediate) /* 412 */ \
OP(Uniform2ui) /* 413 */ \
OP(Uniform2uivImmediate) /* 414 */ \
OP(Uniform3f) /* 415 */ \
OP(Uniform3fvImmediate) /* 416 */ \
OP(Uniform3i) /* 417 */ \
OP(Uniform3ivImmediate) /* 418 */ \
OP(Uniform3ui) /* 419 */ \
OP(Uniform3uivImmediate) /* 420 */ \
OP(Uniform4f) /* 421 */ \
OP(Uniform4fvImmediate) /* 422 */ \
OP(Uniform4i) /* 423 */ \
OP(Uniform4ivImmediate) /* 424 */ \
OP(Uniform4ui) /* 425 */ \
OP(Uniform4uivImmediate) /* 426 */ \
OP(UniformMatrix2fvImmediate) /* 427 */ \
OP(UniformMatrix2x3fvImmediate) /* 428 */ \
OP(UniformMatrix2x4fvImmediate) /* 429 */ \
OP(UniformMatrix3fvImmediate) /* 430 */ \
OP(UniformMatrix3x2fvImmediate) /* 431 */ \
OP(UniformMatrix3x4fvImmediate) /* 432 */ \
OP(UniformMatrix4fvImmediate) /* 433 */ \
OP(UniformMatrix4x2fvImmediate) /* 434 */ \
OP(UniformMatrix4x3fvImmediate) /* 435 */ \
OP(UseProgram) /* 436 */ \
OP(ValidateProgram) /* 437 */ \
OP(VertexAttrib1f) /* 438 */ \
OP(VertexAttrib1fvImmediate) /* 439 */ \
OP(VertexAttrib2f) /* 440 */ \
OP(VertexAttrib2fvImmediate) /* 441 */ \
OP(VertexAttrib3f) /* 442 */ \
OP(VertexAttrib3fvImmediate) /* 443 */ \
OP(VertexAttrib4f) /* 444 */ \
OP(VertexAttrib4fvImmediate) /* 445 */ \
OP(VertexAttribI4i) /* 446 */ \
OP(VertexAttribI4ivImmediate) /* 447 */ \
OP(VertexAttribI4ui) /* 448 */ \
OP(VertexAttribI4uivImmediate) /* 449 */ \
OP(VertexAttribIPointer) /* 450 */ \
OP(VertexAttribPointer) /* 451 */ \
OP(Viewport) /* 452 */ \
OP(BlitFramebufferCHROMIUM) /* 453 */ \
OP(RenderbufferStorageMultisampleCHROMIUM) /* 454 */ \
OP(RenderbufferStorageMultisampleEXT) /* 455 */ \
OP(FramebufferTexture2DMultisampleEXT) /* 456 */ \
OP(TexStorage2DEXT) /* 457 */ \
OP(GenQueriesEXTImmediate) /* 458 */ \
OP(DeleteQueriesEXTImmediate) /* 459 */ \
OP(BeginQueryEXT) /* 460 */ \
OP(BeginTransformFeedback) /* 461 */ \
OP(EndQueryEXT) /* 462 */ \
OP(EndTransformFeedback) /* 463 */ \
OP(InsertEventMarkerEXT) /* 464 */ \
OP(PushGroupMarkerEXT) /* 465 */ \
OP(PopGroupMarkerEXT) /* 466 */ \
OP(GenVertexArraysOESImmediate) /* 467 */ \
OP(DeleteVertexArraysOESImmediate) /* 468 */ \
OP(IsVertexArrayOES) /* 469 */ \
OP(BindVertexArrayOES) /* 470 */ \
OP(SwapBuffers) /* 471 */ \
OP(GetMaxValueInBufferCHROMIUM) /* 472 */ \
OP(EnableFeatureCHROMIUM) /* 473 */ \
OP(ResizeCHROMIUM) /* 474 */ \
OP(GetRequestableExtensionsCHROMIUM) /* 475 */ \
OP(RequestExtensionCHROMIUM) /* 476 */ \
OP(GetProgramInfoCHROMIUM) /* 477 */ \
OP(GetTranslatedShaderSourceANGLE) /* 478 */ \
OP(PostSubBufferCHROMIUM) /* 479 */ \
OP(TexImageIOSurface2DCHROMIUM) /* 480 */ \
OP(CopyTextureCHROMIUM) /* 481 */ \
OP(DrawArraysInstancedANGLE) /* 482 */ \
OP(DrawElementsInstancedANGLE) /* 483 */ \
OP(VertexAttribDivisorANGLE) /* 484 */ \
OP(GenMailboxCHROMIUM) /* 485 */ \
OP(ProduceTextureCHROMIUMImmediate) /* 486 */ \
OP(ProduceTextureDirectCHROMIUMImmediate) /* 487 */ \
OP(ConsumeTextureCHROMIUMImmediate) /* 488 */ \
OP(CreateAndConsumeTextureCHROMIUMImmediate) /* 489 */ \
OP(BindUniformLocationCHROMIUMBucket) /* 490 */ \
OP(GenValuebuffersCHROMIUMImmediate) /* 491 */ \
OP(DeleteValuebuffersCHROMIUMImmediate) /* 492 */ \
OP(IsValuebufferCHROMIUM) /* 493 */ \
OP(BindValuebufferCHROMIUM) /* 494 */ \
OP(SubscribeValueCHROMIUM) /* 495 */ \
OP(PopulateSubscribedValuesCHROMIUM) /* 496 */ \
OP(UniformValuebufferCHROMIUM) /* 497 */ \
OP(BindTexImage2DCHROMIUM) /* 498 */ \
OP(ReleaseTexImage2DCHROMIUM) /* 499 */ \
OP(TraceBeginCHROMIUM) /* 500 */ \
OP(TraceEndCHROMIUM) /* 501 */ \
OP(AsyncTexSubImage2DCHROMIUM) /* 502 */ \
OP(AsyncTexImage2DCHROMIUM) /* 503 */ \
OP(WaitAsyncTexImage2DCHROMIUM) /* 504 */ \
OP(WaitAllAsyncTexImage2DCHROMIUM) /* 505 */ \
OP(DiscardFramebufferEXTImmediate) /* 506 */ \
OP(LoseContextCHROMIUM) /* 507 */ \
OP(InsertSyncPointCHROMIUM) /* 508 */ \
OP(WaitSyncPointCHROMIUM) /* 509 */ \
OP(DrawBuffersEXTImmediate) /* 510 */ \
OP(DiscardBackbufferCHROMIUM) /* 511 */ \
OP(ScheduleOverlayPlaneCHROMIUM) /* 512 */ \
OP(SwapInterval) /* 513 */ \
OP(MatrixLoadfCHROMIUMImmediate) /* 514 */ \
OP(MatrixLoadIdentityCHROMIUM) /* 515 */ \
OP(BlendBarrierKHR) /* 516 */
enum CommandId {
kStartPoint = cmd::kLastCommonId, // All GLES2 commands start after this.

1
gpu/command_buffer/common/gles2_cmd_utils_autogen.h

@ -62,6 +62,7 @@ static std::string GetStringSrcBlendFactor(uint32_t value);
static std::string GetStringStencilOp(uint32_t value);
static std::string GetStringStringType(uint32_t value);
static std::string GetStringSubscriptionTarget(uint32_t value);
static std::string GetStringSyncCondition(uint32_t value);
static std::string GetStringTexture3DTarget(uint32_t value);
static std::string GetStringTextureBindTarget(uint32_t value);
static std::string GetStringTextureFormat(uint32_t value);

8
gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h

@ -5092,6 +5092,14 @@ std::string GLES2Util::GetStringSubscriptionTarget(uint32_t value) {
arraysize(string_table), value);
}
std::string GLES2Util::GetStringSyncCondition(uint32_t value) {
static const EnumToString string_table[] = {
{0x9117, "0x9117"},
};
return GLES2Util::GetQualifiedEnumString(string_table,
arraysize(string_table), value);
}
std::string GLES2Util::GetStringTexture3DTarget(uint32_t value) {
static const EnumToString string_table[] = {
{GL_TEXTURE_3D, "GL_TEXTURE_3D"},

28
gpu/command_buffer/service/context_group.h

@ -5,7 +5,6 @@
#ifndef GPU_COMMAND_BUFFER_SERVICE_CONTEXT_GROUP_H_
#define GPU_COMMAND_BUFFER_SERVICE_CONTEXT_GROUP_H_
#include <map>
#include <string>
#include <vector>
#include "base/basictypes.h"
@ -184,7 +183,7 @@ class GPU_EXPORT ContextGroup : public base::RefCounted<ContextGroup> {
}
bool GetSamplerServiceId(GLuint client_id, GLuint* service_id) const {
std::map<GLuint, GLuint>::const_iterator iter =
base::hash_map<GLuint, GLuint>::const_iterator iter =
samplers_id_map_.find(client_id);
if (iter == samplers_id_map_.end())
return false;
@ -203,7 +202,7 @@ class GPU_EXPORT ContextGroup : public base::RefCounted<ContextGroup> {
bool GetTransformFeedbackServiceId(
GLuint client_id, GLuint* service_id) const {
std::map<GLuint, GLuint>::const_iterator iter =
base::hash_map<GLuint, GLuint>::const_iterator iter =
transformfeedbacks_id_map_.find(client_id);
if (iter == transformfeedbacks_id_map_.end())
return false;
@ -216,6 +215,24 @@ class GPU_EXPORT ContextGroup : public base::RefCounted<ContextGroup> {
transformfeedbacks_id_map_.erase(client_id);
}
void AddSyncId(GLuint client_id, GLsync service_id) {
syncs_id_map_[client_id] = service_id;
}
bool GetSyncServiceId(GLuint client_id, GLsync* service_id) const {
base::hash_map<GLuint, GLsync>::const_iterator iter =
syncs_id_map_.find(client_id);
if (iter == syncs_id_map_.end())
return false;
if (service_id)
*service_id = iter->second;
return true;
}
void RemoveSyncId(GLuint client_id) {
syncs_id_map_.erase(client_id);
}
private:
friend class base::RefCounted<ContextGroup>;
~ContextGroup();
@ -267,8 +284,9 @@ class GPU_EXPORT ContextGroup : public base::RefCounted<ContextGroup> {
std::vector<base::WeakPtr<gles2::GLES2Decoder> > decoders_;
// Mappings from client side IDs to service side IDs.
std::map<GLuint, GLuint> samplers_id_map_;
std::map<GLuint, GLuint> transformfeedbacks_id_map_;
base::hash_map<GLuint, GLuint> samplers_id_map_;
base::hash_map<GLuint, GLuint> transformfeedbacks_id_map_;
base::hash_map<GLuint, GLsync> syncs_id_map_;
GLenum draw_buffer_;

28
gpu/command_buffer/service/gles2_cmd_decoder.cc

@ -1278,12 +1278,6 @@ class GLES2DecoderImpl : public GLES2Decoder,
void GetVertexAttribHelper(
const VertexAttrib* attrib, GLenum pname, GLint* param);
// Wrapper for glCreateProgram
bool CreateProgramHelper(GLuint client_id);
// Wrapper for glCreateShader
bool CreateShaderHelper(GLenum type, GLuint client_id);
// Wrapper for glActiveTexture
void DoActiveTexture(GLenum texture_unit);
@ -4049,28 +4043,6 @@ void GLES2DecoderImpl::RemoveBuffer(GLuint client_id) {
buffer_manager()->RemoveBuffer(client_id);
}
bool GLES2DecoderImpl::CreateProgramHelper(GLuint client_id) {
if (GetProgram(client_id)) {
return false;
}
GLuint service_id = glCreateProgram();
if (service_id != 0) {
CreateProgram(client_id, service_id);
}
return true;
}
bool GLES2DecoderImpl::CreateShaderHelper(GLenum type, GLuint client_id) {
if (GetShader(client_id)) {
return false;
}
GLuint service_id = glCreateShader(type);
if (service_id != 0) {
CreateShader(client_id, service_id, type);
}
return true;
}
void GLES2DecoderImpl::DoFinish() {
glFinish();
ProcessPendingReadPixels();

78
gpu/command_buffer/service/gles2_cmd_decoder_autogen.h

@ -703,9 +703,13 @@ error::Error GLES2DecoderImpl::HandleCreateProgram(uint32_t immediate_data_size,
*static_cast<const gles2::cmds::CreateProgram*>(cmd_data);
(void)c;
uint32_t client_id = c.client_id;
if (!CreateProgramHelper(client_id)) {
if (GetProgram(client_id)) {
return error::kInvalidArguments;
}
GLuint service_id = glCreateProgram();
if (service_id) {
CreateProgram(client_id, service_id);
}
return error::kNoError;
}
@ -720,9 +724,13 @@ error::Error GLES2DecoderImpl::HandleCreateShader(uint32_t immediate_data_size,
return error::kNoError;
}
uint32_t client_id = c.client_id;
if (!CreateShaderHelper(type, client_id)) {
if (GetShader(client_id)) {
return error::kInvalidArguments;
}
GLuint service_id = glCreateShader(type);
if (service_id) {
CreateShader(client_id, service_id, type);
}
return error::kNoError;
}
@ -831,6 +839,24 @@ error::Error GLES2DecoderImpl::HandleDeleteSamplersImmediate(
return error::kNoError;
}
error::Error GLES2DecoderImpl::HandleDeleteSync(uint32_t immediate_data_size,
const void* cmd_data) {
if (!unsafe_es3_apis_enabled())
return error::kUnknownCommand;
const gles2::cmds::DeleteSync& c =
*static_cast<const gles2::cmds::DeleteSync*>(cmd_data);
(void)c;
GLuint sync = c.sync;
GLsync service_id = 0;
if (group_->GetSyncServiceId(sync, &service_id)) {
glDeleteSync(service_id);
group_->RemoveSyncId(sync);
} else {
LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glDeleteSync", "unknown sync");
}
return error::kNoError;
}
error::Error GLES2DecoderImpl::HandleDeleteTexturesImmediate(
uint32_t immediate_data_size,
const void* cmd_data) {
@ -982,6 +1008,27 @@ error::Error GLES2DecoderImpl::HandleEnableVertexAttribArray(
return error::kNoError;
}
error::Error GLES2DecoderImpl::HandleFenceSync(uint32_t immediate_data_size,
const void* cmd_data) {
if (!unsafe_es3_apis_enabled())
return error::kUnknownCommand;
const gles2::cmds::FenceSync& c =
*static_cast<const gles2::cmds::FenceSync*>(cmd_data);
(void)c;
GLenum condition = static_cast<GLenum>(c.condition);
GLbitfield flags = static_cast<GLbitfield>(c.flags);
uint32_t client_id = c.client_id;
GLsync service_id = 0;
if (group_->GetSyncServiceId(client_id, &service_id)) {
return error::kInvalidArguments;
}
service_id = glFenceSync(condition, flags);
if (service_id) {
group_->AddSyncId(client_id, service_id);
}
return error::kNoError;
}
error::Error GLES2DecoderImpl::HandleFinish(uint32_t immediate_data_size,
const void* cmd_data) {
const gles2::cmds::Finish& c =
@ -2044,7 +2091,8 @@ error::Error GLES2DecoderImpl::HandleIsSampler(uint32_t immediate_data_size,
if (!result_dst) {
return error::kOutOfBounds;
}
*result_dst = group_->GetSamplerServiceId(sampler, &sampler);
GLuint service_sampler = 0;
*result_dst = group_->GetSamplerServiceId(sampler, &service_sampler);
return error::kNoError;
}
@ -2064,6 +2112,25 @@ error::Error GLES2DecoderImpl::HandleIsShader(uint32_t immediate_data_size,
return error::kNoError;
}
error::Error GLES2DecoderImpl::HandleIsSync(uint32_t immediate_data_size,
const void* cmd_data) {
if (!unsafe_es3_apis_enabled())
return error::kUnknownCommand;
const gles2::cmds::IsSync& c =
*static_cast<const gles2::cmds::IsSync*>(cmd_data);
(void)c;
GLuint sync = c.sync;
typedef cmds::IsSync::Result Result;
Result* result_dst = GetSharedMemoryAs<Result*>(
c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
if (!result_dst) {
return error::kOutOfBounds;
}
GLsync service_sync = 0;
*result_dst = group_->GetSyncServiceId(sync, &service_sync);
return error::kNoError;
}
error::Error GLES2DecoderImpl::HandleIsTexture(uint32_t immediate_data_size,
const void* cmd_data) {
const gles2::cmds::IsTexture& c =
@ -2095,8 +2162,9 @@ error::Error GLES2DecoderImpl::HandleIsTransformFeedback(
if (!result_dst) {
return error::kOutOfBounds;
}
*result_dst = group_->GetTransformFeedbackServiceId(transformfeedback,
&transformfeedback);
GLuint service_transformfeedback = 0;
*result_dst = group_->GetTransformFeedbackServiceId(
transformfeedback, &service_transformfeedback);
return error::kNoError;
}

27
gpu/command_buffer/service/gles2_cmd_decoder_unittest_1.cc

@ -252,33 +252,6 @@ void GLES2DecoderTestBase::SpecializedSetup<cmds::GetProgramInfoLog, 0>(
base::Bind(&ShaderCacheCb));
};
template <>
void GLES2DecoderTestBase::SpecializedSetup<cmds::GetVertexAttribfv, 0>(
bool valid) {
DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
DoVertexAttribPointer(1, 1, GL_FLOAT, 0, 0);
if (valid) {
EXPECT_CALL(*gl_, GetError())
.WillOnce(Return(GL_NO_ERROR))
.WillOnce(Return(GL_NO_ERROR))
.RetiresOnSaturation();
}
};
template <>
void GLES2DecoderTestBase::SpecializedSetup<cmds::GetVertexAttribiv, 0>(
bool valid) {
DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
DoVertexAttribPointer(1, 1, GL_FLOAT, 0, 0);
if (valid) {
EXPECT_CALL(*gl_, GetError())
.WillOnce(Return(GL_NO_ERROR))
.WillOnce(Return(GL_NO_ERROR))
.RetiresOnSaturation();
}
};
#include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h"
} // namespace gles2

111
gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h

@ -558,7 +558,7 @@ TEST_P(GLES2DecoderTest1, CreateProgramValidArgs) {
cmd.Init(kNewClientId);
EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
EXPECT_EQ(GL_NO_ERROR, GetGLError());
EXPECT_TRUE(GetProgram(kNewClientId) != NULL);
EXPECT_TRUE(GetProgram(kNewClientId));
}
TEST_P(GLES2DecoderTest1, CreateShaderValidArgs) {
@ -569,7 +569,7 @@ TEST_P(GLES2DecoderTest1, CreateShaderValidArgs) {
cmd.Init(GL_VERTEX_SHADER, kNewClientId);
EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
EXPECT_EQ(GL_NO_ERROR, GetGLError());
EXPECT_TRUE(GetShader(kNewClientId) != NULL);
EXPECT_TRUE(GetShader(kNewClientId));
}
TEST_P(GLES2DecoderTest1, CreateShaderInvalidArgs0_0) {
@ -692,6 +692,18 @@ TEST_P(GLES2DecoderTest1, DeleteSamplersImmediateInvalidArgs) {
EXPECT_EQ(error::kUnknownCommand, ExecuteImmediateCmd(cmd, sizeof(temp)));
}
TEST_P(GLES2DecoderTest1, DeleteSyncValidArgs) {
EXPECT_CALL(*gl_, DeleteSync(reinterpret_cast<GLsync>(kServiceSyncId)));
SpecializedSetup<cmds::DeleteSync, 0>(true);
cmds::DeleteSync cmd;
cmd.Init(client_sync_id_);
decoder_->set_unsafe_es3_apis_enabled(true);
EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
EXPECT_EQ(GL_NO_ERROR, GetGLError());
decoder_->set_unsafe_es3_apis_enabled(false);
EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
}
TEST_P(GLES2DecoderTest1, DeleteShaderValidArgs) {
EXPECT_CALL(*gl_, DeleteShader(kServiceShaderId));
SpecializedSetup<cmds::DeleteShader, 0>(true);
@ -862,6 +874,22 @@ TEST_P(GLES2DecoderTest1, EnableVertexAttribArrayValidArgs) {
EXPECT_EQ(GL_NO_ERROR, GetGLError());
}
TEST_P(GLES2DecoderTest1, FenceSyncValidArgs) {
const GLsync kNewServiceIdGLuint = reinterpret_cast<GLsync>(kNewServiceId);
EXPECT_CALL(*gl_, FenceSync(0x9117, 0)).WillOnce(Return(kNewServiceIdGLuint));
SpecializedSetup<cmds::FenceSync, 0>(true);
cmds::FenceSync cmd;
cmd.Init(kNewClientId);
decoder_->set_unsafe_es3_apis_enabled(true);
EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
EXPECT_EQ(GL_NO_ERROR, GetGLError());
GLsync service_id = 0;
EXPECT_TRUE(GetSyncServiceId(kNewClientId, &service_id));
EXPECT_EQ(kNewServiceIdGLuint, service_id);
decoder_->set_unsafe_es3_apis_enabled(false);
EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
}
TEST_P(GLES2DecoderTest1, FinishValidArgs) {
EXPECT_CALL(*gl_, Finish());
SpecializedSetup<cmds::Finish, 0>(true);
@ -1917,83 +1945,4 @@ TEST_P(GLES2DecoderTest1, GetTexParameterivInvalidArgs2_1) {
// TODO(gman): GetUniformLocation
TEST_P(GLES2DecoderTest1, GetVertexAttribfvValidArgs) {
SpecializedSetup<cmds::GetVertexAttribfv, 0>(true);
typedef cmds::GetVertexAttribfv::Result Result;
Result* result = static_cast<Result*>(shared_memory_address_);
result->size = 0;
cmds::GetVertexAttribfv cmd;
cmd.Init(1, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, shared_memory_id_,
shared_memory_offset_);
EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(
GL_VERTEX_ATTRIB_ARRAY_NORMALIZED),
result->GetNumResults());
EXPECT_EQ(GL_NO_ERROR, GetGLError());
}
TEST_P(GLES2DecoderTest1, GetVertexAttribfvInvalidArgs2_0) {
EXPECT_CALL(*gl_, GetVertexAttribfv(_, _, _)).Times(0);
SpecializedSetup<cmds::GetVertexAttribfv, 0>(false);
cmds::GetVertexAttribfv::Result* result =
static_cast<cmds::GetVertexAttribfv::Result*>(shared_memory_address_);
result->size = 0;
cmds::GetVertexAttribfv cmd;
cmd.Init(1, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, kInvalidSharedMemoryId, 0);
EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
EXPECT_EQ(0u, result->size);
}
TEST_P(GLES2DecoderTest1, GetVertexAttribfvInvalidArgs2_1) {
EXPECT_CALL(*gl_, GetVertexAttribfv(_, _, _)).Times(0);
SpecializedSetup<cmds::GetVertexAttribfv, 0>(false);
cmds::GetVertexAttribfv::Result* result =
static_cast<cmds::GetVertexAttribfv::Result*>(shared_memory_address_);
result->size = 0;
cmds::GetVertexAttribfv cmd;
cmd.Init(1, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, shared_memory_id_,
kInvalidSharedMemoryOffset);
EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
EXPECT_EQ(0u, result->size);
}
TEST_P(GLES2DecoderTest1, GetVertexAttribivValidArgs) {
SpecializedSetup<cmds::GetVertexAttribiv, 0>(true);
typedef cmds::GetVertexAttribiv::Result Result;
Result* result = static_cast<Result*>(shared_memory_address_);
result->size = 0;
cmds::GetVertexAttribiv cmd;
cmd.Init(1, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, shared_memory_id_,
shared_memory_offset_);
EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(
GL_VERTEX_ATTRIB_ARRAY_NORMALIZED),
result->GetNumResults());
EXPECT_EQ(GL_NO_ERROR, GetGLError());
}
TEST_P(GLES2DecoderTest1, GetVertexAttribivInvalidArgs2_0) {
EXPECT_CALL(*gl_, GetVertexAttribiv(_, _, _)).Times(0);
SpecializedSetup<cmds::GetVertexAttribiv, 0>(false);
cmds::GetVertexAttribiv::Result* result =
static_cast<cmds::GetVertexAttribiv::Result*>(shared_memory_address_);
result->size = 0;
cmds::GetVertexAttribiv cmd;
cmd.Init(1, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, kInvalidSharedMemoryId, 0);
EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
EXPECT_EQ(0u, result->size);
}
TEST_P(GLES2DecoderTest1, GetVertexAttribivInvalidArgs2_1) {
EXPECT_CALL(*gl_, GetVertexAttribiv(_, _, _)).Times(0);
SpecializedSetup<cmds::GetVertexAttribiv, 0>(false);
cmds::GetVertexAttribiv::Result* result =
static_cast<cmds::GetVertexAttribiv::Result*>(shared_memory_address_);
result->size = 0;
cmds::GetVertexAttribiv cmd;
cmd.Init(1, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, shared_memory_id_,
kInvalidSharedMemoryOffset);
EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
EXPECT_EQ(0u, result->size);
}
#endif // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_1_AUTOGEN_H_

27
gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc

@ -518,6 +518,33 @@ void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameterivImmediate, 0>(
DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
};
template <>
void GLES2DecoderTestBase::SpecializedSetup<cmds::GetVertexAttribiv, 0>(
bool valid) {
DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
DoVertexAttribPointer(1, 1, GL_FLOAT, 0, 0);
if (valid) {
EXPECT_CALL(*gl_, GetError())
.WillOnce(Return(GL_NO_ERROR))
.WillOnce(Return(GL_NO_ERROR))
.RetiresOnSaturation();
}
};
template <>
void GLES2DecoderTestBase::SpecializedSetup<cmds::GetVertexAttribfv, 0>(
bool valid) {
DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
DoVertexAttribPointer(1, 1, GL_FLOAT, 0, 0);
if (valid) {
EXPECT_CALL(*gl_, GetError())
.WillOnce(Return(GL_NO_ERROR))
.WillOnce(Return(GL_NO_ERROR))
.RetiresOnSaturation();
}
};
#include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h"
TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT) {

127
gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h

@ -12,6 +12,85 @@
#ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_2_AUTOGEN_H_
#define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_2_AUTOGEN_H_
TEST_P(GLES2DecoderTest2, GetVertexAttribfvValidArgs) {
SpecializedSetup<cmds::GetVertexAttribfv, 0>(true);
typedef cmds::GetVertexAttribfv::Result Result;
Result* result = static_cast<Result*>(shared_memory_address_);
result->size = 0;
cmds::GetVertexAttribfv cmd;
cmd.Init(1, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, shared_memory_id_,
shared_memory_offset_);
EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(
GL_VERTEX_ATTRIB_ARRAY_NORMALIZED),
result->GetNumResults());
EXPECT_EQ(GL_NO_ERROR, GetGLError());
}
TEST_P(GLES2DecoderTest2, GetVertexAttribfvInvalidArgs2_0) {
EXPECT_CALL(*gl_, GetVertexAttribfv(_, _, _)).Times(0);
SpecializedSetup<cmds::GetVertexAttribfv, 0>(false);
cmds::GetVertexAttribfv::Result* result =
static_cast<cmds::GetVertexAttribfv::Result*>(shared_memory_address_);
result->size = 0;
cmds::GetVertexAttribfv cmd;
cmd.Init(1, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, kInvalidSharedMemoryId, 0);
EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
EXPECT_EQ(0u, result->size);
}
TEST_P(GLES2DecoderTest2, GetVertexAttribfvInvalidArgs2_1) {
EXPECT_CALL(*gl_, GetVertexAttribfv(_, _, _)).Times(0);
SpecializedSetup<cmds::GetVertexAttribfv, 0>(false);
cmds::GetVertexAttribfv::Result* result =
static_cast<cmds::GetVertexAttribfv::Result*>(shared_memory_address_);
result->size = 0;
cmds::GetVertexAttribfv cmd;
cmd.Init(1, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, shared_memory_id_,
kInvalidSharedMemoryOffset);
EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
EXPECT_EQ(0u, result->size);
}
TEST_P(GLES2DecoderTest2, GetVertexAttribivValidArgs) {
SpecializedSetup<cmds::GetVertexAttribiv, 0>(true);
typedef cmds::GetVertexAttribiv::Result Result;
Result* result = static_cast<Result*>(shared_memory_address_);
result->size = 0;
cmds::GetVertexAttribiv cmd;
cmd.Init(1, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, shared_memory_id_,
shared_memory_offset_);
EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(
GL_VERTEX_ATTRIB_ARRAY_NORMALIZED),
result->GetNumResults());
EXPECT_EQ(GL_NO_ERROR, GetGLError());
}
TEST_P(GLES2DecoderTest2, GetVertexAttribivInvalidArgs2_0) {
EXPECT_CALL(*gl_, GetVertexAttribiv(_, _, _)).Times(0);
SpecializedSetup<cmds::GetVertexAttribiv, 0>(false);
cmds::GetVertexAttribiv::Result* result =
static_cast<cmds::GetVertexAttribiv::Result*>(shared_memory_address_);
result->size = 0;
cmds::GetVertexAttribiv cmd;
cmd.Init(1, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, kInvalidSharedMemoryId, 0);
EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
EXPECT_EQ(0u, result->size);
}
TEST_P(GLES2DecoderTest2, GetVertexAttribivInvalidArgs2_1) {
EXPECT_CALL(*gl_, GetVertexAttribiv(_, _, _)).Times(0);
SpecializedSetup<cmds::GetVertexAttribiv, 0>(false);
cmds::GetVertexAttribiv::Result* result =
static_cast<cmds::GetVertexAttribiv::Result*>(shared_memory_address_);
result->size = 0;
cmds::GetVertexAttribiv cmd;
cmd.Init(1, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, shared_memory_id_,
kInvalidSharedMemoryOffset);
EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
EXPECT_EQ(0u, result->size);
}
// TODO(gman): GetVertexAttribPointerv
TEST_P(GLES2DecoderTest2, HintValidArgs) {
@ -180,6 +259,28 @@ TEST_P(GLES2DecoderTest2, IsShaderInvalidArgsBadSharedMemoryId) {
EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
}
TEST_P(GLES2DecoderTest2, IsSyncValidArgs) {
SpecializedSetup<cmds::IsSync, 0>(true);
cmds::IsSync cmd;
cmd.Init(client_sync_id_, shared_memory_id_, shared_memory_offset_);
decoder_->set_unsafe_es3_apis_enabled(true);
EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
EXPECT_EQ(GL_NO_ERROR, GetGLError());
decoder_->set_unsafe_es3_apis_enabled(false);
EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
}
TEST_P(GLES2DecoderTest2, IsSyncInvalidArgsBadSharedMemoryId) {
SpecializedSetup<cmds::IsSync, 0>(false);
decoder_->set_unsafe_es3_apis_enabled(true);
cmds::IsSync cmd;
cmd.Init(client_sync_id_, kInvalidSharedMemoryId, shared_memory_offset_);
EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
cmd.Init(client_sync_id_, shared_memory_id_, kInvalidSharedMemoryOffset);
EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
decoder_->set_unsafe_es3_apis_enabled(true);
}
TEST_P(GLES2DecoderTest2, IsTextureValidArgs) {
SpecializedSetup<cmds::IsTexture, 0>(true);
cmds::IsTexture cmd;
@ -1322,30 +1423,4 @@ TEST_P(GLES2DecoderTest2, VertexAttribI4uivImmediateValidArgs) {
// TODO(gman): VertexAttribPointer
TEST_P(GLES2DecoderTest2, ViewportValidArgs) {
EXPECT_CALL(*gl_, Viewport(1, 2, 3, 4));
SpecializedSetup<cmds::Viewport, 0>(true);
cmds::Viewport cmd;
cmd.Init(1, 2, 3, 4);
EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
EXPECT_EQ(GL_NO_ERROR, GetGLError());
}
TEST_P(GLES2DecoderTest2, ViewportInvalidArgs2_0) {
EXPECT_CALL(*gl_, Viewport(_, _, _, _)).Times(0);
SpecializedSetup<cmds::Viewport, 0>(false);
cmds::Viewport cmd;
cmd.Init(1, 2, -1, 4);
EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
}
TEST_P(GLES2DecoderTest2, ViewportInvalidArgs3_0) {
EXPECT_CALL(*gl_, Viewport(_, _, _, _)).Times(0);
SpecializedSetup<cmds::Viewport, 0>(false);
cmds::Viewport cmd;
cmd.Init(1, 2, 3, -1);
EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
}
#endif // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_2_AUTOGEN_H_

26
gpu/command_buffer/service/gles2_cmd_decoder_unittest_3_autogen.h

@ -12,6 +12,32 @@
#ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_3_AUTOGEN_H_
#define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_3_AUTOGEN_H_
TEST_P(GLES2DecoderTest3, ViewportValidArgs) {
EXPECT_CALL(*gl_, Viewport(1, 2, 3, 4));
SpecializedSetup<cmds::Viewport, 0>(true);
cmds::Viewport cmd;
cmd.Init(1, 2, 3, 4);
EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
EXPECT_EQ(GL_NO_ERROR, GetGLError());
}
TEST_P(GLES2DecoderTest3, ViewportInvalidArgs2_0) {
EXPECT_CALL(*gl_, Viewport(_, _, _, _)).Times(0);
SpecializedSetup<cmds::Viewport, 0>(false);
cmds::Viewport cmd;
cmd.Init(1, 2, -1, 4);
EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
}
TEST_P(GLES2DecoderTest3, ViewportInvalidArgs3_0) {
EXPECT_CALL(*gl_, Viewport(_, _, _, _)).Times(0);
SpecializedSetup<cmds::Viewport, 0>(false);
cmds::Viewport cmd;
cmd.Init(1, 2, 3, -1);
EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
}
// TODO(gman): TexStorage2DEXT
// TODO(gman): GenQueriesEXTImmediate
// TODO(gman): DeleteQueriesEXTImmediate

14
gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc

@ -100,6 +100,7 @@ GLES2DecoderTestBase::GLES2DecoderTestBase()
client_vertexarray_id_(124),
client_valuebuffer_id_(125),
client_transformfeedback_id_(126),
client_sync_id_(127),
service_renderbuffer_id_(0),
service_renderbuffer_valid_(false),
ignore_cached_state_for_test_(GetParam()),
@ -430,6 +431,7 @@ void GLES2DecoderTestBase::InitDecoderWithCommandLine(
.WillOnce(SetArgumentPointee<1>(kServiceTransformFeedbackId))
.RetiresOnSaturation();
GenHelper<cmds::GenTransformFeedbacksImmediate>(client_transformfeedback_id_);
DoFenceSync(client_sync_id_, kServiceSyncId);
if (reset_unsafe_es3_apis_enabled) {
decoder_->set_unsafe_es3_apis_enabled(false);
}
@ -536,6 +538,17 @@ void GLES2DecoderTestBase::DoDeleteProgram(
EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
}
void GLES2DecoderTestBase::DoFenceSync(
GLuint client_id, GLuint service_id) {
EXPECT_CALL(*gl_, FenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0))
.Times(1)
.WillOnce(Return(reinterpret_cast<GLsync>(service_id)))
.RetiresOnSaturation();
cmds::FenceSync cmd;
cmd.Init(client_id);
EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
}
void GLES2DecoderTestBase::SetBucketAsCString(
uint32 bucket_id, const char* str) {
uint32 size = str ? (strlen(str) + 1) : 0;
@ -1307,6 +1320,7 @@ const GLuint GLES2DecoderTestBase::kServiceElementBufferId;
const GLuint GLES2DecoderTestBase::kServiceQueryId;
const GLuint GLES2DecoderTestBase::kServiceVertexArrayId;
const GLuint GLES2DecoderTestBase::kServiceTransformFeedbackId;
const GLuint GLES2DecoderTestBase::kServiceSyncId;
const int32 GLES2DecoderTestBase::kSharedMemoryId;
const size_t GLES2DecoderTestBase::kSharedBufferSize;

7
gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h

@ -142,6 +142,10 @@ class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
return group_->GetTransformFeedbackServiceId(client_id, service_id);
}
bool GetSyncServiceId(GLuint client_id, GLsync* service_id) const {
return group_->GetSyncServiceId(client_id, service_id);
}
// This name doesn't match the underlying function, but doing it this way
// prevents the need to special-case the unit test generation
VertexAttribManager* GetVertexArrayInfo(GLuint client_id) {
@ -164,6 +168,7 @@ class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
void DoCreateProgram(GLuint client_id, GLuint service_id);
void DoCreateShader(GLenum shader_type, GLuint client_id, GLuint service_id);
void DoFenceSync(GLuint client_id, GLuint service_id);
void SetBucketAsCString(uint32 bucket_id, const char* str);
// If we want a valid bucket, just set |count_in_header| as |count|,
@ -448,6 +453,7 @@ class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
static const GLuint kServiceQueryId = 309;
static const GLuint kServiceVertexArrayId = 310;
static const GLuint kServiceTransformFeedbackId = 311;
static const GLuint kServiceSyncId = 312;
static const int32 kSharedMemoryId = 401;
static const size_t kSharedBufferSize = 2048;
@ -547,6 +553,7 @@ class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
GLuint client_vertexarray_id_;
GLuint client_valuebuffer_id_;
GLuint client_transformfeedback_id_;
GLuint client_sync_id_;
uint32 shared_memory_id_;
uint32 shared_memory_offset_;