-// Copyright (c) 2014 The Chromium Authors. All rights reserved.
+// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// This file is auto-generated from
// gpu/command_buffer/build_gles2_cmd_buffer.py
+// It's formatted by clang-format using chromium coding style:
+// clang-format -i -style=chromium filename
// DO NOT EDIT!
// It is included by gles2_cmd_decoder.cc
#ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_AUTOGEN_H_
#define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_AUTOGEN_H_
-error::Error GLES2DecoderImpl::HandleActiveTexture(
- uint32 immediate_data_size, const gles2::cmds::ActiveTexture& c) {
+error::Error GLES2DecoderImpl::HandleActiveTexture(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::ActiveTexture& c =
+ *static_cast<const gles2::cmds::ActiveTexture*>(cmd_data);
+ (void)c;
GLenum texture = static_cast<GLenum>(c.texture);
DoActiveTexture(texture);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleAttachShader(
- uint32 immediate_data_size, const gles2::cmds::AttachShader& c) {
+error::Error GLES2DecoderImpl::HandleAttachShader(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::AttachShader& c =
+ *static_cast<const gles2::cmds::AttachShader*>(cmd_data);
+ (void)c;
GLuint program = c.program;
GLuint shader = c.shader;
DoAttachShader(program, shader);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleBindBuffer(
- uint32 immediate_data_size, const gles2::cmds::BindBuffer& c) {
+error::Error GLES2DecoderImpl::HandleBindBuffer(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::BindBuffer& c =
+ *static_cast<const gles2::cmds::BindBuffer*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLuint buffer = c.buffer;
if (!validators_->buffer_target.IsValid(target)) {
}
error::Error GLES2DecoderImpl::HandleBindFramebuffer(
- uint32 immediate_data_size, const gles2::cmds::BindFramebuffer& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::BindFramebuffer& c =
+ *static_cast<const gles2::cmds::BindFramebuffer*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLuint framebuffer = c.framebuffer;
if (!validators_->frame_buffer_target.IsValid(target)) {
}
error::Error GLES2DecoderImpl::HandleBindRenderbuffer(
- uint32 immediate_data_size, const gles2::cmds::BindRenderbuffer& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::BindRenderbuffer& c =
+ *static_cast<const gles2::cmds::BindRenderbuffer*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLuint renderbuffer = c.renderbuffer;
if (!validators_->render_buffer_target.IsValid(target)) {
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleBindTexture(
- uint32 immediate_data_size, const gles2::cmds::BindTexture& c) {
+error::Error GLES2DecoderImpl::HandleBindTexture(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::BindTexture& c =
+ *static_cast<const gles2::cmds::BindTexture*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLuint texture = c.texture;
if (!validators_->texture_bind_target.IsValid(target)) {
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleBlendColor(
- uint32 immediate_data_size, const gles2::cmds::BlendColor& c) {
+error::Error GLES2DecoderImpl::HandleBlendColor(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::BlendColor& c =
+ *static_cast<const gles2::cmds::BlendColor*>(cmd_data);
+ (void)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);
- if (state_.blend_color_red != red ||
- state_.blend_color_green != green ||
- state_.blend_color_blue != blue ||
- state_.blend_color_alpha != alpha) {
+ if (state_.blend_color_red != red || state_.blend_color_green != green ||
+ state_.blend_color_blue != blue || state_.blend_color_alpha != alpha) {
state_.blend_color_red = red;
state_.blend_color_green = green;
state_.blend_color_blue = blue;
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleBlendEquation(
- uint32 immediate_data_size, const gles2::cmds::BlendEquation& c) {
+error::Error GLES2DecoderImpl::HandleBlendEquation(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::BlendEquation& c =
+ *static_cast<const gles2::cmds::BlendEquation*>(cmd_data);
+ (void)c;
GLenum mode = static_cast<GLenum>(c.mode);
if (!validators_->equation.IsValid(mode)) {
LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendEquation", mode, "mode");
}
error::Error GLES2DecoderImpl::HandleBlendEquationSeparate(
- uint32 immediate_data_size, const gles2::cmds::BlendEquationSeparate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::BlendEquationSeparate& c =
+ *static_cast<const gles2::cmds::BlendEquationSeparate*>(cmd_data);
+ (void)c;
GLenum modeRGB = static_cast<GLenum>(c.modeRGB);
GLenum modeAlpha = static_cast<GLenum>(c.modeAlpha);
if (!validators_->equation.IsValid(modeRGB)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendEquationSeparate", modeRGB,
- "modeRGB");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glBlendEquationSeparate", modeRGB, "modeRGB");
return error::kNoError;
}
if (!validators_->equation.IsValid(modeAlpha)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendEquationSeparate", modeAlpha,
- "modeAlpha");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glBlendEquationSeparate", modeAlpha, "modeAlpha");
return error::kNoError;
}
if (state_.blend_equation_rgb != modeRGB ||
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleBlendFunc(
- uint32 immediate_data_size, const gles2::cmds::BlendFunc& c) {
+error::Error GLES2DecoderImpl::HandleBlendFunc(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::BlendFunc& c =
+ *static_cast<const gles2::cmds::BlendFunc*>(cmd_data);
+ (void)c;
GLenum sfactor = static_cast<GLenum>(c.sfactor);
GLenum dfactor = static_cast<GLenum>(c.dfactor);
if (!validators_->src_blend_factor.IsValid(sfactor)) {
LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendFunc", dfactor, "dfactor");
return error::kNoError;
}
- if (state_.blend_source_rgb != sfactor ||
- state_.blend_dest_rgb != dfactor ||
+ if (state_.blend_source_rgb != sfactor || state_.blend_dest_rgb != dfactor ||
state_.blend_source_alpha != sfactor ||
state_.blend_dest_alpha != dfactor) {
state_.blend_source_rgb = sfactor;
}
error::Error GLES2DecoderImpl::HandleBlendFuncSeparate(
- uint32 immediate_data_size, const gles2::cmds::BlendFuncSeparate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::BlendFuncSeparate& c =
+ *static_cast<const gles2::cmds::BlendFuncSeparate*>(cmd_data);
+ (void)c;
GLenum srcRGB = static_cast<GLenum>(c.srcRGB);
GLenum dstRGB = static_cast<GLenum>(c.dstRGB);
GLenum srcAlpha = static_cast<GLenum>(c.srcAlpha);
return error::kNoError;
}
if (!validators_->src_blend_factor.IsValid(srcAlpha)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendFuncSeparate", srcAlpha,
- "srcAlpha");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glBlendFuncSeparate", srcAlpha, "srcAlpha");
return error::kNoError;
}
if (!validators_->dst_blend_factor.IsValid(dstAlpha)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendFuncSeparate", dstAlpha,
- "dstAlpha");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glBlendFuncSeparate", dstAlpha, "dstAlpha");
return error::kNoError;
}
- if (state_.blend_source_rgb != srcRGB ||
- state_.blend_dest_rgb != dstRGB ||
+ if (state_.blend_source_rgb != srcRGB || state_.blend_dest_rgb != dstRGB ||
state_.blend_source_alpha != srcAlpha ||
state_.blend_dest_alpha != dstAlpha) {
state_.blend_source_rgb = srcRGB;
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleBufferSubData(
- uint32 immediate_data_size, const gles2::cmds::BufferSubData& c) {
+error::Error GLES2DecoderImpl::HandleBufferSubData(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::BufferSubData& c =
+ *static_cast<const gles2::cmds::BufferSubData*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLintptr offset = static_cast<GLintptr>(c.offset);
GLsizeiptr size = static_cast<GLsizeiptr>(c.size);
- uint32 data_size = size;
+ uint32_t data_size = size;
const void* data = GetSharedMemoryAs<const void*>(
c.data_shm_id, c.data_shm_offset, data_size);
if (!validators_->buffer_target.IsValid(target)) {
}
error::Error GLES2DecoderImpl::HandleCheckFramebufferStatus(
- uint32 immediate_data_size, const gles2::cmds::CheckFramebufferStatus& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::CheckFramebufferStatus& c =
+ *static_cast<const gles2::cmds::CheckFramebufferStatus*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
typedef cmds::CheckFramebufferStatus::Result Result;
Result* result_dst = GetSharedMemoryAs<Result*>(
return error::kOutOfBounds;
}
if (!validators_->frame_buffer_target.IsValid(target)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glCheckFramebufferStatus", target,
- "target");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glCheckFramebufferStatus", target, "target");
return error::kNoError;
}
*result_dst = DoCheckFramebufferStatus(target);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleClear(
- uint32 immediate_data_size, const gles2::cmds::Clear& c) {
+error::Error GLES2DecoderImpl::HandleClear(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Clear& c =
+ *static_cast<const gles2::cmds::Clear*>(cmd_data);
+ (void)c;
error::Error error;
error = WillAccessBoundFramebufferForDraw();
if (error != error::kNoError)
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleClearColor(
- uint32 immediate_data_size, const gles2::cmds::ClearColor& c) {
+error::Error GLES2DecoderImpl::HandleClearColor(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::ClearColor& c =
+ *static_cast<const gles2::cmds::ClearColor*>(cmd_data);
+ (void)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);
- if (state_.color_clear_red != red ||
- state_.color_clear_green != green ||
- state_.color_clear_blue != blue ||
- state_.color_clear_alpha != alpha) {
+ if (state_.color_clear_red != red || state_.color_clear_green != green ||
+ state_.color_clear_blue != blue || state_.color_clear_alpha != alpha) {
state_.color_clear_red = red;
state_.color_clear_green = green;
state_.color_clear_blue = blue;
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleClearDepthf(
- uint32 immediate_data_size, const gles2::cmds::ClearDepthf& c) {
+error::Error GLES2DecoderImpl::HandleClearDepthf(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::ClearDepthf& c =
+ *static_cast<const gles2::cmds::ClearDepthf*>(cmd_data);
+ (void)c;
GLclampf depth = static_cast<GLclampf>(c.depth);
if (state_.depth_clear != depth) {
state_.depth_clear = depth;
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleClearStencil(
- uint32 immediate_data_size, const gles2::cmds::ClearStencil& c) {
+error::Error GLES2DecoderImpl::HandleClearStencil(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::ClearStencil& c =
+ *static_cast<const gles2::cmds::ClearStencil*>(cmd_data);
+ (void)c;
GLint s = static_cast<GLint>(c.s);
if (state_.stencil_clear != s) {
state_.stencil_clear = s;
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleColorMask(
- uint32 immediate_data_size, const gles2::cmds::ColorMask& c) {
+error::Error GLES2DecoderImpl::HandleColorMask(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::ColorMask& c =
+ *static_cast<const gles2::cmds::ColorMask*>(cmd_data);
+ (void)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);
- if (state_.color_mask_red != red ||
- state_.color_mask_green != green ||
- state_.color_mask_blue != blue ||
- state_.color_mask_alpha != alpha) {
+ if (state_.color_mask_red != red || state_.color_mask_green != green ||
+ state_.color_mask_blue != blue || state_.color_mask_alpha != alpha) {
state_.color_mask_red = red;
state_.color_mask_green = green;
state_.color_mask_blue = blue;
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleCompileShader(
- uint32 immediate_data_size, const gles2::cmds::CompileShader& c) {
+error::Error GLES2DecoderImpl::HandleCompileShader(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::CompileShader& c =
+ *static_cast<const gles2::cmds::CompileShader*>(cmd_data);
+ (void)c;
GLuint shader = c.shader;
DoCompileShader(shader);
return error::kNoError;
}
error::Error GLES2DecoderImpl::HandleCompressedTexSubImage2D(
- uint32 immediate_data_size,
- const gles2::cmds::CompressedTexSubImage2D& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::CompressedTexSubImage2D& c =
+ *static_cast<const gles2::cmds::CompressedTexSubImage2D*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLint level = static_cast<GLint>(c.level);
GLint xoffset = static_cast<GLint>(c.xoffset);
GLsizei height = static_cast<GLsizei>(c.height);
GLenum format = static_cast<GLenum>(c.format);
GLsizei imageSize = static_cast<GLsizei>(c.imageSize);
- uint32 data_size = imageSize;
+ uint32_t data_size = imageSize;
const void* data = GetSharedMemoryAs<const void*>(
c.data_shm_id, c.data_shm_offset, data_size);
if (!validators_->texture_target.IsValid(target)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glCompressedTexSubImage2D", target,
- "target");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glCompressedTexSubImage2D", target, "target");
return error::kNoError;
}
if (width < 0) {
return error::kNoError;
}
if (!validators_->compressed_texture_format.IsValid(format)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glCompressedTexSubImage2D", format,
- "format");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glCompressedTexSubImage2D", format, "format");
return error::kNoError;
}
if (imageSize < 0) {
}
error::Error GLES2DecoderImpl::HandleCopyTexImage2D(
- uint32 immediate_data_size, const gles2::cmds::CopyTexImage2D& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::CopyTexImage2D& c =
+ *static_cast<const gles2::cmds::CopyTexImage2D*>(cmd_data);
+ (void)c;
error::Error error;
error = WillAccessBoundFramebufferForRead();
if (error != error::kNoError)
return error::kNoError;
}
if (!validators_->texture_internal_format.IsValid(internalformat)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glCopyTexImage2D", internalformat,
- "internalformat");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glCopyTexImage2D", internalformat, "internalformat");
return error::kNoError;
}
if (width < 0) {
LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glCopyTexImage2D", "height < 0");
return error::kNoError;
}
- if (!validators_->texture_border.IsValid(border)) {
- LOCAL_SET_GL_ERROR(
- GL_INVALID_VALUE, "glCopyTexImage2D", "border GL_INVALID_VALUE");
- return error::kNoError;
- }
DoCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
return error::kNoError;
}
error::Error GLES2DecoderImpl::HandleCopyTexSubImage2D(
- uint32 immediate_data_size, const gles2::cmds::CopyTexSubImage2D& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::CopyTexSubImage2D& c =
+ *static_cast<const gles2::cmds::CopyTexSubImage2D*>(cmd_data);
+ (void)c;
error::Error error;
error = WillAccessBoundFramebufferForRead();
if (error != error::kNoError)
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleCreateProgram(
- uint32 immediate_data_size, const gles2::cmds::CreateProgram& c) {
- uint32 client_id = c.client_id;
+error::Error GLES2DecoderImpl::HandleCreateProgram(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::CreateProgram& c =
+ *static_cast<const gles2::cmds::CreateProgram*>(cmd_data);
+ (void)c;
+ uint32_t client_id = c.client_id;
if (!CreateProgramHelper(client_id)) {
return error::kInvalidArguments;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleCreateShader(
- uint32 immediate_data_size, const gles2::cmds::CreateShader& c) {
+error::Error GLES2DecoderImpl::HandleCreateShader(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::CreateShader& c =
+ *static_cast<const gles2::cmds::CreateShader*>(cmd_data);
+ (void)c;
GLenum type = static_cast<GLenum>(c.type);
if (!validators_->shader_type.IsValid(type)) {
LOCAL_SET_GL_ERROR_INVALID_ENUM("glCreateShader", type, "type");
return error::kNoError;
}
- uint32 client_id = c.client_id;
+ uint32_t client_id = c.client_id;
if (!CreateShaderHelper(type, client_id)) {
return error::kInvalidArguments;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleCullFace(
- uint32 immediate_data_size, const gles2::cmds::CullFace& c) {
+error::Error GLES2DecoderImpl::HandleCullFace(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::CullFace& c =
+ *static_cast<const gles2::cmds::CullFace*>(cmd_data);
+ (void)c;
GLenum mode = static_cast<GLenum>(c.mode);
if (!validators_->face_type.IsValid(mode)) {
LOCAL_SET_GL_ERROR_INVALID_ENUM("glCullFace", mode, "mode");
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleDeleteBuffers(
- uint32 immediate_data_size, const gles2::cmds::DeleteBuffers& c) {
- GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
- if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
- return error::kOutOfBounds;
- }
- const GLuint* buffers = GetSharedMemoryAs<const GLuint*>(
- c.buffers_shm_id, c.buffers_shm_offset, data_size);
- if (buffers == NULL) {
- return error::kOutOfBounds;
- }
- DeleteBuffersHelper(n, buffers);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleDeleteBuffersImmediate(
- uint32 immediate_data_size, const gles2::cmds::DeleteBuffersImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::DeleteBuffersImmediate& c =
+ *static_cast<const gles2::cmds::DeleteBuffersImmediate*>(cmd_data);
+ (void)c;
GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
+ uint32_t data_size;
if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
return error::kOutOfBounds;
}
- const GLuint* buffers = GetImmediateDataAs<const GLuint*>(
- c, data_size, immediate_data_size);
+ const GLuint* buffers =
+ GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
if (buffers == NULL) {
return error::kOutOfBounds;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleDeleteFramebuffers(
- uint32 immediate_data_size, const gles2::cmds::DeleteFramebuffers& c) {
- GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
- if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
- return error::kOutOfBounds;
- }
- const GLuint* framebuffers = GetSharedMemoryAs<const GLuint*>(
- c.framebuffers_shm_id, c.framebuffers_shm_offset, data_size);
- if (framebuffers == NULL) {
- return error::kOutOfBounds;
- }
- DeleteFramebuffersHelper(n, framebuffers);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleDeleteFramebuffersImmediate(
- uint32 immediate_data_size,
- const gles2::cmds::DeleteFramebuffersImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::DeleteFramebuffersImmediate& c =
+ *static_cast<const gles2::cmds::DeleteFramebuffersImmediate*>(cmd_data);
+ (void)c;
GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
+ uint32_t data_size;
if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
return error::kOutOfBounds;
}
- const GLuint* framebuffers = GetImmediateDataAs<const GLuint*>(
- c, data_size, immediate_data_size);
+ const GLuint* framebuffers =
+ GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
if (framebuffers == NULL) {
return error::kOutOfBounds;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleDeleteRenderbuffers(
- uint32 immediate_data_size, const gles2::cmds::DeleteRenderbuffers& c) {
- GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
- if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
- return error::kOutOfBounds;
- }
- const GLuint* renderbuffers = GetSharedMemoryAs<const GLuint*>(
- c.renderbuffers_shm_id, c.renderbuffers_shm_offset, data_size);
- if (renderbuffers == NULL) {
- return error::kOutOfBounds;
- }
- DeleteRenderbuffersHelper(n, renderbuffers);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleDeleteRenderbuffersImmediate(
- uint32 immediate_data_size,
- const gles2::cmds::DeleteRenderbuffersImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::DeleteRenderbuffersImmediate& c =
+ *static_cast<const gles2::cmds::DeleteRenderbuffersImmediate*>(cmd_data);
+ (void)c;
GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
+ uint32_t data_size;
if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
return error::kOutOfBounds;
}
- const GLuint* renderbuffers = GetImmediateDataAs<const GLuint*>(
- c, data_size, immediate_data_size);
+ const GLuint* renderbuffers =
+ GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
if (renderbuffers == NULL) {
return error::kOutOfBounds;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleDeleteTextures(
- uint32 immediate_data_size, const gles2::cmds::DeleteTextures& c) {
- GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
- if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
- return error::kOutOfBounds;
- }
- const GLuint* textures = GetSharedMemoryAs<const GLuint*>(
- c.textures_shm_id, c.textures_shm_offset, data_size);
- if (textures == NULL) {
- return error::kOutOfBounds;
- }
- DeleteTexturesHelper(n, textures);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleDeleteTexturesImmediate(
- uint32 immediate_data_size,
- const gles2::cmds::DeleteTexturesImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::DeleteTexturesImmediate& c =
+ *static_cast<const gles2::cmds::DeleteTexturesImmediate*>(cmd_data);
+ (void)c;
GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
+ uint32_t data_size;
if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
return error::kOutOfBounds;
}
- const GLuint* textures = GetImmediateDataAs<const GLuint*>(
- c, data_size, immediate_data_size);
+ const GLuint* textures =
+ GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
if (textures == NULL) {
return error::kOutOfBounds;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleDepthFunc(
- uint32 immediate_data_size, const gles2::cmds::DepthFunc& c) {
+error::Error GLES2DecoderImpl::HandleDepthFunc(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::DepthFunc& c =
+ *static_cast<const gles2::cmds::DepthFunc*>(cmd_data);
+ (void)c;
GLenum func = static_cast<GLenum>(c.func);
if (!validators_->cmp_function.IsValid(func)) {
LOCAL_SET_GL_ERROR_INVALID_ENUM("glDepthFunc", func, "func");
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleDepthMask(
- uint32 immediate_data_size, const gles2::cmds::DepthMask& c) {
+error::Error GLES2DecoderImpl::HandleDepthMask(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::DepthMask& c =
+ *static_cast<const gles2::cmds::DepthMask*>(cmd_data);
+ (void)c;
GLboolean flag = static_cast<GLboolean>(c.flag);
if (state_.depth_mask != flag) {
state_.depth_mask = flag;
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleDepthRangef(
- uint32 immediate_data_size, const gles2::cmds::DepthRangef& c) {
+error::Error GLES2DecoderImpl::HandleDepthRangef(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::DepthRangef& c =
+ *static_cast<const gles2::cmds::DepthRangef*>(cmd_data);
+ (void)c;
GLclampf zNear = static_cast<GLclampf>(c.zNear);
GLclampf zFar = static_cast<GLclampf>(c.zFar);
DoDepthRangef(zNear, zFar);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleDetachShader(
- uint32 immediate_data_size, const gles2::cmds::DetachShader& c) {
+error::Error GLES2DecoderImpl::HandleDetachShader(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::DetachShader& c =
+ *static_cast<const gles2::cmds::DetachShader*>(cmd_data);
+ (void)c;
GLuint program = c.program;
GLuint shader = c.shader;
DoDetachShader(program, shader);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleDisable(
- uint32 immediate_data_size, const gles2::cmds::Disable& c) {
+error::Error GLES2DecoderImpl::HandleDisable(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Disable& c =
+ *static_cast<const gles2::cmds::Disable*>(cmd_data);
+ (void)c;
GLenum cap = static_cast<GLenum>(c.cap);
if (!validators_->capability.IsValid(cap)) {
LOCAL_SET_GL_ERROR_INVALID_ENUM("glDisable", cap, "cap");
}
error::Error GLES2DecoderImpl::HandleDisableVertexAttribArray(
- uint32 immediate_data_size,
- const gles2::cmds::DisableVertexAttribArray& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::DisableVertexAttribArray& c =
+ *static_cast<const gles2::cmds::DisableVertexAttribArray*>(cmd_data);
+ (void)c;
GLuint index = static_cast<GLuint>(c.index);
DoDisableVertexAttribArray(index);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleEnable(
- uint32 immediate_data_size, const gles2::cmds::Enable& c) {
+error::Error GLES2DecoderImpl::HandleEnable(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Enable& c =
+ *static_cast<const gles2::cmds::Enable*>(cmd_data);
+ (void)c;
GLenum cap = static_cast<GLenum>(c.cap);
if (!validators_->capability.IsValid(cap)) {
LOCAL_SET_GL_ERROR_INVALID_ENUM("glEnable", cap, "cap");
}
error::Error GLES2DecoderImpl::HandleEnableVertexAttribArray(
- uint32 immediate_data_size,
- const gles2::cmds::EnableVertexAttribArray& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::EnableVertexAttribArray& c =
+ *static_cast<const gles2::cmds::EnableVertexAttribArray*>(cmd_data);
+ (void)c;
GLuint index = static_cast<GLuint>(c.index);
DoEnableVertexAttribArray(index);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleFinish(
- uint32 immediate_data_size, const gles2::cmds::Finish& c) {
+error::Error GLES2DecoderImpl::HandleFinish(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Finish& c =
+ *static_cast<const gles2::cmds::Finish*>(cmd_data);
+ (void)c;
error::Error error;
error = WillAccessBoundFramebufferForRead();
if (error != error::kNoError)
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleFlush(
- uint32 immediate_data_size, const gles2::cmds::Flush& c) {
+error::Error GLES2DecoderImpl::HandleFlush(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Flush& c =
+ *static_cast<const gles2::cmds::Flush*>(cmd_data);
+ (void)c;
DoFlush();
return error::kNoError;
}
error::Error GLES2DecoderImpl::HandleFramebufferRenderbuffer(
- uint32 immediate_data_size,
- const gles2::cmds::FramebufferRenderbuffer& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::FramebufferRenderbuffer& c =
+ *static_cast<const gles2::cmds::FramebufferRenderbuffer*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLenum attachment = static_cast<GLenum>(c.attachment);
GLenum renderbuffertarget = static_cast<GLenum>(c.renderbuffertarget);
GLuint renderbuffer = c.renderbuffer;
if (!validators_->frame_buffer_target.IsValid(target)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferRenderbuffer", target,
- "target");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glFramebufferRenderbuffer", target, "target");
return error::kNoError;
}
if (!validators_->attachment.IsValid(attachment)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferRenderbuffer", attachment,
- "attachment");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glFramebufferRenderbuffer", attachment, "attachment");
return error::kNoError;
}
if (!validators_->render_buffer_target.IsValid(renderbuffertarget)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferRenderbuffer", renderbuffertarget, "renderbuffertarget"); // NOLINT
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glFramebufferRenderbuffer", renderbuffertarget, "renderbuffertarget");
return error::kNoError;
}
DoFramebufferRenderbuffer(
}
error::Error GLES2DecoderImpl::HandleFramebufferTexture2D(
- uint32 immediate_data_size, const gles2::cmds::FramebufferTexture2D& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::FramebufferTexture2D& c =
+ *static_cast<const gles2::cmds::FramebufferTexture2D*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLenum attachment = static_cast<GLenum>(c.attachment);
GLenum textarget = static_cast<GLenum>(c.textarget);
GLuint texture = c.texture;
GLint level = static_cast<GLint>(c.level);
if (!validators_->frame_buffer_target.IsValid(target)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferTexture2D", target,
- "target");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferTexture2D", target, "target");
return error::kNoError;
}
if (!validators_->attachment.IsValid(attachment)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferTexture2D", attachment,
- "attachment");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glFramebufferTexture2D", attachment, "attachment");
return error::kNoError;
}
if (!validators_->texture_target.IsValid(textarget)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferTexture2D", textarget,
- "textarget");
- return error::kNoError;
- }
- if (!validators_->zero_only.IsValid(level)) {
- LOCAL_SET_GL_ERROR(
- GL_INVALID_VALUE, "glFramebufferTexture2D", "level GL_INVALID_VALUE");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glFramebufferTexture2D", textarget, "textarget");
return error::kNoError;
}
DoFramebufferTexture2D(target, attachment, textarget, texture, level);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleFrontFace(
- uint32 immediate_data_size, const gles2::cmds::FrontFace& c) {
+error::Error GLES2DecoderImpl::HandleFrontFace(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::FrontFace& c =
+ *static_cast<const gles2::cmds::FrontFace*>(cmd_data);
+ (void)c;
GLenum mode = static_cast<GLenum>(c.mode);
if (!validators_->face_mode.IsValid(mode)) {
LOCAL_SET_GL_ERROR_INVALID_ENUM("glFrontFace", mode, "mode");
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleGenBuffers(
- uint32 immediate_data_size, const gles2::cmds::GenBuffers& c) {
- GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
- if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
- return error::kOutOfBounds;
- }
- GLuint* buffers = GetSharedMemoryAs<GLuint*>(
- c.buffers_shm_id, c.buffers_shm_offset, data_size);
- if (buffers == NULL) {
- return error::kOutOfBounds;
- }
- if (!GenBuffersHelper(n, buffers)) {
- return error::kInvalidArguments;
- }
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleGenBuffersImmediate(
- uint32 immediate_data_size, const gles2::cmds::GenBuffersImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::GenBuffersImmediate& c =
+ *static_cast<const gles2::cmds::GenBuffersImmediate*>(cmd_data);
+ (void)c;
GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
+ uint32_t data_size;
if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
return error::kOutOfBounds;
}
- GLuint* buffers = GetImmediateDataAs<GLuint*>(
- c, data_size, immediate_data_size);
+ GLuint* buffers =
+ GetImmediateDataAs<GLuint*>(c, data_size, immediate_data_size);
if (buffers == NULL) {
return error::kOutOfBounds;
}
}
error::Error GLES2DecoderImpl::HandleGenerateMipmap(
- uint32 immediate_data_size, const gles2::cmds::GenerateMipmap& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::GenerateMipmap& c =
+ *static_cast<const gles2::cmds::GenerateMipmap*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
if (!validators_->texture_bind_target.IsValid(target)) {
LOCAL_SET_GL_ERROR_INVALID_ENUM("glGenerateMipmap", target, "target");
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleGenFramebuffers(
- uint32 immediate_data_size, const gles2::cmds::GenFramebuffers& c) {
- GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
- if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
- return error::kOutOfBounds;
- }
- GLuint* framebuffers = GetSharedMemoryAs<GLuint*>(
- c.framebuffers_shm_id, c.framebuffers_shm_offset, data_size);
- if (framebuffers == NULL) {
- return error::kOutOfBounds;
- }
- if (!GenFramebuffersHelper(n, framebuffers)) {
- return error::kInvalidArguments;
- }
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleGenFramebuffersImmediate(
- uint32 immediate_data_size,
- const gles2::cmds::GenFramebuffersImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::GenFramebuffersImmediate& c =
+ *static_cast<const gles2::cmds::GenFramebuffersImmediate*>(cmd_data);
+ (void)c;
GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
+ uint32_t data_size;
if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
return error::kOutOfBounds;
}
- GLuint* framebuffers = GetImmediateDataAs<GLuint*>(
- c, data_size, immediate_data_size);
+ GLuint* framebuffers =
+ GetImmediateDataAs<GLuint*>(c, data_size, immediate_data_size);
if (framebuffers == NULL) {
return error::kOutOfBounds;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleGenRenderbuffers(
- uint32 immediate_data_size, const gles2::cmds::GenRenderbuffers& c) {
- GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
- if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
- return error::kOutOfBounds;
- }
- GLuint* renderbuffers = GetSharedMemoryAs<GLuint*>(
- c.renderbuffers_shm_id, c.renderbuffers_shm_offset, data_size);
- if (renderbuffers == NULL) {
- return error::kOutOfBounds;
- }
- if (!GenRenderbuffersHelper(n, renderbuffers)) {
- return error::kInvalidArguments;
- }
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleGenRenderbuffersImmediate(
- uint32 immediate_data_size,
- const gles2::cmds::GenRenderbuffersImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::GenRenderbuffersImmediate& c =
+ *static_cast<const gles2::cmds::GenRenderbuffersImmediate*>(cmd_data);
+ (void)c;
GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
+ uint32_t data_size;
if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
return error::kOutOfBounds;
}
- GLuint* renderbuffers = GetImmediateDataAs<GLuint*>(
- c, data_size, immediate_data_size);
+ GLuint* renderbuffers =
+ GetImmediateDataAs<GLuint*>(c, data_size, immediate_data_size);
if (renderbuffers == NULL) {
return error::kOutOfBounds;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleGenTextures(
- uint32 immediate_data_size, const gles2::cmds::GenTextures& c) {
- GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
- if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
- return error::kOutOfBounds;
- }
- GLuint* textures = GetSharedMemoryAs<GLuint*>(
- c.textures_shm_id, c.textures_shm_offset, data_size);
- if (textures == NULL) {
- return error::kOutOfBounds;
- }
- if (!GenTexturesHelper(n, textures)) {
- return error::kInvalidArguments;
- }
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleGenTexturesImmediate(
- uint32 immediate_data_size, const gles2::cmds::GenTexturesImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::GenTexturesImmediate& c =
+ *static_cast<const gles2::cmds::GenTexturesImmediate*>(cmd_data);
+ (void)c;
GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
+ uint32_t data_size;
if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
return error::kOutOfBounds;
}
- GLuint* textures = GetImmediateDataAs<GLuint*>(
- c, data_size, immediate_data_size);
+ GLuint* textures =
+ GetImmediateDataAs<GLuint*>(c, data_size, immediate_data_size);
if (textures == NULL) {
return error::kOutOfBounds;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleGetBooleanv(
- uint32 immediate_data_size, const gles2::cmds::GetBooleanv& c) {
+error::Error GLES2DecoderImpl::HandleGetBooleanv(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::GetBooleanv& c =
+ *static_cast<const gles2::cmds::GetBooleanv*>(cmd_data);
+ (void)c;
GLenum pname = static_cast<GLenum>(c.pname);
typedef cmds::GetBooleanv::Result Result;
GLsizei num_values = 0;
}
error::Error GLES2DecoderImpl::HandleGetBufferParameteriv(
- uint32 immediate_data_size, const gles2::cmds::GetBufferParameteriv& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::GetBufferParameteriv& c =
+ *static_cast<const gles2::cmds::GetBufferParameteriv*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLenum pname = static_cast<GLenum>(c.pname);
typedef cmds::GetBufferParameteriv::Result Result;
c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
GLint* params = result ? result->GetData() : NULL;
if (!validators_->buffer_target.IsValid(target)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetBufferParameteriv", target,
- "target");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetBufferParameteriv", target, "target");
return error::kNoError;
}
if (!validators_->buffer_parameter.IsValid(pname)) {
result->SetNumResults(num_values);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleGetError(
- uint32 immediate_data_size, const gles2::cmds::GetError& c) {
+error::Error GLES2DecoderImpl::HandleGetError(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::GetError& c =
+ *static_cast<const gles2::cmds::GetError*>(cmd_data);
+ (void)c;
typedef cmds::GetError::Result Result;
Result* result_dst = GetSharedMemoryAs<Result*>(
c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleGetFloatv(
- uint32 immediate_data_size, const gles2::cmds::GetFloatv& c) {
+error::Error GLES2DecoderImpl::HandleGetFloatv(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::GetFloatv& c =
+ *static_cast<const gles2::cmds::GetFloatv*>(cmd_data);
+ (void)c;
GLenum pname = static_cast<GLenum>(c.pname);
typedef cmds::GetFloatv::Result Result;
GLsizei num_values = 0;
}
error::Error GLES2DecoderImpl::HandleGetFramebufferAttachmentParameteriv(
- uint32 immediate_data_size,
- const gles2::cmds::GetFramebufferAttachmentParameteriv& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::GetFramebufferAttachmentParameteriv& c =
+ *static_cast<const gles2::cmds::GetFramebufferAttachmentParameteriv*>(
+ cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLenum attachment = static_cast<GLenum>(c.attachment);
GLenum pname = static_cast<GLenum>(c.pname);
c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
GLint* params = result ? result->GetData() : NULL;
if (!validators_->frame_buffer_target.IsValid(target)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetFramebufferAttachmentParameteriv", target, "target"); // NOLINT
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glGetFramebufferAttachmentParameteriv", target, "target");
return error::kNoError;
}
if (!validators_->attachment.IsValid(attachment)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetFramebufferAttachmentParameteriv", attachment, "attachment"); // NOLINT
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glGetFramebufferAttachmentParameteriv", attachment, "attachment");
return error::kNoError;
}
if (!validators_->frame_buffer_parameter.IsValid(pname)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetFramebufferAttachmentParameteriv", pname, "pname"); // NOLINT
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glGetFramebufferAttachmentParameteriv", pname, "pname");
return error::kNoError;
}
if (params == NULL) {
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleGetIntegerv(
- uint32 immediate_data_size, const gles2::cmds::GetIntegerv& c) {
+error::Error GLES2DecoderImpl::HandleGetIntegerv(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::GetIntegerv& c =
+ *static_cast<const gles2::cmds::GetIntegerv*>(cmd_data);
+ (void)c;
GLenum pname = static_cast<GLenum>(c.pname);
typedef cmds::GetIntegerv::Result Result;
GLsizei num_values = 0;
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleGetProgramiv(
- uint32 immediate_data_size, const gles2::cmds::GetProgramiv& c) {
+error::Error GLES2DecoderImpl::HandleGetProgramiv(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::GetProgramiv& c =
+ *static_cast<const gles2::cmds::GetProgramiv*>(cmd_data);
+ (void)c;
GLuint program = c.program;
GLenum pname = static_cast<GLenum>(c.pname);
typedef cmds::GetProgramiv::Result Result;
}
error::Error GLES2DecoderImpl::HandleGetRenderbufferParameteriv(
- uint32 immediate_data_size,
- const gles2::cmds::GetRenderbufferParameteriv& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::GetRenderbufferParameteriv& c =
+ *static_cast<const gles2::cmds::GetRenderbufferParameteriv*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLenum pname = static_cast<GLenum>(c.pname);
typedef cmds::GetRenderbufferParameteriv::Result Result;
c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
GLint* params = result ? result->GetData() : NULL;
if (!validators_->render_buffer_target.IsValid(target)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetRenderbufferParameteriv", target,
- "target");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glGetRenderbufferParameteriv", target, "target");
return error::kNoError;
}
if (!validators_->render_buffer_parameter.IsValid(pname)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetRenderbufferParameteriv", pname,
- "pname");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glGetRenderbufferParameteriv", pname, "pname");
return error::kNoError;
}
if (params == NULL) {
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleGetShaderiv(
- uint32 immediate_data_size, const gles2::cmds::GetShaderiv& c) {
+error::Error GLES2DecoderImpl::HandleGetShaderiv(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::GetShaderiv& c =
+ *static_cast<const gles2::cmds::GetShaderiv*>(cmd_data);
+ (void)c;
GLuint shader = c.shader;
GLenum pname = static_cast<GLenum>(c.pname);
typedef cmds::GetShaderiv::Result Result;
}
error::Error GLES2DecoderImpl::HandleGetTexParameterfv(
- uint32 immediate_data_size, const gles2::cmds::GetTexParameterfv& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::GetTexParameterfv& c =
+ *static_cast<const gles2::cmds::GetTexParameterfv*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLenum pname = static_cast<GLenum>(c.pname);
typedef cmds::GetTexParameterfv::Result Result;
if (result->size != 0) {
return error::kInvalidArguments;
}
- glGetTexParameterfv(target, pname, params);
+ DoGetTexParameterfv(target, pname, params);
GLenum error = glGetError();
if (error == GL_NO_ERROR) {
result->SetNumResults(num_values);
}
error::Error GLES2DecoderImpl::HandleGetTexParameteriv(
- uint32 immediate_data_size, const gles2::cmds::GetTexParameteriv& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::GetTexParameteriv& c =
+ *static_cast<const gles2::cmds::GetTexParameteriv*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLenum pname = static_cast<GLenum>(c.pname);
typedef cmds::GetTexParameteriv::Result Result;
if (result->size != 0) {
return error::kInvalidArguments;
}
- glGetTexParameteriv(target, pname, params);
+ DoGetTexParameteriv(target, pname, params);
GLenum error = glGetError();
if (error == GL_NO_ERROR) {
result->SetNumResults(num_values);
}
error::Error GLES2DecoderImpl::HandleGetVertexAttribfv(
- uint32 immediate_data_size, const gles2::cmds::GetVertexAttribfv& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::GetVertexAttribfv& c =
+ *static_cast<const gles2::cmds::GetVertexAttribfv*>(cmd_data);
+ (void)c;
GLuint index = static_cast<GLuint>(c.index);
GLenum pname = static_cast<GLenum>(c.pname);
typedef cmds::GetVertexAttribfv::Result Result;
}
error::Error GLES2DecoderImpl::HandleGetVertexAttribiv(
- uint32 immediate_data_size, const gles2::cmds::GetVertexAttribiv& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::GetVertexAttribiv& c =
+ *static_cast<const gles2::cmds::GetVertexAttribiv*>(cmd_data);
+ (void)c;
GLuint index = static_cast<GLuint>(c.index);
GLenum pname = static_cast<GLenum>(c.pname);
typedef cmds::GetVertexAttribiv::Result Result;
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleHint(
- uint32 immediate_data_size, const gles2::cmds::Hint& c) {
+error::Error GLES2DecoderImpl::HandleHint(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Hint& c = *static_cast<const gles2::cmds::Hint*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLenum mode = static_cast<GLenum>(c.mode);
if (!validators_->hint_target.IsValid(target)) {
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleIsBuffer(
- uint32 immediate_data_size, const gles2::cmds::IsBuffer& c) {
+error::Error GLES2DecoderImpl::HandleIsBuffer(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::IsBuffer& c =
+ *static_cast<const gles2::cmds::IsBuffer*>(cmd_data);
+ (void)c;
GLuint buffer = c.buffer;
typedef cmds::IsBuffer::Result Result;
Result* result_dst = GetSharedMemoryAs<Result*>(
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleIsEnabled(
- uint32 immediate_data_size, const gles2::cmds::IsEnabled& c) {
+error::Error GLES2DecoderImpl::HandleIsEnabled(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::IsEnabled& c =
+ *static_cast<const gles2::cmds::IsEnabled*>(cmd_data);
+ (void)c;
GLenum cap = static_cast<GLenum>(c.cap);
typedef cmds::IsEnabled::Result Result;
Result* result_dst = GetSharedMemoryAs<Result*>(
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleIsFramebuffer(
- uint32 immediate_data_size, const gles2::cmds::IsFramebuffer& c) {
+error::Error GLES2DecoderImpl::HandleIsFramebuffer(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::IsFramebuffer& c =
+ *static_cast<const gles2::cmds::IsFramebuffer*>(cmd_data);
+ (void)c;
GLuint framebuffer = c.framebuffer;
typedef cmds::IsFramebuffer::Result Result;
Result* result_dst = GetSharedMemoryAs<Result*>(
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleIsProgram(
- uint32 immediate_data_size, const gles2::cmds::IsProgram& c) {
+error::Error GLES2DecoderImpl::HandleIsProgram(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::IsProgram& c =
+ *static_cast<const gles2::cmds::IsProgram*>(cmd_data);
+ (void)c;
GLuint program = c.program;
typedef cmds::IsProgram::Result Result;
Result* result_dst = GetSharedMemoryAs<Result*>(
}
error::Error GLES2DecoderImpl::HandleIsRenderbuffer(
- uint32 immediate_data_size, const gles2::cmds::IsRenderbuffer& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::IsRenderbuffer& c =
+ *static_cast<const gles2::cmds::IsRenderbuffer*>(cmd_data);
+ (void)c;
GLuint renderbuffer = c.renderbuffer;
typedef cmds::IsRenderbuffer::Result Result;
Result* result_dst = GetSharedMemoryAs<Result*>(
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleIsShader(
- uint32 immediate_data_size, const gles2::cmds::IsShader& c) {
+error::Error GLES2DecoderImpl::HandleIsShader(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::IsShader& c =
+ *static_cast<const gles2::cmds::IsShader*>(cmd_data);
+ (void)c;
GLuint shader = c.shader;
typedef cmds::IsShader::Result Result;
Result* result_dst = GetSharedMemoryAs<Result*>(
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleIsTexture(
- uint32 immediate_data_size, const gles2::cmds::IsTexture& c) {
+error::Error GLES2DecoderImpl::HandleIsTexture(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::IsTexture& c =
+ *static_cast<const gles2::cmds::IsTexture*>(cmd_data);
+ (void)c;
GLuint texture = c.texture;
typedef cmds::IsTexture::Result Result;
Result* result_dst = GetSharedMemoryAs<Result*>(
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleLineWidth(
- uint32 immediate_data_size, const gles2::cmds::LineWidth& c) {
+error::Error GLES2DecoderImpl::HandleLineWidth(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::LineWidth& c =
+ *static_cast<const gles2::cmds::LineWidth*>(cmd_data);
+ (void)c;
GLfloat width = static_cast<GLfloat>(c.width);
- if (width <= 0.0f) {
+ if (width <= 0.0f || base::IsNaN(width)) {
LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "LineWidth", "width out of range");
return error::kNoError;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleLinkProgram(
- uint32 immediate_data_size, const gles2::cmds::LinkProgram& c) {
+error::Error GLES2DecoderImpl::HandleLinkProgram(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::LinkProgram& c =
+ *static_cast<const gles2::cmds::LinkProgram*>(cmd_data);
+ (void)c;
GLuint program = c.program;
DoLinkProgram(program);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandlePolygonOffset(
- uint32 immediate_data_size, const gles2::cmds::PolygonOffset& c) {
+error::Error GLES2DecoderImpl::HandlePolygonOffset(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::PolygonOffset& c =
+ *static_cast<const gles2::cmds::PolygonOffset*>(cmd_data);
+ (void)c;
GLfloat factor = static_cast<GLfloat>(c.factor);
GLfloat units = static_cast<GLfloat>(c.units);
if (state_.polygon_offset_factor != factor ||
}
error::Error GLES2DecoderImpl::HandleReleaseShaderCompiler(
- uint32 immediate_data_size, const gles2::cmds::ReleaseShaderCompiler& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::ReleaseShaderCompiler& c =
+ *static_cast<const gles2::cmds::ReleaseShaderCompiler*>(cmd_data);
+ (void)c;
DoReleaseShaderCompiler();
return error::kNoError;
}
error::Error GLES2DecoderImpl::HandleRenderbufferStorage(
- uint32 immediate_data_size, const gles2::cmds::RenderbufferStorage& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::RenderbufferStorage& c =
+ *static_cast<const gles2::cmds::RenderbufferStorage*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLenum internalformat = static_cast<GLenum>(c.internalformat);
GLsizei width = static_cast<GLsizei>(c.width);
return error::kNoError;
}
if (!validators_->render_buffer_format.IsValid(internalformat)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glRenderbufferStorage", internalformat,
- "internalformat");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glRenderbufferStorage", internalformat, "internalformat");
return error::kNoError;
}
if (width < 0) {
return error::kNoError;
}
if (height < 0) {
- LOCAL_SET_GL_ERROR(
- GL_INVALID_VALUE, "glRenderbufferStorage", "height < 0");
+ LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glRenderbufferStorage", "height < 0");
return error::kNoError;
}
DoRenderbufferStorage(target, internalformat, width, height);
}
error::Error GLES2DecoderImpl::HandleSampleCoverage(
- uint32 immediate_data_size, const gles2::cmds::SampleCoverage& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::SampleCoverage& c =
+ *static_cast<const gles2::cmds::SampleCoverage*>(cmd_data);
+ (void)c;
GLclampf value = static_cast<GLclampf>(c.value);
GLboolean invert = static_cast<GLboolean>(c.invert);
DoSampleCoverage(value, invert);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleScissor(
- uint32 immediate_data_size, const gles2::cmds::Scissor& c) {
+error::Error GLES2DecoderImpl::HandleScissor(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Scissor& c =
+ *static_cast<const gles2::cmds::Scissor*>(cmd_data);
+ (void)c;
GLint x = static_cast<GLint>(c.x);
GLint y = static_cast<GLint>(c.y);
GLsizei width = static_cast<GLsizei>(c.width);
LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glScissor", "height < 0");
return error::kNoError;
}
- if (state_.scissor_x != x ||
- state_.scissor_y != y ||
- state_.scissor_width != width ||
- state_.scissor_height != height) {
+ if (state_.scissor_x != x || state_.scissor_y != y ||
+ state_.scissor_width != width || state_.scissor_height != height) {
state_.scissor_x = x;
state_.scissor_y = y;
state_.scissor_width = width;
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleStencilFunc(
- uint32 immediate_data_size, const gles2::cmds::StencilFunc& c) {
+error::Error GLES2DecoderImpl::HandleStencilFunc(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::StencilFunc& c =
+ *static_cast<const gles2::cmds::StencilFunc*>(cmd_data);
+ (void)c;
GLenum func = static_cast<GLenum>(c.func);
GLint ref = static_cast<GLint>(c.ref);
GLuint mask = static_cast<GLuint>(c.mask);
LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilFunc", func, "func");
return error::kNoError;
}
- if (state_.stencil_front_func != func ||
- state_.stencil_front_ref != ref ||
- state_.stencil_front_mask != mask ||
- state_.stencil_back_func != func ||
- state_.stencil_back_ref != ref ||
- state_.stencil_back_mask != mask) {
+ if (state_.stencil_front_func != func || state_.stencil_front_ref != ref ||
+ state_.stencil_front_mask != mask || state_.stencil_back_func != func ||
+ state_.stencil_back_ref != ref || state_.stencil_back_mask != mask) {
state_.stencil_front_func = func;
state_.stencil_front_ref = ref;
state_.stencil_front_mask = mask;
}
error::Error GLES2DecoderImpl::HandleStencilFuncSeparate(
- uint32 immediate_data_size, const gles2::cmds::StencilFuncSeparate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::StencilFuncSeparate& c =
+ *static_cast<const gles2::cmds::StencilFuncSeparate*>(cmd_data);
+ (void)c;
GLenum face = static_cast<GLenum>(c.face);
GLenum func = static_cast<GLenum>(c.func);
GLint ref = static_cast<GLint>(c.ref);
bool changed = false;
if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
changed |= state_.stencil_front_func != func ||
- state_.stencil_front_ref != ref ||
- state_.stencil_front_mask != mask;
+ state_.stencil_front_ref != ref ||
+ state_.stencil_front_mask != mask;
}
if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
changed |= state_.stencil_back_func != func ||
- state_.stencil_back_ref != ref ||
- state_.stencil_back_mask != mask;
+ state_.stencil_back_ref != ref ||
+ state_.stencil_back_mask != mask;
}
if (changed) {
if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleStencilMask(
- uint32 immediate_data_size, const gles2::cmds::StencilMask& c) {
+error::Error GLES2DecoderImpl::HandleStencilMask(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::StencilMask& c =
+ *static_cast<const gles2::cmds::StencilMask*>(cmd_data);
+ (void)c;
GLuint mask = static_cast<GLuint>(c.mask);
if (state_.stencil_front_writemask != mask ||
state_.stencil_back_writemask != mask) {
}
error::Error GLES2DecoderImpl::HandleStencilMaskSeparate(
- uint32 immediate_data_size, const gles2::cmds::StencilMaskSeparate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::StencilMaskSeparate& c =
+ *static_cast<const gles2::cmds::StencilMaskSeparate*>(cmd_data);
+ (void)c;
GLenum face = static_cast<GLenum>(c.face);
GLuint mask = static_cast<GLuint>(c.mask);
if (!validators_->face_type.IsValid(face)) {
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleStencilOp(
- uint32 immediate_data_size, const gles2::cmds::StencilOp& c) {
+error::Error GLES2DecoderImpl::HandleStencilOp(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::StencilOp& c =
+ *static_cast<const gles2::cmds::StencilOp*>(cmd_data);
+ (void)c;
GLenum fail = static_cast<GLenum>(c.fail);
GLenum zfail = static_cast<GLenum>(c.zfail);
GLenum zpass = static_cast<GLenum>(c.zpass);
}
error::Error GLES2DecoderImpl::HandleStencilOpSeparate(
- uint32 immediate_data_size, const gles2::cmds::StencilOpSeparate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::StencilOpSeparate& c =
+ *static_cast<const gles2::cmds::StencilOpSeparate*>(cmd_data);
+ (void)c;
GLenum face = static_cast<GLenum>(c.face);
GLenum fail = static_cast<GLenum>(c.fail);
GLenum zfail = static_cast<GLenum>(c.zfail);
bool changed = false;
if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
changed |= state_.stencil_front_fail_op != fail ||
- state_.stencil_front_z_fail_op != zfail ||
- state_.stencil_front_z_pass_op != zpass;
+ state_.stencil_front_z_fail_op != zfail ||
+ state_.stencil_front_z_pass_op != zpass;
}
if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
changed |= state_.stencil_back_fail_op != fail ||
- state_.stencil_back_z_fail_op != zfail ||
- state_.stencil_back_z_pass_op != zpass;
+ state_.stencil_back_z_fail_op != zfail ||
+ state_.stencil_back_z_pass_op != zpass;
}
if (changed) {
if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleTexParameterf(
- uint32 immediate_data_size, const gles2::cmds::TexParameterf& c) {
+error::Error GLES2DecoderImpl::HandleTexParameterf(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::TexParameterf& c =
+ *static_cast<const gles2::cmds::TexParameterf*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLenum pname = static_cast<GLenum>(c.pname);
GLfloat param = static_cast<GLfloat>(c.param);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleTexParameterfv(
- uint32 immediate_data_size, const gles2::cmds::TexParameterfv& c) {
- GLenum target = static_cast<GLenum>(c.target);
- GLenum pname = static_cast<GLenum>(c.pname);
- uint32 data_size;
- if (!ComputeDataSize(1, sizeof(GLfloat), 1, &data_size)) {
- return error::kOutOfBounds;
- }
- const GLfloat* params = GetSharedMemoryAs<const GLfloat*>(
- c.params_shm_id, c.params_shm_offset, data_size);
- if (!validators_->texture_bind_target.IsValid(target)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameterfv", target, "target");
- return error::kNoError;
- }
- if (!validators_->texture_parameter.IsValid(pname)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameterfv", pname, "pname");
- return error::kNoError;
- }
- if (params == NULL) {
- return error::kOutOfBounds;
- }
- DoTexParameterfv(target, pname, params);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleTexParameterfvImmediate(
- uint32 immediate_data_size,
- const gles2::cmds::TexParameterfvImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::TexParameterfvImmediate& c =
+ *static_cast<const gles2::cmds::TexParameterfvImmediate*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLenum pname = static_cast<GLenum>(c.pname);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(1, sizeof(GLfloat), 1, &data_size)) {
return error::kOutOfBounds;
}
if (data_size > immediate_data_size) {
return error::kOutOfBounds;
}
- const GLfloat* params = GetImmediateDataAs<const GLfloat*>(
- c, data_size, immediate_data_size);
+ const GLfloat* params =
+ GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
if (!validators_->texture_bind_target.IsValid(target)) {
LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameterfv", target, "target");
return error::kNoError;
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleTexParameteri(
- uint32 immediate_data_size, const gles2::cmds::TexParameteri& c) {
+error::Error GLES2DecoderImpl::HandleTexParameteri(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::TexParameteri& c =
+ *static_cast<const gles2::cmds::TexParameteri*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLenum pname = static_cast<GLenum>(c.pname);
GLint param = static_cast<GLint>(c.param);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleTexParameteriv(
- uint32 immediate_data_size, const gles2::cmds::TexParameteriv& c) {
- GLenum target = static_cast<GLenum>(c.target);
- GLenum pname = static_cast<GLenum>(c.pname);
- uint32 data_size;
- if (!ComputeDataSize(1, sizeof(GLint), 1, &data_size)) {
- return error::kOutOfBounds;
- }
- const GLint* params = GetSharedMemoryAs<const GLint*>(
- c.params_shm_id, c.params_shm_offset, data_size);
- if (!validators_->texture_bind_target.IsValid(target)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameteriv", target, "target");
- return error::kNoError;
- }
- if (!validators_->texture_parameter.IsValid(pname)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameteriv", pname, "pname");
- return error::kNoError;
- }
- if (params == NULL) {
- return error::kOutOfBounds;
- }
- DoTexParameteriv(target, pname, params);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleTexParameterivImmediate(
- uint32 immediate_data_size,
- const gles2::cmds::TexParameterivImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::TexParameterivImmediate& c =
+ *static_cast<const gles2::cmds::TexParameterivImmediate*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLenum pname = static_cast<GLenum>(c.pname);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(1, sizeof(GLint), 1, &data_size)) {
return error::kOutOfBounds;
}
if (data_size > immediate_data_size) {
return error::kOutOfBounds;
}
- const GLint* params = GetImmediateDataAs<const GLint*>(
- c, data_size, immediate_data_size);
+ const GLint* params =
+ GetImmediateDataAs<const GLint*>(c, data_size, immediate_data_size);
if (!validators_->texture_bind_target.IsValid(target)) {
LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameteriv", target, "target");
return error::kNoError;
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleUniform1f(
- uint32 immediate_data_size, const gles2::cmds::Uniform1f& c) {
+error::Error GLES2DecoderImpl::HandleUniform1f(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Uniform1f& c =
+ *static_cast<const gles2::cmds::Uniform1f*>(cmd_data);
+ (void)c;
GLint location = static_cast<GLint>(c.location);
GLfloat x = static_cast<GLfloat>(c.x);
- GLfloat temp[1] = { x, };
+ GLfloat temp[1] = {
+ x,
+ };
DoUniform1fv(location, 1, &temp[0]);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleUniform1fv(
- uint32 immediate_data_size, const gles2::cmds::Uniform1fv& c) {
- GLint location = static_cast<GLint>(c.location);
- GLsizei count = static_cast<GLsizei>(c.count);
- uint32 data_size;
- if (!ComputeDataSize(count, sizeof(GLfloat), 1, &data_size)) {
- return error::kOutOfBounds;
- }
- const GLfloat* v = GetSharedMemoryAs<const GLfloat*>(
- c.v_shm_id, c.v_shm_offset, data_size);
- if (v == NULL) {
- return error::kOutOfBounds;
- }
- DoUniform1fv(location, count, v);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleUniform1fvImmediate(
- uint32 immediate_data_size, const gles2::cmds::Uniform1fvImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Uniform1fvImmediate& c =
+ *static_cast<const gles2::cmds::Uniform1fvImmediate*>(cmd_data);
+ (void)c;
GLint location = static_cast<GLint>(c.location);
GLsizei count = static_cast<GLsizei>(c.count);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(count, sizeof(GLfloat), 1, &data_size)) {
return error::kOutOfBounds;
}
if (data_size > immediate_data_size) {
return error::kOutOfBounds;
}
- const GLfloat* v = GetImmediateDataAs<const GLfloat*>(
- c, data_size, immediate_data_size);
+ const GLfloat* v =
+ GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
if (v == NULL) {
return error::kOutOfBounds;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleUniform1i(
- uint32 immediate_data_size, const gles2::cmds::Uniform1i& c) {
+error::Error GLES2DecoderImpl::HandleUniform1i(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Uniform1i& c =
+ *static_cast<const gles2::cmds::Uniform1i*>(cmd_data);
+ (void)c;
GLint location = static_cast<GLint>(c.location);
GLint x = static_cast<GLint>(c.x);
DoUniform1i(location, x);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleUniform1iv(
- uint32 immediate_data_size, const gles2::cmds::Uniform1iv& c) {
- GLint location = static_cast<GLint>(c.location);
- GLsizei count = static_cast<GLsizei>(c.count);
- uint32 data_size;
- if (!ComputeDataSize(count, sizeof(GLint), 1, &data_size)) {
- return error::kOutOfBounds;
- }
- const GLint* v = GetSharedMemoryAs<const GLint*>(
- c.v_shm_id, c.v_shm_offset, data_size);
- if (v == NULL) {
- return error::kOutOfBounds;
- }
- DoUniform1iv(location, count, v);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleUniform1ivImmediate(
- uint32 immediate_data_size, const gles2::cmds::Uniform1ivImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Uniform1ivImmediate& c =
+ *static_cast<const gles2::cmds::Uniform1ivImmediate*>(cmd_data);
+ (void)c;
GLint location = static_cast<GLint>(c.location);
GLsizei count = static_cast<GLsizei>(c.count);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(count, sizeof(GLint), 1, &data_size)) {
return error::kOutOfBounds;
}
if (data_size > immediate_data_size) {
return error::kOutOfBounds;
}
- const GLint* v = GetImmediateDataAs<const GLint*>(
- c, data_size, immediate_data_size);
+ const GLint* v =
+ GetImmediateDataAs<const GLint*>(c, data_size, immediate_data_size);
if (v == NULL) {
return error::kOutOfBounds;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleUniform2f(
- uint32 immediate_data_size, const gles2::cmds::Uniform2f& c) {
+error::Error GLES2DecoderImpl::HandleUniform2f(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Uniform2f& c =
+ *static_cast<const gles2::cmds::Uniform2f*>(cmd_data);
+ (void)c;
GLint location = static_cast<GLint>(c.location);
GLfloat x = static_cast<GLfloat>(c.x);
GLfloat y = static_cast<GLfloat>(c.y);
- GLfloat temp[2] = { x, y, };
+ GLfloat temp[2] = {
+ x, y,
+ };
DoUniform2fv(location, 1, &temp[0]);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleUniform2fv(
- uint32 immediate_data_size, const gles2::cmds::Uniform2fv& c) {
- GLint location = static_cast<GLint>(c.location);
- GLsizei count = static_cast<GLsizei>(c.count);
- uint32 data_size;
- if (!ComputeDataSize(count, sizeof(GLfloat), 2, &data_size)) {
- return error::kOutOfBounds;
- }
- const GLfloat* v = GetSharedMemoryAs<const GLfloat*>(
- c.v_shm_id, c.v_shm_offset, data_size);
- if (v == NULL) {
- return error::kOutOfBounds;
- }
- DoUniform2fv(location, count, v);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleUniform2fvImmediate(
- uint32 immediate_data_size, const gles2::cmds::Uniform2fvImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Uniform2fvImmediate& c =
+ *static_cast<const gles2::cmds::Uniform2fvImmediate*>(cmd_data);
+ (void)c;
GLint location = static_cast<GLint>(c.location);
GLsizei count = static_cast<GLsizei>(c.count);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(count, sizeof(GLfloat), 2, &data_size)) {
return error::kOutOfBounds;
}
if (data_size > immediate_data_size) {
return error::kOutOfBounds;
}
- const GLfloat* v = GetImmediateDataAs<const GLfloat*>(
- c, data_size, immediate_data_size);
+ const GLfloat* v =
+ GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
if (v == NULL) {
return error::kOutOfBounds;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleUniform2i(
- uint32 immediate_data_size, const gles2::cmds::Uniform2i& c) {
+error::Error GLES2DecoderImpl::HandleUniform2i(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Uniform2i& c =
+ *static_cast<const gles2::cmds::Uniform2i*>(cmd_data);
+ (void)c;
GLint location = static_cast<GLint>(c.location);
GLint x = static_cast<GLint>(c.x);
GLint y = static_cast<GLint>(c.y);
- GLint temp[2] = { x, y, };
+ GLint temp[2] = {
+ x, y,
+ };
DoUniform2iv(location, 1, &temp[0]);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleUniform2iv(
- uint32 immediate_data_size, const gles2::cmds::Uniform2iv& c) {
- GLint location = static_cast<GLint>(c.location);
- GLsizei count = static_cast<GLsizei>(c.count);
- uint32 data_size;
- if (!ComputeDataSize(count, sizeof(GLint), 2, &data_size)) {
- return error::kOutOfBounds;
- }
- const GLint* v = GetSharedMemoryAs<const GLint*>(
- c.v_shm_id, c.v_shm_offset, data_size);
- if (v == NULL) {
- return error::kOutOfBounds;
- }
- DoUniform2iv(location, count, v);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleUniform2ivImmediate(
- uint32 immediate_data_size, const gles2::cmds::Uniform2ivImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Uniform2ivImmediate& c =
+ *static_cast<const gles2::cmds::Uniform2ivImmediate*>(cmd_data);
+ (void)c;
GLint location = static_cast<GLint>(c.location);
GLsizei count = static_cast<GLsizei>(c.count);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(count, sizeof(GLint), 2, &data_size)) {
return error::kOutOfBounds;
}
if (data_size > immediate_data_size) {
return error::kOutOfBounds;
}
- const GLint* v = GetImmediateDataAs<const GLint*>(
- c, data_size, immediate_data_size);
+ const GLint* v =
+ GetImmediateDataAs<const GLint*>(c, data_size, immediate_data_size);
if (v == NULL) {
return error::kOutOfBounds;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleUniform3f(
- uint32 immediate_data_size, const gles2::cmds::Uniform3f& c) {
+error::Error GLES2DecoderImpl::HandleUniform3f(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Uniform3f& c =
+ *static_cast<const gles2::cmds::Uniform3f*>(cmd_data);
+ (void)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);
- GLfloat temp[3] = { x, y, z, };
+ GLfloat temp[3] = {
+ x, y, z,
+ };
DoUniform3fv(location, 1, &temp[0]);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleUniform3fv(
- uint32 immediate_data_size, const gles2::cmds::Uniform3fv& c) {
- GLint location = static_cast<GLint>(c.location);
- GLsizei count = static_cast<GLsizei>(c.count);
- uint32 data_size;
- if (!ComputeDataSize(count, sizeof(GLfloat), 3, &data_size)) {
- return error::kOutOfBounds;
- }
- const GLfloat* v = GetSharedMemoryAs<const GLfloat*>(
- c.v_shm_id, c.v_shm_offset, data_size);
- if (v == NULL) {
- return error::kOutOfBounds;
- }
- DoUniform3fv(location, count, v);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleUniform3fvImmediate(
- uint32 immediate_data_size, const gles2::cmds::Uniform3fvImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Uniform3fvImmediate& c =
+ *static_cast<const gles2::cmds::Uniform3fvImmediate*>(cmd_data);
+ (void)c;
GLint location = static_cast<GLint>(c.location);
GLsizei count = static_cast<GLsizei>(c.count);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(count, sizeof(GLfloat), 3, &data_size)) {
return error::kOutOfBounds;
}
if (data_size > immediate_data_size) {
return error::kOutOfBounds;
}
- const GLfloat* v = GetImmediateDataAs<const GLfloat*>(
- c, data_size, immediate_data_size);
+ const GLfloat* v =
+ GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
if (v == NULL) {
return error::kOutOfBounds;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleUniform3i(
- uint32 immediate_data_size, const gles2::cmds::Uniform3i& c) {
+error::Error GLES2DecoderImpl::HandleUniform3i(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Uniform3i& c =
+ *static_cast<const gles2::cmds::Uniform3i*>(cmd_data);
+ (void)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);
- GLint temp[3] = { x, y, z, };
+ GLint temp[3] = {
+ x, y, z,
+ };
DoUniform3iv(location, 1, &temp[0]);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleUniform3iv(
- uint32 immediate_data_size, const gles2::cmds::Uniform3iv& c) {
- GLint location = static_cast<GLint>(c.location);
- GLsizei count = static_cast<GLsizei>(c.count);
- uint32 data_size;
- if (!ComputeDataSize(count, sizeof(GLint), 3, &data_size)) {
- return error::kOutOfBounds;
- }
- const GLint* v = GetSharedMemoryAs<const GLint*>(
- c.v_shm_id, c.v_shm_offset, data_size);
- if (v == NULL) {
- return error::kOutOfBounds;
- }
- DoUniform3iv(location, count, v);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleUniform3ivImmediate(
- uint32 immediate_data_size, const gles2::cmds::Uniform3ivImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Uniform3ivImmediate& c =
+ *static_cast<const gles2::cmds::Uniform3ivImmediate*>(cmd_data);
+ (void)c;
GLint location = static_cast<GLint>(c.location);
GLsizei count = static_cast<GLsizei>(c.count);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(count, sizeof(GLint), 3, &data_size)) {
return error::kOutOfBounds;
}
if (data_size > immediate_data_size) {
return error::kOutOfBounds;
}
- const GLint* v = GetImmediateDataAs<const GLint*>(
- c, data_size, immediate_data_size);
+ const GLint* v =
+ GetImmediateDataAs<const GLint*>(c, data_size, immediate_data_size);
if (v == NULL) {
return error::kOutOfBounds;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleUniform4f(
- uint32 immediate_data_size, const gles2::cmds::Uniform4f& c) {
+error::Error GLES2DecoderImpl::HandleUniform4f(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Uniform4f& c =
+ *static_cast<const gles2::cmds::Uniform4f*>(cmd_data);
+ (void)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);
GLfloat w = static_cast<GLfloat>(c.w);
- GLfloat temp[4] = { x, y, z, w, };
+ GLfloat temp[4] = {
+ x, y, z, w,
+ };
DoUniform4fv(location, 1, &temp[0]);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleUniform4fv(
- uint32 immediate_data_size, const gles2::cmds::Uniform4fv& c) {
- GLint location = static_cast<GLint>(c.location);
- GLsizei count = static_cast<GLsizei>(c.count);
- uint32 data_size;
- if (!ComputeDataSize(count, sizeof(GLfloat), 4, &data_size)) {
- return error::kOutOfBounds;
- }
- const GLfloat* v = GetSharedMemoryAs<const GLfloat*>(
- c.v_shm_id, c.v_shm_offset, data_size);
- if (v == NULL) {
- return error::kOutOfBounds;
- }
- DoUniform4fv(location, count, v);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleUniform4fvImmediate(
- uint32 immediate_data_size, const gles2::cmds::Uniform4fvImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Uniform4fvImmediate& c =
+ *static_cast<const gles2::cmds::Uniform4fvImmediate*>(cmd_data);
+ (void)c;
GLint location = static_cast<GLint>(c.location);
GLsizei count = static_cast<GLsizei>(c.count);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(count, sizeof(GLfloat), 4, &data_size)) {
return error::kOutOfBounds;
}
if (data_size > immediate_data_size) {
return error::kOutOfBounds;
}
- const GLfloat* v = GetImmediateDataAs<const GLfloat*>(
- c, data_size, immediate_data_size);
+ const GLfloat* v =
+ GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
if (v == NULL) {
return error::kOutOfBounds;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleUniform4i(
- uint32 immediate_data_size, const gles2::cmds::Uniform4i& c) {
+error::Error GLES2DecoderImpl::HandleUniform4i(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Uniform4i& c =
+ *static_cast<const gles2::cmds::Uniform4i*>(cmd_data);
+ (void)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);
GLint w = static_cast<GLint>(c.w);
- GLint temp[4] = { x, y, z, w, };
+ GLint temp[4] = {
+ x, y, z, w,
+ };
DoUniform4iv(location, 1, &temp[0]);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleUniform4iv(
- uint32 immediate_data_size, const gles2::cmds::Uniform4iv& c) {
- GLint location = static_cast<GLint>(c.location);
- GLsizei count = static_cast<GLsizei>(c.count);
- uint32 data_size;
- if (!ComputeDataSize(count, sizeof(GLint), 4, &data_size)) {
- return error::kOutOfBounds;
- }
- const GLint* v = GetSharedMemoryAs<const GLint*>(
- c.v_shm_id, c.v_shm_offset, data_size);
- if (v == NULL) {
- return error::kOutOfBounds;
- }
- DoUniform4iv(location, count, v);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleUniform4ivImmediate(
- uint32 immediate_data_size, const gles2::cmds::Uniform4ivImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Uniform4ivImmediate& c =
+ *static_cast<const gles2::cmds::Uniform4ivImmediate*>(cmd_data);
+ (void)c;
GLint location = static_cast<GLint>(c.location);
GLsizei count = static_cast<GLsizei>(c.count);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(count, sizeof(GLint), 4, &data_size)) {
return error::kOutOfBounds;
}
if (data_size > immediate_data_size) {
return error::kOutOfBounds;
}
- const GLint* v = GetImmediateDataAs<const GLint*>(
- c, data_size, immediate_data_size);
+ const GLint* v =
+ GetImmediateDataAs<const GLint*>(c, data_size, immediate_data_size);
if (v == NULL) {
return error::kOutOfBounds;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleUniformMatrix2fv(
- uint32 immediate_data_size, const gles2::cmds::UniformMatrix2fv& c) {
- GLint location = static_cast<GLint>(c.location);
- GLsizei count = static_cast<GLsizei>(c.count);
- GLboolean transpose = static_cast<GLboolean>(c.transpose);
- uint32 data_size;
- if (!ComputeDataSize(count, sizeof(GLfloat), 4, &data_size)) {
- return error::kOutOfBounds;
- }
- const GLfloat* value = GetSharedMemoryAs<const GLfloat*>(
- c.value_shm_id, c.value_shm_offset, data_size);
- if (!validators_->false_only.IsValid(transpose)) {
- LOCAL_SET_GL_ERROR(
- GL_INVALID_VALUE, "glUniformMatrix2fv", "transpose GL_INVALID_VALUE");
- return error::kNoError;
- }
- if (value == NULL) {
- return error::kOutOfBounds;
- }
- DoUniformMatrix2fv(location, count, transpose, value);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleUniformMatrix2fvImmediate(
- uint32 immediate_data_size,
- const gles2::cmds::UniformMatrix2fvImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::UniformMatrix2fvImmediate& c =
+ *static_cast<const gles2::cmds::UniformMatrix2fvImmediate*>(cmd_data);
+ (void)c;
GLint location = static_cast<GLint>(c.location);
GLsizei count = static_cast<GLsizei>(c.count);
GLboolean transpose = static_cast<GLboolean>(c.transpose);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(count, sizeof(GLfloat), 4, &data_size)) {
return error::kOutOfBounds;
}
if (data_size > immediate_data_size) {
return error::kOutOfBounds;
}
- const GLfloat* value = GetImmediateDataAs<const GLfloat*>(
- c, data_size, immediate_data_size);
- if (!validators_->false_only.IsValid(transpose)) {
- LOCAL_SET_GL_ERROR(
- GL_INVALID_VALUE, "glUniformMatrix2fv", "transpose GL_INVALID_VALUE");
- return error::kNoError;
- }
+ const GLfloat* value =
+ GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
if (value == NULL) {
return error::kOutOfBounds;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleUniformMatrix3fv(
- uint32 immediate_data_size, const gles2::cmds::UniformMatrix3fv& c) {
- GLint location = static_cast<GLint>(c.location);
- GLsizei count = static_cast<GLsizei>(c.count);
- GLboolean transpose = static_cast<GLboolean>(c.transpose);
- uint32 data_size;
- if (!ComputeDataSize(count, sizeof(GLfloat), 9, &data_size)) {
- return error::kOutOfBounds;
- }
- const GLfloat* value = GetSharedMemoryAs<const GLfloat*>(
- c.value_shm_id, c.value_shm_offset, data_size);
- if (!validators_->false_only.IsValid(transpose)) {
- LOCAL_SET_GL_ERROR(
- GL_INVALID_VALUE, "glUniformMatrix3fv", "transpose GL_INVALID_VALUE");
- return error::kNoError;
- }
- if (value == NULL) {
- return error::kOutOfBounds;
- }
- DoUniformMatrix3fv(location, count, transpose, value);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleUniformMatrix3fvImmediate(
- uint32 immediate_data_size,
- const gles2::cmds::UniformMatrix3fvImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::UniformMatrix3fvImmediate& c =
+ *static_cast<const gles2::cmds::UniformMatrix3fvImmediate*>(cmd_data);
+ (void)c;
GLint location = static_cast<GLint>(c.location);
GLsizei count = static_cast<GLsizei>(c.count);
GLboolean transpose = static_cast<GLboolean>(c.transpose);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(count, sizeof(GLfloat), 9, &data_size)) {
return error::kOutOfBounds;
}
if (data_size > immediate_data_size) {
return error::kOutOfBounds;
}
- const GLfloat* value = GetImmediateDataAs<const GLfloat*>(
- c, data_size, immediate_data_size);
- if (!validators_->false_only.IsValid(transpose)) {
- LOCAL_SET_GL_ERROR(
- GL_INVALID_VALUE, "glUniformMatrix3fv", "transpose GL_INVALID_VALUE");
- return error::kNoError;
- }
+ const GLfloat* value =
+ GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
if (value == NULL) {
return error::kOutOfBounds;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleUniformMatrix4fv(
- uint32 immediate_data_size, const gles2::cmds::UniformMatrix4fv& c) {
- GLint location = static_cast<GLint>(c.location);
- GLsizei count = static_cast<GLsizei>(c.count);
- GLboolean transpose = static_cast<GLboolean>(c.transpose);
- uint32 data_size;
- if (!ComputeDataSize(count, sizeof(GLfloat), 16, &data_size)) {
- return error::kOutOfBounds;
- }
- const GLfloat* value = GetSharedMemoryAs<const GLfloat*>(
- c.value_shm_id, c.value_shm_offset, data_size);
- if (!validators_->false_only.IsValid(transpose)) {
- LOCAL_SET_GL_ERROR(
- GL_INVALID_VALUE, "glUniformMatrix4fv", "transpose GL_INVALID_VALUE");
- return error::kNoError;
- }
- if (value == NULL) {
- return error::kOutOfBounds;
- }
- DoUniformMatrix4fv(location, count, transpose, value);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleUniformMatrix4fvImmediate(
- uint32 immediate_data_size,
- const gles2::cmds::UniformMatrix4fvImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::UniformMatrix4fvImmediate& c =
+ *static_cast<const gles2::cmds::UniformMatrix4fvImmediate*>(cmd_data);
+ (void)c;
GLint location = static_cast<GLint>(c.location);
GLsizei count = static_cast<GLsizei>(c.count);
GLboolean transpose = static_cast<GLboolean>(c.transpose);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(count, sizeof(GLfloat), 16, &data_size)) {
return error::kOutOfBounds;
}
if (data_size > immediate_data_size) {
return error::kOutOfBounds;
}
- const GLfloat* value = GetImmediateDataAs<const GLfloat*>(
- c, data_size, immediate_data_size);
- if (!validators_->false_only.IsValid(transpose)) {
- LOCAL_SET_GL_ERROR(
- GL_INVALID_VALUE, "glUniformMatrix4fv", "transpose GL_INVALID_VALUE");
- return error::kNoError;
- }
+ const GLfloat* value =
+ GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
if (value == NULL) {
return error::kOutOfBounds;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleUseProgram(
- uint32 immediate_data_size, const gles2::cmds::UseProgram& c) {
+error::Error GLES2DecoderImpl::HandleUseProgram(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::UseProgram& c =
+ *static_cast<const gles2::cmds::UseProgram*>(cmd_data);
+ (void)c;
GLuint program = c.program;
DoUseProgram(program);
return error::kNoError;
}
error::Error GLES2DecoderImpl::HandleValidateProgram(
- uint32 immediate_data_size, const gles2::cmds::ValidateProgram& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::ValidateProgram& c =
+ *static_cast<const gles2::cmds::ValidateProgram*>(cmd_data);
+ (void)c;
GLuint program = c.program;
DoValidateProgram(program);
return error::kNoError;
}
error::Error GLES2DecoderImpl::HandleVertexAttrib1f(
- uint32 immediate_data_size, const gles2::cmds::VertexAttrib1f& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::VertexAttrib1f& c =
+ *static_cast<const gles2::cmds::VertexAttrib1f*>(cmd_data);
+ (void)c;
GLuint indx = static_cast<GLuint>(c.indx);
GLfloat x = static_cast<GLfloat>(c.x);
DoVertexAttrib1f(indx, x);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleVertexAttrib1fv(
- uint32 immediate_data_size, const gles2::cmds::VertexAttrib1fv& c) {
- GLuint indx = static_cast<GLuint>(c.indx);
- uint32 data_size;
- if (!ComputeDataSize(1, sizeof(GLfloat), 1, &data_size)) {
- return error::kOutOfBounds;
- }
- const GLfloat* values = GetSharedMemoryAs<const GLfloat*>(
- c.values_shm_id, c.values_shm_offset, data_size);
- if (values == NULL) {
- return error::kOutOfBounds;
- }
- DoVertexAttrib1fv(indx, values);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleVertexAttrib1fvImmediate(
- uint32 immediate_data_size,
- const gles2::cmds::VertexAttrib1fvImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::VertexAttrib1fvImmediate& c =
+ *static_cast<const gles2::cmds::VertexAttrib1fvImmediate*>(cmd_data);
+ (void)c;
GLuint indx = static_cast<GLuint>(c.indx);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(1, sizeof(GLfloat), 1, &data_size)) {
return error::kOutOfBounds;
}
if (data_size > immediate_data_size) {
return error::kOutOfBounds;
}
- const GLfloat* values = GetImmediateDataAs<const GLfloat*>(
- c, data_size, immediate_data_size);
+ const GLfloat* values =
+ GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
if (values == NULL) {
return error::kOutOfBounds;
}
}
error::Error GLES2DecoderImpl::HandleVertexAttrib2f(
- uint32 immediate_data_size, const gles2::cmds::VertexAttrib2f& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::VertexAttrib2f& c =
+ *static_cast<const gles2::cmds::VertexAttrib2f*>(cmd_data);
+ (void)c;
GLuint indx = static_cast<GLuint>(c.indx);
GLfloat x = static_cast<GLfloat>(c.x);
GLfloat y = static_cast<GLfloat>(c.y);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleVertexAttrib2fv(
- uint32 immediate_data_size, const gles2::cmds::VertexAttrib2fv& c) {
- GLuint indx = static_cast<GLuint>(c.indx);
- uint32 data_size;
- if (!ComputeDataSize(1, sizeof(GLfloat), 2, &data_size)) {
- return error::kOutOfBounds;
- }
- const GLfloat* values = GetSharedMemoryAs<const GLfloat*>(
- c.values_shm_id, c.values_shm_offset, data_size);
- if (values == NULL) {
- return error::kOutOfBounds;
- }
- DoVertexAttrib2fv(indx, values);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleVertexAttrib2fvImmediate(
- uint32 immediate_data_size,
- const gles2::cmds::VertexAttrib2fvImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::VertexAttrib2fvImmediate& c =
+ *static_cast<const gles2::cmds::VertexAttrib2fvImmediate*>(cmd_data);
+ (void)c;
GLuint indx = static_cast<GLuint>(c.indx);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(1, sizeof(GLfloat), 2, &data_size)) {
return error::kOutOfBounds;
}
if (data_size > immediate_data_size) {
return error::kOutOfBounds;
}
- const GLfloat* values = GetImmediateDataAs<const GLfloat*>(
- c, data_size, immediate_data_size);
+ const GLfloat* values =
+ GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
if (values == NULL) {
return error::kOutOfBounds;
}
}
error::Error GLES2DecoderImpl::HandleVertexAttrib3f(
- uint32 immediate_data_size, const gles2::cmds::VertexAttrib3f& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::VertexAttrib3f& c =
+ *static_cast<const gles2::cmds::VertexAttrib3f*>(cmd_data);
+ (void)c;
GLuint indx = static_cast<GLuint>(c.indx);
GLfloat x = static_cast<GLfloat>(c.x);
GLfloat y = static_cast<GLfloat>(c.y);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleVertexAttrib3fv(
- uint32 immediate_data_size, const gles2::cmds::VertexAttrib3fv& c) {
- GLuint indx = static_cast<GLuint>(c.indx);
- uint32 data_size;
- if (!ComputeDataSize(1, sizeof(GLfloat), 3, &data_size)) {
- return error::kOutOfBounds;
- }
- const GLfloat* values = GetSharedMemoryAs<const GLfloat*>(
- c.values_shm_id, c.values_shm_offset, data_size);
- if (values == NULL) {
- return error::kOutOfBounds;
- }
- DoVertexAttrib3fv(indx, values);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleVertexAttrib3fvImmediate(
- uint32 immediate_data_size,
- const gles2::cmds::VertexAttrib3fvImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::VertexAttrib3fvImmediate& c =
+ *static_cast<const gles2::cmds::VertexAttrib3fvImmediate*>(cmd_data);
+ (void)c;
GLuint indx = static_cast<GLuint>(c.indx);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(1, sizeof(GLfloat), 3, &data_size)) {
return error::kOutOfBounds;
}
if (data_size > immediate_data_size) {
return error::kOutOfBounds;
}
- const GLfloat* values = GetImmediateDataAs<const GLfloat*>(
- c, data_size, immediate_data_size);
+ const GLfloat* values =
+ GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
if (values == NULL) {
return error::kOutOfBounds;
}
}
error::Error GLES2DecoderImpl::HandleVertexAttrib4f(
- uint32 immediate_data_size, const gles2::cmds::VertexAttrib4f& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::VertexAttrib4f& c =
+ *static_cast<const gles2::cmds::VertexAttrib4f*>(cmd_data);
+ (void)c;
GLuint indx = static_cast<GLuint>(c.indx);
GLfloat x = static_cast<GLfloat>(c.x);
GLfloat y = static_cast<GLfloat>(c.y);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleVertexAttrib4fv(
- uint32 immediate_data_size, const gles2::cmds::VertexAttrib4fv& c) {
- GLuint indx = static_cast<GLuint>(c.indx);
- uint32 data_size;
- if (!ComputeDataSize(1, sizeof(GLfloat), 4, &data_size)) {
- return error::kOutOfBounds;
- }
- const GLfloat* values = GetSharedMemoryAs<const GLfloat*>(
- c.values_shm_id, c.values_shm_offset, data_size);
- if (values == NULL) {
- return error::kOutOfBounds;
- }
- DoVertexAttrib4fv(indx, values);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleVertexAttrib4fvImmediate(
- uint32 immediate_data_size,
- const gles2::cmds::VertexAttrib4fvImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::VertexAttrib4fvImmediate& c =
+ *static_cast<const gles2::cmds::VertexAttrib4fvImmediate*>(cmd_data);
+ (void)c;
GLuint indx = static_cast<GLuint>(c.indx);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(1, sizeof(GLfloat), 4, &data_size)) {
return error::kOutOfBounds;
}
if (data_size > immediate_data_size) {
return error::kOutOfBounds;
}
- const GLfloat* values = GetImmediateDataAs<const GLfloat*>(
- c, data_size, immediate_data_size);
+ const GLfloat* values =
+ GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
if (values == NULL) {
return error::kOutOfBounds;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleViewport(
- uint32 immediate_data_size, const gles2::cmds::Viewport& c) {
+error::Error GLES2DecoderImpl::HandleViewport(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::Viewport& c =
+ *static_cast<const gles2::cmds::Viewport*>(cmd_data);
+ (void)c;
GLint x = static_cast<GLint>(c.x);
GLint y = static_cast<GLint>(c.y);
GLsizei width = static_cast<GLsizei>(c.width);
}
error::Error GLES2DecoderImpl::HandleBlitFramebufferCHROMIUM(
- uint32 immediate_data_size,
- const gles2::cmds::BlitFramebufferCHROMIUM& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::BlitFramebufferCHROMIUM& c =
+ *static_cast<const gles2::cmds::BlitFramebufferCHROMIUM*>(cmd_data);
+ (void)c;
+ if (!features().chromium_framebuffer_multisample) {
+ LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
+ "glBlitFramebufferCHROMIUM",
+ "function not available");
+ return error::kNoError;
+ }
+
error::Error error;
error = WillAccessBoundFramebufferForDraw();
if (error != error::kNoError)
GLbitfield mask = static_cast<GLbitfield>(c.mask);
GLenum filter = static_cast<GLenum>(c.filter);
if (!validators_->blit_filter.IsValid(filter)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlitFramebufferCHROMIUM", filter,
- "filter");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glBlitFramebufferCHROMIUM", filter, "filter");
return error::kNoError;
}
DoBlitFramebufferCHROMIUM(
}
error::Error GLES2DecoderImpl::HandleRenderbufferStorageMultisampleCHROMIUM(
- uint32 immediate_data_size,
- const gles2::cmds::RenderbufferStorageMultisampleCHROMIUM& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::RenderbufferStorageMultisampleCHROMIUM& c =
+ *static_cast<const gles2::cmds::RenderbufferStorageMultisampleCHROMIUM*>(
+ cmd_data);
+ (void)c;
+ if (!features().chromium_framebuffer_multisample) {
+ LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
+ "glRenderbufferStorageMultisampleCHROMIUM",
+ "function not available");
+ return error::kNoError;
+ }
+
GLenum target = static_cast<GLenum>(c.target);
GLsizei samples = static_cast<GLsizei>(c.samples);
GLenum internalformat = static_cast<GLenum>(c.internalformat);
GLsizei width = static_cast<GLsizei>(c.width);
GLsizei height = static_cast<GLsizei>(c.height);
if (!validators_->render_buffer_target.IsValid(target)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glRenderbufferStorageMultisampleCHROMIUM", target, "target"); // NOLINT
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glRenderbufferStorageMultisampleCHROMIUM", target, "target");
return error::kNoError;
}
if (samples < 0) {
- LOCAL_SET_GL_ERROR(
- GL_INVALID_VALUE, "glRenderbufferStorageMultisampleCHROMIUM", "samples < 0"); // NOLINT
+ LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
+ "glRenderbufferStorageMultisampleCHROMIUM",
+ "samples < 0");
return error::kNoError;
}
if (!validators_->render_buffer_format.IsValid(internalformat)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glRenderbufferStorageMultisampleCHROMIUM", internalformat, "internalformat"); // NOLINT
+ LOCAL_SET_GL_ERROR_INVALID_ENUM("glRenderbufferStorageMultisampleCHROMIUM",
+ internalformat,
+ "internalformat");
return error::kNoError;
}
if (width < 0) {
- LOCAL_SET_GL_ERROR(
- GL_INVALID_VALUE, "glRenderbufferStorageMultisampleCHROMIUM", "width < 0"); // NOLINT
+ LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
+ "glRenderbufferStorageMultisampleCHROMIUM",
+ "width < 0");
return error::kNoError;
}
if (height < 0) {
- LOCAL_SET_GL_ERROR(
- GL_INVALID_VALUE, "glRenderbufferStorageMultisampleCHROMIUM", "height < 0"); // NOLINT
+ LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
+ "glRenderbufferStorageMultisampleCHROMIUM",
+ "height < 0");
return error::kNoError;
}
DoRenderbufferStorageMultisampleCHROMIUM(
}
error::Error GLES2DecoderImpl::HandleRenderbufferStorageMultisampleEXT(
- uint32 immediate_data_size,
- const gles2::cmds::RenderbufferStorageMultisampleEXT& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::RenderbufferStorageMultisampleEXT& c =
+ *static_cast<const gles2::cmds::RenderbufferStorageMultisampleEXT*>(
+ cmd_data);
+ (void)c;
+ if (!features().multisampled_render_to_texture) {
+ LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
+ "glRenderbufferStorageMultisampleEXT",
+ "function not available");
+ return error::kNoError;
+ }
+
GLenum target = static_cast<GLenum>(c.target);
GLsizei samples = static_cast<GLsizei>(c.samples);
GLenum internalformat = static_cast<GLenum>(c.internalformat);
GLsizei width = static_cast<GLsizei>(c.width);
GLsizei height = static_cast<GLsizei>(c.height);
if (!validators_->render_buffer_target.IsValid(target)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glRenderbufferStorageMultisampleEXT", target, "target"); // NOLINT
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glRenderbufferStorageMultisampleEXT", target, "target");
return error::kNoError;
}
if (samples < 0) {
return error::kNoError;
}
if (!validators_->render_buffer_format.IsValid(internalformat)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glRenderbufferStorageMultisampleEXT", internalformat, "internalformat"); // NOLINT
+ LOCAL_SET_GL_ERROR_INVALID_ENUM("glRenderbufferStorageMultisampleEXT",
+ internalformat,
+ "internalformat");
return error::kNoError;
}
if (width < 0) {
}
error::Error GLES2DecoderImpl::HandleFramebufferTexture2DMultisampleEXT(
- uint32 immediate_data_size,
- const gles2::cmds::FramebufferTexture2DMultisampleEXT& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::FramebufferTexture2DMultisampleEXT& c =
+ *static_cast<const gles2::cmds::FramebufferTexture2DMultisampleEXT*>(
+ cmd_data);
+ (void)c;
+ if (!features().multisampled_render_to_texture) {
+ LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
+ "glFramebufferTexture2DMultisampleEXT",
+ "function not available");
+ return error::kNoError;
+ }
+
GLenum target = static_cast<GLenum>(c.target);
GLenum attachment = static_cast<GLenum>(c.attachment);
GLenum textarget = static_cast<GLenum>(c.textarget);
GLint level = static_cast<GLint>(c.level);
GLsizei samples = static_cast<GLsizei>(c.samples);
if (!validators_->frame_buffer_target.IsValid(target)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferTexture2DMultisampleEXT", target, "target"); // NOLINT
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glFramebufferTexture2DMultisampleEXT", target, "target");
return error::kNoError;
}
if (!validators_->attachment.IsValid(attachment)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferTexture2DMultisampleEXT", attachment, "attachment"); // NOLINT
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glFramebufferTexture2DMultisampleEXT", attachment, "attachment");
return error::kNoError;
}
if (!validators_->texture_target.IsValid(textarget)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferTexture2DMultisampleEXT", textarget, "textarget"); // NOLINT
- return error::kNoError;
- }
- if (!validators_->zero_only.IsValid(level)) {
- LOCAL_SET_GL_ERROR(
- GL_INVALID_VALUE, "glFramebufferTexture2DMultisampleEXT", "level GL_INVALID_VALUE"); // NOLINT
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glFramebufferTexture2DMultisampleEXT", textarget, "textarget");
return error::kNoError;
}
if (samples < 0) {
- LOCAL_SET_GL_ERROR(
- GL_INVALID_VALUE, "glFramebufferTexture2DMultisampleEXT", "samples < 0"); // NOLINT
+ LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
+ "glFramebufferTexture2DMultisampleEXT",
+ "samples < 0");
return error::kNoError;
}
DoFramebufferTexture2DMultisample(
}
error::Error GLES2DecoderImpl::HandleTexStorage2DEXT(
- uint32 immediate_data_size, const gles2::cmds::TexStorage2DEXT& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::TexStorage2DEXT& c =
+ *static_cast<const gles2::cmds::TexStorage2DEXT*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLsizei levels = static_cast<GLsizei>(c.levels);
GLenum internalFormat = static_cast<GLenum>(c.internalFormat);
return error::kNoError;
}
if (!validators_->texture_internal_format_storage.IsValid(internalFormat)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexStorage2DEXT", internalFormat,
- "internalFormat");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glTexStorage2DEXT", internalFormat, "internalFormat");
return error::kNoError;
}
if (width < 0) {
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleGenQueriesEXT(
- uint32 immediate_data_size, const gles2::cmds::GenQueriesEXT& c) {
- GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
- if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
- return error::kOutOfBounds;
- }
- GLuint* queries = GetSharedMemoryAs<GLuint*>(
- c.queries_shm_id, c.queries_shm_offset, data_size);
- if (queries == NULL) {
- return error::kOutOfBounds;
- }
- if (!GenQueriesEXTHelper(n, queries)) {
- return error::kInvalidArguments;
- }
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleGenQueriesEXTImmediate(
- uint32 immediate_data_size, const gles2::cmds::GenQueriesEXTImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::GenQueriesEXTImmediate& c =
+ *static_cast<const gles2::cmds::GenQueriesEXTImmediate*>(cmd_data);
+ (void)c;
GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
+ uint32_t data_size;
if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
return error::kOutOfBounds;
}
- GLuint* queries = GetImmediateDataAs<GLuint*>(
- c, data_size, immediate_data_size);
+ GLuint* queries =
+ GetImmediateDataAs<GLuint*>(c, data_size, immediate_data_size);
if (queries == NULL) {
return error::kOutOfBounds;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleDeleteQueriesEXT(
- uint32 immediate_data_size, const gles2::cmds::DeleteQueriesEXT& c) {
- GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
- if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
- return error::kOutOfBounds;
- }
- const GLuint* queries = GetSharedMemoryAs<const GLuint*>(
- c.queries_shm_id, c.queries_shm_offset, data_size);
- if (queries == NULL) {
- return error::kOutOfBounds;
- }
- DeleteQueriesEXTHelper(n, queries);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleDeleteQueriesEXTImmediate(
- uint32 immediate_data_size,
- const gles2::cmds::DeleteQueriesEXTImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::DeleteQueriesEXTImmediate& c =
+ *static_cast<const gles2::cmds::DeleteQueriesEXTImmediate*>(cmd_data);
+ (void)c;
GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
+ uint32_t data_size;
if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
return error::kOutOfBounds;
}
- const GLuint* queries = GetImmediateDataAs<const GLuint*>(
- c, data_size, immediate_data_size);
+ const GLuint* queries =
+ GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
if (queries == NULL) {
return error::kOutOfBounds;
}
}
error::Error GLES2DecoderImpl::HandleInsertEventMarkerEXT(
- uint32 immediate_data_size, const gles2::cmds::InsertEventMarkerEXT& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::InsertEventMarkerEXT& c =
+ *static_cast<const gles2::cmds::InsertEventMarkerEXT*>(cmd_data);
+ (void)c;
+
GLuint bucket_id = static_cast<GLuint>(c.bucket_id);
Bucket* bucket = GetBucket(bucket_id);
if (!bucket || bucket->size() == 0) {
}
error::Error GLES2DecoderImpl::HandlePushGroupMarkerEXT(
- uint32 immediate_data_size, const gles2::cmds::PushGroupMarkerEXT& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::PushGroupMarkerEXT& c =
+ *static_cast<const gles2::cmds::PushGroupMarkerEXT*>(cmd_data);
+ (void)c;
+
GLuint bucket_id = static_cast<GLuint>(c.bucket_id);
Bucket* bucket = GetBucket(bucket_id);
if (!bucket || bucket->size() == 0) {
}
error::Error GLES2DecoderImpl::HandlePopGroupMarkerEXT(
- uint32 immediate_data_size, const gles2::cmds::PopGroupMarkerEXT& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::PopGroupMarkerEXT& c =
+ *static_cast<const gles2::cmds::PopGroupMarkerEXT*>(cmd_data);
+ (void)c;
DoPopGroupMarkerEXT();
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleGenVertexArraysOES(
- uint32 immediate_data_size, const gles2::cmds::GenVertexArraysOES& c) {
- GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
- if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
- return error::kOutOfBounds;
- }
- GLuint* arrays = GetSharedMemoryAs<GLuint*>(
- c.arrays_shm_id, c.arrays_shm_offset, data_size);
- if (arrays == NULL) {
- return error::kOutOfBounds;
- }
- if (!GenVertexArraysOESHelper(n, arrays)) {
- return error::kInvalidArguments;
- }
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleGenVertexArraysOESImmediate(
- uint32 immediate_data_size,
- const gles2::cmds::GenVertexArraysOESImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::GenVertexArraysOESImmediate& c =
+ *static_cast<const gles2::cmds::GenVertexArraysOESImmediate*>(cmd_data);
+ (void)c;
GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
+ uint32_t data_size;
if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
return error::kOutOfBounds;
}
- GLuint* arrays = GetImmediateDataAs<GLuint*>(
- c, data_size, immediate_data_size);
+ GLuint* arrays =
+ GetImmediateDataAs<GLuint*>(c, data_size, immediate_data_size);
if (arrays == NULL) {
return error::kOutOfBounds;
}
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleDeleteVertexArraysOES(
- uint32 immediate_data_size, const gles2::cmds::DeleteVertexArraysOES& c) {
- GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
- if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
- return error::kOutOfBounds;
- }
- const GLuint* arrays = GetSharedMemoryAs<const GLuint*>(
- c.arrays_shm_id, c.arrays_shm_offset, data_size);
- if (arrays == NULL) {
- return error::kOutOfBounds;
- }
- DeleteVertexArraysOESHelper(n, arrays);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleDeleteVertexArraysOESImmediate(
- uint32 immediate_data_size,
- const gles2::cmds::DeleteVertexArraysOESImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::DeleteVertexArraysOESImmediate& c =
+ *static_cast<const gles2::cmds::DeleteVertexArraysOESImmediate*>(
+ cmd_data);
+ (void)c;
GLsizei n = static_cast<GLsizei>(c.n);
- uint32 data_size;
+ uint32_t data_size;
if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
return error::kOutOfBounds;
}
- const GLuint* arrays = GetImmediateDataAs<const GLuint*>(
- c, data_size, immediate_data_size);
+ const GLuint* arrays =
+ GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
if (arrays == NULL) {
return error::kOutOfBounds;
}
}
error::Error GLES2DecoderImpl::HandleIsVertexArrayOES(
- uint32 immediate_data_size, const gles2::cmds::IsVertexArrayOES& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::IsVertexArrayOES& c =
+ *static_cast<const gles2::cmds::IsVertexArrayOES*>(cmd_data);
+ (void)c;
GLuint array = c.array;
typedef cmds::IsVertexArrayOES::Result Result;
Result* result_dst = GetSharedMemoryAs<Result*>(
}
error::Error GLES2DecoderImpl::HandleBindVertexArrayOES(
- uint32 immediate_data_size, const gles2::cmds::BindVertexArrayOES& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::BindVertexArrayOES& c =
+ *static_cast<const gles2::cmds::BindVertexArrayOES*>(cmd_data);
+ (void)c;
GLuint array = c.array;
DoBindVertexArrayOES(array);
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleSwapBuffers(
- uint32 immediate_data_size, const gles2::cmds::SwapBuffers& c) {
+error::Error GLES2DecoderImpl::HandleSwapBuffers(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::SwapBuffers& c =
+ *static_cast<const gles2::cmds::SwapBuffers*>(cmd_data);
+ (void)c;
DoSwapBuffers();
return error::kNoError;
}
error::Error GLES2DecoderImpl::HandleGetMaxValueInBufferCHROMIUM(
- uint32 immediate_data_size,
- const gles2::cmds::GetMaxValueInBufferCHROMIUM& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::GetMaxValueInBufferCHROMIUM& c =
+ *static_cast<const gles2::cmds::GetMaxValueInBufferCHROMIUM*>(cmd_data);
+ (void)c;
GLuint buffer_id = c.buffer_id;
GLsizei count = static_cast<GLsizei>(c.count);
GLenum type = static_cast<GLenum>(c.type);
return error::kNoError;
}
if (!validators_->get_max_index_type.IsValid(type)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetMaxValueInBufferCHROMIUM", type,
- "type");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glGetMaxValueInBufferCHROMIUM", type, "type");
return error::kNoError;
}
*result_dst = DoGetMaxValueInBufferCHROMIUM(buffer_id, count, type, offset);
}
error::Error GLES2DecoderImpl::HandleTexImageIOSurface2DCHROMIUM(
- uint32 immediate_data_size,
- const gles2::cmds::TexImageIOSurface2DCHROMIUM& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::TexImageIOSurface2DCHROMIUM& c =
+ *static_cast<const gles2::cmds::TexImageIOSurface2DCHROMIUM*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLsizei width = static_cast<GLsizei>(c.width);
GLsizei height = static_cast<GLsizei>(c.height);
GLuint ioSurfaceId = static_cast<GLuint>(c.ioSurfaceId);
GLuint plane = static_cast<GLuint>(c.plane);
if (!validators_->texture_bind_target.IsValid(target)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexImageIOSurface2DCHROMIUM", target,
- "target");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glTexImageIOSurface2DCHROMIUM", target, "target");
return error::kNoError;
}
if (width < 0) {
}
error::Error GLES2DecoderImpl::HandleCopyTextureCHROMIUM(
- uint32 immediate_data_size, const gles2::cmds::CopyTextureCHROMIUM& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::CopyTextureCHROMIUM& c =
+ *static_cast<const gles2::cmds::CopyTextureCHROMIUM*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLenum source_id = static_cast<GLenum>(c.source_id);
GLenum dest_id = static_cast<GLenum>(c.dest_id);
GLint internalformat = static_cast<GLint>(c.internalformat);
GLenum dest_type = static_cast<GLenum>(c.dest_type);
if (!validators_->texture_internal_format.IsValid(internalformat)) {
- LOCAL_SET_GL_ERROR(
- GL_INVALID_VALUE, "glCopyTextureCHROMIUM", "internalformat GL_INVALID_VALUE"); // NOLINT
+ LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
+ "glCopyTextureCHROMIUM",
+ "internalformat GL_INVALID_VALUE");
return error::kNoError;
}
if (!validators_->pixel_type.IsValid(dest_type)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glCopyTextureCHROMIUM", dest_type,
- "dest_type");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glCopyTextureCHROMIUM", dest_type, "dest_type");
return error::kNoError;
}
DoCopyTextureCHROMIUM(
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleProduceTextureCHROMIUM(
- uint32 immediate_data_size, const gles2::cmds::ProduceTextureCHROMIUM& c) {
- GLenum target = static_cast<GLenum>(c.target);
- uint32 data_size;
- if (!ComputeDataSize(1, sizeof(GLbyte), 64, &data_size)) {
- return error::kOutOfBounds;
- }
- const GLbyte* mailbox = GetSharedMemoryAs<const GLbyte*>(
- c.mailbox_shm_id, c.mailbox_shm_offset, data_size);
- if (!validators_->texture_bind_target.IsValid(target)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glProduceTextureCHROMIUM", target,
- "target");
- return error::kNoError;
- }
- if (mailbox == NULL) {
- return error::kOutOfBounds;
- }
- DoProduceTextureCHROMIUM(target, mailbox);
- return error::kNoError;
-}
-
error::Error GLES2DecoderImpl::HandleProduceTextureCHROMIUMImmediate(
- uint32 immediate_data_size,
- const gles2::cmds::ProduceTextureCHROMIUMImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::ProduceTextureCHROMIUMImmediate& c =
+ *static_cast<const gles2::cmds::ProduceTextureCHROMIUMImmediate*>(
+ cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(1, sizeof(GLbyte), 64, &data_size)) {
return error::kOutOfBounds;
}
if (data_size > immediate_data_size) {
return error::kOutOfBounds;
}
- const GLbyte* mailbox = GetImmediateDataAs<const GLbyte*>(
- c, data_size, immediate_data_size);
+ const GLbyte* mailbox =
+ GetImmediateDataAs<const GLbyte*>(c, data_size, immediate_data_size);
if (!validators_->texture_bind_target.IsValid(target)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glProduceTextureCHROMIUM", target,
- "target");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glProduceTextureCHROMIUM", target, "target");
return error::kNoError;
}
if (mailbox == NULL) {
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleConsumeTextureCHROMIUM(
- uint32 immediate_data_size, const gles2::cmds::ConsumeTextureCHROMIUM& c) {
+error::Error GLES2DecoderImpl::HandleProduceTextureDirectCHROMIUMImmediate(
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::ProduceTextureDirectCHROMIUMImmediate& c =
+ *static_cast<const gles2::cmds::ProduceTextureDirectCHROMIUMImmediate*>(
+ cmd_data);
+ (void)c;
+ GLuint texture = c.texture;
GLenum target = static_cast<GLenum>(c.target);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(1, sizeof(GLbyte), 64, &data_size)) {
return error::kOutOfBounds;
}
- const GLbyte* mailbox = GetSharedMemoryAs<const GLbyte*>(
- c.mailbox_shm_id, c.mailbox_shm_offset, data_size);
+ if (data_size > immediate_data_size) {
+ return error::kOutOfBounds;
+ }
+ const GLbyte* mailbox =
+ GetImmediateDataAs<const GLbyte*>(c, data_size, immediate_data_size);
if (!validators_->texture_bind_target.IsValid(target)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glConsumeTextureCHROMIUM", target,
- "target");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glProduceTextureDirectCHROMIUM", target, "target");
return error::kNoError;
}
if (mailbox == NULL) {
return error::kOutOfBounds;
}
- DoConsumeTextureCHROMIUM(target, mailbox);
+ DoProduceTextureDirectCHROMIUM(texture, target, mailbox);
return error::kNoError;
}
error::Error GLES2DecoderImpl::HandleConsumeTextureCHROMIUMImmediate(
- uint32 immediate_data_size,
- const gles2::cmds::ConsumeTextureCHROMIUMImmediate& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::ConsumeTextureCHROMIUMImmediate& c =
+ *static_cast<const gles2::cmds::ConsumeTextureCHROMIUMImmediate*>(
+ cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(1, sizeof(GLbyte), 64, &data_size)) {
return error::kOutOfBounds;
}
if (data_size > immediate_data_size) {
return error::kOutOfBounds;
}
- const GLbyte* mailbox = GetImmediateDataAs<const GLbyte*>(
- c, data_size, immediate_data_size);
+ const GLbyte* mailbox =
+ GetImmediateDataAs<const GLbyte*>(c, data_size, immediate_data_size);
if (!validators_->texture_bind_target.IsValid(target)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glConsumeTextureCHROMIUM", target,
- "target");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glConsumeTextureCHROMIUM", target, "target");
return error::kNoError;
}
if (mailbox == NULL) {
}
error::Error GLES2DecoderImpl::HandleBindTexImage2DCHROMIUM(
- uint32 immediate_data_size, const gles2::cmds::BindTexImage2DCHROMIUM& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::BindTexImage2DCHROMIUM& c =
+ *static_cast<const gles2::cmds::BindTexImage2DCHROMIUM*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLint imageId = static_cast<GLint>(c.imageId);
if (!validators_->texture_bind_target.IsValid(target)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glBindTexImage2DCHROMIUM", target,
- "target");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glBindTexImage2DCHROMIUM", target, "target");
return error::kNoError;
}
DoBindTexImage2DCHROMIUM(target, imageId);
}
error::Error GLES2DecoderImpl::HandleReleaseTexImage2DCHROMIUM(
- uint32 immediate_data_size,
- const gles2::cmds::ReleaseTexImage2DCHROMIUM& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::ReleaseTexImage2DCHROMIUM& c =
+ *static_cast<const gles2::cmds::ReleaseTexImage2DCHROMIUM*>(cmd_data);
+ (void)c;
GLenum target = static_cast<GLenum>(c.target);
GLint imageId = static_cast<GLint>(c.imageId);
if (!validators_->texture_bind_target.IsValid(target)) {
- LOCAL_SET_GL_ERROR_INVALID_ENUM("glReleaseTexImage2DCHROMIUM", target,
- "target");
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glReleaseTexImage2DCHROMIUM", target, "target");
return error::kNoError;
}
DoReleaseTexImage2DCHROMIUM(target, imageId);
}
error::Error GLES2DecoderImpl::HandleTraceEndCHROMIUM(
- uint32 immediate_data_size, const gles2::cmds::TraceEndCHROMIUM& c) {
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::TraceEndCHROMIUM& c =
+ *static_cast<const gles2::cmds::TraceEndCHROMIUM*>(cmd_data);
+ (void)c;
DoTraceEndCHROMIUM();
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleDiscardFramebufferEXT(
- uint32 immediate_data_size, const gles2::cmds::DiscardFramebufferEXT& c) {
- GLenum target = static_cast<GLenum>(c.target);
- GLsizei count = static_cast<GLsizei>(c.count);
- uint32 data_size;
- if (!ComputeDataSize(count, sizeof(GLenum), 1, &data_size)) {
- return error::kOutOfBounds;
- }
- const GLenum* attachments = GetSharedMemoryAs<const GLenum*>(
- c.attachments_shm_id, c.attachments_shm_offset, data_size);
- if (count < 0) {
- LOCAL_SET_GL_ERROR(
- GL_INVALID_VALUE, "glDiscardFramebufferEXT", "count < 0");
+error::Error GLES2DecoderImpl::HandleDiscardFramebufferEXTImmediate(
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::DiscardFramebufferEXTImmediate& c =
+ *static_cast<const gles2::cmds::DiscardFramebufferEXTImmediate*>(
+ cmd_data);
+ (void)c;
+ if (!features().ext_discard_framebuffer) {
+ LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
+ "glDiscardFramebufferEXT",
+ "function not available");
return error::kNoError;
}
- if (attachments == NULL) {
- return error::kOutOfBounds;
- }
- DoDiscardFramebufferEXT(target, count, attachments);
- return error::kNoError;
-}
-error::Error GLES2DecoderImpl::HandleDiscardFramebufferEXTImmediate(
- uint32 immediate_data_size,
- const gles2::cmds::DiscardFramebufferEXTImmediate& c) {
GLenum target = static_cast<GLenum>(c.target);
GLsizei count = static_cast<GLsizei>(c.count);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(count, sizeof(GLenum), 1, &data_size)) {
return error::kOutOfBounds;
}
if (data_size > immediate_data_size) {
return error::kOutOfBounds;
}
- const GLenum* attachments = GetImmediateDataAs<const GLenum*>(
- c, data_size, immediate_data_size);
+ const GLenum* attachments =
+ GetImmediateDataAs<const GLenum*>(c, data_size, immediate_data_size);
if (count < 0) {
LOCAL_SET_GL_ERROR(
GL_INVALID_VALUE, "glDiscardFramebufferEXT", "count < 0");
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleDrawBuffersEXT(
- uint32 immediate_data_size, const gles2::cmds::DrawBuffersEXT& c) {
+error::Error GLES2DecoderImpl::HandleLoseContextCHROMIUM(
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::LoseContextCHROMIUM& c =
+ *static_cast<const gles2::cmds::LoseContextCHROMIUM*>(cmd_data);
+ (void)c;
+ GLenum current = static_cast<GLenum>(c.current);
+ GLenum other = static_cast<GLenum>(c.other);
+ if (!validators_->reset_status.IsValid(current)) {
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glLoseContextCHROMIUM", current, "current");
+ return error::kNoError;
+ }
+ if (!validators_->reset_status.IsValid(other)) {
+ LOCAL_SET_GL_ERROR_INVALID_ENUM("glLoseContextCHROMIUM", other, "other");
+ return error::kNoError;
+ }
+ DoLoseContextCHROMIUM(current, other);
+ return error::kNoError;
+}
+
+error::Error GLES2DecoderImpl::HandleDrawBuffersEXTImmediate(
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::DrawBuffersEXTImmediate& c =
+ *static_cast<const gles2::cmds::DrawBuffersEXTImmediate*>(cmd_data);
+ (void)c;
GLsizei count = static_cast<GLsizei>(c.count);
- uint32 data_size;
+ uint32_t data_size;
if (!ComputeDataSize(count, sizeof(GLenum), 1, &data_size)) {
return error::kOutOfBounds;
}
- const GLenum* bufs = GetSharedMemoryAs<const GLenum*>(
- c.bufs_shm_id, c.bufs_shm_offset, data_size);
+ if (data_size > immediate_data_size) {
+ return error::kOutOfBounds;
+ }
+ const GLenum* bufs =
+ GetImmediateDataAs<const GLenum*>(c, data_size, immediate_data_size);
if (count < 0) {
LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glDrawBuffersEXT", "count < 0");
return error::kNoError;
return error::kNoError;
}
-error::Error GLES2DecoderImpl::HandleDrawBuffersEXTImmediate(
- uint32 immediate_data_size,
- const gles2::cmds::DrawBuffersEXTImmediate& c) {
- GLsizei count = static_cast<GLsizei>(c.count);
- uint32 data_size;
- if (!ComputeDataSize(count, sizeof(GLenum), 1, &data_size)) {
+error::Error GLES2DecoderImpl::HandleMatrixLoadfCHROMIUMImmediate(
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::MatrixLoadfCHROMIUMImmediate& c =
+ *static_cast<const gles2::cmds::MatrixLoadfCHROMIUMImmediate*>(cmd_data);
+ (void)c;
+ if (!features().chromium_path_rendering) {
+ LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
+ "glMatrixLoadfCHROMIUM",
+ "function not available");
+ return error::kNoError;
+ }
+
+ GLenum matrixMode = static_cast<GLenum>(c.matrixMode);
+ uint32_t data_size;
+ if (!ComputeDataSize(1, sizeof(GLfloat), 16, &data_size)) {
return error::kOutOfBounds;
}
if (data_size > immediate_data_size) {
return error::kOutOfBounds;
}
- const GLenum* bufs = GetImmediateDataAs<const GLenum*>(
- c, data_size, immediate_data_size);
- if (count < 0) {
- LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glDrawBuffersEXT", "count < 0");
+ const GLfloat* m =
+ GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
+ if (!validators_->matrix_mode.IsValid(matrixMode)) {
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glMatrixLoadfCHROMIUM", matrixMode, "matrixMode");
return error::kNoError;
}
- if (bufs == NULL) {
+ if (m == NULL) {
return error::kOutOfBounds;
}
- DoDrawBuffersEXT(count, bufs);
+ DoMatrixLoadfCHROMIUM(matrixMode, m);
return error::kNoError;
}
+error::Error GLES2DecoderImpl::HandleMatrixLoadIdentityCHROMIUM(
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::MatrixLoadIdentityCHROMIUM& c =
+ *static_cast<const gles2::cmds::MatrixLoadIdentityCHROMIUM*>(cmd_data);
+ (void)c;
+ if (!features().chromium_path_rendering) {
+ LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
+ "glMatrixLoadIdentityCHROMIUM",
+ "function not available");
+ return error::kNoError;
+ }
+
+ GLenum matrixMode = static_cast<GLenum>(c.matrixMode);
+ if (!validators_->matrix_mode.IsValid(matrixMode)) {
+ LOCAL_SET_GL_ERROR_INVALID_ENUM(
+ "glMatrixLoadIdentityCHROMIUM", matrixMode, "matrixMode");
+ return error::kNoError;
+ }
+ DoMatrixLoadIdentityCHROMIUM(matrixMode);
+ return error::kNoError;
+}
bool GLES2DecoderImpl::SetCapabilityState(GLenum cap, bool enabled) {
switch (cap) {
case GL_BLEND:
state_.enable_flags.blend = enabled;
- return true;
+ if (state_.enable_flags.cached_blend != enabled ||
+ state_.ignore_cached_state) {
+ state_.enable_flags.cached_blend = enabled;
+ return true;
+ }
+ return false;
case GL_CULL_FACE:
state_.enable_flags.cull_face = enabled;
- return true;
+ if (state_.enable_flags.cached_cull_face != enabled ||
+ state_.ignore_cached_state) {
+ state_.enable_flags.cached_cull_face = enabled;
+ return true;
+ }
+ return false;
case GL_DEPTH_TEST:
- if (state_.enable_flags.depth_test != enabled) {
- state_.enable_flags.depth_test = enabled;
+ state_.enable_flags.depth_test = enabled;
+ if (state_.enable_flags.cached_depth_test != enabled ||
+ state_.ignore_cached_state) {
framebuffer_state_.clear_state_dirty = true;
}
return false;
case GL_DITHER:
state_.enable_flags.dither = enabled;
- return true;
+ if (state_.enable_flags.cached_dither != enabled ||
+ state_.ignore_cached_state) {
+ state_.enable_flags.cached_dither = enabled;
+ return true;
+ }
+ return false;
case GL_POLYGON_OFFSET_FILL:
state_.enable_flags.polygon_offset_fill = enabled;
- return true;
+ if (state_.enable_flags.cached_polygon_offset_fill != enabled ||
+ state_.ignore_cached_state) {
+ state_.enable_flags.cached_polygon_offset_fill = enabled;
+ return true;
+ }
+ return false;
case GL_SAMPLE_ALPHA_TO_COVERAGE:
state_.enable_flags.sample_alpha_to_coverage = enabled;
- return true;
+ if (state_.enable_flags.cached_sample_alpha_to_coverage != enabled ||
+ state_.ignore_cached_state) {
+ state_.enable_flags.cached_sample_alpha_to_coverage = enabled;
+ return true;
+ }
+ return false;
case GL_SAMPLE_COVERAGE:
state_.enable_flags.sample_coverage = enabled;
- return true;
+ if (state_.enable_flags.cached_sample_coverage != enabled ||
+ state_.ignore_cached_state) {
+ state_.enable_flags.cached_sample_coverage = enabled;
+ return true;
+ }
+ return false;
case GL_SCISSOR_TEST:
- if (state_.enable_flags.scissor_test != enabled) {
- state_.enable_flags.scissor_test = enabled;
- framebuffer_state_.clear_state_dirty = true;
+ state_.enable_flags.scissor_test = enabled;
+ if (state_.enable_flags.cached_scissor_test != enabled ||
+ state_.ignore_cached_state) {
+ state_.enable_flags.cached_scissor_test = enabled;
+ return true;
}
return false;
case GL_STENCIL_TEST:
- if (state_.enable_flags.stencil_test != enabled) {
- state_.enable_flags.stencil_test = enabled;
+ state_.enable_flags.stencil_test = enabled;
+ if (state_.enable_flags.cached_stencil_test != enabled ||
+ state_.ignore_cached_state) {
framebuffer_state_.clear_state_dirty = true;
}
return false;
}
}
#endif // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_AUTOGEN_H_
-