| Index: gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
|
| ===================================================================
|
| --- gpu/command_buffer/service/gles2_cmd_decoder_autogen.h (revision 37750)
|
| +++ gpu/command_buffer/service/gles2_cmd_decoder_autogen.h (working copy)
|
| @@ -8,185 +8,185 @@
|
| #ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_AUTOGEN_H_
|
| #define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_AUTOGEN_H_
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleActiveTexture(
|
| +error::Error GLES2DecoderImpl::HandleActiveTexture(
|
| uint32 immediate_data_size, const gles2::ActiveTexture& c) {
|
| GLenum texture = static_cast<GLenum>(c.texture);
|
| glActiveTexture(texture);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleAttachShader(
|
| +error::Error GLES2DecoderImpl::HandleAttachShader(
|
| uint32 immediate_data_size, const gles2::AttachShader& c) {
|
| GLuint program;
|
| if (!id_manager_->GetServiceId(c.program, &program)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| GLuint shader;
|
| if (!id_manager_->GetServiceId(c.shader, &shader)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glAttachShader(program, shader);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleBindAttribLocation(
|
| +error::Error GLES2DecoderImpl::HandleBindAttribLocation(
|
| uint32 immediate_data_size, const gles2::BindAttribLocation& c) {
|
| GLuint program;
|
| if (!id_manager_->GetServiceId(c.program, &program)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| GLuint index = static_cast<GLuint>(c.index);
|
| uint32 name_size = c.data_size;
|
| const char* name = GetSharedMemoryAs<const char*>(
|
| c.name_shm_id, c.name_shm_offset, name_size);
|
| if (name == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| String name_str(name, name_size);
|
| glBindAttribLocation(program, index, name_str.c_str());
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleBindAttribLocationImmediate(
|
| +error::Error GLES2DecoderImpl::HandleBindAttribLocationImmediate(
|
| uint32 immediate_data_size, const gles2::BindAttribLocationImmediate& c) {
|
| GLuint program;
|
| if (!id_manager_->GetServiceId(c.program, &program)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| GLuint index = static_cast<GLuint>(c.index);
|
| uint32 name_size = c.data_size;
|
| const char* name = GetImmediateDataAs<const char*>(
|
| c, name_size, immediate_data_size);
|
| if (name == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| String name_str(name, name_size);
|
| glBindAttribLocation(program, index, name_str.c_str());
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleBindBuffer(
|
| +error::Error GLES2DecoderImpl::HandleBindBuffer(
|
| uint32 immediate_data_size, const gles2::BindBuffer& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLuint buffer;
|
| if (!id_manager_->GetServiceId(c.buffer, &buffer)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumBufferTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| DoBindBuffer(target, buffer);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleBindFramebuffer(
|
| +error::Error GLES2DecoderImpl::HandleBindFramebuffer(
|
| uint32 immediate_data_size, const gles2::BindFramebuffer& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLuint framebuffer;
|
| if (!id_manager_->GetServiceId(c.framebuffer, &framebuffer)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumFrameBufferTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glBindFramebufferEXT(target, framebuffer);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleBindRenderbuffer(
|
| +error::Error GLES2DecoderImpl::HandleBindRenderbuffer(
|
| uint32 immediate_data_size, const gles2::BindRenderbuffer& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLuint renderbuffer;
|
| if (!id_manager_->GetServiceId(c.renderbuffer, &renderbuffer)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumRenderBufferTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glBindRenderbufferEXT(target, renderbuffer);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleBindTexture(
|
| +error::Error GLES2DecoderImpl::HandleBindTexture(
|
| uint32 immediate_data_size, const gles2::BindTexture& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLuint texture;
|
| if (!id_manager_->GetServiceId(c.texture, &texture)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumTextureBindTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glBindTexture(target, texture);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleBlendColor(
|
| +error::Error GLES2DecoderImpl::HandleBlendColor(
|
| uint32 immediate_data_size, const gles2::BlendColor& c) {
|
| GLclampf red = static_cast<GLclampf>(c.red);
|
| GLclampf green = static_cast<GLclampf>(c.green);
|
| GLclampf blue = static_cast<GLclampf>(c.blue);
|
| GLclampf alpha = static_cast<GLclampf>(c.alpha);
|
| glBlendColor(red, green, blue, alpha);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleBlendEquation(
|
| +error::Error GLES2DecoderImpl::HandleBlendEquation(
|
| uint32 immediate_data_size, const gles2::BlendEquation& c) {
|
| GLenum mode = static_cast<GLenum>(c.mode);
|
| if (!ValidateGLenumEquation(mode)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glBlendEquation(mode);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleBlendEquationSeparate(
|
| +error::Error GLES2DecoderImpl::HandleBlendEquationSeparate(
|
| uint32 immediate_data_size, const gles2::BlendEquationSeparate& c) {
|
| GLenum modeRGB = static_cast<GLenum>(c.modeRGB);
|
| GLenum modeAlpha = static_cast<GLenum>(c.modeAlpha);
|
| if (!ValidateGLenumEquation(modeRGB)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumEquation(modeAlpha)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glBlendEquationSeparate(modeRGB, modeAlpha);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleBlendFunc(
|
| +error::Error GLES2DecoderImpl::HandleBlendFunc(
|
| uint32 immediate_data_size, const gles2::BlendFunc& c) {
|
| GLenum sfactor = static_cast<GLenum>(c.sfactor);
|
| GLenum dfactor = static_cast<GLenum>(c.dfactor);
|
| if (!ValidateGLenumSrcBlendFactor(sfactor)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumDstBlendFactor(dfactor)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glBlendFunc(sfactor, dfactor);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleBlendFuncSeparate(
|
| +error::Error GLES2DecoderImpl::HandleBlendFuncSeparate(
|
| uint32 immediate_data_size, const gles2::BlendFuncSeparate& c) {
|
| GLenum srcRGB = static_cast<GLenum>(c.srcRGB);
|
| GLenum dstRGB = static_cast<GLenum>(c.dstRGB);
|
| @@ -194,25 +194,25 @@
|
| GLenum dstAlpha = static_cast<GLenum>(c.dstAlpha);
|
| if (!ValidateGLenumSrcBlendFactor(srcRGB)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumDstBlendFactor(dstRGB)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumSrcBlendFactor(srcAlpha)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumDstBlendFactor(dstAlpha)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleBufferSubData(
|
| +error::Error GLES2DecoderImpl::HandleBufferSubData(
|
| uint32 immediate_data_size, const gles2::BufferSubData& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLintptr offset = static_cast<GLintptr>(c.offset);
|
| @@ -222,16 +222,16 @@
|
| c.data_shm_id, c.data_shm_offset, data_size);
|
| if (!ValidateGLenumBufferTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (data == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glBufferSubData(target, offset, size, data);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleBufferSubDataImmediate(
|
| +error::Error GLES2DecoderImpl::HandleBufferSubDataImmediate(
|
| uint32 immediate_data_size, const gles2::BufferSubDataImmediate& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLintptr offset = static_cast<GLintptr>(c.offset);
|
| @@ -241,79 +241,79 @@
|
| c, data_size, immediate_data_size);
|
| if (!ValidateGLenumBufferTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (data == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glBufferSubData(target, offset, size, data);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleCheckFramebufferStatus(
|
| +error::Error GLES2DecoderImpl::HandleCheckFramebufferStatus(
|
| uint32 immediate_data_size, const gles2::CheckFramebufferStatus& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| if (!ValidateGLenumFrameBufferTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glCheckFramebufferStatusEXT(target);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleClear(
|
| +error::Error GLES2DecoderImpl::HandleClear(
|
| uint32 immediate_data_size, const gles2::Clear& c) {
|
| GLbitfield mask = static_cast<GLbitfield>(c.mask);
|
| glClear(mask);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleClearColor(
|
| +error::Error GLES2DecoderImpl::HandleClearColor(
|
| uint32 immediate_data_size, const gles2::ClearColor& c) {
|
| GLclampf red = static_cast<GLclampf>(c.red);
|
| GLclampf green = static_cast<GLclampf>(c.green);
|
| GLclampf blue = static_cast<GLclampf>(c.blue);
|
| GLclampf alpha = static_cast<GLclampf>(c.alpha);
|
| glClearColor(red, green, blue, alpha);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleClearDepthf(
|
| +error::Error GLES2DecoderImpl::HandleClearDepthf(
|
| uint32 immediate_data_size, const gles2::ClearDepthf& c) {
|
| GLclampf depth = static_cast<GLclampf>(c.depth);
|
| glClearDepth(depth);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleClearStencil(
|
| +error::Error GLES2DecoderImpl::HandleClearStencil(
|
| uint32 immediate_data_size, const gles2::ClearStencil& c) {
|
| GLint s = static_cast<GLint>(c.s);
|
| glClearStencil(s);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleColorMask(
|
| +error::Error GLES2DecoderImpl::HandleColorMask(
|
| uint32 immediate_data_size, const gles2::ColorMask& c) {
|
| GLboolean red = static_cast<GLboolean>(c.red);
|
| GLboolean green = static_cast<GLboolean>(c.green);
|
| GLboolean blue = static_cast<GLboolean>(c.blue);
|
| GLboolean alpha = static_cast<GLboolean>(c.alpha);
|
| glColorMask(red, green, blue, alpha);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleCompileShader(
|
| +error::Error GLES2DecoderImpl::HandleCompileShader(
|
| uint32 immediate_data_size, const gles2::CompileShader& c) {
|
| GLuint shader;
|
| if (!id_manager_->GetServiceId(c.shader, &shader)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glCompileShader(shader);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleCompressedTexSubImage2D(
|
| +error::Error GLES2DecoderImpl::HandleCompressedTexSubImage2D(
|
| uint32 immediate_data_size, const gles2::CompressedTexSubImage2D& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLint level = static_cast<GLint>(c.level);
|
| @@ -328,17 +328,17 @@
|
| c.data_shm_id, c.data_shm_offset, data_size);
|
| if (!ValidateGLenumTextureTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (data == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glCompressedTexSubImage2D(
|
| target, level, xoffset, yoffset, width, height, format, imageSize, data);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleCompressedTexSubImage2DImmediate(
|
| +error::Error GLES2DecoderImpl::HandleCompressedTexSubImage2DImmediate(
|
| uint32 immediate_data_size,
|
| const gles2::CompressedTexSubImage2DImmediate& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| @@ -354,17 +354,17 @@
|
| c, data_size, immediate_data_size);
|
| if (!ValidateGLenumTextureTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (data == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glCompressedTexSubImage2D(
|
| target, level, xoffset, yoffset, width, height, format, imageSize, data);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleCopyTexImage2D(
|
| +error::Error GLES2DecoderImpl::HandleCopyTexImage2D(
|
| uint32 immediate_data_size, const gles2::CopyTexImage2D& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLint level = static_cast<GLint>(c.level);
|
| @@ -376,13 +376,13 @@
|
| GLint border = static_cast<GLint>(c.border);
|
| if (!ValidateGLenumTextureTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleCopyTexSubImage2D(
|
| +error::Error GLES2DecoderImpl::HandleCopyTexSubImage2D(
|
| uint32 immediate_data_size, const gles2::CopyTexSubImage2D& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLint level = static_cast<GLint>(c.level);
|
| @@ -394,250 +394,250 @@
|
| GLsizei height = static_cast<GLsizei>(c.height);
|
| if (!ValidateGLenumTextureTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleCreateProgram(
|
| +error::Error GLES2DecoderImpl::HandleCreateProgram(
|
| uint32 immediate_data_size, const gles2::CreateProgram& c) {
|
| uint32 client_id = c.client_id;
|
| CreateProgramHelper(client_id);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleCreateShader(
|
| +error::Error GLES2DecoderImpl::HandleCreateShader(
|
| uint32 immediate_data_size, const gles2::CreateShader& c) {
|
| GLenum type = static_cast<GLenum>(c.type);
|
| if (!ValidateGLenumShaderType(type)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| uint32 client_id = c.client_id;
|
| CreateShaderHelper(type, client_id);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleCullFace(
|
| +error::Error GLES2DecoderImpl::HandleCullFace(
|
| uint32 immediate_data_size, const gles2::CullFace& c) {
|
| GLenum mode = static_cast<GLenum>(c.mode);
|
| if (!ValidateGLenumFaceType(mode)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glCullFace(mode);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleDeleteBuffers(
|
| +error::Error GLES2DecoderImpl::HandleDeleteBuffers(
|
| uint32 immediate_data_size, const gles2::DeleteBuffers& c) {
|
| GLsizei n = static_cast<GLsizei>(c.n);
|
| uint32 data_size = n * sizeof(GLuint);
|
| const GLuint* buffers = GetSharedMemoryAs<const GLuint*>(
|
| c.buffers_shm_id, c.buffers_shm_offset, data_size);
|
| if (buffers == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| DeleteGLObjects<GLDeleteBuffersHelper>(n, buffers);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleDeleteBuffersImmediate(
|
| +error::Error GLES2DecoderImpl::HandleDeleteBuffersImmediate(
|
| uint32 immediate_data_size, const gles2::DeleteBuffersImmediate& c) {
|
| GLsizei n = static_cast<GLsizei>(c.n);
|
| uint32 data_size = n * sizeof(GLuint);
|
| const GLuint* buffers = GetImmediateDataAs<const GLuint*>(
|
| c, data_size, immediate_data_size);
|
| if (buffers == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| DeleteGLObjects<GLDeleteBuffersHelper>(n, buffers);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleDeleteFramebuffers(
|
| +error::Error GLES2DecoderImpl::HandleDeleteFramebuffers(
|
| uint32 immediate_data_size, const gles2::DeleteFramebuffers& c) {
|
| GLsizei n = static_cast<GLsizei>(c.n);
|
| uint32 data_size = n * sizeof(GLuint);
|
| const GLuint* framebuffers = GetSharedMemoryAs<const GLuint*>(
|
| c.framebuffers_shm_id, c.framebuffers_shm_offset, data_size);
|
| if (framebuffers == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| DeleteGLObjects<GLDeleteFramebuffersHelper>(n, framebuffers);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleDeleteFramebuffersImmediate(
|
| +error::Error GLES2DecoderImpl::HandleDeleteFramebuffersImmediate(
|
| uint32 immediate_data_size, const gles2::DeleteFramebuffersImmediate& c) {
|
| GLsizei n = static_cast<GLsizei>(c.n);
|
| uint32 data_size = n * sizeof(GLuint);
|
| const GLuint* framebuffers = GetImmediateDataAs<const GLuint*>(
|
| c, data_size, immediate_data_size);
|
| if (framebuffers == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| DeleteGLObjects<GLDeleteFramebuffersHelper>(n, framebuffers);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleDeleteRenderbuffers(
|
| +error::Error GLES2DecoderImpl::HandleDeleteRenderbuffers(
|
| uint32 immediate_data_size, const gles2::DeleteRenderbuffers& c) {
|
| GLsizei n = static_cast<GLsizei>(c.n);
|
| uint32 data_size = n * sizeof(GLuint);
|
| const GLuint* renderbuffers = GetSharedMemoryAs<const GLuint*>(
|
| c.renderbuffers_shm_id, c.renderbuffers_shm_offset, data_size);
|
| if (renderbuffers == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| DeleteGLObjects<GLDeleteRenderbuffersHelper>(n, renderbuffers);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleDeleteRenderbuffersImmediate(
|
| +error::Error GLES2DecoderImpl::HandleDeleteRenderbuffersImmediate(
|
| uint32 immediate_data_size, const gles2::DeleteRenderbuffersImmediate& c) {
|
| GLsizei n = static_cast<GLsizei>(c.n);
|
| uint32 data_size = n * sizeof(GLuint);
|
| const GLuint* renderbuffers = GetImmediateDataAs<const GLuint*>(
|
| c, data_size, immediate_data_size);
|
| if (renderbuffers == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| DeleteGLObjects<GLDeleteRenderbuffersHelper>(n, renderbuffers);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleDeleteTextures(
|
| +error::Error GLES2DecoderImpl::HandleDeleteTextures(
|
| uint32 immediate_data_size, const gles2::DeleteTextures& c) {
|
| GLsizei n = static_cast<GLsizei>(c.n);
|
| uint32 data_size = n * sizeof(GLuint);
|
| const GLuint* textures = GetSharedMemoryAs<const GLuint*>(
|
| c.textures_shm_id, c.textures_shm_offset, data_size);
|
| if (textures == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| DeleteGLObjects<GLDeleteTexturesHelper>(n, textures);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleDeleteTexturesImmediate(
|
| +error::Error GLES2DecoderImpl::HandleDeleteTexturesImmediate(
|
| uint32 immediate_data_size, const gles2::DeleteTexturesImmediate& c) {
|
| GLsizei n = static_cast<GLsizei>(c.n);
|
| uint32 data_size = n * sizeof(GLuint);
|
| const GLuint* textures = GetImmediateDataAs<const GLuint*>(
|
| c, data_size, immediate_data_size);
|
| if (textures == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| DeleteGLObjects<GLDeleteTexturesHelper>(n, textures);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleDepthFunc(
|
| +error::Error GLES2DecoderImpl::HandleDepthFunc(
|
| uint32 immediate_data_size, const gles2::DepthFunc& c) {
|
| GLenum func = static_cast<GLenum>(c.func);
|
| if (!ValidateGLenumCmpFunction(func)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glDepthFunc(func);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleDepthMask(
|
| +error::Error GLES2DecoderImpl::HandleDepthMask(
|
| uint32 immediate_data_size, const gles2::DepthMask& c) {
|
| GLboolean flag = static_cast<GLboolean>(c.flag);
|
| glDepthMask(flag);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleDepthRangef(
|
| +error::Error GLES2DecoderImpl::HandleDepthRangef(
|
| uint32 immediate_data_size, const gles2::DepthRangef& c) {
|
| GLclampf zNear = static_cast<GLclampf>(c.zNear);
|
| GLclampf zFar = static_cast<GLclampf>(c.zFar);
|
| glDepthRange(zNear, zFar);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleDetachShader(
|
| +error::Error GLES2DecoderImpl::HandleDetachShader(
|
| uint32 immediate_data_size, const gles2::DetachShader& c) {
|
| GLuint program;
|
| if (!id_manager_->GetServiceId(c.program, &program)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| GLuint shader;
|
| if (!id_manager_->GetServiceId(c.shader, &shader)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glDetachShader(program, shader);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleDisable(
|
| +error::Error GLES2DecoderImpl::HandleDisable(
|
| uint32 immediate_data_size, const gles2::Disable& c) {
|
| GLenum cap = static_cast<GLenum>(c.cap);
|
| if (!ValidateGLenumCapability(cap)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glDisable(cap);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleDisableVertexAttribArray(
|
| +error::Error GLES2DecoderImpl::HandleDisableVertexAttribArray(
|
| uint32 immediate_data_size, const gles2::DisableVertexAttribArray& c) {
|
| GLuint index = static_cast<GLuint>(c.index);
|
| DoDisableVertexAttribArray(index);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleDrawArrays(
|
| +error::Error GLES2DecoderImpl::HandleDrawArrays(
|
| uint32 immediate_data_size, const gles2::DrawArrays& c) {
|
| GLenum mode = static_cast<GLenum>(c.mode);
|
| GLint first = static_cast<GLint>(c.first);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| if (!ValidateGLenumDrawMode(mode)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| DoDrawArrays(mode, first, count);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleEnable(
|
| +error::Error GLES2DecoderImpl::HandleEnable(
|
| uint32 immediate_data_size, const gles2::Enable& c) {
|
| GLenum cap = static_cast<GLenum>(c.cap);
|
| if (!ValidateGLenumCapability(cap)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glEnable(cap);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleEnableVertexAttribArray(
|
| +error::Error GLES2DecoderImpl::HandleEnableVertexAttribArray(
|
| uint32 immediate_data_size, const gles2::EnableVertexAttribArray& c) {
|
| GLuint index = static_cast<GLuint>(c.index);
|
| DoEnableVertexAttribArray(index);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleFinish(
|
| +error::Error GLES2DecoderImpl::HandleFinish(
|
| uint32 immediate_data_size, const gles2::Finish& c) {
|
| glFinish();
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleFlush(
|
| +error::Error GLES2DecoderImpl::HandleFlush(
|
| uint32 immediate_data_size, const gles2::Flush& c) {
|
| glFlush();
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleFramebufferRenderbuffer(
|
| +error::Error GLES2DecoderImpl::HandleFramebufferRenderbuffer(
|
| uint32 immediate_data_size, const gles2::FramebufferRenderbuffer& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLenum attachment = static_cast<GLenum>(c.attachment);
|
| @@ -645,26 +645,26 @@
|
| GLuint renderbuffer;
|
| if (!id_manager_->GetServiceId(c.renderbuffer, &renderbuffer)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumFrameBufferTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumAttachment(attachment)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumRenderBufferTarget(renderbuffertarget)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glFramebufferRenderbufferEXT(
|
| target, attachment, renderbuffertarget, renderbuffer);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleFramebufferTexture2D(
|
| +error::Error GLES2DecoderImpl::HandleFramebufferTexture2D(
|
| uint32 immediate_data_size, const gles2::FramebufferTexture2D& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLenum attachment = static_cast<GLenum>(c.attachment);
|
| @@ -672,168 +672,168 @@
|
| GLuint texture;
|
| if (!id_manager_->GetServiceId(c.texture, &texture)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| GLint level = static_cast<GLint>(c.level);
|
| if (!ValidateGLenumFrameBufferTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumAttachment(attachment)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumTextureTarget(textarget)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glFramebufferTexture2DEXT(target, attachment, textarget, texture, level);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleFrontFace(
|
| +error::Error GLES2DecoderImpl::HandleFrontFace(
|
| uint32 immediate_data_size, const gles2::FrontFace& c) {
|
| GLenum mode = static_cast<GLenum>(c.mode);
|
| if (!ValidateGLenumFaceMode(mode)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glFrontFace(mode);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGenBuffers(
|
| +error::Error GLES2DecoderImpl::HandleGenBuffers(
|
| uint32 immediate_data_size, const gles2::GenBuffers& c) {
|
| GLsizei n = static_cast<GLsizei>(c.n);
|
| uint32 data_size = n * sizeof(GLuint);
|
| GLuint* buffers = GetSharedMemoryAs<GLuint*>(
|
| c.buffers_shm_id, c.buffers_shm_offset, data_size);
|
| if (buffers == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| if (!GenGLObjects<GLGenBuffersHelper>(n, buffers)) {
|
| - return parse_error::kParseInvalidArguments;
|
| + return error::kInvalidArguments;
|
| }
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGenBuffersImmediate(
|
| +error::Error GLES2DecoderImpl::HandleGenBuffersImmediate(
|
| uint32 immediate_data_size, const gles2::GenBuffersImmediate& c) {
|
| GLsizei n = static_cast<GLsizei>(c.n);
|
| uint32 data_size = n * sizeof(GLuint);
|
| GLuint* buffers = GetImmediateDataAs<GLuint*>(
|
| c, data_size, immediate_data_size);
|
| if (buffers == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| if (!GenGLObjects<GLGenBuffersHelper>(n, buffers)) {
|
| - return parse_error::kParseInvalidArguments;
|
| + return error::kInvalidArguments;
|
| }
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGenerateMipmap(
|
| +error::Error GLES2DecoderImpl::HandleGenerateMipmap(
|
| uint32 immediate_data_size, const gles2::GenerateMipmap& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| if (!ValidateGLenumTextureBindTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glGenerateMipmapEXT(target);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGenFramebuffers(
|
| +error::Error GLES2DecoderImpl::HandleGenFramebuffers(
|
| uint32 immediate_data_size, const gles2::GenFramebuffers& c) {
|
| GLsizei n = static_cast<GLsizei>(c.n);
|
| uint32 data_size = n * sizeof(GLuint);
|
| GLuint* framebuffers = GetSharedMemoryAs<GLuint*>(
|
| c.framebuffers_shm_id, c.framebuffers_shm_offset, data_size);
|
| if (framebuffers == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| if (!GenGLObjects<GLGenFramebuffersHelper>(n, framebuffers)) {
|
| - return parse_error::kParseInvalidArguments;
|
| + return error::kInvalidArguments;
|
| }
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGenFramebuffersImmediate(
|
| +error::Error GLES2DecoderImpl::HandleGenFramebuffersImmediate(
|
| uint32 immediate_data_size, const gles2::GenFramebuffersImmediate& c) {
|
| GLsizei n = static_cast<GLsizei>(c.n);
|
| uint32 data_size = n * sizeof(GLuint);
|
| GLuint* framebuffers = GetImmediateDataAs<GLuint*>(
|
| c, data_size, immediate_data_size);
|
| if (framebuffers == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| if (!GenGLObjects<GLGenFramebuffersHelper>(n, framebuffers)) {
|
| - return parse_error::kParseInvalidArguments;
|
| + return error::kInvalidArguments;
|
| }
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGenRenderbuffers(
|
| +error::Error GLES2DecoderImpl::HandleGenRenderbuffers(
|
| uint32 immediate_data_size, const gles2::GenRenderbuffers& c) {
|
| GLsizei n = static_cast<GLsizei>(c.n);
|
| uint32 data_size = n * sizeof(GLuint);
|
| GLuint* renderbuffers = GetSharedMemoryAs<GLuint*>(
|
| c.renderbuffers_shm_id, c.renderbuffers_shm_offset, data_size);
|
| if (renderbuffers == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| if (!GenGLObjects<GLGenRenderbuffersHelper>(n, renderbuffers)) {
|
| - return parse_error::kParseInvalidArguments;
|
| + return error::kInvalidArguments;
|
| }
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGenRenderbuffersImmediate(
|
| +error::Error GLES2DecoderImpl::HandleGenRenderbuffersImmediate(
|
| uint32 immediate_data_size, const gles2::GenRenderbuffersImmediate& c) {
|
| GLsizei n = static_cast<GLsizei>(c.n);
|
| uint32 data_size = n * sizeof(GLuint);
|
| GLuint* renderbuffers = GetImmediateDataAs<GLuint*>(
|
| c, data_size, immediate_data_size);
|
| if (renderbuffers == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| if (!GenGLObjects<GLGenRenderbuffersHelper>(n, renderbuffers)) {
|
| - return parse_error::kParseInvalidArguments;
|
| + return error::kInvalidArguments;
|
| }
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGenTextures(
|
| +error::Error GLES2DecoderImpl::HandleGenTextures(
|
| uint32 immediate_data_size, const gles2::GenTextures& c) {
|
| GLsizei n = static_cast<GLsizei>(c.n);
|
| uint32 data_size = n * sizeof(GLuint);
|
| GLuint* textures = GetSharedMemoryAs<GLuint*>(
|
| c.textures_shm_id, c.textures_shm_offset, data_size);
|
| if (textures == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| if (!GenGLObjects<GLGenTexturesHelper>(n, textures)) {
|
| - return parse_error::kParseInvalidArguments;
|
| + return error::kInvalidArguments;
|
| }
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGenTexturesImmediate(
|
| +error::Error GLES2DecoderImpl::HandleGenTexturesImmediate(
|
| uint32 immediate_data_size, const gles2::GenTexturesImmediate& c) {
|
| GLsizei n = static_cast<GLsizei>(c.n);
|
| uint32 data_size = n * sizeof(GLuint);
|
| GLuint* textures = GetImmediateDataAs<GLuint*>(
|
| c, data_size, immediate_data_size);
|
| if (textures == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| if (!GenGLObjects<GLGenTexturesHelper>(n, textures)) {
|
| - return parse_error::kParseInvalidArguments;
|
| + return error::kInvalidArguments;
|
| }
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGetBooleanv(
|
| +error::Error GLES2DecoderImpl::HandleGetBooleanv(
|
| uint32 immediate_data_size, const gles2::GetBooleanv& c) {
|
| GLenum pname = static_cast<GLenum>(c.pname);
|
| GLboolean* params;
|
| @@ -842,13 +842,13 @@
|
| params = GetSharedMemoryAs<GLboolean*>(
|
| c.params_shm_id, c.params_shm_offset, params_size);
|
| if (params == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glGetBooleanv(pname, params);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGetBufferParameteriv(
|
| +error::Error GLES2DecoderImpl::HandleGetBufferParameteriv(
|
| uint32 immediate_data_size, const gles2::GetBufferParameteriv& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLenum pname = static_cast<GLenum>(c.pname);
|
| @@ -859,28 +859,28 @@
|
| c.params_shm_id, c.params_shm_offset, params_size);
|
| if (!ValidateGLenumBufferTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumBufferParameter(pname)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (params == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glGetBufferParameteriv(target, pname, params);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGetError(
|
| +error::Error GLES2DecoderImpl::HandleGetError(
|
| uint32 immediate_data_size, const gles2::GetError& c) {
|
| GLenum* result_dst = GetSharedMemoryAs<GLenum*>(
|
| c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
|
| *result_dst = GetGLError();
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGetFloatv(
|
| +error::Error GLES2DecoderImpl::HandleGetFloatv(
|
| uint32 immediate_data_size, const gles2::GetFloatv& c) {
|
| GLenum pname = static_cast<GLenum>(c.pname);
|
| GLfloat* params;
|
| @@ -889,13 +889,13 @@
|
| params = GetSharedMemoryAs<GLfloat*>(
|
| c.params_shm_id, c.params_shm_offset, params_size);
|
| if (params == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glGetFloatv(pname, params);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGetFramebufferAttachmentParameteriv(
|
| +error::Error GLES2DecoderImpl::HandleGetFramebufferAttachmentParameteriv(
|
| uint32 immediate_data_size,
|
| const gles2::GetFramebufferAttachmentParameteriv& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| @@ -908,24 +908,24 @@
|
| c.params_shm_id, c.params_shm_offset, params_size);
|
| if (!ValidateGLenumFrameBufferTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumAttachment(attachment)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumFrameBufferParameter(pname)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (params == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, params);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGetIntegerv(
|
| +error::Error GLES2DecoderImpl::HandleGetIntegerv(
|
| uint32 immediate_data_size, const gles2::GetIntegerv& c) {
|
| GLenum pname = static_cast<GLenum>(c.pname);
|
| GLint* params;
|
| @@ -934,18 +934,18 @@
|
| params = GetSharedMemoryAs<GLint*>(
|
| c.params_shm_id, c.params_shm_offset, params_size);
|
| if (params == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glGetIntegerv(pname, params);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGetProgramiv(
|
| +error::Error GLES2DecoderImpl::HandleGetProgramiv(
|
| uint32 immediate_data_size, const gles2::GetProgramiv& c) {
|
| GLuint program;
|
| if (!id_manager_->GetServiceId(c.program, &program)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| GLenum pname = static_cast<GLenum>(c.pname);
|
| GLint* params;
|
| @@ -955,21 +955,21 @@
|
| c.params_shm_id, c.params_shm_offset, params_size);
|
| if (!ValidateGLenumProgramParameter(pname)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (params == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glGetProgramiv(program, pname, params);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGetProgramInfoLog(
|
| +error::Error GLES2DecoderImpl::HandleGetProgramInfoLog(
|
| uint32 immediate_data_size, const gles2::GetProgramInfoLog& c) {
|
| GLuint program;
|
| if (!id_manager_->GetServiceId(c.program, &program)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| GLsizei bufsize = static_cast<GLsizei>(c.bufsize);
|
| uint32 size_shm_id = c.length_shm_id;
|
| @@ -979,19 +979,19 @@
|
| length = GetSharedMemoryAs<GLsizei*>(
|
| size_shm_id, size_shm_offset, sizeof(*length));
|
| if (!length) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| }
|
| char* infolog = GetSharedMemoryAs<char*>(
|
| c.infolog_shm_id, c.infolog_shm_offset, bufsize);
|
| if (infolog == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glGetProgramInfoLog(program, bufsize, length, infolog);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGetRenderbufferParameteriv(
|
| +error::Error GLES2DecoderImpl::HandleGetRenderbufferParameteriv(
|
| uint32 immediate_data_size, const gles2::GetRenderbufferParameteriv& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLenum pname = static_cast<GLenum>(c.pname);
|
| @@ -1002,25 +1002,25 @@
|
| c.params_shm_id, c.params_shm_offset, params_size);
|
| if (!ValidateGLenumRenderBufferTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumRenderBufferParameter(pname)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (params == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glGetRenderbufferParameterivEXT(target, pname, params);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGetShaderiv(
|
| +error::Error GLES2DecoderImpl::HandleGetShaderiv(
|
| uint32 immediate_data_size, const gles2::GetShaderiv& c) {
|
| GLuint shader;
|
| if (!id_manager_->GetServiceId(c.shader, &shader)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| GLenum pname = static_cast<GLenum>(c.pname);
|
| GLint* params;
|
| @@ -1030,21 +1030,21 @@
|
| c.params_shm_id, c.params_shm_offset, params_size);
|
| if (!ValidateGLenumShaderParameter(pname)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (params == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glGetShaderiv(shader, pname, params);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGetShaderInfoLog(
|
| +error::Error GLES2DecoderImpl::HandleGetShaderInfoLog(
|
| uint32 immediate_data_size, const gles2::GetShaderInfoLog& c) {
|
| GLuint shader;
|
| if (!id_manager_->GetServiceId(c.shader, &shader)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| GLsizei bufsize = static_cast<GLsizei>(c.bufsize);
|
| uint32 size_shm_id = c.length_shm_id;
|
| @@ -1054,24 +1054,24 @@
|
| length = GetSharedMemoryAs<GLsizei*>(
|
| size_shm_id, size_shm_offset, sizeof(*length));
|
| if (!length) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| }
|
| char* infolog = GetSharedMemoryAs<char*>(
|
| c.infolog_shm_id, c.infolog_shm_offset, bufsize);
|
| if (infolog == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glGetShaderInfoLog(shader, bufsize, length, infolog);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGetShaderSource(
|
| +error::Error GLES2DecoderImpl::HandleGetShaderSource(
|
| uint32 immediate_data_size, const gles2::GetShaderSource& c) {
|
| GLuint shader;
|
| if (!id_manager_->GetServiceId(c.shader, &shader)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| GLsizei bufsize = static_cast<GLsizei>(c.bufsize);
|
| uint32 size_shm_id = c.length_shm_id;
|
| @@ -1081,30 +1081,30 @@
|
| length = GetSharedMemoryAs<GLsizei*>(
|
| size_shm_id, size_shm_offset, sizeof(*length));
|
| if (!length) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| }
|
| char* source = GetSharedMemoryAs<char*>(
|
| c.source_shm_id, c.source_shm_offset, bufsize);
|
| if (source == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glGetShaderSource(shader, bufsize, length, source);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGetString(
|
| +error::Error GLES2DecoderImpl::HandleGetString(
|
| uint32 immediate_data_size, const gles2::GetString& c) {
|
| GLenum name = static_cast<GLenum>(c.name);
|
| if (!ValidateGLenumStringType(name)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glGetString(name);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGetTexParameterfv(
|
| +error::Error GLES2DecoderImpl::HandleGetTexParameterfv(
|
| uint32 immediate_data_size, const gles2::GetTexParameterfv& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLenum pname = static_cast<GLenum>(c.pname);
|
| @@ -1115,20 +1115,20 @@
|
| c.params_shm_id, c.params_shm_offset, params_size);
|
| if (!ValidateGLenumTextureTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumTextureParameter(pname)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (params == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glGetTexParameterfv(target, pname, params);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGetTexParameteriv(
|
| +error::Error GLES2DecoderImpl::HandleGetTexParameteriv(
|
| uint32 immediate_data_size, const gles2::GetTexParameteriv& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLenum pname = static_cast<GLenum>(c.pname);
|
| @@ -1139,20 +1139,20 @@
|
| c.params_shm_id, c.params_shm_offset, params_size);
|
| if (!ValidateGLenumTextureTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumTextureParameter(pname)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (params == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glGetTexParameteriv(target, pname, params);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGetVertexAttribfv(
|
| +error::Error GLES2DecoderImpl::HandleGetVertexAttribfv(
|
| uint32 immediate_data_size, const gles2::GetVertexAttribfv& c) {
|
| GLuint index = static_cast<GLuint>(c.index);
|
| GLenum pname = static_cast<GLenum>(c.pname);
|
| @@ -1163,16 +1163,16 @@
|
| c.params_shm_id, c.params_shm_offset, params_size);
|
| if (!ValidateGLenumVertexAttribute(pname)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (params == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glGetVertexAttribfv(index, pname, params);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleGetVertexAttribiv(
|
| +error::Error GLES2DecoderImpl::HandleGetVertexAttribiv(
|
| uint32 immediate_data_size, const gles2::GetVertexAttribiv& c) {
|
| GLuint index = static_cast<GLuint>(c.index);
|
| GLenum pname = static_cast<GLenum>(c.pname);
|
| @@ -1183,149 +1183,149 @@
|
| c.params_shm_id, c.params_shm_offset, params_size);
|
| if (!ValidateGLenumVertexAttribute(pname)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (params == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glGetVertexAttribiv(index, pname, params);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleHint(
|
| +error::Error GLES2DecoderImpl::HandleHint(
|
| uint32 immediate_data_size, const gles2::Hint& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLenum mode = static_cast<GLenum>(c.mode);
|
| if (!ValidateGLenumHintTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumHintMode(mode)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glHint(target, mode);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleIsBuffer(
|
| +error::Error GLES2DecoderImpl::HandleIsBuffer(
|
| uint32 immediate_data_size, const gles2::IsBuffer& c) {
|
| GLuint buffer;
|
| if (!id_manager_->GetServiceId(c.buffer, &buffer)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| GLboolean* result_dst = GetSharedMemoryAs<GLboolean*>(
|
| c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
|
| *result_dst = glIsBuffer(buffer);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleIsEnabled(
|
| +error::Error GLES2DecoderImpl::HandleIsEnabled(
|
| uint32 immediate_data_size, const gles2::IsEnabled& c) {
|
| GLenum cap = static_cast<GLenum>(c.cap);
|
| GLboolean* result_dst = GetSharedMemoryAs<GLboolean*>(
|
| c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
|
| if (!ValidateGLenumCapability(cap)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| *result_dst = glIsEnabled(cap);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleIsFramebuffer(
|
| +error::Error GLES2DecoderImpl::HandleIsFramebuffer(
|
| uint32 immediate_data_size, const gles2::IsFramebuffer& c) {
|
| GLuint framebuffer;
|
| if (!id_manager_->GetServiceId(c.framebuffer, &framebuffer)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| GLboolean* result_dst = GetSharedMemoryAs<GLboolean*>(
|
| c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
|
| *result_dst = glIsFramebufferEXT(framebuffer);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleIsProgram(
|
| +error::Error GLES2DecoderImpl::HandleIsProgram(
|
| uint32 immediate_data_size, const gles2::IsProgram& c) {
|
| GLuint program;
|
| if (!id_manager_->GetServiceId(c.program, &program)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| GLboolean* result_dst = GetSharedMemoryAs<GLboolean*>(
|
| c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
|
| *result_dst = glIsProgram(program);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleIsRenderbuffer(
|
| +error::Error GLES2DecoderImpl::HandleIsRenderbuffer(
|
| uint32 immediate_data_size, const gles2::IsRenderbuffer& c) {
|
| GLuint renderbuffer;
|
| if (!id_manager_->GetServiceId(c.renderbuffer, &renderbuffer)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| GLboolean* result_dst = GetSharedMemoryAs<GLboolean*>(
|
| c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
|
| *result_dst = glIsRenderbufferEXT(renderbuffer);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleIsShader(
|
| +error::Error GLES2DecoderImpl::HandleIsShader(
|
| uint32 immediate_data_size, const gles2::IsShader& c) {
|
| GLuint shader;
|
| if (!id_manager_->GetServiceId(c.shader, &shader)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| GLboolean* result_dst = GetSharedMemoryAs<GLboolean*>(
|
| c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
|
| *result_dst = glIsShader(shader);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleIsTexture(
|
| +error::Error GLES2DecoderImpl::HandleIsTexture(
|
| uint32 immediate_data_size, const gles2::IsTexture& c) {
|
| GLuint texture;
|
| if (!id_manager_->GetServiceId(c.texture, &texture)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| GLboolean* result_dst = GetSharedMemoryAs<GLboolean*>(
|
| c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
|
| *result_dst = glIsTexture(texture);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleLineWidth(
|
| +error::Error GLES2DecoderImpl::HandleLineWidth(
|
| uint32 immediate_data_size, const gles2::LineWidth& c) {
|
| GLfloat width = static_cast<GLfloat>(c.width);
|
| glLineWidth(width);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleLinkProgram(
|
| +error::Error GLES2DecoderImpl::HandleLinkProgram(
|
| uint32 immediate_data_size, const gles2::LinkProgram& c) {
|
| GLuint program;
|
| if (!id_manager_->GetServiceId(c.program, &program)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| DoLinkProgram(program);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandlePolygonOffset(
|
| +error::Error GLES2DecoderImpl::HandlePolygonOffset(
|
| uint32 immediate_data_size, const gles2::PolygonOffset& c) {
|
| GLfloat factor = static_cast<GLfloat>(c.factor);
|
| GLfloat units = static_cast<GLfloat>(c.units);
|
| glPolygonOffset(factor, units);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleRenderbufferStorage(
|
| +error::Error GLES2DecoderImpl::HandleRenderbufferStorage(
|
| uint32 immediate_data_size, const gles2::RenderbufferStorage& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLenum internalformat = static_cast<GLenum>(c.internalformat);
|
| @@ -1333,48 +1333,48 @@
|
| GLsizei height = static_cast<GLsizei>(c.height);
|
| if (!ValidateGLenumRenderBufferTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumRenderBufferFormat(internalformat)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glRenderbufferStorageEXT(target, internalformat, width, height);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleSampleCoverage(
|
| +error::Error GLES2DecoderImpl::HandleSampleCoverage(
|
| uint32 immediate_data_size, const gles2::SampleCoverage& c) {
|
| GLclampf value = static_cast<GLclampf>(c.value);
|
| GLboolean invert = static_cast<GLboolean>(c.invert);
|
| glSampleCoverage(value, invert);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleScissor(
|
| +error::Error GLES2DecoderImpl::HandleScissor(
|
| uint32 immediate_data_size, const gles2::Scissor& c) {
|
| GLint x = static_cast<GLint>(c.x);
|
| GLint y = static_cast<GLint>(c.y);
|
| GLsizei width = static_cast<GLsizei>(c.width);
|
| GLsizei height = static_cast<GLsizei>(c.height);
|
| glScissor(x, y, width, height);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleStencilFunc(
|
| +error::Error GLES2DecoderImpl::HandleStencilFunc(
|
| uint32 immediate_data_size, const gles2::StencilFunc& c) {
|
| GLenum func = static_cast<GLenum>(c.func);
|
| GLint ref = static_cast<GLint>(c.ref);
|
| GLuint mask = static_cast<GLuint>(c.mask);
|
| if (!ValidateGLenumCmpFunction(func)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glStencilFunc(func, ref, mask);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleStencilFuncSeparate(
|
| +error::Error GLES2DecoderImpl::HandleStencilFuncSeparate(
|
| uint32 immediate_data_size, const gles2::StencilFuncSeparate& c) {
|
| GLenum face = static_cast<GLenum>(c.face);
|
| GLenum func = static_cast<GLenum>(c.func);
|
| @@ -1382,57 +1382,57 @@
|
| GLuint mask = static_cast<GLuint>(c.mask);
|
| if (!ValidateGLenumFaceType(face)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumCmpFunction(func)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glStencilFuncSeparate(face, func, ref, mask);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleStencilMask(
|
| +error::Error GLES2DecoderImpl::HandleStencilMask(
|
| uint32 immediate_data_size, const gles2::StencilMask& c) {
|
| GLuint mask = static_cast<GLuint>(c.mask);
|
| glStencilMask(mask);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleStencilMaskSeparate(
|
| +error::Error GLES2DecoderImpl::HandleStencilMaskSeparate(
|
| uint32 immediate_data_size, const gles2::StencilMaskSeparate& c) {
|
| GLenum face = static_cast<GLenum>(c.face);
|
| GLuint mask = static_cast<GLuint>(c.mask);
|
| if (!ValidateGLenumFaceType(face)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glStencilMaskSeparate(face, mask);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleStencilOp(
|
| +error::Error GLES2DecoderImpl::HandleStencilOp(
|
| uint32 immediate_data_size, const gles2::StencilOp& c) {
|
| GLenum fail = static_cast<GLenum>(c.fail);
|
| GLenum zfail = static_cast<GLenum>(c.zfail);
|
| GLenum zpass = static_cast<GLenum>(c.zpass);
|
| if (!ValidateGLenumStencilOp(fail)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumStencilOp(zfail)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumStencilOp(zpass)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glStencilOp(fail, zfail, zpass);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleStencilOpSeparate(
|
| +error::Error GLES2DecoderImpl::HandleStencilOpSeparate(
|
| uint32 immediate_data_size, const gles2::StencilOpSeparate& c) {
|
| GLenum face = static_cast<GLenum>(c.face);
|
| GLenum fail = static_cast<GLenum>(c.fail);
|
| @@ -1440,42 +1440,42 @@
|
| GLenum zpass = static_cast<GLenum>(c.zpass);
|
| if (!ValidateGLenumFaceType(face)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumStencilOp(fail)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumStencilOp(zfail)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumStencilOp(zpass)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glStencilOpSeparate(face, fail, zfail, zpass);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleTexParameterf(
|
| +error::Error GLES2DecoderImpl::HandleTexParameterf(
|
| uint32 immediate_data_size, const gles2::TexParameterf& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLenum pname = static_cast<GLenum>(c.pname);
|
| GLfloat param = static_cast<GLfloat>(c.param);
|
| if (!ValidateGLenumTextureBindTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumTextureParameter(pname)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glTexParameterf(target, pname, param);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleTexParameterfv(
|
| +error::Error GLES2DecoderImpl::HandleTexParameterfv(
|
| uint32 immediate_data_size, const gles2::TexParameterfv& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLenum pname = static_cast<GLenum>(c.pname);
|
| @@ -1485,20 +1485,20 @@
|
| c.params_shm_id, c.params_shm_offset, data_size);
|
| if (!ValidateGLenumTextureBindTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumTextureParameter(pname)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (params == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glTexParameterfv(target, pname, params);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleTexParameterfvImmediate(
|
| +error::Error GLES2DecoderImpl::HandleTexParameterfvImmediate(
|
| uint32 immediate_data_size, const gles2::TexParameterfvImmediate& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLenum pname = static_cast<GLenum>(c.pname);
|
| @@ -1508,37 +1508,37 @@
|
| c, data_size, immediate_data_size);
|
| if (!ValidateGLenumTextureBindTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumTextureParameter(pname)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (params == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glTexParameterfv(target, pname, params);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleTexParameteri(
|
| +error::Error GLES2DecoderImpl::HandleTexParameteri(
|
| uint32 immediate_data_size, const gles2::TexParameteri& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLenum pname = static_cast<GLenum>(c.pname);
|
| GLint param = static_cast<GLint>(c.param);
|
| if (!ValidateGLenumTextureBindTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumTextureParameter(pname)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glTexParameteri(target, pname, param);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleTexParameteriv(
|
| +error::Error GLES2DecoderImpl::HandleTexParameteriv(
|
| uint32 immediate_data_size, const gles2::TexParameteriv& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLenum pname = static_cast<GLenum>(c.pname);
|
| @@ -1548,20 +1548,20 @@
|
| c.params_shm_id, c.params_shm_offset, data_size);
|
| if (!ValidateGLenumTextureBindTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumTextureParameter(pname)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (params == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glTexParameteriv(target, pname, params);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleTexParameterivImmediate(
|
| +error::Error GLES2DecoderImpl::HandleTexParameterivImmediate(
|
| uint32 immediate_data_size, const gles2::TexParameterivImmediate& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLenum pname = static_cast<GLenum>(c.pname);
|
| @@ -1571,20 +1571,20 @@
|
| c, data_size, immediate_data_size);
|
| if (!ValidateGLenumTextureBindTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumTextureParameter(pname)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (params == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glTexParameteriv(target, pname, params);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleTexSubImage2D(
|
| +error::Error GLES2DecoderImpl::HandleTexSubImage2D(
|
| uint32 immediate_data_size, const gles2::TexSubImage2D& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLint level = static_cast<GLint>(c.level);
|
| @@ -1600,25 +1600,25 @@
|
| c.pixels_shm_id, c.pixels_shm_offset, data_size);
|
| if (!ValidateGLenumTextureTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumTextureFormat(format)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumPixelType(type)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (pixels == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glTexSubImage2D(
|
| target, level, xoffset, yoffset, width, height, format, type, pixels);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleTexSubImage2DImmediate(
|
| +error::Error GLES2DecoderImpl::HandleTexSubImage2DImmediate(
|
| uint32 immediate_data_size, const gles2::TexSubImage2DImmediate& c) {
|
| GLenum target = static_cast<GLenum>(c.target);
|
| GLint level = static_cast<GLint>(c.level);
|
| @@ -1634,33 +1634,33 @@
|
| c, data_size, immediate_data_size);
|
| if (!ValidateGLenumTextureTarget(target)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumTextureFormat(format)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (!ValidateGLenumPixelType(type)) {
|
| SetGLError(GL_INVALID_ENUM);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (pixels == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glTexSubImage2D(
|
| target, level, xoffset, yoffset, width, height, format, type, pixels);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform1f(
|
| +error::Error GLES2DecoderImpl::HandleUniform1f(
|
| uint32 immediate_data_size, const gles2::Uniform1f& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLfloat x = static_cast<GLfloat>(c.x);
|
| glUniform1f(location, x);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform1fv(
|
| +error::Error GLES2DecoderImpl::HandleUniform1fv(
|
| uint32 immediate_data_size, const gles2::Uniform1fv& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -1669,13 +1669,13 @@
|
| const GLfloat* v = GetSharedMemoryAs<const GLfloat*>(
|
| c.v_shm_id, c.v_shm_offset, data_size);
|
| if (v == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniform1fv(location, count, v);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform1fvImmediate(
|
| +error::Error GLES2DecoderImpl::HandleUniform1fvImmediate(
|
| uint32 immediate_data_size, const gles2::Uniform1fvImmediate& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -1684,21 +1684,21 @@
|
| const GLfloat* v = GetImmediateDataAs<const GLfloat*>(
|
| c, data_size, immediate_data_size);
|
| if (v == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniform1fv(location, count, v);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform1i(
|
| +error::Error GLES2DecoderImpl::HandleUniform1i(
|
| uint32 immediate_data_size, const gles2::Uniform1i& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLint x = static_cast<GLint>(c.x);
|
| glUniform1i(location, x);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform1iv(
|
| +error::Error GLES2DecoderImpl::HandleUniform1iv(
|
| uint32 immediate_data_size, const gles2::Uniform1iv& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -1707,13 +1707,13 @@
|
| const GLint* v = GetSharedMemoryAs<const GLint*>(
|
| c.v_shm_id, c.v_shm_offset, data_size);
|
| if (v == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniform1iv(location, count, v);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform1ivImmediate(
|
| +error::Error GLES2DecoderImpl::HandleUniform1ivImmediate(
|
| uint32 immediate_data_size, const gles2::Uniform1ivImmediate& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -1722,22 +1722,22 @@
|
| const GLint* v = GetImmediateDataAs<const GLint*>(
|
| c, data_size, immediate_data_size);
|
| if (v == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniform1iv(location, count, v);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform2f(
|
| +error::Error GLES2DecoderImpl::HandleUniform2f(
|
| uint32 immediate_data_size, const gles2::Uniform2f& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLfloat x = static_cast<GLfloat>(c.x);
|
| GLfloat y = static_cast<GLfloat>(c.y);
|
| glUniform2f(location, x, y);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform2fv(
|
| +error::Error GLES2DecoderImpl::HandleUniform2fv(
|
| uint32 immediate_data_size, const gles2::Uniform2fv& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -1746,13 +1746,13 @@
|
| const GLfloat* v = GetSharedMemoryAs<const GLfloat*>(
|
| c.v_shm_id, c.v_shm_offset, data_size);
|
| if (v == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniform2fv(location, count, v);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform2fvImmediate(
|
| +error::Error GLES2DecoderImpl::HandleUniform2fvImmediate(
|
| uint32 immediate_data_size, const gles2::Uniform2fvImmediate& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -1761,22 +1761,22 @@
|
| const GLfloat* v = GetImmediateDataAs<const GLfloat*>(
|
| c, data_size, immediate_data_size);
|
| if (v == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniform2fv(location, count, v);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform2i(
|
| +error::Error GLES2DecoderImpl::HandleUniform2i(
|
| uint32 immediate_data_size, const gles2::Uniform2i& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLint x = static_cast<GLint>(c.x);
|
| GLint y = static_cast<GLint>(c.y);
|
| glUniform2i(location, x, y);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform2iv(
|
| +error::Error GLES2DecoderImpl::HandleUniform2iv(
|
| uint32 immediate_data_size, const gles2::Uniform2iv& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -1785,13 +1785,13 @@
|
| const GLint* v = GetSharedMemoryAs<const GLint*>(
|
| c.v_shm_id, c.v_shm_offset, data_size);
|
| if (v == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniform2iv(location, count, v);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform2ivImmediate(
|
| +error::Error GLES2DecoderImpl::HandleUniform2ivImmediate(
|
| uint32 immediate_data_size, const gles2::Uniform2ivImmediate& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -1800,23 +1800,23 @@
|
| const GLint* v = GetImmediateDataAs<const GLint*>(
|
| c, data_size, immediate_data_size);
|
| if (v == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniform2iv(location, count, v);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform3f(
|
| +error::Error GLES2DecoderImpl::HandleUniform3f(
|
| uint32 immediate_data_size, const gles2::Uniform3f& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLfloat x = static_cast<GLfloat>(c.x);
|
| GLfloat y = static_cast<GLfloat>(c.y);
|
| GLfloat z = static_cast<GLfloat>(c.z);
|
| glUniform3f(location, x, y, z);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform3fv(
|
| +error::Error GLES2DecoderImpl::HandleUniform3fv(
|
| uint32 immediate_data_size, const gles2::Uniform3fv& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -1825,13 +1825,13 @@
|
| const GLfloat* v = GetSharedMemoryAs<const GLfloat*>(
|
| c.v_shm_id, c.v_shm_offset, data_size);
|
| if (v == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniform3fv(location, count, v);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform3fvImmediate(
|
| +error::Error GLES2DecoderImpl::HandleUniform3fvImmediate(
|
| uint32 immediate_data_size, const gles2::Uniform3fvImmediate& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -1840,23 +1840,23 @@
|
| const GLfloat* v = GetImmediateDataAs<const GLfloat*>(
|
| c, data_size, immediate_data_size);
|
| if (v == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniform3fv(location, count, v);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform3i(
|
| +error::Error GLES2DecoderImpl::HandleUniform3i(
|
| uint32 immediate_data_size, const gles2::Uniform3i& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLint x = static_cast<GLint>(c.x);
|
| GLint y = static_cast<GLint>(c.y);
|
| GLint z = static_cast<GLint>(c.z);
|
| glUniform3i(location, x, y, z);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform3iv(
|
| +error::Error GLES2DecoderImpl::HandleUniform3iv(
|
| uint32 immediate_data_size, const gles2::Uniform3iv& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -1865,13 +1865,13 @@
|
| const GLint* v = GetSharedMemoryAs<const GLint*>(
|
| c.v_shm_id, c.v_shm_offset, data_size);
|
| if (v == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniform3iv(location, count, v);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform3ivImmediate(
|
| +error::Error GLES2DecoderImpl::HandleUniform3ivImmediate(
|
| uint32 immediate_data_size, const gles2::Uniform3ivImmediate& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -1880,13 +1880,13 @@
|
| const GLint* v = GetImmediateDataAs<const GLint*>(
|
| c, data_size, immediate_data_size);
|
| if (v == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniform3iv(location, count, v);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform4f(
|
| +error::Error GLES2DecoderImpl::HandleUniform4f(
|
| uint32 immediate_data_size, const gles2::Uniform4f& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLfloat x = static_cast<GLfloat>(c.x);
|
| @@ -1894,10 +1894,10 @@
|
| GLfloat z = static_cast<GLfloat>(c.z);
|
| GLfloat w = static_cast<GLfloat>(c.w);
|
| glUniform4f(location, x, y, z, w);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform4fv(
|
| +error::Error GLES2DecoderImpl::HandleUniform4fv(
|
| uint32 immediate_data_size, const gles2::Uniform4fv& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -1906,13 +1906,13 @@
|
| const GLfloat* v = GetSharedMemoryAs<const GLfloat*>(
|
| c.v_shm_id, c.v_shm_offset, data_size);
|
| if (v == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniform4fv(location, count, v);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform4fvImmediate(
|
| +error::Error GLES2DecoderImpl::HandleUniform4fvImmediate(
|
| uint32 immediate_data_size, const gles2::Uniform4fvImmediate& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -1921,13 +1921,13 @@
|
| const GLfloat* v = GetImmediateDataAs<const GLfloat*>(
|
| c, data_size, immediate_data_size);
|
| if (v == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniform4fv(location, count, v);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform4i(
|
| +error::Error GLES2DecoderImpl::HandleUniform4i(
|
| uint32 immediate_data_size, const gles2::Uniform4i& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLint x = static_cast<GLint>(c.x);
|
| @@ -1935,10 +1935,10 @@
|
| GLint z = static_cast<GLint>(c.z);
|
| GLint w = static_cast<GLint>(c.w);
|
| glUniform4i(location, x, y, z, w);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform4iv(
|
| +error::Error GLES2DecoderImpl::HandleUniform4iv(
|
| uint32 immediate_data_size, const gles2::Uniform4iv& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -1947,13 +1947,13 @@
|
| const GLint* v = GetSharedMemoryAs<const GLint*>(
|
| c.v_shm_id, c.v_shm_offset, data_size);
|
| if (v == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniform4iv(location, count, v);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniform4ivImmediate(
|
| +error::Error GLES2DecoderImpl::HandleUniform4ivImmediate(
|
| uint32 immediate_data_size, const gles2::Uniform4ivImmediate& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -1962,13 +1962,13 @@
|
| const GLint* v = GetImmediateDataAs<const GLint*>(
|
| c, data_size, immediate_data_size);
|
| if (v == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniform4iv(location, count, v);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniformMatrix2fv(
|
| +error::Error GLES2DecoderImpl::HandleUniformMatrix2fv(
|
| uint32 immediate_data_size, const gles2::UniformMatrix2fv& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -1979,16 +1979,16 @@
|
| c.value_shm_id, c.value_shm_offset, data_size);
|
| if (!ValidateGLbooleanFalse(transpose)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (value == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniformMatrix2fv(location, count, transpose, value);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniformMatrix2fvImmediate(
|
| +error::Error GLES2DecoderImpl::HandleUniformMatrix2fvImmediate(
|
| uint32 immediate_data_size, const gles2::UniformMatrix2fvImmediate& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -1999,16 +1999,16 @@
|
| c, data_size, immediate_data_size);
|
| if (!ValidateGLbooleanFalse(transpose)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (value == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniformMatrix2fv(location, count, transpose, value);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniformMatrix3fv(
|
| +error::Error GLES2DecoderImpl::HandleUniformMatrix3fv(
|
| uint32 immediate_data_size, const gles2::UniformMatrix3fv& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -2019,16 +2019,16 @@
|
| c.value_shm_id, c.value_shm_offset, data_size);
|
| if (!ValidateGLbooleanFalse(transpose)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (value == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniformMatrix3fv(location, count, transpose, value);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniformMatrix3fvImmediate(
|
| +error::Error GLES2DecoderImpl::HandleUniformMatrix3fvImmediate(
|
| uint32 immediate_data_size, const gles2::UniformMatrix3fvImmediate& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -2039,16 +2039,16 @@
|
| c, data_size, immediate_data_size);
|
| if (!ValidateGLbooleanFalse(transpose)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (value == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniformMatrix3fv(location, count, transpose, value);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniformMatrix4fv(
|
| +error::Error GLES2DecoderImpl::HandleUniformMatrix4fv(
|
| uint32 immediate_data_size, const gles2::UniformMatrix4fv& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -2059,16 +2059,16 @@
|
| c.value_shm_id, c.value_shm_offset, data_size);
|
| if (!ValidateGLbooleanFalse(transpose)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (value == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniformMatrix4fv(location, count, transpose, value);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUniformMatrix4fvImmediate(
|
| +error::Error GLES2DecoderImpl::HandleUniformMatrix4fvImmediate(
|
| uint32 immediate_data_size, const gles2::UniformMatrix4fvImmediate& c) {
|
| GLint location = static_cast<GLint>(c.location);
|
| GLsizei count = static_cast<GLsizei>(c.count);
|
| @@ -2079,46 +2079,46 @@
|
| c, data_size, immediate_data_size);
|
| if (!ValidateGLbooleanFalse(transpose)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| if (value == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glUniformMatrix4fv(location, count, transpose, value);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleUseProgram(
|
| +error::Error GLES2DecoderImpl::HandleUseProgram(
|
| uint32 immediate_data_size, const gles2::UseProgram& c) {
|
| GLuint program;
|
| if (!id_manager_->GetServiceId(c.program, &program)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| DoUseProgram(program);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleValidateProgram(
|
| +error::Error GLES2DecoderImpl::HandleValidateProgram(
|
| uint32 immediate_data_size, const gles2::ValidateProgram& c) {
|
| GLuint program;
|
| if (!id_manager_->GetServiceId(c.program, &program)) {
|
| SetGLError(GL_INVALID_VALUE);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
| glValidateProgram(program);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleVertexAttrib1f(
|
| +error::Error GLES2DecoderImpl::HandleVertexAttrib1f(
|
| uint32 immediate_data_size, const gles2::VertexAttrib1f& c) {
|
| GLuint indx = static_cast<GLuint>(c.indx);
|
| GLfloat x = static_cast<GLfloat>(c.x);
|
| glVertexAttrib1f(indx, x);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleVertexAttrib1fv(
|
| +error::Error GLES2DecoderImpl::HandleVertexAttrib1fv(
|
| uint32 immediate_data_size, const gles2::VertexAttrib1fv& c) {
|
| GLuint indx = static_cast<GLuint>(c.indx);
|
| uint32 data_size =
|
| @@ -2126,13 +2126,13 @@
|
| const GLfloat* values = GetSharedMemoryAs<const GLfloat*>(
|
| c.values_shm_id, c.values_shm_offset, data_size);
|
| if (values == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glVertexAttrib1fv(indx, values);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleVertexAttrib1fvImmediate(
|
| +error::Error GLES2DecoderImpl::HandleVertexAttrib1fvImmediate(
|
| uint32 immediate_data_size, const gles2::VertexAttrib1fvImmediate& c) {
|
| GLuint indx = static_cast<GLuint>(c.indx);
|
| uint32 data_size =
|
| @@ -2140,22 +2140,22 @@
|
| const GLfloat* values = GetImmediateDataAs<const GLfloat*>(
|
| c, data_size, immediate_data_size);
|
| if (values == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glVertexAttrib1fv(indx, values);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleVertexAttrib2f(
|
| +error::Error GLES2DecoderImpl::HandleVertexAttrib2f(
|
| uint32 immediate_data_size, const gles2::VertexAttrib2f& c) {
|
| GLuint indx = static_cast<GLuint>(c.indx);
|
| GLfloat x = static_cast<GLfloat>(c.x);
|
| GLfloat y = static_cast<GLfloat>(c.y);
|
| glVertexAttrib2f(indx, x, y);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleVertexAttrib2fv(
|
| +error::Error GLES2DecoderImpl::HandleVertexAttrib2fv(
|
| uint32 immediate_data_size, const gles2::VertexAttrib2fv& c) {
|
| GLuint indx = static_cast<GLuint>(c.indx);
|
| uint32 data_size =
|
| @@ -2163,13 +2163,13 @@
|
| const GLfloat* values = GetSharedMemoryAs<const GLfloat*>(
|
| c.values_shm_id, c.values_shm_offset, data_size);
|
| if (values == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glVertexAttrib2fv(indx, values);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleVertexAttrib2fvImmediate(
|
| +error::Error GLES2DecoderImpl::HandleVertexAttrib2fvImmediate(
|
| uint32 immediate_data_size, const gles2::VertexAttrib2fvImmediate& c) {
|
| GLuint indx = static_cast<GLuint>(c.indx);
|
| uint32 data_size =
|
| @@ -2177,23 +2177,23 @@
|
| const GLfloat* values = GetImmediateDataAs<const GLfloat*>(
|
| c, data_size, immediate_data_size);
|
| if (values == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glVertexAttrib2fv(indx, values);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleVertexAttrib3f(
|
| +error::Error GLES2DecoderImpl::HandleVertexAttrib3f(
|
| uint32 immediate_data_size, const gles2::VertexAttrib3f& c) {
|
| GLuint indx = static_cast<GLuint>(c.indx);
|
| GLfloat x = static_cast<GLfloat>(c.x);
|
| GLfloat y = static_cast<GLfloat>(c.y);
|
| GLfloat z = static_cast<GLfloat>(c.z);
|
| glVertexAttrib3f(indx, x, y, z);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleVertexAttrib3fv(
|
| +error::Error GLES2DecoderImpl::HandleVertexAttrib3fv(
|
| uint32 immediate_data_size, const gles2::VertexAttrib3fv& c) {
|
| GLuint indx = static_cast<GLuint>(c.indx);
|
| uint32 data_size =
|
| @@ -2201,13 +2201,13 @@
|
| const GLfloat* values = GetSharedMemoryAs<const GLfloat*>(
|
| c.values_shm_id, c.values_shm_offset, data_size);
|
| if (values == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glVertexAttrib3fv(indx, values);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleVertexAttrib3fvImmediate(
|
| +error::Error GLES2DecoderImpl::HandleVertexAttrib3fvImmediate(
|
| uint32 immediate_data_size, const gles2::VertexAttrib3fvImmediate& c) {
|
| GLuint indx = static_cast<GLuint>(c.indx);
|
| uint32 data_size =
|
| @@ -2215,13 +2215,13 @@
|
| const GLfloat* values = GetImmediateDataAs<const GLfloat*>(
|
| c, data_size, immediate_data_size);
|
| if (values == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glVertexAttrib3fv(indx, values);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleVertexAttrib4f(
|
| +error::Error GLES2DecoderImpl::HandleVertexAttrib4f(
|
| uint32 immediate_data_size, const gles2::VertexAttrib4f& c) {
|
| GLuint indx = static_cast<GLuint>(c.indx);
|
| GLfloat x = static_cast<GLfloat>(c.x);
|
| @@ -2229,10 +2229,10 @@
|
| GLfloat z = static_cast<GLfloat>(c.z);
|
| GLfloat w = static_cast<GLfloat>(c.w);
|
| glVertexAttrib4f(indx, x, y, z, w);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleVertexAttrib4fv(
|
| +error::Error GLES2DecoderImpl::HandleVertexAttrib4fv(
|
| uint32 immediate_data_size, const gles2::VertexAttrib4fv& c) {
|
| GLuint indx = static_cast<GLuint>(c.indx);
|
| uint32 data_size =
|
| @@ -2240,13 +2240,13 @@
|
| const GLfloat* values = GetSharedMemoryAs<const GLfloat*>(
|
| c.values_shm_id, c.values_shm_offset, data_size);
|
| if (values == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glVertexAttrib4fv(indx, values);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleVertexAttrib4fvImmediate(
|
| +error::Error GLES2DecoderImpl::HandleVertexAttrib4fvImmediate(
|
| uint32 immediate_data_size, const gles2::VertexAttrib4fvImmediate& c) {
|
| GLuint indx = static_cast<GLuint>(c.indx);
|
| uint32 data_size =
|
| @@ -2254,26 +2254,26 @@
|
| const GLfloat* values = GetImmediateDataAs<const GLfloat*>(
|
| c, data_size, immediate_data_size);
|
| if (values == NULL) {
|
| - return parse_error::kParseOutOfBounds;
|
| + return error::kOutOfBounds;
|
| }
|
| glVertexAttrib4fv(indx, values);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleViewport(
|
| +error::Error GLES2DecoderImpl::HandleViewport(
|
| uint32 immediate_data_size, const gles2::Viewport& c) {
|
| GLint x = static_cast<GLint>(c.x);
|
| GLint y = static_cast<GLint>(c.y);
|
| GLsizei width = static_cast<GLsizei>(c.width);
|
| GLsizei height = static_cast<GLsizei>(c.height);
|
| glViewport(x, y, width, height);
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| -parse_error::ParseError GLES2DecoderImpl::HandleSwapBuffers(
|
| +error::Error GLES2DecoderImpl::HandleSwapBuffers(
|
| uint32 immediate_data_size, const gles2::SwapBuffers& c) {
|
| DoSwapBuffers();
|
| - return parse_error::kParseNoError;
|
| + return error::kNoError;
|
| }
|
|
|
| #endif // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_AUTOGEN_H_
|
|
|
Chromium Code Reviews
Issue 558054:
Renamed ParseError -> Error, parse_error -> error, kParseNoError -> kNoError,... (Closed)
Base URL: svn://chrome-svn/chrome/trunk/src/