1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // This file is auto-generated from
6 // gpu/command_buffer/build_gles2_cmd_buffer.py
7 // DO NOT EDIT!
8
9 // It is included by gles2_cmd_decoder.cc
10 #ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_AUTOGEN_H_
11 #define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_AUTOGEN_H_
12
HandleActiveTexture(uint32 immediate_data_size,const gles2::cmds::ActiveTexture & c)13 error::Error GLES2DecoderImpl::HandleActiveTexture(
14 uint32 immediate_data_size, const gles2::cmds::ActiveTexture& c) {
15 GLenum texture = static_cast<GLenum>(c.texture);
16 DoActiveTexture(texture);
17 return error::kNoError;
18 }
19
HandleAttachShader(uint32 immediate_data_size,const gles2::cmds::AttachShader & c)20 error::Error GLES2DecoderImpl::HandleAttachShader(
21 uint32 immediate_data_size, const gles2::cmds::AttachShader& c) {
22 GLuint program = c.program;
23 GLuint shader = c.shader;
24 DoAttachShader(program, shader);
25 return error::kNoError;
26 }
27
HandleBindBuffer(uint32 immediate_data_size,const gles2::cmds::BindBuffer & c)28 error::Error GLES2DecoderImpl::HandleBindBuffer(
29 uint32 immediate_data_size, const gles2::cmds::BindBuffer& c) {
30 GLenum target = static_cast<GLenum>(c.target);
31 GLuint buffer = c.buffer;
32 if (!validators_->buffer_target.IsValid(target)) {
33 LOCAL_SET_GL_ERROR_INVALID_ENUM("glBindBuffer", target, "target");
34 return error::kNoError;
35 }
36 DoBindBuffer(target, buffer);
37 return error::kNoError;
38 }
39
HandleBindFramebuffer(uint32 immediate_data_size,const gles2::cmds::BindFramebuffer & c)40 error::Error GLES2DecoderImpl::HandleBindFramebuffer(
41 uint32 immediate_data_size, const gles2::cmds::BindFramebuffer& c) {
42 GLenum target = static_cast<GLenum>(c.target);
43 GLuint framebuffer = c.framebuffer;
44 if (!validators_->frame_buffer_target.IsValid(target)) {
45 LOCAL_SET_GL_ERROR_INVALID_ENUM("glBindFramebuffer", target, "target");
46 return error::kNoError;
47 }
48 DoBindFramebuffer(target, framebuffer);
49 return error::kNoError;
50 }
51
HandleBindRenderbuffer(uint32 immediate_data_size,const gles2::cmds::BindRenderbuffer & c)52 error::Error GLES2DecoderImpl::HandleBindRenderbuffer(
53 uint32 immediate_data_size, const gles2::cmds::BindRenderbuffer& c) {
54 GLenum target = static_cast<GLenum>(c.target);
55 GLuint renderbuffer = c.renderbuffer;
56 if (!validators_->render_buffer_target.IsValid(target)) {
57 LOCAL_SET_GL_ERROR_INVALID_ENUM("glBindRenderbuffer", target, "target");
58 return error::kNoError;
59 }
60 DoBindRenderbuffer(target, renderbuffer);
61 return error::kNoError;
62 }
63
HandleBindTexture(uint32 immediate_data_size,const gles2::cmds::BindTexture & c)64 error::Error GLES2DecoderImpl::HandleBindTexture(
65 uint32 immediate_data_size, const gles2::cmds::BindTexture& c) {
66 GLenum target = static_cast<GLenum>(c.target);
67 GLuint texture = c.texture;
68 if (!validators_->texture_bind_target.IsValid(target)) {
69 LOCAL_SET_GL_ERROR_INVALID_ENUM("glBindTexture", target, "target");
70 return error::kNoError;
71 }
72 DoBindTexture(target, texture);
73 return error::kNoError;
74 }
75
HandleBlendColor(uint32 immediate_data_size,const gles2::cmds::BlendColor & c)76 error::Error GLES2DecoderImpl::HandleBlendColor(
77 uint32 immediate_data_size, const gles2::cmds::BlendColor& c) {
78 GLclampf red = static_cast<GLclampf>(c.red);
79 GLclampf green = static_cast<GLclampf>(c.green);
80 GLclampf blue = static_cast<GLclampf>(c.blue);
81 GLclampf alpha = static_cast<GLclampf>(c.alpha);
82 if (state_.blend_color_red != red ||
83 state_.blend_color_green != green ||
84 state_.blend_color_blue != blue ||
85 state_.blend_color_alpha != alpha) {
86 state_.blend_color_red = red;
87 state_.blend_color_green = green;
88 state_.blend_color_blue = blue;
89 state_.blend_color_alpha = alpha;
90 glBlendColor(red, green, blue, alpha);
91 }
92 return error::kNoError;
93 }
94
HandleBlendEquation(uint32 immediate_data_size,const gles2::cmds::BlendEquation & c)95 error::Error GLES2DecoderImpl::HandleBlendEquation(
96 uint32 immediate_data_size, const gles2::cmds::BlendEquation& c) {
97 GLenum mode = static_cast<GLenum>(c.mode);
98 if (!validators_->equation.IsValid(mode)) {
99 LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendEquation", mode, "mode");
100 return error::kNoError;
101 }
102 if (state_.blend_equation_rgb != mode ||
103 state_.blend_equation_alpha != mode) {
104 state_.blend_equation_rgb = mode;
105 state_.blend_equation_alpha = mode;
106 glBlendEquation(mode);
107 }
108 return error::kNoError;
109 }
110
HandleBlendEquationSeparate(uint32 immediate_data_size,const gles2::cmds::BlendEquationSeparate & c)111 error::Error GLES2DecoderImpl::HandleBlendEquationSeparate(
112 uint32 immediate_data_size, const gles2::cmds::BlendEquationSeparate& c) {
113 GLenum modeRGB = static_cast<GLenum>(c.modeRGB);
114 GLenum modeAlpha = static_cast<GLenum>(c.modeAlpha);
115 if (!validators_->equation.IsValid(modeRGB)) {
116 LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendEquationSeparate", modeRGB,
117 "modeRGB");
118 return error::kNoError;
119 }
120 if (!validators_->equation.IsValid(modeAlpha)) {
121 LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendEquationSeparate", modeAlpha,
122 "modeAlpha");
123 return error::kNoError;
124 }
125 if (state_.blend_equation_rgb != modeRGB ||
126 state_.blend_equation_alpha != modeAlpha) {
127 state_.blend_equation_rgb = modeRGB;
128 state_.blend_equation_alpha = modeAlpha;
129 glBlendEquationSeparate(modeRGB, modeAlpha);
130 }
131 return error::kNoError;
132 }
133
HandleBlendFunc(uint32 immediate_data_size,const gles2::cmds::BlendFunc & c)134 error::Error GLES2DecoderImpl::HandleBlendFunc(
135 uint32 immediate_data_size, const gles2::cmds::BlendFunc& c) {
136 GLenum sfactor = static_cast<GLenum>(c.sfactor);
137 GLenum dfactor = static_cast<GLenum>(c.dfactor);
138 if (!validators_->src_blend_factor.IsValid(sfactor)) {
139 LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendFunc", sfactor, "sfactor");
140 return error::kNoError;
141 }
142 if (!validators_->dst_blend_factor.IsValid(dfactor)) {
143 LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendFunc", dfactor, "dfactor");
144 return error::kNoError;
145 }
146 if (state_.blend_source_rgb != sfactor ||
147 state_.blend_dest_rgb != dfactor ||
148 state_.blend_source_alpha != sfactor ||
149 state_.blend_dest_alpha != dfactor) {
150 state_.blend_source_rgb = sfactor;
151 state_.blend_dest_rgb = dfactor;
152 state_.blend_source_alpha = sfactor;
153 state_.blend_dest_alpha = dfactor;
154 glBlendFunc(sfactor, dfactor);
155 }
156 return error::kNoError;
157 }
158
HandleBlendFuncSeparate(uint32 immediate_data_size,const gles2::cmds::BlendFuncSeparate & c)159 error::Error GLES2DecoderImpl::HandleBlendFuncSeparate(
160 uint32 immediate_data_size, const gles2::cmds::BlendFuncSeparate& c) {
161 GLenum srcRGB = static_cast<GLenum>(c.srcRGB);
162 GLenum dstRGB = static_cast<GLenum>(c.dstRGB);
163 GLenum srcAlpha = static_cast<GLenum>(c.srcAlpha);
164 GLenum dstAlpha = static_cast<GLenum>(c.dstAlpha);
165 if (!validators_->src_blend_factor.IsValid(srcRGB)) {
166 LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendFuncSeparate", srcRGB, "srcRGB");
167 return error::kNoError;
168 }
169 if (!validators_->dst_blend_factor.IsValid(dstRGB)) {
170 LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendFuncSeparate", dstRGB, "dstRGB");
171 return error::kNoError;
172 }
173 if (!validators_->src_blend_factor.IsValid(srcAlpha)) {
174 LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendFuncSeparate", srcAlpha,
175 "srcAlpha");
176 return error::kNoError;
177 }
178 if (!validators_->dst_blend_factor.IsValid(dstAlpha)) {
179 LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendFuncSeparate", dstAlpha,
180 "dstAlpha");
181 return error::kNoError;
182 }
183 if (state_.blend_source_rgb != srcRGB ||
184 state_.blend_dest_rgb != dstRGB ||
185 state_.blend_source_alpha != srcAlpha ||
186 state_.blend_dest_alpha != dstAlpha) {
187 state_.blend_source_rgb = srcRGB;
188 state_.blend_dest_rgb = dstRGB;
189 state_.blend_source_alpha = srcAlpha;
190 state_.blend_dest_alpha = dstAlpha;
191 glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
192 }
193 return error::kNoError;
194 }
195
HandleBufferSubData(uint32 immediate_data_size,const gles2::cmds::BufferSubData & c)196 error::Error GLES2DecoderImpl::HandleBufferSubData(
197 uint32 immediate_data_size, const gles2::cmds::BufferSubData& c) {
198 GLenum target = static_cast<GLenum>(c.target);
199 GLintptr offset = static_cast<GLintptr>(c.offset);
200 GLsizeiptr size = static_cast<GLsizeiptr>(c.size);
201 uint32 data_size = size;
202 const void* data = GetSharedMemoryAs<const void*>(
203 c.data_shm_id, c.data_shm_offset, data_size);
204 if (!validators_->buffer_target.IsValid(target)) {
205 LOCAL_SET_GL_ERROR_INVALID_ENUM("glBufferSubData", target, "target");
206 return error::kNoError;
207 }
208 if (size < 0) {
209 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glBufferSubData", "size < 0");
210 return error::kNoError;
211 }
212 if (data == NULL) {
213 return error::kOutOfBounds;
214 }
215 DoBufferSubData(target, offset, size, data);
216 return error::kNoError;
217 }
218
HandleCheckFramebufferStatus(uint32 immediate_data_size,const gles2::cmds::CheckFramebufferStatus & c)219 error::Error GLES2DecoderImpl::HandleCheckFramebufferStatus(
220 uint32 immediate_data_size, const gles2::cmds::CheckFramebufferStatus& c) {
221 GLenum target = static_cast<GLenum>(c.target);
222 typedef cmds::CheckFramebufferStatus::Result Result;
223 Result* result_dst = GetSharedMemoryAs<Result*>(
224 c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
225 if (!result_dst) {
226 return error::kOutOfBounds;
227 }
228 if (!validators_->frame_buffer_target.IsValid(target)) {
229 LOCAL_SET_GL_ERROR_INVALID_ENUM("glCheckFramebufferStatus", target,
230 "target");
231 return error::kNoError;
232 }
233 *result_dst = DoCheckFramebufferStatus(target);
234 return error::kNoError;
235 }
236
HandleClear(uint32 immediate_data_size,const gles2::cmds::Clear & c)237 error::Error GLES2DecoderImpl::HandleClear(
238 uint32 immediate_data_size, const gles2::cmds::Clear& c) {
239 error::Error error;
240 error = WillAccessBoundFramebufferForDraw();
241 if (error != error::kNoError)
242 return error;
243 GLbitfield mask = static_cast<GLbitfield>(c.mask);
244 DoClear(mask);
245 return error::kNoError;
246 }
247
HandleClearColor(uint32 immediate_data_size,const gles2::cmds::ClearColor & c)248 error::Error GLES2DecoderImpl::HandleClearColor(
249 uint32 immediate_data_size, const gles2::cmds::ClearColor& c) {
250 GLclampf red = static_cast<GLclampf>(c.red);
251 GLclampf green = static_cast<GLclampf>(c.green);
252 GLclampf blue = static_cast<GLclampf>(c.blue);
253 GLclampf alpha = static_cast<GLclampf>(c.alpha);
254 if (state_.color_clear_red != red ||
255 state_.color_clear_green != green ||
256 state_.color_clear_blue != blue ||
257 state_.color_clear_alpha != alpha) {
258 state_.color_clear_red = red;
259 state_.color_clear_green = green;
260 state_.color_clear_blue = blue;
261 state_.color_clear_alpha = alpha;
262 glClearColor(red, green, blue, alpha);
263 }
264 return error::kNoError;
265 }
266
HandleClearDepthf(uint32 immediate_data_size,const gles2::cmds::ClearDepthf & c)267 error::Error GLES2DecoderImpl::HandleClearDepthf(
268 uint32 immediate_data_size, const gles2::cmds::ClearDepthf& c) {
269 GLclampf depth = static_cast<GLclampf>(c.depth);
270 if (state_.depth_clear != depth) {
271 state_.depth_clear = depth;
272 glClearDepth(depth);
273 }
274 return error::kNoError;
275 }
276
HandleClearStencil(uint32 immediate_data_size,const gles2::cmds::ClearStencil & c)277 error::Error GLES2DecoderImpl::HandleClearStencil(
278 uint32 immediate_data_size, const gles2::cmds::ClearStencil& c) {
279 GLint s = static_cast<GLint>(c.s);
280 if (state_.stencil_clear != s) {
281 state_.stencil_clear = s;
282 glClearStencil(s);
283 }
284 return error::kNoError;
285 }
286
HandleColorMask(uint32 immediate_data_size,const gles2::cmds::ColorMask & c)287 error::Error GLES2DecoderImpl::HandleColorMask(
288 uint32 immediate_data_size, const gles2::cmds::ColorMask& c) {
289 GLboolean red = static_cast<GLboolean>(c.red);
290 GLboolean green = static_cast<GLboolean>(c.green);
291 GLboolean blue = static_cast<GLboolean>(c.blue);
292 GLboolean alpha = static_cast<GLboolean>(c.alpha);
293 if (state_.color_mask_red != red ||
294 state_.color_mask_green != green ||
295 state_.color_mask_blue != blue ||
296 state_.color_mask_alpha != alpha) {
297 state_.color_mask_red = red;
298 state_.color_mask_green = green;
299 state_.color_mask_blue = blue;
300 state_.color_mask_alpha = alpha;
301 framebuffer_state_.clear_state_dirty = true;
302 }
303 return error::kNoError;
304 }
305
HandleCompileShader(uint32 immediate_data_size,const gles2::cmds::CompileShader & c)306 error::Error GLES2DecoderImpl::HandleCompileShader(
307 uint32 immediate_data_size, const gles2::cmds::CompileShader& c) {
308 GLuint shader = c.shader;
309 DoCompileShader(shader);
310 return error::kNoError;
311 }
312
HandleCompressedTexSubImage2D(uint32 immediate_data_size,const gles2::cmds::CompressedTexSubImage2D & c)313 error::Error GLES2DecoderImpl::HandleCompressedTexSubImage2D(
314 uint32 immediate_data_size,
315 const gles2::cmds::CompressedTexSubImage2D& c) {
316 GLenum target = static_cast<GLenum>(c.target);
317 GLint level = static_cast<GLint>(c.level);
318 GLint xoffset = static_cast<GLint>(c.xoffset);
319 GLint yoffset = static_cast<GLint>(c.yoffset);
320 GLsizei width = static_cast<GLsizei>(c.width);
321 GLsizei height = static_cast<GLsizei>(c.height);
322 GLenum format = static_cast<GLenum>(c.format);
323 GLsizei imageSize = static_cast<GLsizei>(c.imageSize);
324 uint32 data_size = imageSize;
325 const void* data = GetSharedMemoryAs<const void*>(
326 c.data_shm_id, c.data_shm_offset, data_size);
327 if (!validators_->texture_target.IsValid(target)) {
328 LOCAL_SET_GL_ERROR_INVALID_ENUM("glCompressedTexSubImage2D", target,
329 "target");
330 return error::kNoError;
331 }
332 if (width < 0) {
333 LOCAL_SET_GL_ERROR(
334 GL_INVALID_VALUE, "glCompressedTexSubImage2D", "width < 0");
335 return error::kNoError;
336 }
337 if (height < 0) {
338 LOCAL_SET_GL_ERROR(
339 GL_INVALID_VALUE, "glCompressedTexSubImage2D", "height < 0");
340 return error::kNoError;
341 }
342 if (!validators_->compressed_texture_format.IsValid(format)) {
343 LOCAL_SET_GL_ERROR_INVALID_ENUM("glCompressedTexSubImage2D", format,
344 "format");
345 return error::kNoError;
346 }
347 if (imageSize < 0) {
348 LOCAL_SET_GL_ERROR(
349 GL_INVALID_VALUE, "glCompressedTexSubImage2D", "imageSize < 0");
350 return error::kNoError;
351 }
352 if (data == NULL) {
353 return error::kOutOfBounds;
354 }
355 DoCompressedTexSubImage2D(
356 target, level, xoffset, yoffset, width, height, format, imageSize, data);
357 return error::kNoError;
358 }
359
HandleCopyTexImage2D(uint32 immediate_data_size,const gles2::cmds::CopyTexImage2D & c)360 error::Error GLES2DecoderImpl::HandleCopyTexImage2D(
361 uint32 immediate_data_size, const gles2::cmds::CopyTexImage2D& c) {
362 error::Error error;
363 error = WillAccessBoundFramebufferForRead();
364 if (error != error::kNoError)
365 return error;
366 GLenum target = static_cast<GLenum>(c.target);
367 GLint level = static_cast<GLint>(c.level);
368 GLenum internalformat = static_cast<GLenum>(c.internalformat);
369 GLint x = static_cast<GLint>(c.x);
370 GLint y = static_cast<GLint>(c.y);
371 GLsizei width = static_cast<GLsizei>(c.width);
372 GLsizei height = static_cast<GLsizei>(c.height);
373 GLint border = static_cast<GLint>(c.border);
374 if (!validators_->texture_target.IsValid(target)) {
375 LOCAL_SET_GL_ERROR_INVALID_ENUM("glCopyTexImage2D", target, "target");
376 return error::kNoError;
377 }
378 if (!validators_->texture_internal_format.IsValid(internalformat)) {
379 LOCAL_SET_GL_ERROR_INVALID_ENUM("glCopyTexImage2D", internalformat,
380 "internalformat");
381 return error::kNoError;
382 }
383 if (width < 0) {
384 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glCopyTexImage2D", "width < 0");
385 return error::kNoError;
386 }
387 if (height < 0) {
388 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glCopyTexImage2D", "height < 0");
389 return error::kNoError;
390 }
391 if (!validators_->texture_border.IsValid(border)) {
392 LOCAL_SET_GL_ERROR(
393 GL_INVALID_VALUE, "glCopyTexImage2D", "border GL_INVALID_VALUE");
394 return error::kNoError;
395 }
396 DoCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
397 return error::kNoError;
398 }
399
HandleCopyTexSubImage2D(uint32 immediate_data_size,const gles2::cmds::CopyTexSubImage2D & c)400 error::Error GLES2DecoderImpl::HandleCopyTexSubImage2D(
401 uint32 immediate_data_size, const gles2::cmds::CopyTexSubImage2D& c) {
402 error::Error error;
403 error = WillAccessBoundFramebufferForRead();
404 if (error != error::kNoError)
405 return error;
406 GLenum target = static_cast<GLenum>(c.target);
407 GLint level = static_cast<GLint>(c.level);
408 GLint xoffset = static_cast<GLint>(c.xoffset);
409 GLint yoffset = static_cast<GLint>(c.yoffset);
410 GLint x = static_cast<GLint>(c.x);
411 GLint y = static_cast<GLint>(c.y);
412 GLsizei width = static_cast<GLsizei>(c.width);
413 GLsizei height = static_cast<GLsizei>(c.height);
414 if (!validators_->texture_target.IsValid(target)) {
415 LOCAL_SET_GL_ERROR_INVALID_ENUM("glCopyTexSubImage2D", target, "target");
416 return error::kNoError;
417 }
418 if (width < 0) {
419 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glCopyTexSubImage2D", "width < 0");
420 return error::kNoError;
421 }
422 if (height < 0) {
423 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glCopyTexSubImage2D", "height < 0");
424 return error::kNoError;
425 }
426 DoCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
427 return error::kNoError;
428 }
429
HandleCreateProgram(uint32 immediate_data_size,const gles2::cmds::CreateProgram & c)430 error::Error GLES2DecoderImpl::HandleCreateProgram(
431 uint32 immediate_data_size, const gles2::cmds::CreateProgram& c) {
432 uint32 client_id = c.client_id;
433 if (!CreateProgramHelper(client_id)) {
434 return error::kInvalidArguments;
435 }
436 return error::kNoError;
437 }
438
HandleCreateShader(uint32 immediate_data_size,const gles2::cmds::CreateShader & c)439 error::Error GLES2DecoderImpl::HandleCreateShader(
440 uint32 immediate_data_size, const gles2::cmds::CreateShader& c) {
441 GLenum type = static_cast<GLenum>(c.type);
442 if (!validators_->shader_type.IsValid(type)) {
443 LOCAL_SET_GL_ERROR_INVALID_ENUM("glCreateShader", type, "type");
444 return error::kNoError;
445 }
446 uint32 client_id = c.client_id;
447 if (!CreateShaderHelper(type, client_id)) {
448 return error::kInvalidArguments;
449 }
450 return error::kNoError;
451 }
452
HandleCullFace(uint32 immediate_data_size,const gles2::cmds::CullFace & c)453 error::Error GLES2DecoderImpl::HandleCullFace(
454 uint32 immediate_data_size, const gles2::cmds::CullFace& c) {
455 GLenum mode = static_cast<GLenum>(c.mode);
456 if (!validators_->face_type.IsValid(mode)) {
457 LOCAL_SET_GL_ERROR_INVALID_ENUM("glCullFace", mode, "mode");
458 return error::kNoError;
459 }
460 if (state_.cull_mode != mode) {
461 state_.cull_mode = mode;
462 glCullFace(mode);
463 }
464 return error::kNoError;
465 }
466
HandleDeleteBuffers(uint32 immediate_data_size,const gles2::cmds::DeleteBuffers & c)467 error::Error GLES2DecoderImpl::HandleDeleteBuffers(
468 uint32 immediate_data_size, const gles2::cmds::DeleteBuffers& c) {
469 GLsizei n = static_cast<GLsizei>(c.n);
470 uint32 data_size;
471 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
472 return error::kOutOfBounds;
473 }
474 const GLuint* buffers = GetSharedMemoryAs<const GLuint*>(
475 c.buffers_shm_id, c.buffers_shm_offset, data_size);
476 if (buffers == NULL) {
477 return error::kOutOfBounds;
478 }
479 DeleteBuffersHelper(n, buffers);
480 return error::kNoError;
481 }
482
HandleDeleteBuffersImmediate(uint32 immediate_data_size,const gles2::cmds::DeleteBuffersImmediate & c)483 error::Error GLES2DecoderImpl::HandleDeleteBuffersImmediate(
484 uint32 immediate_data_size, const gles2::cmds::DeleteBuffersImmediate& c) {
485 GLsizei n = static_cast<GLsizei>(c.n);
486 uint32 data_size;
487 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
488 return error::kOutOfBounds;
489 }
490 const GLuint* buffers = GetImmediateDataAs<const GLuint*>(
491 c, data_size, immediate_data_size);
492 if (buffers == NULL) {
493 return error::kOutOfBounds;
494 }
495 DeleteBuffersHelper(n, buffers);
496 return error::kNoError;
497 }
498
HandleDeleteFramebuffers(uint32 immediate_data_size,const gles2::cmds::DeleteFramebuffers & c)499 error::Error GLES2DecoderImpl::HandleDeleteFramebuffers(
500 uint32 immediate_data_size, const gles2::cmds::DeleteFramebuffers& c) {
501 GLsizei n = static_cast<GLsizei>(c.n);
502 uint32 data_size;
503 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
504 return error::kOutOfBounds;
505 }
506 const GLuint* framebuffers = GetSharedMemoryAs<const GLuint*>(
507 c.framebuffers_shm_id, c.framebuffers_shm_offset, data_size);
508 if (framebuffers == NULL) {
509 return error::kOutOfBounds;
510 }
511 DeleteFramebuffersHelper(n, framebuffers);
512 return error::kNoError;
513 }
514
HandleDeleteFramebuffersImmediate(uint32 immediate_data_size,const gles2::cmds::DeleteFramebuffersImmediate & c)515 error::Error GLES2DecoderImpl::HandleDeleteFramebuffersImmediate(
516 uint32 immediate_data_size,
517 const gles2::cmds::DeleteFramebuffersImmediate& c) {
518 GLsizei n = static_cast<GLsizei>(c.n);
519 uint32 data_size;
520 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
521 return error::kOutOfBounds;
522 }
523 const GLuint* framebuffers = GetImmediateDataAs<const GLuint*>(
524 c, data_size, immediate_data_size);
525 if (framebuffers == NULL) {
526 return error::kOutOfBounds;
527 }
528 DeleteFramebuffersHelper(n, framebuffers);
529 return error::kNoError;
530 }
531
HandleDeleteRenderbuffers(uint32 immediate_data_size,const gles2::cmds::DeleteRenderbuffers & c)532 error::Error GLES2DecoderImpl::HandleDeleteRenderbuffers(
533 uint32 immediate_data_size, const gles2::cmds::DeleteRenderbuffers& c) {
534 GLsizei n = static_cast<GLsizei>(c.n);
535 uint32 data_size;
536 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
537 return error::kOutOfBounds;
538 }
539 const GLuint* renderbuffers = GetSharedMemoryAs<const GLuint*>(
540 c.renderbuffers_shm_id, c.renderbuffers_shm_offset, data_size);
541 if (renderbuffers == NULL) {
542 return error::kOutOfBounds;
543 }
544 DeleteRenderbuffersHelper(n, renderbuffers);
545 return error::kNoError;
546 }
547
HandleDeleteRenderbuffersImmediate(uint32 immediate_data_size,const gles2::cmds::DeleteRenderbuffersImmediate & c)548 error::Error GLES2DecoderImpl::HandleDeleteRenderbuffersImmediate(
549 uint32 immediate_data_size,
550 const gles2::cmds::DeleteRenderbuffersImmediate& c) {
551 GLsizei n = static_cast<GLsizei>(c.n);
552 uint32 data_size;
553 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
554 return error::kOutOfBounds;
555 }
556 const GLuint* renderbuffers = GetImmediateDataAs<const GLuint*>(
557 c, data_size, immediate_data_size);
558 if (renderbuffers == NULL) {
559 return error::kOutOfBounds;
560 }
561 DeleteRenderbuffersHelper(n, renderbuffers);
562 return error::kNoError;
563 }
564
HandleDeleteTextures(uint32 immediate_data_size,const gles2::cmds::DeleteTextures & c)565 error::Error GLES2DecoderImpl::HandleDeleteTextures(
566 uint32 immediate_data_size, const gles2::cmds::DeleteTextures& c) {
567 GLsizei n = static_cast<GLsizei>(c.n);
568 uint32 data_size;
569 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
570 return error::kOutOfBounds;
571 }
572 const GLuint* textures = GetSharedMemoryAs<const GLuint*>(
573 c.textures_shm_id, c.textures_shm_offset, data_size);
574 if (textures == NULL) {
575 return error::kOutOfBounds;
576 }
577 DeleteTexturesHelper(n, textures);
578 return error::kNoError;
579 }
580
HandleDeleteTexturesImmediate(uint32 immediate_data_size,const gles2::cmds::DeleteTexturesImmediate & c)581 error::Error GLES2DecoderImpl::HandleDeleteTexturesImmediate(
582 uint32 immediate_data_size,
583 const gles2::cmds::DeleteTexturesImmediate& c) {
584 GLsizei n = static_cast<GLsizei>(c.n);
585 uint32 data_size;
586 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
587 return error::kOutOfBounds;
588 }
589 const GLuint* textures = GetImmediateDataAs<const GLuint*>(
590 c, data_size, immediate_data_size);
591 if (textures == NULL) {
592 return error::kOutOfBounds;
593 }
594 DeleteTexturesHelper(n, textures);
595 return error::kNoError;
596 }
597
HandleDepthFunc(uint32 immediate_data_size,const gles2::cmds::DepthFunc & c)598 error::Error GLES2DecoderImpl::HandleDepthFunc(
599 uint32 immediate_data_size, const gles2::cmds::DepthFunc& c) {
600 GLenum func = static_cast<GLenum>(c.func);
601 if (!validators_->cmp_function.IsValid(func)) {
602 LOCAL_SET_GL_ERROR_INVALID_ENUM("glDepthFunc", func, "func");
603 return error::kNoError;
604 }
605 if (state_.depth_func != func) {
606 state_.depth_func = func;
607 glDepthFunc(func);
608 }
609 return error::kNoError;
610 }
611
HandleDepthMask(uint32 immediate_data_size,const gles2::cmds::DepthMask & c)612 error::Error GLES2DecoderImpl::HandleDepthMask(
613 uint32 immediate_data_size, const gles2::cmds::DepthMask& c) {
614 GLboolean flag = static_cast<GLboolean>(c.flag);
615 if (state_.depth_mask != flag) {
616 state_.depth_mask = flag;
617 framebuffer_state_.clear_state_dirty = true;
618 }
619 return error::kNoError;
620 }
621
HandleDepthRangef(uint32 immediate_data_size,const gles2::cmds::DepthRangef & c)622 error::Error GLES2DecoderImpl::HandleDepthRangef(
623 uint32 immediate_data_size, const gles2::cmds::DepthRangef& c) {
624 GLclampf zNear = static_cast<GLclampf>(c.zNear);
625 GLclampf zFar = static_cast<GLclampf>(c.zFar);
626 DoDepthRangef(zNear, zFar);
627 return error::kNoError;
628 }
629
HandleDetachShader(uint32 immediate_data_size,const gles2::cmds::DetachShader & c)630 error::Error GLES2DecoderImpl::HandleDetachShader(
631 uint32 immediate_data_size, const gles2::cmds::DetachShader& c) {
632 GLuint program = c.program;
633 GLuint shader = c.shader;
634 DoDetachShader(program, shader);
635 return error::kNoError;
636 }
637
HandleDisable(uint32 immediate_data_size,const gles2::cmds::Disable & c)638 error::Error GLES2DecoderImpl::HandleDisable(
639 uint32 immediate_data_size, const gles2::cmds::Disable& c) {
640 GLenum cap = static_cast<GLenum>(c.cap);
641 if (!validators_->capability.IsValid(cap)) {
642 LOCAL_SET_GL_ERROR_INVALID_ENUM("glDisable", cap, "cap");
643 return error::kNoError;
644 }
645 DoDisable(cap);
646 return error::kNoError;
647 }
648
HandleDisableVertexAttribArray(uint32 immediate_data_size,const gles2::cmds::DisableVertexAttribArray & c)649 error::Error GLES2DecoderImpl::HandleDisableVertexAttribArray(
650 uint32 immediate_data_size,
651 const gles2::cmds::DisableVertexAttribArray& c) {
652 GLuint index = static_cast<GLuint>(c.index);
653 DoDisableVertexAttribArray(index);
654 return error::kNoError;
655 }
656
HandleEnable(uint32 immediate_data_size,const gles2::cmds::Enable & c)657 error::Error GLES2DecoderImpl::HandleEnable(
658 uint32 immediate_data_size, const gles2::cmds::Enable& c) {
659 GLenum cap = static_cast<GLenum>(c.cap);
660 if (!validators_->capability.IsValid(cap)) {
661 LOCAL_SET_GL_ERROR_INVALID_ENUM("glEnable", cap, "cap");
662 return error::kNoError;
663 }
664 DoEnable(cap);
665 return error::kNoError;
666 }
667
HandleEnableVertexAttribArray(uint32 immediate_data_size,const gles2::cmds::EnableVertexAttribArray & c)668 error::Error GLES2DecoderImpl::HandleEnableVertexAttribArray(
669 uint32 immediate_data_size,
670 const gles2::cmds::EnableVertexAttribArray& c) {
671 GLuint index = static_cast<GLuint>(c.index);
672 DoEnableVertexAttribArray(index);
673 return error::kNoError;
674 }
675
HandleFinish(uint32 immediate_data_size,const gles2::cmds::Finish & c)676 error::Error GLES2DecoderImpl::HandleFinish(
677 uint32 immediate_data_size, const gles2::cmds::Finish& c) {
678 error::Error error;
679 error = WillAccessBoundFramebufferForRead();
680 if (error != error::kNoError)
681 return error;
682 DoFinish();
683 return error::kNoError;
684 }
685
HandleFlush(uint32 immediate_data_size,const gles2::cmds::Flush & c)686 error::Error GLES2DecoderImpl::HandleFlush(
687 uint32 immediate_data_size, const gles2::cmds::Flush& c) {
688 DoFlush();
689 return error::kNoError;
690 }
691
HandleFramebufferRenderbuffer(uint32 immediate_data_size,const gles2::cmds::FramebufferRenderbuffer & c)692 error::Error GLES2DecoderImpl::HandleFramebufferRenderbuffer(
693 uint32 immediate_data_size,
694 const gles2::cmds::FramebufferRenderbuffer& c) {
695 GLenum target = static_cast<GLenum>(c.target);
696 GLenum attachment = static_cast<GLenum>(c.attachment);
697 GLenum renderbuffertarget = static_cast<GLenum>(c.renderbuffertarget);
698 GLuint renderbuffer = c.renderbuffer;
699 if (!validators_->frame_buffer_target.IsValid(target)) {
700 LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferRenderbuffer", target,
701 "target");
702 return error::kNoError;
703 }
704 if (!validators_->attachment.IsValid(attachment)) {
705 LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferRenderbuffer", attachment,
706 "attachment");
707 return error::kNoError;
708 }
709 if (!validators_->render_buffer_target.IsValid(renderbuffertarget)) {
710 LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferRenderbuffer", renderbuffertarget, "renderbuffertarget"); // NOLINT
711 return error::kNoError;
712 }
713 DoFramebufferRenderbuffer(
714 target, attachment, renderbuffertarget, renderbuffer);
715 return error::kNoError;
716 }
717
HandleFramebufferTexture2D(uint32 immediate_data_size,const gles2::cmds::FramebufferTexture2D & c)718 error::Error GLES2DecoderImpl::HandleFramebufferTexture2D(
719 uint32 immediate_data_size, const gles2::cmds::FramebufferTexture2D& c) {
720 GLenum target = static_cast<GLenum>(c.target);
721 GLenum attachment = static_cast<GLenum>(c.attachment);
722 GLenum textarget = static_cast<GLenum>(c.textarget);
723 GLuint texture = c.texture;
724 GLint level = static_cast<GLint>(c.level);
725 if (!validators_->frame_buffer_target.IsValid(target)) {
726 LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferTexture2D", target,
727 "target");
728 return error::kNoError;
729 }
730 if (!validators_->attachment.IsValid(attachment)) {
731 LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferTexture2D", attachment,
732 "attachment");
733 return error::kNoError;
734 }
735 if (!validators_->texture_target.IsValid(textarget)) {
736 LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferTexture2D", textarget,
737 "textarget");
738 return error::kNoError;
739 }
740 if (!validators_->zero_only.IsValid(level)) {
741 LOCAL_SET_GL_ERROR(
742 GL_INVALID_VALUE, "glFramebufferTexture2D", "level GL_INVALID_VALUE");
743 return error::kNoError;
744 }
745 DoFramebufferTexture2D(target, attachment, textarget, texture, level);
746 return error::kNoError;
747 }
748
HandleFrontFace(uint32 immediate_data_size,const gles2::cmds::FrontFace & c)749 error::Error GLES2DecoderImpl::HandleFrontFace(
750 uint32 immediate_data_size, const gles2::cmds::FrontFace& c) {
751 GLenum mode = static_cast<GLenum>(c.mode);
752 if (!validators_->face_mode.IsValid(mode)) {
753 LOCAL_SET_GL_ERROR_INVALID_ENUM("glFrontFace", mode, "mode");
754 return error::kNoError;
755 }
756 if (state_.front_face != mode) {
757 state_.front_face = mode;
758 glFrontFace(mode);
759 }
760 return error::kNoError;
761 }
762
HandleGenBuffers(uint32 immediate_data_size,const gles2::cmds::GenBuffers & c)763 error::Error GLES2DecoderImpl::HandleGenBuffers(
764 uint32 immediate_data_size, const gles2::cmds::GenBuffers& c) {
765 GLsizei n = static_cast<GLsizei>(c.n);
766 uint32 data_size;
767 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
768 return error::kOutOfBounds;
769 }
770 GLuint* buffers = GetSharedMemoryAs<GLuint*>(
771 c.buffers_shm_id, c.buffers_shm_offset, data_size);
772 if (buffers == NULL) {
773 return error::kOutOfBounds;
774 }
775 if (!GenBuffersHelper(n, buffers)) {
776 return error::kInvalidArguments;
777 }
778 return error::kNoError;
779 }
780
HandleGenBuffersImmediate(uint32 immediate_data_size,const gles2::cmds::GenBuffersImmediate & c)781 error::Error GLES2DecoderImpl::HandleGenBuffersImmediate(
782 uint32 immediate_data_size, const gles2::cmds::GenBuffersImmediate& c) {
783 GLsizei n = static_cast<GLsizei>(c.n);
784 uint32 data_size;
785 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
786 return error::kOutOfBounds;
787 }
788 GLuint* buffers = GetImmediateDataAs<GLuint*>(
789 c, data_size, immediate_data_size);
790 if (buffers == NULL) {
791 return error::kOutOfBounds;
792 }
793 if (!GenBuffersHelper(n, buffers)) {
794 return error::kInvalidArguments;
795 }
796 return error::kNoError;
797 }
798
HandleGenerateMipmap(uint32 immediate_data_size,const gles2::cmds::GenerateMipmap & c)799 error::Error GLES2DecoderImpl::HandleGenerateMipmap(
800 uint32 immediate_data_size, const gles2::cmds::GenerateMipmap& c) {
801 GLenum target = static_cast<GLenum>(c.target);
802 if (!validators_->texture_bind_target.IsValid(target)) {
803 LOCAL_SET_GL_ERROR_INVALID_ENUM("glGenerateMipmap", target, "target");
804 return error::kNoError;
805 }
806 DoGenerateMipmap(target);
807 return error::kNoError;
808 }
809
HandleGenFramebuffers(uint32 immediate_data_size,const gles2::cmds::GenFramebuffers & c)810 error::Error GLES2DecoderImpl::HandleGenFramebuffers(
811 uint32 immediate_data_size, const gles2::cmds::GenFramebuffers& c) {
812 GLsizei n = static_cast<GLsizei>(c.n);
813 uint32 data_size;
814 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
815 return error::kOutOfBounds;
816 }
817 GLuint* framebuffers = GetSharedMemoryAs<GLuint*>(
818 c.framebuffers_shm_id, c.framebuffers_shm_offset, data_size);
819 if (framebuffers == NULL) {
820 return error::kOutOfBounds;
821 }
822 if (!GenFramebuffersHelper(n, framebuffers)) {
823 return error::kInvalidArguments;
824 }
825 return error::kNoError;
826 }
827
HandleGenFramebuffersImmediate(uint32 immediate_data_size,const gles2::cmds::GenFramebuffersImmediate & c)828 error::Error GLES2DecoderImpl::HandleGenFramebuffersImmediate(
829 uint32 immediate_data_size,
830 const gles2::cmds::GenFramebuffersImmediate& c) {
831 GLsizei n = static_cast<GLsizei>(c.n);
832 uint32 data_size;
833 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
834 return error::kOutOfBounds;
835 }
836 GLuint* framebuffers = GetImmediateDataAs<GLuint*>(
837 c, data_size, immediate_data_size);
838 if (framebuffers == NULL) {
839 return error::kOutOfBounds;
840 }
841 if (!GenFramebuffersHelper(n, framebuffers)) {
842 return error::kInvalidArguments;
843 }
844 return error::kNoError;
845 }
846
HandleGenRenderbuffers(uint32 immediate_data_size,const gles2::cmds::GenRenderbuffers & c)847 error::Error GLES2DecoderImpl::HandleGenRenderbuffers(
848 uint32 immediate_data_size, const gles2::cmds::GenRenderbuffers& c) {
849 GLsizei n = static_cast<GLsizei>(c.n);
850 uint32 data_size;
851 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
852 return error::kOutOfBounds;
853 }
854 GLuint* renderbuffers = GetSharedMemoryAs<GLuint*>(
855 c.renderbuffers_shm_id, c.renderbuffers_shm_offset, data_size);
856 if (renderbuffers == NULL) {
857 return error::kOutOfBounds;
858 }
859 if (!GenRenderbuffersHelper(n, renderbuffers)) {
860 return error::kInvalidArguments;
861 }
862 return error::kNoError;
863 }
864
HandleGenRenderbuffersImmediate(uint32 immediate_data_size,const gles2::cmds::GenRenderbuffersImmediate & c)865 error::Error GLES2DecoderImpl::HandleGenRenderbuffersImmediate(
866 uint32 immediate_data_size,
867 const gles2::cmds::GenRenderbuffersImmediate& c) {
868 GLsizei n = static_cast<GLsizei>(c.n);
869 uint32 data_size;
870 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
871 return error::kOutOfBounds;
872 }
873 GLuint* renderbuffers = GetImmediateDataAs<GLuint*>(
874 c, data_size, immediate_data_size);
875 if (renderbuffers == NULL) {
876 return error::kOutOfBounds;
877 }
878 if (!GenRenderbuffersHelper(n, renderbuffers)) {
879 return error::kInvalidArguments;
880 }
881 return error::kNoError;
882 }
883
HandleGenTextures(uint32 immediate_data_size,const gles2::cmds::GenTextures & c)884 error::Error GLES2DecoderImpl::HandleGenTextures(
885 uint32 immediate_data_size, const gles2::cmds::GenTextures& c) {
886 GLsizei n = static_cast<GLsizei>(c.n);
887 uint32 data_size;
888 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
889 return error::kOutOfBounds;
890 }
891 GLuint* textures = GetSharedMemoryAs<GLuint*>(
892 c.textures_shm_id, c.textures_shm_offset, data_size);
893 if (textures == NULL) {
894 return error::kOutOfBounds;
895 }
896 if (!GenTexturesHelper(n, textures)) {
897 return error::kInvalidArguments;
898 }
899 return error::kNoError;
900 }
901
HandleGenTexturesImmediate(uint32 immediate_data_size,const gles2::cmds::GenTexturesImmediate & c)902 error::Error GLES2DecoderImpl::HandleGenTexturesImmediate(
903 uint32 immediate_data_size, const gles2::cmds::GenTexturesImmediate& c) {
904 GLsizei n = static_cast<GLsizei>(c.n);
905 uint32 data_size;
906 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
907 return error::kOutOfBounds;
908 }
909 GLuint* textures = GetImmediateDataAs<GLuint*>(
910 c, data_size, immediate_data_size);
911 if (textures == NULL) {
912 return error::kOutOfBounds;
913 }
914 if (!GenTexturesHelper(n, textures)) {
915 return error::kInvalidArguments;
916 }
917 return error::kNoError;
918 }
919
HandleGetBooleanv(uint32 immediate_data_size,const gles2::cmds::GetBooleanv & c)920 error::Error GLES2DecoderImpl::HandleGetBooleanv(
921 uint32 immediate_data_size, const gles2::cmds::GetBooleanv& c) {
922 GLenum pname = static_cast<GLenum>(c.pname);
923 typedef cmds::GetBooleanv::Result Result;
924 GLsizei num_values = 0;
925 GetNumValuesReturnedForGLGet(pname, &num_values);
926 Result* result = GetSharedMemoryAs<Result*>(
927 c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
928 GLboolean* params = result ? result->GetData() : NULL;
929 if (!validators_->g_l_state.IsValid(pname)) {
930 LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetBooleanv", pname, "pname");
931 return error::kNoError;
932 }
933 if (params == NULL) {
934 return error::kOutOfBounds;
935 }
936 LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetBooleanv");
937 // Check that the client initialized the result.
938 if (result->size != 0) {
939 return error::kInvalidArguments;
940 }
941 DoGetBooleanv(pname, params);
942 GLenum error = glGetError();
943 if (error == GL_NO_ERROR) {
944 result->SetNumResults(num_values);
945 } else {
946 LOCAL_SET_GL_ERROR(error, "GetBooleanv", "");
947 }
948 return error::kNoError;
949 }
950
HandleGetBufferParameteriv(uint32 immediate_data_size,const gles2::cmds::GetBufferParameteriv & c)951 error::Error GLES2DecoderImpl::HandleGetBufferParameteriv(
952 uint32 immediate_data_size, const gles2::cmds::GetBufferParameteriv& c) {
953 GLenum target = static_cast<GLenum>(c.target);
954 GLenum pname = static_cast<GLenum>(c.pname);
955 typedef cmds::GetBufferParameteriv::Result Result;
956 GLsizei num_values = 0;
957 GetNumValuesReturnedForGLGet(pname, &num_values);
958 Result* result = GetSharedMemoryAs<Result*>(
959 c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
960 GLint* params = result ? result->GetData() : NULL;
961 if (!validators_->buffer_target.IsValid(target)) {
962 LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetBufferParameteriv", target,
963 "target");
964 return error::kNoError;
965 }
966 if (!validators_->buffer_parameter.IsValid(pname)) {
967 LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetBufferParameteriv", pname, "pname");
968 return error::kNoError;
969 }
970 if (params == NULL) {
971 return error::kOutOfBounds;
972 }
973 // Check that the client initialized the result.
974 if (result->size != 0) {
975 return error::kInvalidArguments;
976 }
977 DoGetBufferParameteriv(target, pname, params);
978 result->SetNumResults(num_values);
979 return error::kNoError;
980 }
HandleGetError(uint32 immediate_data_size,const gles2::cmds::GetError & c)981 error::Error GLES2DecoderImpl::HandleGetError(
982 uint32 immediate_data_size, const gles2::cmds::GetError& c) {
983 typedef cmds::GetError::Result Result;
984 Result* result_dst = GetSharedMemoryAs<Result*>(
985 c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
986 if (!result_dst) {
987 return error::kOutOfBounds;
988 }
989 *result_dst = GetErrorState()->GetGLError();
990 return error::kNoError;
991 }
992
HandleGetFloatv(uint32 immediate_data_size,const gles2::cmds::GetFloatv & c)993 error::Error GLES2DecoderImpl::HandleGetFloatv(
994 uint32 immediate_data_size, const gles2::cmds::GetFloatv& c) {
995 GLenum pname = static_cast<GLenum>(c.pname);
996 typedef cmds::GetFloatv::Result Result;
997 GLsizei num_values = 0;
998 GetNumValuesReturnedForGLGet(pname, &num_values);
999 Result* result = GetSharedMemoryAs<Result*>(
1000 c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1001 GLfloat* params = result ? result->GetData() : NULL;
1002 if (!validators_->g_l_state.IsValid(pname)) {
1003 LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetFloatv", pname, "pname");
1004 return error::kNoError;
1005 }
1006 if (params == NULL) {
1007 return error::kOutOfBounds;
1008 }
1009 LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetFloatv");
1010 // Check that the client initialized the result.
1011 if (result->size != 0) {
1012 return error::kInvalidArguments;
1013 }
1014 DoGetFloatv(pname, params);
1015 GLenum error = glGetError();
1016 if (error == GL_NO_ERROR) {
1017 result->SetNumResults(num_values);
1018 } else {
1019 LOCAL_SET_GL_ERROR(error, "GetFloatv", "");
1020 }
1021 return error::kNoError;
1022 }
1023
HandleGetFramebufferAttachmentParameteriv(uint32 immediate_data_size,const gles2::cmds::GetFramebufferAttachmentParameteriv & c)1024 error::Error GLES2DecoderImpl::HandleGetFramebufferAttachmentParameteriv(
1025 uint32 immediate_data_size,
1026 const gles2::cmds::GetFramebufferAttachmentParameteriv& c) {
1027 GLenum target = static_cast<GLenum>(c.target);
1028 GLenum attachment = static_cast<GLenum>(c.attachment);
1029 GLenum pname = static_cast<GLenum>(c.pname);
1030 typedef cmds::GetFramebufferAttachmentParameteriv::Result Result;
1031 GLsizei num_values = 0;
1032 GetNumValuesReturnedForGLGet(pname, &num_values);
1033 Result* result = GetSharedMemoryAs<Result*>(
1034 c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1035 GLint* params = result ? result->GetData() : NULL;
1036 if (!validators_->frame_buffer_target.IsValid(target)) {
1037 LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetFramebufferAttachmentParameteriv", target, "target"); // NOLINT
1038 return error::kNoError;
1039 }
1040 if (!validators_->attachment.IsValid(attachment)) {
1041 LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetFramebufferAttachmentParameteriv", attachment, "attachment"); // NOLINT
1042 return error::kNoError;
1043 }
1044 if (!validators_->frame_buffer_parameter.IsValid(pname)) {
1045 LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetFramebufferAttachmentParameteriv", pname, "pname"); // NOLINT
1046 return error::kNoError;
1047 }
1048 if (params == NULL) {
1049 return error::kOutOfBounds;
1050 }
1051 LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetFramebufferAttachmentParameteriv");
1052 // Check that the client initialized the result.
1053 if (result->size != 0) {
1054 return error::kInvalidArguments;
1055 }
1056 DoGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
1057 GLenum error = glGetError();
1058 if (error == GL_NO_ERROR) {
1059 result->SetNumResults(num_values);
1060 } else {
1061 LOCAL_SET_GL_ERROR(error, "GetFramebufferAttachmentParameteriv", "");
1062 }
1063 return error::kNoError;
1064 }
1065
HandleGetIntegerv(uint32 immediate_data_size,const gles2::cmds::GetIntegerv & c)1066 error::Error GLES2DecoderImpl::HandleGetIntegerv(
1067 uint32 immediate_data_size, const gles2::cmds::GetIntegerv& c) {
1068 GLenum pname = static_cast<GLenum>(c.pname);
1069 typedef cmds::GetIntegerv::Result Result;
1070 GLsizei num_values = 0;
1071 GetNumValuesReturnedForGLGet(pname, &num_values);
1072 Result* result = GetSharedMemoryAs<Result*>(
1073 c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1074 GLint* params = result ? result->GetData() : NULL;
1075 if (!validators_->g_l_state.IsValid(pname)) {
1076 LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetIntegerv", pname, "pname");
1077 return error::kNoError;
1078 }
1079 if (params == NULL) {
1080 return error::kOutOfBounds;
1081 }
1082 LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetIntegerv");
1083 // Check that the client initialized the result.
1084 if (result->size != 0) {
1085 return error::kInvalidArguments;
1086 }
1087 DoGetIntegerv(pname, params);
1088 GLenum error = glGetError();
1089 if (error == GL_NO_ERROR) {
1090 result->SetNumResults(num_values);
1091 } else {
1092 LOCAL_SET_GL_ERROR(error, "GetIntegerv", "");
1093 }
1094 return error::kNoError;
1095 }
1096
HandleGetProgramiv(uint32 immediate_data_size,const gles2::cmds::GetProgramiv & c)1097 error::Error GLES2DecoderImpl::HandleGetProgramiv(
1098 uint32 immediate_data_size, const gles2::cmds::GetProgramiv& c) {
1099 GLuint program = c.program;
1100 GLenum pname = static_cast<GLenum>(c.pname);
1101 typedef cmds::GetProgramiv::Result Result;
1102 GLsizei num_values = 0;
1103 GetNumValuesReturnedForGLGet(pname, &num_values);
1104 Result* result = GetSharedMemoryAs<Result*>(
1105 c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1106 GLint* params = result ? result->GetData() : NULL;
1107 if (!validators_->program_parameter.IsValid(pname)) {
1108 LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetProgramiv", pname, "pname");
1109 return error::kNoError;
1110 }
1111 if (params == NULL) {
1112 return error::kOutOfBounds;
1113 }
1114 LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetProgramiv");
1115 // Check that the client initialized the result.
1116 if (result->size != 0) {
1117 return error::kInvalidArguments;
1118 }
1119 DoGetProgramiv(program, pname, params);
1120 GLenum error = glGetError();
1121 if (error == GL_NO_ERROR) {
1122 result->SetNumResults(num_values);
1123 } else {
1124 LOCAL_SET_GL_ERROR(error, "GetProgramiv", "");
1125 }
1126 return error::kNoError;
1127 }
1128
HandleGetRenderbufferParameteriv(uint32 immediate_data_size,const gles2::cmds::GetRenderbufferParameteriv & c)1129 error::Error GLES2DecoderImpl::HandleGetRenderbufferParameteriv(
1130 uint32 immediate_data_size,
1131 const gles2::cmds::GetRenderbufferParameteriv& c) {
1132 GLenum target = static_cast<GLenum>(c.target);
1133 GLenum pname = static_cast<GLenum>(c.pname);
1134 typedef cmds::GetRenderbufferParameteriv::Result Result;
1135 GLsizei num_values = 0;
1136 GetNumValuesReturnedForGLGet(pname, &num_values);
1137 Result* result = GetSharedMemoryAs<Result*>(
1138 c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1139 GLint* params = result ? result->GetData() : NULL;
1140 if (!validators_->render_buffer_target.IsValid(target)) {
1141 LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetRenderbufferParameteriv", target,
1142 "target");
1143 return error::kNoError;
1144 }
1145 if (!validators_->render_buffer_parameter.IsValid(pname)) {
1146 LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetRenderbufferParameteriv", pname,
1147 "pname");
1148 return error::kNoError;
1149 }
1150 if (params == NULL) {
1151 return error::kOutOfBounds;
1152 }
1153 LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetRenderbufferParameteriv");
1154 // Check that the client initialized the result.
1155 if (result->size != 0) {
1156 return error::kInvalidArguments;
1157 }
1158 DoGetRenderbufferParameteriv(target, pname, params);
1159 GLenum error = glGetError();
1160 if (error == GL_NO_ERROR) {
1161 result->SetNumResults(num_values);
1162 } else {
1163 LOCAL_SET_GL_ERROR(error, "GetRenderbufferParameteriv", "");
1164 }
1165 return error::kNoError;
1166 }
1167
HandleGetShaderiv(uint32 immediate_data_size,const gles2::cmds::GetShaderiv & c)1168 error::Error GLES2DecoderImpl::HandleGetShaderiv(
1169 uint32 immediate_data_size, const gles2::cmds::GetShaderiv& c) {
1170 GLuint shader = c.shader;
1171 GLenum pname = static_cast<GLenum>(c.pname);
1172 typedef cmds::GetShaderiv::Result Result;
1173 GLsizei num_values = 0;
1174 GetNumValuesReturnedForGLGet(pname, &num_values);
1175 Result* result = GetSharedMemoryAs<Result*>(
1176 c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1177 GLint* params = result ? result->GetData() : NULL;
1178 if (!validators_->shader_parameter.IsValid(pname)) {
1179 LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetShaderiv", pname, "pname");
1180 return error::kNoError;
1181 }
1182 if (params == NULL) {
1183 return error::kOutOfBounds;
1184 }
1185 LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetShaderiv");
1186 // Check that the client initialized the result.
1187 if (result->size != 0) {
1188 return error::kInvalidArguments;
1189 }
1190 DoGetShaderiv(shader, pname, params);
1191 GLenum error = glGetError();
1192 if (error == GL_NO_ERROR) {
1193 result->SetNumResults(num_values);
1194 } else {
1195 LOCAL_SET_GL_ERROR(error, "GetShaderiv", "");
1196 }
1197 return error::kNoError;
1198 }
1199
HandleGetTexParameterfv(uint32 immediate_data_size,const gles2::cmds::GetTexParameterfv & c)1200 error::Error GLES2DecoderImpl::HandleGetTexParameterfv(
1201 uint32 immediate_data_size, const gles2::cmds::GetTexParameterfv& c) {
1202 GLenum target = static_cast<GLenum>(c.target);
1203 GLenum pname = static_cast<GLenum>(c.pname);
1204 typedef cmds::GetTexParameterfv::Result Result;
1205 GLsizei num_values = 0;
1206 GetNumValuesReturnedForGLGet(pname, &num_values);
1207 Result* result = GetSharedMemoryAs<Result*>(
1208 c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1209 GLfloat* params = result ? result->GetData() : NULL;
1210 if (!validators_->get_tex_param_target.IsValid(target)) {
1211 LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetTexParameterfv", target, "target");
1212 return error::kNoError;
1213 }
1214 if (!validators_->texture_parameter.IsValid(pname)) {
1215 LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetTexParameterfv", pname, "pname");
1216 return error::kNoError;
1217 }
1218 if (params == NULL) {
1219 return error::kOutOfBounds;
1220 }
1221 LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetTexParameterfv");
1222 // Check that the client initialized the result.
1223 if (result->size != 0) {
1224 return error::kInvalidArguments;
1225 }
1226 glGetTexParameterfv(target, pname, params);
1227 GLenum error = glGetError();
1228 if (error == GL_NO_ERROR) {
1229 result->SetNumResults(num_values);
1230 } else {
1231 LOCAL_SET_GL_ERROR(error, "GetTexParameterfv", "");
1232 }
1233 return error::kNoError;
1234 }
1235
HandleGetTexParameteriv(uint32 immediate_data_size,const gles2::cmds::GetTexParameteriv & c)1236 error::Error GLES2DecoderImpl::HandleGetTexParameteriv(
1237 uint32 immediate_data_size, const gles2::cmds::GetTexParameteriv& c) {
1238 GLenum target = static_cast<GLenum>(c.target);
1239 GLenum pname = static_cast<GLenum>(c.pname);
1240 typedef cmds::GetTexParameteriv::Result Result;
1241 GLsizei num_values = 0;
1242 GetNumValuesReturnedForGLGet(pname, &num_values);
1243 Result* result = GetSharedMemoryAs<Result*>(
1244 c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1245 GLint* params = result ? result->GetData() : NULL;
1246 if (!validators_->get_tex_param_target.IsValid(target)) {
1247 LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetTexParameteriv", target, "target");
1248 return error::kNoError;
1249 }
1250 if (!validators_->texture_parameter.IsValid(pname)) {
1251 LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetTexParameteriv", pname, "pname");
1252 return error::kNoError;
1253 }
1254 if (params == NULL) {
1255 return error::kOutOfBounds;
1256 }
1257 LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetTexParameteriv");
1258 // Check that the client initialized the result.
1259 if (result->size != 0) {
1260 return error::kInvalidArguments;
1261 }
1262 glGetTexParameteriv(target, pname, params);
1263 GLenum error = glGetError();
1264 if (error == GL_NO_ERROR) {
1265 result->SetNumResults(num_values);
1266 } else {
1267 LOCAL_SET_GL_ERROR(error, "GetTexParameteriv", "");
1268 }
1269 return error::kNoError;
1270 }
1271
HandleGetVertexAttribfv(uint32 immediate_data_size,const gles2::cmds::GetVertexAttribfv & c)1272 error::Error GLES2DecoderImpl::HandleGetVertexAttribfv(
1273 uint32 immediate_data_size, const gles2::cmds::GetVertexAttribfv& c) {
1274 GLuint index = static_cast<GLuint>(c.index);
1275 GLenum pname = static_cast<GLenum>(c.pname);
1276 typedef cmds::GetVertexAttribfv::Result Result;
1277 GLsizei num_values = 0;
1278 GetNumValuesReturnedForGLGet(pname, &num_values);
1279 Result* result = GetSharedMemoryAs<Result*>(
1280 c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1281 GLfloat* params = result ? result->GetData() : NULL;
1282 if (!validators_->vertex_attribute.IsValid(pname)) {
1283 LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetVertexAttribfv", pname, "pname");
1284 return error::kNoError;
1285 }
1286 if (params == NULL) {
1287 return error::kOutOfBounds;
1288 }
1289 LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetVertexAttribfv");
1290 // Check that the client initialized the result.
1291 if (result->size != 0) {
1292 return error::kInvalidArguments;
1293 }
1294 DoGetVertexAttribfv(index, pname, params);
1295 GLenum error = glGetError();
1296 if (error == GL_NO_ERROR) {
1297 result->SetNumResults(num_values);
1298 } else {
1299 LOCAL_SET_GL_ERROR(error, "GetVertexAttribfv", "");
1300 }
1301 return error::kNoError;
1302 }
1303
HandleGetVertexAttribiv(uint32 immediate_data_size,const gles2::cmds::GetVertexAttribiv & c)1304 error::Error GLES2DecoderImpl::HandleGetVertexAttribiv(
1305 uint32 immediate_data_size, const gles2::cmds::GetVertexAttribiv& c) {
1306 GLuint index = static_cast<GLuint>(c.index);
1307 GLenum pname = static_cast<GLenum>(c.pname);
1308 typedef cmds::GetVertexAttribiv::Result Result;
1309 GLsizei num_values = 0;
1310 GetNumValuesReturnedForGLGet(pname, &num_values);
1311 Result* result = GetSharedMemoryAs<Result*>(
1312 c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1313 GLint* params = result ? result->GetData() : NULL;
1314 if (!validators_->vertex_attribute.IsValid(pname)) {
1315 LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetVertexAttribiv", pname, "pname");
1316 return error::kNoError;
1317 }
1318 if (params == NULL) {
1319 return error::kOutOfBounds;
1320 }
1321 LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetVertexAttribiv");
1322 // Check that the client initialized the result.
1323 if (result->size != 0) {
1324 return error::kInvalidArguments;
1325 }
1326 DoGetVertexAttribiv(index, pname, params);
1327 GLenum error = glGetError();
1328 if (error == GL_NO_ERROR) {
1329 result->SetNumResults(num_values);
1330 } else {
1331 LOCAL_SET_GL_ERROR(error, "GetVertexAttribiv", "");
1332 }
1333 return error::kNoError;
1334 }
1335
HandleHint(uint32 immediate_data_size,const gles2::cmds::Hint & c)1336 error::Error GLES2DecoderImpl::HandleHint(
1337 uint32 immediate_data_size, const gles2::cmds::Hint& c) {
1338 GLenum target = static_cast<GLenum>(c.target);
1339 GLenum mode = static_cast<GLenum>(c.mode);
1340 if (!validators_->hint_target.IsValid(target)) {
1341 LOCAL_SET_GL_ERROR_INVALID_ENUM("glHint", target, "target");
1342 return error::kNoError;
1343 }
1344 if (!validators_->hint_mode.IsValid(mode)) {
1345 LOCAL_SET_GL_ERROR_INVALID_ENUM("glHint", mode, "mode");
1346 return error::kNoError;
1347 }
1348 switch (target) {
1349 case GL_GENERATE_MIPMAP_HINT:
1350 if (state_.hint_generate_mipmap != mode) {
1351 state_.hint_generate_mipmap = mode;
1352 glHint(target, mode);
1353 }
1354 break;
1355 case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES:
1356 if (state_.hint_fragment_shader_derivative != mode) {
1357 state_.hint_fragment_shader_derivative = mode;
1358 glHint(target, mode);
1359 }
1360 break;
1361 default:
1362 NOTREACHED();
1363 }
1364 return error::kNoError;
1365 }
1366
HandleIsBuffer(uint32 immediate_data_size,const gles2::cmds::IsBuffer & c)1367 error::Error GLES2DecoderImpl::HandleIsBuffer(
1368 uint32 immediate_data_size, const gles2::cmds::IsBuffer& c) {
1369 GLuint buffer = c.buffer;
1370 typedef cmds::IsBuffer::Result Result;
1371 Result* result_dst = GetSharedMemoryAs<Result*>(
1372 c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
1373 if (!result_dst) {
1374 return error::kOutOfBounds;
1375 }
1376 *result_dst = DoIsBuffer(buffer);
1377 return error::kNoError;
1378 }
1379
HandleIsEnabled(uint32 immediate_data_size,const gles2::cmds::IsEnabled & c)1380 error::Error GLES2DecoderImpl::HandleIsEnabled(
1381 uint32 immediate_data_size, const gles2::cmds::IsEnabled& c) {
1382 GLenum cap = static_cast<GLenum>(c.cap);
1383 typedef cmds::IsEnabled::Result Result;
1384 Result* result_dst = GetSharedMemoryAs<Result*>(
1385 c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
1386 if (!result_dst) {
1387 return error::kOutOfBounds;
1388 }
1389 if (!validators_->capability.IsValid(cap)) {
1390 LOCAL_SET_GL_ERROR_INVALID_ENUM("glIsEnabled", cap, "cap");
1391 return error::kNoError;
1392 }
1393 *result_dst = DoIsEnabled(cap);
1394 return error::kNoError;
1395 }
1396
HandleIsFramebuffer(uint32 immediate_data_size,const gles2::cmds::IsFramebuffer & c)1397 error::Error GLES2DecoderImpl::HandleIsFramebuffer(
1398 uint32 immediate_data_size, const gles2::cmds::IsFramebuffer& c) {
1399 GLuint framebuffer = c.framebuffer;
1400 typedef cmds::IsFramebuffer::Result Result;
1401 Result* result_dst = GetSharedMemoryAs<Result*>(
1402 c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
1403 if (!result_dst) {
1404 return error::kOutOfBounds;
1405 }
1406 *result_dst = DoIsFramebuffer(framebuffer);
1407 return error::kNoError;
1408 }
1409
HandleIsProgram(uint32 immediate_data_size,const gles2::cmds::IsProgram & c)1410 error::Error GLES2DecoderImpl::HandleIsProgram(
1411 uint32 immediate_data_size, const gles2::cmds::IsProgram& c) {
1412 GLuint program = c.program;
1413 typedef cmds::IsProgram::Result Result;
1414 Result* result_dst = GetSharedMemoryAs<Result*>(
1415 c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
1416 if (!result_dst) {
1417 return error::kOutOfBounds;
1418 }
1419 *result_dst = DoIsProgram(program);
1420 return error::kNoError;
1421 }
1422
HandleIsRenderbuffer(uint32 immediate_data_size,const gles2::cmds::IsRenderbuffer & c)1423 error::Error GLES2DecoderImpl::HandleIsRenderbuffer(
1424 uint32 immediate_data_size, const gles2::cmds::IsRenderbuffer& c) {
1425 GLuint renderbuffer = c.renderbuffer;
1426 typedef cmds::IsRenderbuffer::Result Result;
1427 Result* result_dst = GetSharedMemoryAs<Result*>(
1428 c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
1429 if (!result_dst) {
1430 return error::kOutOfBounds;
1431 }
1432 *result_dst = DoIsRenderbuffer(renderbuffer);
1433 return error::kNoError;
1434 }
1435
HandleIsShader(uint32 immediate_data_size,const gles2::cmds::IsShader & c)1436 error::Error GLES2DecoderImpl::HandleIsShader(
1437 uint32 immediate_data_size, const gles2::cmds::IsShader& c) {
1438 GLuint shader = c.shader;
1439 typedef cmds::IsShader::Result Result;
1440 Result* result_dst = GetSharedMemoryAs<Result*>(
1441 c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
1442 if (!result_dst) {
1443 return error::kOutOfBounds;
1444 }
1445 *result_dst = DoIsShader(shader);
1446 return error::kNoError;
1447 }
1448
HandleIsTexture(uint32 immediate_data_size,const gles2::cmds::IsTexture & c)1449 error::Error GLES2DecoderImpl::HandleIsTexture(
1450 uint32 immediate_data_size, const gles2::cmds::IsTexture& c) {
1451 GLuint texture = c.texture;
1452 typedef cmds::IsTexture::Result Result;
1453 Result* result_dst = GetSharedMemoryAs<Result*>(
1454 c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
1455 if (!result_dst) {
1456 return error::kOutOfBounds;
1457 }
1458 *result_dst = DoIsTexture(texture);
1459 return error::kNoError;
1460 }
1461
HandleLineWidth(uint32 immediate_data_size,const gles2::cmds::LineWidth & c)1462 error::Error GLES2DecoderImpl::HandleLineWidth(
1463 uint32 immediate_data_size, const gles2::cmds::LineWidth& c) {
1464 GLfloat width = static_cast<GLfloat>(c.width);
1465 if (width <= 0.0f) {
1466 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "LineWidth", "width out of range");
1467 return error::kNoError;
1468 }
1469 if (state_.line_width != width) {
1470 state_.line_width = width;
1471 glLineWidth(width);
1472 }
1473 return error::kNoError;
1474 }
1475
HandleLinkProgram(uint32 immediate_data_size,const gles2::cmds::LinkProgram & c)1476 error::Error GLES2DecoderImpl::HandleLinkProgram(
1477 uint32 immediate_data_size, const gles2::cmds::LinkProgram& c) {
1478 GLuint program = c.program;
1479 DoLinkProgram(program);
1480 return error::kNoError;
1481 }
1482
HandlePolygonOffset(uint32 immediate_data_size,const gles2::cmds::PolygonOffset & c)1483 error::Error GLES2DecoderImpl::HandlePolygonOffset(
1484 uint32 immediate_data_size, const gles2::cmds::PolygonOffset& c) {
1485 GLfloat factor = static_cast<GLfloat>(c.factor);
1486 GLfloat units = static_cast<GLfloat>(c.units);
1487 if (state_.polygon_offset_factor != factor ||
1488 state_.polygon_offset_units != units) {
1489 state_.polygon_offset_factor = factor;
1490 state_.polygon_offset_units = units;
1491 glPolygonOffset(factor, units);
1492 }
1493 return error::kNoError;
1494 }
1495
HandleReleaseShaderCompiler(uint32 immediate_data_size,const gles2::cmds::ReleaseShaderCompiler & c)1496 error::Error GLES2DecoderImpl::HandleReleaseShaderCompiler(
1497 uint32 immediate_data_size, const gles2::cmds::ReleaseShaderCompiler& c) {
1498 DoReleaseShaderCompiler();
1499 return error::kNoError;
1500 }
1501
HandleRenderbufferStorage(uint32 immediate_data_size,const gles2::cmds::RenderbufferStorage & c)1502 error::Error GLES2DecoderImpl::HandleRenderbufferStorage(
1503 uint32 immediate_data_size, const gles2::cmds::RenderbufferStorage& c) {
1504 GLenum target = static_cast<GLenum>(c.target);
1505 GLenum internalformat = static_cast<GLenum>(c.internalformat);
1506 GLsizei width = static_cast<GLsizei>(c.width);
1507 GLsizei height = static_cast<GLsizei>(c.height);
1508 if (!validators_->render_buffer_target.IsValid(target)) {
1509 LOCAL_SET_GL_ERROR_INVALID_ENUM("glRenderbufferStorage", target, "target");
1510 return error::kNoError;
1511 }
1512 if (!validators_->render_buffer_format.IsValid(internalformat)) {
1513 LOCAL_SET_GL_ERROR_INVALID_ENUM("glRenderbufferStorage", internalformat,
1514 "internalformat");
1515 return error::kNoError;
1516 }
1517 if (width < 0) {
1518 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glRenderbufferStorage", "width < 0");
1519 return error::kNoError;
1520 }
1521 if (height < 0) {
1522 LOCAL_SET_GL_ERROR(
1523 GL_INVALID_VALUE, "glRenderbufferStorage", "height < 0");
1524 return error::kNoError;
1525 }
1526 DoRenderbufferStorage(target, internalformat, width, height);
1527 return error::kNoError;
1528 }
1529
HandleSampleCoverage(uint32 immediate_data_size,const gles2::cmds::SampleCoverage & c)1530 error::Error GLES2DecoderImpl::HandleSampleCoverage(
1531 uint32 immediate_data_size, const gles2::cmds::SampleCoverage& c) {
1532 GLclampf value = static_cast<GLclampf>(c.value);
1533 GLboolean invert = static_cast<GLboolean>(c.invert);
1534 DoSampleCoverage(value, invert);
1535 return error::kNoError;
1536 }
1537
HandleScissor(uint32 immediate_data_size,const gles2::cmds::Scissor & c)1538 error::Error GLES2DecoderImpl::HandleScissor(
1539 uint32 immediate_data_size, const gles2::cmds::Scissor& c) {
1540 GLint x = static_cast<GLint>(c.x);
1541 GLint y = static_cast<GLint>(c.y);
1542 GLsizei width = static_cast<GLsizei>(c.width);
1543 GLsizei height = static_cast<GLsizei>(c.height);
1544 if (width < 0) {
1545 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glScissor", "width < 0");
1546 return error::kNoError;
1547 }
1548 if (height < 0) {
1549 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glScissor", "height < 0");
1550 return error::kNoError;
1551 }
1552 if (state_.scissor_x != x ||
1553 state_.scissor_y != y ||
1554 state_.scissor_width != width ||
1555 state_.scissor_height != height) {
1556 state_.scissor_x = x;
1557 state_.scissor_y = y;
1558 state_.scissor_width = width;
1559 state_.scissor_height = height;
1560 glScissor(x, y, width, height);
1561 }
1562 return error::kNoError;
1563 }
1564
HandleStencilFunc(uint32 immediate_data_size,const gles2::cmds::StencilFunc & c)1565 error::Error GLES2DecoderImpl::HandleStencilFunc(
1566 uint32 immediate_data_size, const gles2::cmds::StencilFunc& c) {
1567 GLenum func = static_cast<GLenum>(c.func);
1568 GLint ref = static_cast<GLint>(c.ref);
1569 GLuint mask = static_cast<GLuint>(c.mask);
1570 if (!validators_->cmp_function.IsValid(func)) {
1571 LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilFunc", func, "func");
1572 return error::kNoError;
1573 }
1574 if (state_.stencil_front_func != func ||
1575 state_.stencil_front_ref != ref ||
1576 state_.stencil_front_mask != mask ||
1577 state_.stencil_back_func != func ||
1578 state_.stencil_back_ref != ref ||
1579 state_.stencil_back_mask != mask) {
1580 state_.stencil_front_func = func;
1581 state_.stencil_front_ref = ref;
1582 state_.stencil_front_mask = mask;
1583 state_.stencil_back_func = func;
1584 state_.stencil_back_ref = ref;
1585 state_.stencil_back_mask = mask;
1586 glStencilFunc(func, ref, mask);
1587 }
1588 return error::kNoError;
1589 }
1590
HandleStencilFuncSeparate(uint32 immediate_data_size,const gles2::cmds::StencilFuncSeparate & c)1591 error::Error GLES2DecoderImpl::HandleStencilFuncSeparate(
1592 uint32 immediate_data_size, const gles2::cmds::StencilFuncSeparate& c) {
1593 GLenum face = static_cast<GLenum>(c.face);
1594 GLenum func = static_cast<GLenum>(c.func);
1595 GLint ref = static_cast<GLint>(c.ref);
1596 GLuint mask = static_cast<GLuint>(c.mask);
1597 if (!validators_->face_type.IsValid(face)) {
1598 LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilFuncSeparate", face, "face");
1599 return error::kNoError;
1600 }
1601 if (!validators_->cmp_function.IsValid(func)) {
1602 LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilFuncSeparate", func, "func");
1603 return error::kNoError;
1604 }
1605 bool changed = false;
1606 if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
1607 changed |= state_.stencil_front_func != func ||
1608 state_.stencil_front_ref != ref ||
1609 state_.stencil_front_mask != mask;
1610 }
1611 if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
1612 changed |= state_.stencil_back_func != func ||
1613 state_.stencil_back_ref != ref ||
1614 state_.stencil_back_mask != mask;
1615 }
1616 if (changed) {
1617 if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
1618 state_.stencil_front_func = func;
1619 state_.stencil_front_ref = ref;
1620 state_.stencil_front_mask = mask;
1621 }
1622 if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
1623 state_.stencil_back_func = func;
1624 state_.stencil_back_ref = ref;
1625 state_.stencil_back_mask = mask;
1626 }
1627 glStencilFuncSeparate(face, func, ref, mask);
1628 }
1629 return error::kNoError;
1630 }
1631
HandleStencilMask(uint32 immediate_data_size,const gles2::cmds::StencilMask & c)1632 error::Error GLES2DecoderImpl::HandleStencilMask(
1633 uint32 immediate_data_size, const gles2::cmds::StencilMask& c) {
1634 GLuint mask = static_cast<GLuint>(c.mask);
1635 if (state_.stencil_front_writemask != mask ||
1636 state_.stencil_back_writemask != mask) {
1637 state_.stencil_front_writemask = mask;
1638 state_.stencil_back_writemask = mask;
1639 framebuffer_state_.clear_state_dirty = true;
1640 }
1641 return error::kNoError;
1642 }
1643
HandleStencilMaskSeparate(uint32 immediate_data_size,const gles2::cmds::StencilMaskSeparate & c)1644 error::Error GLES2DecoderImpl::HandleStencilMaskSeparate(
1645 uint32 immediate_data_size, const gles2::cmds::StencilMaskSeparate& c) {
1646 GLenum face = static_cast<GLenum>(c.face);
1647 GLuint mask = static_cast<GLuint>(c.mask);
1648 if (!validators_->face_type.IsValid(face)) {
1649 LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilMaskSeparate", face, "face");
1650 return error::kNoError;
1651 }
1652 bool changed = false;
1653 if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
1654 changed |= state_.stencil_front_writemask != mask;
1655 }
1656 if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
1657 changed |= state_.stencil_back_writemask != mask;
1658 }
1659 if (changed) {
1660 if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
1661 state_.stencil_front_writemask = mask;
1662 }
1663 if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
1664 state_.stencil_back_writemask = mask;
1665 }
1666 framebuffer_state_.clear_state_dirty = true;
1667 }
1668 return error::kNoError;
1669 }
1670
HandleStencilOp(uint32 immediate_data_size,const gles2::cmds::StencilOp & c)1671 error::Error GLES2DecoderImpl::HandleStencilOp(
1672 uint32 immediate_data_size, const gles2::cmds::StencilOp& c) {
1673 GLenum fail = static_cast<GLenum>(c.fail);
1674 GLenum zfail = static_cast<GLenum>(c.zfail);
1675 GLenum zpass = static_cast<GLenum>(c.zpass);
1676 if (!validators_->stencil_op.IsValid(fail)) {
1677 LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilOp", fail, "fail");
1678 return error::kNoError;
1679 }
1680 if (!validators_->stencil_op.IsValid(zfail)) {
1681 LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilOp", zfail, "zfail");
1682 return error::kNoError;
1683 }
1684 if (!validators_->stencil_op.IsValid(zpass)) {
1685 LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilOp", zpass, "zpass");
1686 return error::kNoError;
1687 }
1688 if (state_.stencil_front_fail_op != fail ||
1689 state_.stencil_front_z_fail_op != zfail ||
1690 state_.stencil_front_z_pass_op != zpass ||
1691 state_.stencil_back_fail_op != fail ||
1692 state_.stencil_back_z_fail_op != zfail ||
1693 state_.stencil_back_z_pass_op != zpass) {
1694 state_.stencil_front_fail_op = fail;
1695 state_.stencil_front_z_fail_op = zfail;
1696 state_.stencil_front_z_pass_op = zpass;
1697 state_.stencil_back_fail_op = fail;
1698 state_.stencil_back_z_fail_op = zfail;
1699 state_.stencil_back_z_pass_op = zpass;
1700 glStencilOp(fail, zfail, zpass);
1701 }
1702 return error::kNoError;
1703 }
1704
HandleStencilOpSeparate(uint32 immediate_data_size,const gles2::cmds::StencilOpSeparate & c)1705 error::Error GLES2DecoderImpl::HandleStencilOpSeparate(
1706 uint32 immediate_data_size, const gles2::cmds::StencilOpSeparate& c) {
1707 GLenum face = static_cast<GLenum>(c.face);
1708 GLenum fail = static_cast<GLenum>(c.fail);
1709 GLenum zfail = static_cast<GLenum>(c.zfail);
1710 GLenum zpass = static_cast<GLenum>(c.zpass);
1711 if (!validators_->face_type.IsValid(face)) {
1712 LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilOpSeparate", face, "face");
1713 return error::kNoError;
1714 }
1715 if (!validators_->stencil_op.IsValid(fail)) {
1716 LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilOpSeparate", fail, "fail");
1717 return error::kNoError;
1718 }
1719 if (!validators_->stencil_op.IsValid(zfail)) {
1720 LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilOpSeparate", zfail, "zfail");
1721 return error::kNoError;
1722 }
1723 if (!validators_->stencil_op.IsValid(zpass)) {
1724 LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilOpSeparate", zpass, "zpass");
1725 return error::kNoError;
1726 }
1727 bool changed = false;
1728 if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
1729 changed |= state_.stencil_front_fail_op != fail ||
1730 state_.stencil_front_z_fail_op != zfail ||
1731 state_.stencil_front_z_pass_op != zpass;
1732 }
1733 if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
1734 changed |= state_.stencil_back_fail_op != fail ||
1735 state_.stencil_back_z_fail_op != zfail ||
1736 state_.stencil_back_z_pass_op != zpass;
1737 }
1738 if (changed) {
1739 if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
1740 state_.stencil_front_fail_op = fail;
1741 state_.stencil_front_z_fail_op = zfail;
1742 state_.stencil_front_z_pass_op = zpass;
1743 }
1744 if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
1745 state_.stencil_back_fail_op = fail;
1746 state_.stencil_back_z_fail_op = zfail;
1747 state_.stencil_back_z_pass_op = zpass;
1748 }
1749 glStencilOpSeparate(face, fail, zfail, zpass);
1750 }
1751 return error::kNoError;
1752 }
1753
HandleTexParameterf(uint32 immediate_data_size,const gles2::cmds::TexParameterf & c)1754 error::Error GLES2DecoderImpl::HandleTexParameterf(
1755 uint32 immediate_data_size, const gles2::cmds::TexParameterf& c) {
1756 GLenum target = static_cast<GLenum>(c.target);
1757 GLenum pname = static_cast<GLenum>(c.pname);
1758 GLfloat param = static_cast<GLfloat>(c.param);
1759 if (!validators_->texture_bind_target.IsValid(target)) {
1760 LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameterf", target, "target");
1761 return error::kNoError;
1762 }
1763 if (!validators_->texture_parameter.IsValid(pname)) {
1764 LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameterf", pname, "pname");
1765 return error::kNoError;
1766 }
1767 DoTexParameterf(target, pname, param);
1768 return error::kNoError;
1769 }
1770
HandleTexParameterfv(uint32 immediate_data_size,const gles2::cmds::TexParameterfv & c)1771 error::Error GLES2DecoderImpl::HandleTexParameterfv(
1772 uint32 immediate_data_size, const gles2::cmds::TexParameterfv& c) {
1773 GLenum target = static_cast<GLenum>(c.target);
1774 GLenum pname = static_cast<GLenum>(c.pname);
1775 uint32 data_size;
1776 if (!ComputeDataSize(1, sizeof(GLfloat), 1, &data_size)) {
1777 return error::kOutOfBounds;
1778 }
1779 const GLfloat* params = GetSharedMemoryAs<const GLfloat*>(
1780 c.params_shm_id, c.params_shm_offset, data_size);
1781 if (!validators_->texture_bind_target.IsValid(target)) {
1782 LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameterfv", target, "target");
1783 return error::kNoError;
1784 }
1785 if (!validators_->texture_parameter.IsValid(pname)) {
1786 LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameterfv", pname, "pname");
1787 return error::kNoError;
1788 }
1789 if (params == NULL) {
1790 return error::kOutOfBounds;
1791 }
1792 DoTexParameterfv(target, pname, params);
1793 return error::kNoError;
1794 }
1795
HandleTexParameterfvImmediate(uint32 immediate_data_size,const gles2::cmds::TexParameterfvImmediate & c)1796 error::Error GLES2DecoderImpl::HandleTexParameterfvImmediate(
1797 uint32 immediate_data_size,
1798 const gles2::cmds::TexParameterfvImmediate& c) {
1799 GLenum target = static_cast<GLenum>(c.target);
1800 GLenum pname = static_cast<GLenum>(c.pname);
1801 uint32 data_size;
1802 if (!ComputeDataSize(1, sizeof(GLfloat), 1, &data_size)) {
1803 return error::kOutOfBounds;
1804 }
1805 if (data_size > immediate_data_size) {
1806 return error::kOutOfBounds;
1807 }
1808 const GLfloat* params = GetImmediateDataAs<const GLfloat*>(
1809 c, data_size, immediate_data_size);
1810 if (!validators_->texture_bind_target.IsValid(target)) {
1811 LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameterfv", target, "target");
1812 return error::kNoError;
1813 }
1814 if (!validators_->texture_parameter.IsValid(pname)) {
1815 LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameterfv", pname, "pname");
1816 return error::kNoError;
1817 }
1818 if (params == NULL) {
1819 return error::kOutOfBounds;
1820 }
1821 DoTexParameterfv(target, pname, params);
1822 return error::kNoError;
1823 }
1824
HandleTexParameteri(uint32 immediate_data_size,const gles2::cmds::TexParameteri & c)1825 error::Error GLES2DecoderImpl::HandleTexParameteri(
1826 uint32 immediate_data_size, const gles2::cmds::TexParameteri& c) {
1827 GLenum target = static_cast<GLenum>(c.target);
1828 GLenum pname = static_cast<GLenum>(c.pname);
1829 GLint param = static_cast<GLint>(c.param);
1830 if (!validators_->texture_bind_target.IsValid(target)) {
1831 LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameteri", target, "target");
1832 return error::kNoError;
1833 }
1834 if (!validators_->texture_parameter.IsValid(pname)) {
1835 LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameteri", pname, "pname");
1836 return error::kNoError;
1837 }
1838 DoTexParameteri(target, pname, param);
1839 return error::kNoError;
1840 }
1841
HandleTexParameteriv(uint32 immediate_data_size,const gles2::cmds::TexParameteriv & c)1842 error::Error GLES2DecoderImpl::HandleTexParameteriv(
1843 uint32 immediate_data_size, const gles2::cmds::TexParameteriv& c) {
1844 GLenum target = static_cast<GLenum>(c.target);
1845 GLenum pname = static_cast<GLenum>(c.pname);
1846 uint32 data_size;
1847 if (!ComputeDataSize(1, sizeof(GLint), 1, &data_size)) {
1848 return error::kOutOfBounds;
1849 }
1850 const GLint* params = GetSharedMemoryAs<const GLint*>(
1851 c.params_shm_id, c.params_shm_offset, data_size);
1852 if (!validators_->texture_bind_target.IsValid(target)) {
1853 LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameteriv", target, "target");
1854 return error::kNoError;
1855 }
1856 if (!validators_->texture_parameter.IsValid(pname)) {
1857 LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameteriv", pname, "pname");
1858 return error::kNoError;
1859 }
1860 if (params == NULL) {
1861 return error::kOutOfBounds;
1862 }
1863 DoTexParameteriv(target, pname, params);
1864 return error::kNoError;
1865 }
1866
HandleTexParameterivImmediate(uint32 immediate_data_size,const gles2::cmds::TexParameterivImmediate & c)1867 error::Error GLES2DecoderImpl::HandleTexParameterivImmediate(
1868 uint32 immediate_data_size,
1869 const gles2::cmds::TexParameterivImmediate& c) {
1870 GLenum target = static_cast<GLenum>(c.target);
1871 GLenum pname = static_cast<GLenum>(c.pname);
1872 uint32 data_size;
1873 if (!ComputeDataSize(1, sizeof(GLint), 1, &data_size)) {
1874 return error::kOutOfBounds;
1875 }
1876 if (data_size > immediate_data_size) {
1877 return error::kOutOfBounds;
1878 }
1879 const GLint* params = GetImmediateDataAs<const GLint*>(
1880 c, data_size, immediate_data_size);
1881 if (!validators_->texture_bind_target.IsValid(target)) {
1882 LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameteriv", target, "target");
1883 return error::kNoError;
1884 }
1885 if (!validators_->texture_parameter.IsValid(pname)) {
1886 LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameteriv", pname, "pname");
1887 return error::kNoError;
1888 }
1889 if (params == NULL) {
1890 return error::kOutOfBounds;
1891 }
1892 DoTexParameteriv(target, pname, params);
1893 return error::kNoError;
1894 }
1895
HandleUniform1f(uint32 immediate_data_size,const gles2::cmds::Uniform1f & c)1896 error::Error GLES2DecoderImpl::HandleUniform1f(
1897 uint32 immediate_data_size, const gles2::cmds::Uniform1f& c) {
1898 GLint location = static_cast<GLint>(c.location);
1899 GLfloat x = static_cast<GLfloat>(c.x);
1900 GLfloat temp[1] = { x, };
1901 DoUniform1fv(location, 1, &temp[0]);
1902 return error::kNoError;
1903 }
1904
HandleUniform1fv(uint32 immediate_data_size,const gles2::cmds::Uniform1fv & c)1905 error::Error GLES2DecoderImpl::HandleUniform1fv(
1906 uint32 immediate_data_size, const gles2::cmds::Uniform1fv& c) {
1907 GLint location = static_cast<GLint>(c.location);
1908 GLsizei count = static_cast<GLsizei>(c.count);
1909 uint32 data_size;
1910 if (!ComputeDataSize(count, sizeof(GLfloat), 1, &data_size)) {
1911 return error::kOutOfBounds;
1912 }
1913 const GLfloat* v = GetSharedMemoryAs<const GLfloat*>(
1914 c.v_shm_id, c.v_shm_offset, data_size);
1915 if (v == NULL) {
1916 return error::kOutOfBounds;
1917 }
1918 DoUniform1fv(location, count, v);
1919 return error::kNoError;
1920 }
1921
HandleUniform1fvImmediate(uint32 immediate_data_size,const gles2::cmds::Uniform1fvImmediate & c)1922 error::Error GLES2DecoderImpl::HandleUniform1fvImmediate(
1923 uint32 immediate_data_size, const gles2::cmds::Uniform1fvImmediate& c) {
1924 GLint location = static_cast<GLint>(c.location);
1925 GLsizei count = static_cast<GLsizei>(c.count);
1926 uint32 data_size;
1927 if (!ComputeDataSize(count, sizeof(GLfloat), 1, &data_size)) {
1928 return error::kOutOfBounds;
1929 }
1930 if (data_size > immediate_data_size) {
1931 return error::kOutOfBounds;
1932 }
1933 const GLfloat* v = GetImmediateDataAs<const GLfloat*>(
1934 c, data_size, immediate_data_size);
1935 if (v == NULL) {
1936 return error::kOutOfBounds;
1937 }
1938 DoUniform1fv(location, count, v);
1939 return error::kNoError;
1940 }
1941
HandleUniform1i(uint32 immediate_data_size,const gles2::cmds::Uniform1i & c)1942 error::Error GLES2DecoderImpl::HandleUniform1i(
1943 uint32 immediate_data_size, const gles2::cmds::Uniform1i& c) {
1944 GLint location = static_cast<GLint>(c.location);
1945 GLint x = static_cast<GLint>(c.x);
1946 DoUniform1i(location, x);
1947 return error::kNoError;
1948 }
1949
HandleUniform1iv(uint32 immediate_data_size,const gles2::cmds::Uniform1iv & c)1950 error::Error GLES2DecoderImpl::HandleUniform1iv(
1951 uint32 immediate_data_size, const gles2::cmds::Uniform1iv& c) {
1952 GLint location = static_cast<GLint>(c.location);
1953 GLsizei count = static_cast<GLsizei>(c.count);
1954 uint32 data_size;
1955 if (!ComputeDataSize(count, sizeof(GLint), 1, &data_size)) {
1956 return error::kOutOfBounds;
1957 }
1958 const GLint* v = GetSharedMemoryAs<const GLint*>(
1959 c.v_shm_id, c.v_shm_offset, data_size);
1960 if (v == NULL) {
1961 return error::kOutOfBounds;
1962 }
1963 DoUniform1iv(location, count, v);
1964 return error::kNoError;
1965 }
1966
HandleUniform1ivImmediate(uint32 immediate_data_size,const gles2::cmds::Uniform1ivImmediate & c)1967 error::Error GLES2DecoderImpl::HandleUniform1ivImmediate(
1968 uint32 immediate_data_size, const gles2::cmds::Uniform1ivImmediate& c) {
1969 GLint location = static_cast<GLint>(c.location);
1970 GLsizei count = static_cast<GLsizei>(c.count);
1971 uint32 data_size;
1972 if (!ComputeDataSize(count, sizeof(GLint), 1, &data_size)) {
1973 return error::kOutOfBounds;
1974 }
1975 if (data_size > immediate_data_size) {
1976 return error::kOutOfBounds;
1977 }
1978 const GLint* v = GetImmediateDataAs<const GLint*>(
1979 c, data_size, immediate_data_size);
1980 if (v == NULL) {
1981 return error::kOutOfBounds;
1982 }
1983 DoUniform1iv(location, count, v);
1984 return error::kNoError;
1985 }
1986
HandleUniform2f(uint32 immediate_data_size,const gles2::cmds::Uniform2f & c)1987 error::Error GLES2DecoderImpl::HandleUniform2f(
1988 uint32 immediate_data_size, const gles2::cmds::Uniform2f& c) {
1989 GLint location = static_cast<GLint>(c.location);
1990 GLfloat x = static_cast<GLfloat>(c.x);
1991 GLfloat y = static_cast<GLfloat>(c.y);
1992 GLfloat temp[2] = { x, y, };
1993 DoUniform2fv(location, 1, &temp[0]);
1994 return error::kNoError;
1995 }
1996
HandleUniform2fv(uint32 immediate_data_size,const gles2::cmds::Uniform2fv & c)1997 error::Error GLES2DecoderImpl::HandleUniform2fv(
1998 uint32 immediate_data_size, const gles2::cmds::Uniform2fv& c) {
1999 GLint location = static_cast<GLint>(c.location);
2000 GLsizei count = static_cast<GLsizei>(c.count);
2001 uint32 data_size;
2002 if (!ComputeDataSize(count, sizeof(GLfloat), 2, &data_size)) {
2003 return error::kOutOfBounds;
2004 }
2005 const GLfloat* v = GetSharedMemoryAs<const GLfloat*>(
2006 c.v_shm_id, c.v_shm_offset, data_size);
2007 if (v == NULL) {
2008 return error::kOutOfBounds;
2009 }
2010 DoUniform2fv(location, count, v);
2011 return error::kNoError;
2012 }
2013
HandleUniform2fvImmediate(uint32 immediate_data_size,const gles2::cmds::Uniform2fvImmediate & c)2014 error::Error GLES2DecoderImpl::HandleUniform2fvImmediate(
2015 uint32 immediate_data_size, const gles2::cmds::Uniform2fvImmediate& c) {
2016 GLint location = static_cast<GLint>(c.location);
2017 GLsizei count = static_cast<GLsizei>(c.count);
2018 uint32 data_size;
2019 if (!ComputeDataSize(count, sizeof(GLfloat), 2, &data_size)) {
2020 return error::kOutOfBounds;
2021 }
2022 if (data_size > immediate_data_size) {
2023 return error::kOutOfBounds;
2024 }
2025 const GLfloat* v = GetImmediateDataAs<const GLfloat*>(
2026 c, data_size, immediate_data_size);
2027 if (v == NULL) {
2028 return error::kOutOfBounds;
2029 }
2030 DoUniform2fv(location, count, v);
2031 return error::kNoError;
2032 }
2033
HandleUniform2i(uint32 immediate_data_size,const gles2::cmds::Uniform2i & c)2034 error::Error GLES2DecoderImpl::HandleUniform2i(
2035 uint32 immediate_data_size, const gles2::cmds::Uniform2i& c) {
2036 GLint location = static_cast<GLint>(c.location);
2037 GLint x = static_cast<GLint>(c.x);
2038 GLint y = static_cast<GLint>(c.y);
2039 GLint temp[2] = { x, y, };
2040 DoUniform2iv(location, 1, &temp[0]);
2041 return error::kNoError;
2042 }
2043
HandleUniform2iv(uint32 immediate_data_size,const gles2::cmds::Uniform2iv & c)2044 error::Error GLES2DecoderImpl::HandleUniform2iv(
2045 uint32 immediate_data_size, const gles2::cmds::Uniform2iv& c) {
2046 GLint location = static_cast<GLint>(c.location);
2047 GLsizei count = static_cast<GLsizei>(c.count);
2048 uint32 data_size;
2049 if (!ComputeDataSize(count, sizeof(GLint), 2, &data_size)) {
2050 return error::kOutOfBounds;
2051 }
2052 const GLint* v = GetSharedMemoryAs<const GLint*>(
2053 c.v_shm_id, c.v_shm_offset, data_size);
2054 if (v == NULL) {
2055 return error::kOutOfBounds;
2056 }
2057 DoUniform2iv(location, count, v);
2058 return error::kNoError;
2059 }
2060
HandleUniform2ivImmediate(uint32 immediate_data_size,const gles2::cmds::Uniform2ivImmediate & c)2061 error::Error GLES2DecoderImpl::HandleUniform2ivImmediate(
2062 uint32 immediate_data_size, const gles2::cmds::Uniform2ivImmediate& c) {
2063 GLint location = static_cast<GLint>(c.location);
2064 GLsizei count = static_cast<GLsizei>(c.count);
2065 uint32 data_size;
2066 if (!ComputeDataSize(count, sizeof(GLint), 2, &data_size)) {
2067 return error::kOutOfBounds;
2068 }
2069 if (data_size > immediate_data_size) {
2070 return error::kOutOfBounds;
2071 }
2072 const GLint* v = GetImmediateDataAs<const GLint*>(
2073 c, data_size, immediate_data_size);
2074 if (v == NULL) {
2075 return error::kOutOfBounds;
2076 }
2077 DoUniform2iv(location, count, v);
2078 return error::kNoError;
2079 }
2080
HandleUniform3f(uint32 immediate_data_size,const gles2::cmds::Uniform3f & c)2081 error::Error GLES2DecoderImpl::HandleUniform3f(
2082 uint32 immediate_data_size, const gles2::cmds::Uniform3f& c) {
2083 GLint location = static_cast<GLint>(c.location);
2084 GLfloat x = static_cast<GLfloat>(c.x);
2085 GLfloat y = static_cast<GLfloat>(c.y);
2086 GLfloat z = static_cast<GLfloat>(c.z);
2087 GLfloat temp[3] = { x, y, z, };
2088 DoUniform3fv(location, 1, &temp[0]);
2089 return error::kNoError;
2090 }
2091
HandleUniform3fv(uint32 immediate_data_size,const gles2::cmds::Uniform3fv & c)2092 error::Error GLES2DecoderImpl::HandleUniform3fv(
2093 uint32 immediate_data_size, const gles2::cmds::Uniform3fv& c) {
2094 GLint location = static_cast<GLint>(c.location);
2095 GLsizei count = static_cast<GLsizei>(c.count);
2096 uint32 data_size;
2097 if (!ComputeDataSize(count, sizeof(GLfloat), 3, &data_size)) {
2098 return error::kOutOfBounds;
2099 }
2100 const GLfloat* v = GetSharedMemoryAs<const GLfloat*>(
2101 c.v_shm_id, c.v_shm_offset, data_size);
2102 if (v == NULL) {
2103 return error::kOutOfBounds;
2104 }
2105 DoUniform3fv(location, count, v);
2106 return error::kNoError;
2107 }
2108
HandleUniform3fvImmediate(uint32 immediate_data_size,const gles2::cmds::Uniform3fvImmediate & c)2109 error::Error GLES2DecoderImpl::HandleUniform3fvImmediate(
2110 uint32 immediate_data_size, const gles2::cmds::Uniform3fvImmediate& c) {
2111 GLint location = static_cast<GLint>(c.location);
2112 GLsizei count = static_cast<GLsizei>(c.count);
2113 uint32 data_size;
2114 if (!ComputeDataSize(count, sizeof(GLfloat), 3, &data_size)) {
2115 return error::kOutOfBounds;
2116 }
2117 if (data_size > immediate_data_size) {
2118 return error::kOutOfBounds;
2119 }
2120 const GLfloat* v = GetImmediateDataAs<const GLfloat*>(
2121 c, data_size, immediate_data_size);
2122 if (v == NULL) {
2123 return error::kOutOfBounds;
2124 }
2125 DoUniform3fv(location, count, v);
2126 return error::kNoError;
2127 }
2128
HandleUniform3i(uint32 immediate_data_size,const gles2::cmds::Uniform3i & c)2129 error::Error GLES2DecoderImpl::HandleUniform3i(
2130 uint32 immediate_data_size, const gles2::cmds::Uniform3i& c) {
2131 GLint location = static_cast<GLint>(c.location);
2132 GLint x = static_cast<GLint>(c.x);
2133 GLint y = static_cast<GLint>(c.y);
2134 GLint z = static_cast<GLint>(c.z);
2135 GLint temp[3] = { x, y, z, };
2136 DoUniform3iv(location, 1, &temp[0]);
2137 return error::kNoError;
2138 }
2139
HandleUniform3iv(uint32 immediate_data_size,const gles2::cmds::Uniform3iv & c)2140 error::Error GLES2DecoderImpl::HandleUniform3iv(
2141 uint32 immediate_data_size, const gles2::cmds::Uniform3iv& c) {
2142 GLint location = static_cast<GLint>(c.location);
2143 GLsizei count = static_cast<GLsizei>(c.count);
2144 uint32 data_size;
2145 if (!ComputeDataSize(count, sizeof(GLint), 3, &data_size)) {
2146 return error::kOutOfBounds;
2147 }
2148 const GLint* v = GetSharedMemoryAs<const GLint*>(
2149 c.v_shm_id, c.v_shm_offset, data_size);
2150 if (v == NULL) {
2151 return error::kOutOfBounds;
2152 }
2153 DoUniform3iv(location, count, v);
2154 return error::kNoError;
2155 }
2156
HandleUniform3ivImmediate(uint32 immediate_data_size,const gles2::cmds::Uniform3ivImmediate & c)2157 error::Error GLES2DecoderImpl::HandleUniform3ivImmediate(
2158 uint32 immediate_data_size, const gles2::cmds::Uniform3ivImmediate& c) {
2159 GLint location = static_cast<GLint>(c.location);
2160 GLsizei count = static_cast<GLsizei>(c.count);
2161 uint32 data_size;
2162 if (!ComputeDataSize(count, sizeof(GLint), 3, &data_size)) {
2163 return error::kOutOfBounds;
2164 }
2165 if (data_size > immediate_data_size) {
2166 return error::kOutOfBounds;
2167 }
2168 const GLint* v = GetImmediateDataAs<const GLint*>(
2169 c, data_size, immediate_data_size);
2170 if (v == NULL) {
2171 return error::kOutOfBounds;
2172 }
2173 DoUniform3iv(location, count, v);
2174 return error::kNoError;
2175 }
2176
HandleUniform4f(uint32 immediate_data_size,const gles2::cmds::Uniform4f & c)2177 error::Error GLES2DecoderImpl::HandleUniform4f(
2178 uint32 immediate_data_size, const gles2::cmds::Uniform4f& c) {
2179 GLint location = static_cast<GLint>(c.location);
2180 GLfloat x = static_cast<GLfloat>(c.x);
2181 GLfloat y = static_cast<GLfloat>(c.y);
2182 GLfloat z = static_cast<GLfloat>(c.z);
2183 GLfloat w = static_cast<GLfloat>(c.w);
2184 GLfloat temp[4] = { x, y, z, w, };
2185 DoUniform4fv(location, 1, &temp[0]);
2186 return error::kNoError;
2187 }
2188
HandleUniform4fv(uint32 immediate_data_size,const gles2::cmds::Uniform4fv & c)2189 error::Error GLES2DecoderImpl::HandleUniform4fv(
2190 uint32 immediate_data_size, const gles2::cmds::Uniform4fv& c) {
2191 GLint location = static_cast<GLint>(c.location);
2192 GLsizei count = static_cast<GLsizei>(c.count);
2193 uint32 data_size;
2194 if (!ComputeDataSize(count, sizeof(GLfloat), 4, &data_size)) {
2195 return error::kOutOfBounds;
2196 }
2197 const GLfloat* v = GetSharedMemoryAs<const GLfloat*>(
2198 c.v_shm_id, c.v_shm_offset, data_size);
2199 if (v == NULL) {
2200 return error::kOutOfBounds;
2201 }
2202 DoUniform4fv(location, count, v);
2203 return error::kNoError;
2204 }
2205
HandleUniform4fvImmediate(uint32 immediate_data_size,const gles2::cmds::Uniform4fvImmediate & c)2206 error::Error GLES2DecoderImpl::HandleUniform4fvImmediate(
2207 uint32 immediate_data_size, const gles2::cmds::Uniform4fvImmediate& c) {
2208 GLint location = static_cast<GLint>(c.location);
2209 GLsizei count = static_cast<GLsizei>(c.count);
2210 uint32 data_size;
2211 if (!ComputeDataSize(count, sizeof(GLfloat), 4, &data_size)) {
2212 return error::kOutOfBounds;
2213 }
2214 if (data_size > immediate_data_size) {
2215 return error::kOutOfBounds;
2216 }
2217 const GLfloat* v = GetImmediateDataAs<const GLfloat*>(
2218 c, data_size, immediate_data_size);
2219 if (v == NULL) {
2220 return error::kOutOfBounds;
2221 }
2222 DoUniform4fv(location, count, v);
2223 return error::kNoError;
2224 }
2225
HandleUniform4i(uint32 immediate_data_size,const gles2::cmds::Uniform4i & c)2226 error::Error GLES2DecoderImpl::HandleUniform4i(
2227 uint32 immediate_data_size, const gles2::cmds::Uniform4i& c) {
2228 GLint location = static_cast<GLint>(c.location);
2229 GLint x = static_cast<GLint>(c.x);
2230 GLint y = static_cast<GLint>(c.y);
2231 GLint z = static_cast<GLint>(c.z);
2232 GLint w = static_cast<GLint>(c.w);
2233 GLint temp[4] = { x, y, z, w, };
2234 DoUniform4iv(location, 1, &temp[0]);
2235 return error::kNoError;
2236 }
2237
HandleUniform4iv(uint32 immediate_data_size,const gles2::cmds::Uniform4iv & c)2238 error::Error GLES2DecoderImpl::HandleUniform4iv(
2239 uint32 immediate_data_size, const gles2::cmds::Uniform4iv& c) {
2240 GLint location = static_cast<GLint>(c.location);
2241 GLsizei count = static_cast<GLsizei>(c.count);
2242 uint32 data_size;
2243 if (!ComputeDataSize(count, sizeof(GLint), 4, &data_size)) {
2244 return error::kOutOfBounds;
2245 }
2246 const GLint* v = GetSharedMemoryAs<const GLint*>(
2247 c.v_shm_id, c.v_shm_offset, data_size);
2248 if (v == NULL) {
2249 return error::kOutOfBounds;
2250 }
2251 DoUniform4iv(location, count, v);
2252 return error::kNoError;
2253 }
2254
HandleUniform4ivImmediate(uint32 immediate_data_size,const gles2::cmds::Uniform4ivImmediate & c)2255 error::Error GLES2DecoderImpl::HandleUniform4ivImmediate(
2256 uint32 immediate_data_size, const gles2::cmds::Uniform4ivImmediate& c) {
2257 GLint location = static_cast<GLint>(c.location);
2258 GLsizei count = static_cast<GLsizei>(c.count);
2259 uint32 data_size;
2260 if (!ComputeDataSize(count, sizeof(GLint), 4, &data_size)) {
2261 return error::kOutOfBounds;
2262 }
2263 if (data_size > immediate_data_size) {
2264 return error::kOutOfBounds;
2265 }
2266 const GLint* v = GetImmediateDataAs<const GLint*>(
2267 c, data_size, immediate_data_size);
2268 if (v == NULL) {
2269 return error::kOutOfBounds;
2270 }
2271 DoUniform4iv(location, count, v);
2272 return error::kNoError;
2273 }
2274
HandleUniformMatrix2fv(uint32 immediate_data_size,const gles2::cmds::UniformMatrix2fv & c)2275 error::Error GLES2DecoderImpl::HandleUniformMatrix2fv(
2276 uint32 immediate_data_size, const gles2::cmds::UniformMatrix2fv& c) {
2277 GLint location = static_cast<GLint>(c.location);
2278 GLsizei count = static_cast<GLsizei>(c.count);
2279 GLboolean transpose = static_cast<GLboolean>(c.transpose);
2280 uint32 data_size;
2281 if (!ComputeDataSize(count, sizeof(GLfloat), 4, &data_size)) {
2282 return error::kOutOfBounds;
2283 }
2284 const GLfloat* value = GetSharedMemoryAs<const GLfloat*>(
2285 c.value_shm_id, c.value_shm_offset, data_size);
2286 if (!validators_->false_only.IsValid(transpose)) {
2287 LOCAL_SET_GL_ERROR(
2288 GL_INVALID_VALUE, "glUniformMatrix2fv", "transpose GL_INVALID_VALUE");
2289 return error::kNoError;
2290 }
2291 if (value == NULL) {
2292 return error::kOutOfBounds;
2293 }
2294 DoUniformMatrix2fv(location, count, transpose, value);
2295 return error::kNoError;
2296 }
2297
HandleUniformMatrix2fvImmediate(uint32 immediate_data_size,const gles2::cmds::UniformMatrix2fvImmediate & c)2298 error::Error GLES2DecoderImpl::HandleUniformMatrix2fvImmediate(
2299 uint32 immediate_data_size,
2300 const gles2::cmds::UniformMatrix2fvImmediate& c) {
2301 GLint location = static_cast<GLint>(c.location);
2302 GLsizei count = static_cast<GLsizei>(c.count);
2303 GLboolean transpose = static_cast<GLboolean>(c.transpose);
2304 uint32 data_size;
2305 if (!ComputeDataSize(count, sizeof(GLfloat), 4, &data_size)) {
2306 return error::kOutOfBounds;
2307 }
2308 if (data_size > immediate_data_size) {
2309 return error::kOutOfBounds;
2310 }
2311 const GLfloat* value = GetImmediateDataAs<const GLfloat*>(
2312 c, data_size, immediate_data_size);
2313 if (!validators_->false_only.IsValid(transpose)) {
2314 LOCAL_SET_GL_ERROR(
2315 GL_INVALID_VALUE, "glUniformMatrix2fv", "transpose GL_INVALID_VALUE");
2316 return error::kNoError;
2317 }
2318 if (value == NULL) {
2319 return error::kOutOfBounds;
2320 }
2321 DoUniformMatrix2fv(location, count, transpose, value);
2322 return error::kNoError;
2323 }
2324
HandleUniformMatrix3fv(uint32 immediate_data_size,const gles2::cmds::UniformMatrix3fv & c)2325 error::Error GLES2DecoderImpl::HandleUniformMatrix3fv(
2326 uint32 immediate_data_size, const gles2::cmds::UniformMatrix3fv& c) {
2327 GLint location = static_cast<GLint>(c.location);
2328 GLsizei count = static_cast<GLsizei>(c.count);
2329 GLboolean transpose = static_cast<GLboolean>(c.transpose);
2330 uint32 data_size;
2331 if (!ComputeDataSize(count, sizeof(GLfloat), 9, &data_size)) {
2332 return error::kOutOfBounds;
2333 }
2334 const GLfloat* value = GetSharedMemoryAs<const GLfloat*>(
2335 c.value_shm_id, c.value_shm_offset, data_size);
2336 if (!validators_->false_only.IsValid(transpose)) {
2337 LOCAL_SET_GL_ERROR(
2338 GL_INVALID_VALUE, "glUniformMatrix3fv", "transpose GL_INVALID_VALUE");
2339 return error::kNoError;
2340 }
2341 if (value == NULL) {
2342 return error::kOutOfBounds;
2343 }
2344 DoUniformMatrix3fv(location, count, transpose, value);
2345 return error::kNoError;
2346 }
2347
HandleUniformMatrix3fvImmediate(uint32 immediate_data_size,const gles2::cmds::UniformMatrix3fvImmediate & c)2348 error::Error GLES2DecoderImpl::HandleUniformMatrix3fvImmediate(
2349 uint32 immediate_data_size,
2350 const gles2::cmds::UniformMatrix3fvImmediate& c) {
2351 GLint location = static_cast<GLint>(c.location);
2352 GLsizei count = static_cast<GLsizei>(c.count);
2353 GLboolean transpose = static_cast<GLboolean>(c.transpose);
2354 uint32 data_size;
2355 if (!ComputeDataSize(count, sizeof(GLfloat), 9, &data_size)) {
2356 return error::kOutOfBounds;
2357 }
2358 if (data_size > immediate_data_size) {
2359 return error::kOutOfBounds;
2360 }
2361 const GLfloat* value = GetImmediateDataAs<const GLfloat*>(
2362 c, data_size, immediate_data_size);
2363 if (!validators_->false_only.IsValid(transpose)) {
2364 LOCAL_SET_GL_ERROR(
2365 GL_INVALID_VALUE, "glUniformMatrix3fv", "transpose GL_INVALID_VALUE");
2366 return error::kNoError;
2367 }
2368 if (value == NULL) {
2369 return error::kOutOfBounds;
2370 }
2371 DoUniformMatrix3fv(location, count, transpose, value);
2372 return error::kNoError;
2373 }
2374
HandleUniformMatrix4fv(uint32 immediate_data_size,const gles2::cmds::UniformMatrix4fv & c)2375 error::Error GLES2DecoderImpl::HandleUniformMatrix4fv(
2376 uint32 immediate_data_size, const gles2::cmds::UniformMatrix4fv& c) {
2377 GLint location = static_cast<GLint>(c.location);
2378 GLsizei count = static_cast<GLsizei>(c.count);
2379 GLboolean transpose = static_cast<GLboolean>(c.transpose);
2380 uint32 data_size;
2381 if (!ComputeDataSize(count, sizeof(GLfloat), 16, &data_size)) {
2382 return error::kOutOfBounds;
2383 }
2384 const GLfloat* value = GetSharedMemoryAs<const GLfloat*>(
2385 c.value_shm_id, c.value_shm_offset, data_size);
2386 if (!validators_->false_only.IsValid(transpose)) {
2387 LOCAL_SET_GL_ERROR(
2388 GL_INVALID_VALUE, "glUniformMatrix4fv", "transpose GL_INVALID_VALUE");
2389 return error::kNoError;
2390 }
2391 if (value == NULL) {
2392 return error::kOutOfBounds;
2393 }
2394 DoUniformMatrix4fv(location, count, transpose, value);
2395 return error::kNoError;
2396 }
2397
HandleUniformMatrix4fvImmediate(uint32 immediate_data_size,const gles2::cmds::UniformMatrix4fvImmediate & c)2398 error::Error GLES2DecoderImpl::HandleUniformMatrix4fvImmediate(
2399 uint32 immediate_data_size,
2400 const gles2::cmds::UniformMatrix4fvImmediate& c) {
2401 GLint location = static_cast<GLint>(c.location);
2402 GLsizei count = static_cast<GLsizei>(c.count);
2403 GLboolean transpose = static_cast<GLboolean>(c.transpose);
2404 uint32 data_size;
2405 if (!ComputeDataSize(count, sizeof(GLfloat), 16, &data_size)) {
2406 return error::kOutOfBounds;
2407 }
2408 if (data_size > immediate_data_size) {
2409 return error::kOutOfBounds;
2410 }
2411 const GLfloat* value = GetImmediateDataAs<const GLfloat*>(
2412 c, data_size, immediate_data_size);
2413 if (!validators_->false_only.IsValid(transpose)) {
2414 LOCAL_SET_GL_ERROR(
2415 GL_INVALID_VALUE, "glUniformMatrix4fv", "transpose GL_INVALID_VALUE");
2416 return error::kNoError;
2417 }
2418 if (value == NULL) {
2419 return error::kOutOfBounds;
2420 }
2421 DoUniformMatrix4fv(location, count, transpose, value);
2422 return error::kNoError;
2423 }
2424
HandleUseProgram(uint32 immediate_data_size,const gles2::cmds::UseProgram & c)2425 error::Error GLES2DecoderImpl::HandleUseProgram(
2426 uint32 immediate_data_size, const gles2::cmds::UseProgram& c) {
2427 GLuint program = c.program;
2428 DoUseProgram(program);
2429 return error::kNoError;
2430 }
2431
HandleValidateProgram(uint32 immediate_data_size,const gles2::cmds::ValidateProgram & c)2432 error::Error GLES2DecoderImpl::HandleValidateProgram(
2433 uint32 immediate_data_size, const gles2::cmds::ValidateProgram& c) {
2434 GLuint program = c.program;
2435 DoValidateProgram(program);
2436 return error::kNoError;
2437 }
2438
HandleVertexAttrib1f(uint32 immediate_data_size,const gles2::cmds::VertexAttrib1f & c)2439 error::Error GLES2DecoderImpl::HandleVertexAttrib1f(
2440 uint32 immediate_data_size, const gles2::cmds::VertexAttrib1f& c) {
2441 GLuint indx = static_cast<GLuint>(c.indx);
2442 GLfloat x = static_cast<GLfloat>(c.x);
2443 DoVertexAttrib1f(indx, x);
2444 return error::kNoError;
2445 }
2446
HandleVertexAttrib1fv(uint32 immediate_data_size,const gles2::cmds::VertexAttrib1fv & c)2447 error::Error GLES2DecoderImpl::HandleVertexAttrib1fv(
2448 uint32 immediate_data_size, const gles2::cmds::VertexAttrib1fv& c) {
2449 GLuint indx = static_cast<GLuint>(c.indx);
2450 uint32 data_size;
2451 if (!ComputeDataSize(1, sizeof(GLfloat), 1, &data_size)) {
2452 return error::kOutOfBounds;
2453 }
2454 const GLfloat* values = GetSharedMemoryAs<const GLfloat*>(
2455 c.values_shm_id, c.values_shm_offset, data_size);
2456 if (values == NULL) {
2457 return error::kOutOfBounds;
2458 }
2459 DoVertexAttrib1fv(indx, values);
2460 return error::kNoError;
2461 }
2462
HandleVertexAttrib1fvImmediate(uint32 immediate_data_size,const gles2::cmds::VertexAttrib1fvImmediate & c)2463 error::Error GLES2DecoderImpl::HandleVertexAttrib1fvImmediate(
2464 uint32 immediate_data_size,
2465 const gles2::cmds::VertexAttrib1fvImmediate& c) {
2466 GLuint indx = static_cast<GLuint>(c.indx);
2467 uint32 data_size;
2468 if (!ComputeDataSize(1, sizeof(GLfloat), 1, &data_size)) {
2469 return error::kOutOfBounds;
2470 }
2471 if (data_size > immediate_data_size) {
2472 return error::kOutOfBounds;
2473 }
2474 const GLfloat* values = GetImmediateDataAs<const GLfloat*>(
2475 c, data_size, immediate_data_size);
2476 if (values == NULL) {
2477 return error::kOutOfBounds;
2478 }
2479 DoVertexAttrib1fv(indx, values);
2480 return error::kNoError;
2481 }
2482
HandleVertexAttrib2f(uint32 immediate_data_size,const gles2::cmds::VertexAttrib2f & c)2483 error::Error GLES2DecoderImpl::HandleVertexAttrib2f(
2484 uint32 immediate_data_size, const gles2::cmds::VertexAttrib2f& c) {
2485 GLuint indx = static_cast<GLuint>(c.indx);
2486 GLfloat x = static_cast<GLfloat>(c.x);
2487 GLfloat y = static_cast<GLfloat>(c.y);
2488 DoVertexAttrib2f(indx, x, y);
2489 return error::kNoError;
2490 }
2491
HandleVertexAttrib2fv(uint32 immediate_data_size,const gles2::cmds::VertexAttrib2fv & c)2492 error::Error GLES2DecoderImpl::HandleVertexAttrib2fv(
2493 uint32 immediate_data_size, const gles2::cmds::VertexAttrib2fv& c) {
2494 GLuint indx = static_cast<GLuint>(c.indx);
2495 uint32 data_size;
2496 if (!ComputeDataSize(1, sizeof(GLfloat), 2, &data_size)) {
2497 return error::kOutOfBounds;
2498 }
2499 const GLfloat* values = GetSharedMemoryAs<const GLfloat*>(
2500 c.values_shm_id, c.values_shm_offset, data_size);
2501 if (values == NULL) {
2502 return error::kOutOfBounds;
2503 }
2504 DoVertexAttrib2fv(indx, values);
2505 return error::kNoError;
2506 }
2507
HandleVertexAttrib2fvImmediate(uint32 immediate_data_size,const gles2::cmds::VertexAttrib2fvImmediate & c)2508 error::Error GLES2DecoderImpl::HandleVertexAttrib2fvImmediate(
2509 uint32 immediate_data_size,
2510 const gles2::cmds::VertexAttrib2fvImmediate& c) {
2511 GLuint indx = static_cast<GLuint>(c.indx);
2512 uint32 data_size;
2513 if (!ComputeDataSize(1, sizeof(GLfloat), 2, &data_size)) {
2514 return error::kOutOfBounds;
2515 }
2516 if (data_size > immediate_data_size) {
2517 return error::kOutOfBounds;
2518 }
2519 const GLfloat* values = GetImmediateDataAs<const GLfloat*>(
2520 c, data_size, immediate_data_size);
2521 if (values == NULL) {
2522 return error::kOutOfBounds;
2523 }
2524 DoVertexAttrib2fv(indx, values);
2525 return error::kNoError;
2526 }
2527
HandleVertexAttrib3f(uint32 immediate_data_size,const gles2::cmds::VertexAttrib3f & c)2528 error::Error GLES2DecoderImpl::HandleVertexAttrib3f(
2529 uint32 immediate_data_size, const gles2::cmds::VertexAttrib3f& c) {
2530 GLuint indx = static_cast<GLuint>(c.indx);
2531 GLfloat x = static_cast<GLfloat>(c.x);
2532 GLfloat y = static_cast<GLfloat>(c.y);
2533 GLfloat z = static_cast<GLfloat>(c.z);
2534 DoVertexAttrib3f(indx, x, y, z);
2535 return error::kNoError;
2536 }
2537
HandleVertexAttrib3fv(uint32 immediate_data_size,const gles2::cmds::VertexAttrib3fv & c)2538 error::Error GLES2DecoderImpl::HandleVertexAttrib3fv(
2539 uint32 immediate_data_size, const gles2::cmds::VertexAttrib3fv& c) {
2540 GLuint indx = static_cast<GLuint>(c.indx);
2541 uint32 data_size;
2542 if (!ComputeDataSize(1, sizeof(GLfloat), 3, &data_size)) {
2543 return error::kOutOfBounds;
2544 }
2545 const GLfloat* values = GetSharedMemoryAs<const GLfloat*>(
2546 c.values_shm_id, c.values_shm_offset, data_size);
2547 if (values == NULL) {
2548 return error::kOutOfBounds;
2549 }
2550 DoVertexAttrib3fv(indx, values);
2551 return error::kNoError;
2552 }
2553
HandleVertexAttrib3fvImmediate(uint32 immediate_data_size,const gles2::cmds::VertexAttrib3fvImmediate & c)2554 error::Error GLES2DecoderImpl::HandleVertexAttrib3fvImmediate(
2555 uint32 immediate_data_size,
2556 const gles2::cmds::VertexAttrib3fvImmediate& c) {
2557 GLuint indx = static_cast<GLuint>(c.indx);
2558 uint32 data_size;
2559 if (!ComputeDataSize(1, sizeof(GLfloat), 3, &data_size)) {
2560 return error::kOutOfBounds;
2561 }
2562 if (data_size > immediate_data_size) {
2563 return error::kOutOfBounds;
2564 }
2565 const GLfloat* values = GetImmediateDataAs<const GLfloat*>(
2566 c, data_size, immediate_data_size);
2567 if (values == NULL) {
2568 return error::kOutOfBounds;
2569 }
2570 DoVertexAttrib3fv(indx, values);
2571 return error::kNoError;
2572 }
2573
HandleVertexAttrib4f(uint32 immediate_data_size,const gles2::cmds::VertexAttrib4f & c)2574 error::Error GLES2DecoderImpl::HandleVertexAttrib4f(
2575 uint32 immediate_data_size, const gles2::cmds::VertexAttrib4f& c) {
2576 GLuint indx = static_cast<GLuint>(c.indx);
2577 GLfloat x = static_cast<GLfloat>(c.x);
2578 GLfloat y = static_cast<GLfloat>(c.y);
2579 GLfloat z = static_cast<GLfloat>(c.z);
2580 GLfloat w = static_cast<GLfloat>(c.w);
2581 DoVertexAttrib4f(indx, x, y, z, w);
2582 return error::kNoError;
2583 }
2584
HandleVertexAttrib4fv(uint32 immediate_data_size,const gles2::cmds::VertexAttrib4fv & c)2585 error::Error GLES2DecoderImpl::HandleVertexAttrib4fv(
2586 uint32 immediate_data_size, const gles2::cmds::VertexAttrib4fv& c) {
2587 GLuint indx = static_cast<GLuint>(c.indx);
2588 uint32 data_size;
2589 if (!ComputeDataSize(1, sizeof(GLfloat), 4, &data_size)) {
2590 return error::kOutOfBounds;
2591 }
2592 const GLfloat* values = GetSharedMemoryAs<const GLfloat*>(
2593 c.values_shm_id, c.values_shm_offset, data_size);
2594 if (values == NULL) {
2595 return error::kOutOfBounds;
2596 }
2597 DoVertexAttrib4fv(indx, values);
2598 return error::kNoError;
2599 }
2600
HandleVertexAttrib4fvImmediate(uint32 immediate_data_size,const gles2::cmds::VertexAttrib4fvImmediate & c)2601 error::Error GLES2DecoderImpl::HandleVertexAttrib4fvImmediate(
2602 uint32 immediate_data_size,
2603 const gles2::cmds::VertexAttrib4fvImmediate& c) {
2604 GLuint indx = static_cast<GLuint>(c.indx);
2605 uint32 data_size;
2606 if (!ComputeDataSize(1, sizeof(GLfloat), 4, &data_size)) {
2607 return error::kOutOfBounds;
2608 }
2609 if (data_size > immediate_data_size) {
2610 return error::kOutOfBounds;
2611 }
2612 const GLfloat* values = GetImmediateDataAs<const GLfloat*>(
2613 c, data_size, immediate_data_size);
2614 if (values == NULL) {
2615 return error::kOutOfBounds;
2616 }
2617 DoVertexAttrib4fv(indx, values);
2618 return error::kNoError;
2619 }
2620
HandleViewport(uint32 immediate_data_size,const gles2::cmds::Viewport & c)2621 error::Error GLES2DecoderImpl::HandleViewport(
2622 uint32 immediate_data_size, const gles2::cmds::Viewport& c) {
2623 GLint x = static_cast<GLint>(c.x);
2624 GLint y = static_cast<GLint>(c.y);
2625 GLsizei width = static_cast<GLsizei>(c.width);
2626 GLsizei height = static_cast<GLsizei>(c.height);
2627 if (width < 0) {
2628 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glViewport", "width < 0");
2629 return error::kNoError;
2630 }
2631 if (height < 0) {
2632 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glViewport", "height < 0");
2633 return error::kNoError;
2634 }
2635 DoViewport(x, y, width, height);
2636 return error::kNoError;
2637 }
2638
HandleBlitFramebufferCHROMIUM(uint32 immediate_data_size,const gles2::cmds::BlitFramebufferCHROMIUM & c)2639 error::Error GLES2DecoderImpl::HandleBlitFramebufferCHROMIUM(
2640 uint32 immediate_data_size,
2641 const gles2::cmds::BlitFramebufferCHROMIUM& c) {
2642 error::Error error;
2643 error = WillAccessBoundFramebufferForDraw();
2644 if (error != error::kNoError)
2645 return error;
2646 error = WillAccessBoundFramebufferForRead();
2647 if (error != error::kNoError)
2648 return error;
2649 GLint srcX0 = static_cast<GLint>(c.srcX0);
2650 GLint srcY0 = static_cast<GLint>(c.srcY0);
2651 GLint srcX1 = static_cast<GLint>(c.srcX1);
2652 GLint srcY1 = static_cast<GLint>(c.srcY1);
2653 GLint dstX0 = static_cast<GLint>(c.dstX0);
2654 GLint dstY0 = static_cast<GLint>(c.dstY0);
2655 GLint dstX1 = static_cast<GLint>(c.dstX1);
2656 GLint dstY1 = static_cast<GLint>(c.dstY1);
2657 GLbitfield mask = static_cast<GLbitfield>(c.mask);
2658 GLenum filter = static_cast<GLenum>(c.filter);
2659 if (!validators_->blit_filter.IsValid(filter)) {
2660 LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlitFramebufferCHROMIUM", filter,
2661 "filter");
2662 return error::kNoError;
2663 }
2664 DoBlitFramebufferCHROMIUM(
2665 srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
2666 return error::kNoError;
2667 }
2668
HandleRenderbufferStorageMultisampleCHROMIUM(uint32 immediate_data_size,const gles2::cmds::RenderbufferStorageMultisampleCHROMIUM & c)2669 error::Error GLES2DecoderImpl::HandleRenderbufferStorageMultisampleCHROMIUM(
2670 uint32 immediate_data_size,
2671 const gles2::cmds::RenderbufferStorageMultisampleCHROMIUM& c) {
2672 GLenum target = static_cast<GLenum>(c.target);
2673 GLsizei samples = static_cast<GLsizei>(c.samples);
2674 GLenum internalformat = static_cast<GLenum>(c.internalformat);
2675 GLsizei width = static_cast<GLsizei>(c.width);
2676 GLsizei height = static_cast<GLsizei>(c.height);
2677 if (!validators_->render_buffer_target.IsValid(target)) {
2678 LOCAL_SET_GL_ERROR_INVALID_ENUM("glRenderbufferStorageMultisampleCHROMIUM", target, "target"); // NOLINT
2679 return error::kNoError;
2680 }
2681 if (samples < 0) {
2682 LOCAL_SET_GL_ERROR(
2683 GL_INVALID_VALUE, "glRenderbufferStorageMultisampleCHROMIUM", "samples < 0"); // NOLINT
2684 return error::kNoError;
2685 }
2686 if (!validators_->render_buffer_format.IsValid(internalformat)) {
2687 LOCAL_SET_GL_ERROR_INVALID_ENUM("glRenderbufferStorageMultisampleCHROMIUM", internalformat, "internalformat"); // NOLINT
2688 return error::kNoError;
2689 }
2690 if (width < 0) {
2691 LOCAL_SET_GL_ERROR(
2692 GL_INVALID_VALUE, "glRenderbufferStorageMultisampleCHROMIUM", "width < 0"); // NOLINT
2693 return error::kNoError;
2694 }
2695 if (height < 0) {
2696 LOCAL_SET_GL_ERROR(
2697 GL_INVALID_VALUE, "glRenderbufferStorageMultisampleCHROMIUM", "height < 0"); // NOLINT
2698 return error::kNoError;
2699 }
2700 DoRenderbufferStorageMultisampleCHROMIUM(
2701 target, samples, internalformat, width, height);
2702 return error::kNoError;
2703 }
2704
HandleRenderbufferStorageMultisampleEXT(uint32 immediate_data_size,const gles2::cmds::RenderbufferStorageMultisampleEXT & c)2705 error::Error GLES2DecoderImpl::HandleRenderbufferStorageMultisampleEXT(
2706 uint32 immediate_data_size,
2707 const gles2::cmds::RenderbufferStorageMultisampleEXT& c) {
2708 GLenum target = static_cast<GLenum>(c.target);
2709 GLsizei samples = static_cast<GLsizei>(c.samples);
2710 GLenum internalformat = static_cast<GLenum>(c.internalformat);
2711 GLsizei width = static_cast<GLsizei>(c.width);
2712 GLsizei height = static_cast<GLsizei>(c.height);
2713 if (!validators_->render_buffer_target.IsValid(target)) {
2714 LOCAL_SET_GL_ERROR_INVALID_ENUM("glRenderbufferStorageMultisampleEXT", target, "target"); // NOLINT
2715 return error::kNoError;
2716 }
2717 if (samples < 0) {
2718 LOCAL_SET_GL_ERROR(
2719 GL_INVALID_VALUE, "glRenderbufferStorageMultisampleEXT", "samples < 0");
2720 return error::kNoError;
2721 }
2722 if (!validators_->render_buffer_format.IsValid(internalformat)) {
2723 LOCAL_SET_GL_ERROR_INVALID_ENUM("glRenderbufferStorageMultisampleEXT", internalformat, "internalformat"); // NOLINT
2724 return error::kNoError;
2725 }
2726 if (width < 0) {
2727 LOCAL_SET_GL_ERROR(
2728 GL_INVALID_VALUE, "glRenderbufferStorageMultisampleEXT", "width < 0");
2729 return error::kNoError;
2730 }
2731 if (height < 0) {
2732 LOCAL_SET_GL_ERROR(
2733 GL_INVALID_VALUE, "glRenderbufferStorageMultisampleEXT", "height < 0");
2734 return error::kNoError;
2735 }
2736 DoRenderbufferStorageMultisampleEXT(
2737 target, samples, internalformat, width, height);
2738 return error::kNoError;
2739 }
2740
HandleFramebufferTexture2DMultisampleEXT(uint32 immediate_data_size,const gles2::cmds::FramebufferTexture2DMultisampleEXT & c)2741 error::Error GLES2DecoderImpl::HandleFramebufferTexture2DMultisampleEXT(
2742 uint32 immediate_data_size,
2743 const gles2::cmds::FramebufferTexture2DMultisampleEXT& c) {
2744 GLenum target = static_cast<GLenum>(c.target);
2745 GLenum attachment = static_cast<GLenum>(c.attachment);
2746 GLenum textarget = static_cast<GLenum>(c.textarget);
2747 GLuint texture = c.texture;
2748 GLint level = static_cast<GLint>(c.level);
2749 GLsizei samples = static_cast<GLsizei>(c.samples);
2750 if (!validators_->frame_buffer_target.IsValid(target)) {
2751 LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferTexture2DMultisampleEXT", target, "target"); // NOLINT
2752 return error::kNoError;
2753 }
2754 if (!validators_->attachment.IsValid(attachment)) {
2755 LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferTexture2DMultisampleEXT", attachment, "attachment"); // NOLINT
2756 return error::kNoError;
2757 }
2758 if (!validators_->texture_target.IsValid(textarget)) {
2759 LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferTexture2DMultisampleEXT", textarget, "textarget"); // NOLINT
2760 return error::kNoError;
2761 }
2762 if (!validators_->zero_only.IsValid(level)) {
2763 LOCAL_SET_GL_ERROR(
2764 GL_INVALID_VALUE, "glFramebufferTexture2DMultisampleEXT", "level GL_INVALID_VALUE"); // NOLINT
2765 return error::kNoError;
2766 }
2767 if (samples < 0) {
2768 LOCAL_SET_GL_ERROR(
2769 GL_INVALID_VALUE, "glFramebufferTexture2DMultisampleEXT", "samples < 0"); // NOLINT
2770 return error::kNoError;
2771 }
2772 DoFramebufferTexture2DMultisample(
2773 target, attachment, textarget, texture, level, samples);
2774 return error::kNoError;
2775 }
2776
HandleTexStorage2DEXT(uint32 immediate_data_size,const gles2::cmds::TexStorage2DEXT & c)2777 error::Error GLES2DecoderImpl::HandleTexStorage2DEXT(
2778 uint32 immediate_data_size, const gles2::cmds::TexStorage2DEXT& c) {
2779 GLenum target = static_cast<GLenum>(c.target);
2780 GLsizei levels = static_cast<GLsizei>(c.levels);
2781 GLenum internalFormat = static_cast<GLenum>(c.internalFormat);
2782 GLsizei width = static_cast<GLsizei>(c.width);
2783 GLsizei height = static_cast<GLsizei>(c.height);
2784 if (!validators_->texture_target.IsValid(target)) {
2785 LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexStorage2DEXT", target, "target");
2786 return error::kNoError;
2787 }
2788 if (levels < 0) {
2789 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glTexStorage2DEXT", "levels < 0");
2790 return error::kNoError;
2791 }
2792 if (!validators_->texture_internal_format_storage.IsValid(internalFormat)) {
2793 LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexStorage2DEXT", internalFormat,
2794 "internalFormat");
2795 return error::kNoError;
2796 }
2797 if (width < 0) {
2798 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glTexStorage2DEXT", "width < 0");
2799 return error::kNoError;
2800 }
2801 if (height < 0) {
2802 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glTexStorage2DEXT", "height < 0");
2803 return error::kNoError;
2804 }
2805 DoTexStorage2DEXT(target, levels, internalFormat, width, height);
2806 return error::kNoError;
2807 }
2808
HandleGenQueriesEXT(uint32 immediate_data_size,const gles2::cmds::GenQueriesEXT & c)2809 error::Error GLES2DecoderImpl::HandleGenQueriesEXT(
2810 uint32 immediate_data_size, const gles2::cmds::GenQueriesEXT& c) {
2811 GLsizei n = static_cast<GLsizei>(c.n);
2812 uint32 data_size;
2813 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
2814 return error::kOutOfBounds;
2815 }
2816 GLuint* queries = GetSharedMemoryAs<GLuint*>(
2817 c.queries_shm_id, c.queries_shm_offset, data_size);
2818 if (queries == NULL) {
2819 return error::kOutOfBounds;
2820 }
2821 if (!GenQueriesEXTHelper(n, queries)) {
2822 return error::kInvalidArguments;
2823 }
2824 return error::kNoError;
2825 }
2826
HandleGenQueriesEXTImmediate(uint32 immediate_data_size,const gles2::cmds::GenQueriesEXTImmediate & c)2827 error::Error GLES2DecoderImpl::HandleGenQueriesEXTImmediate(
2828 uint32 immediate_data_size, const gles2::cmds::GenQueriesEXTImmediate& c) {
2829 GLsizei n = static_cast<GLsizei>(c.n);
2830 uint32 data_size;
2831 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
2832 return error::kOutOfBounds;
2833 }
2834 GLuint* queries = GetImmediateDataAs<GLuint*>(
2835 c, data_size, immediate_data_size);
2836 if (queries == NULL) {
2837 return error::kOutOfBounds;
2838 }
2839 if (!GenQueriesEXTHelper(n, queries)) {
2840 return error::kInvalidArguments;
2841 }
2842 return error::kNoError;
2843 }
2844
HandleDeleteQueriesEXT(uint32 immediate_data_size,const gles2::cmds::DeleteQueriesEXT & c)2845 error::Error GLES2DecoderImpl::HandleDeleteQueriesEXT(
2846 uint32 immediate_data_size, const gles2::cmds::DeleteQueriesEXT& c) {
2847 GLsizei n = static_cast<GLsizei>(c.n);
2848 uint32 data_size;
2849 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
2850 return error::kOutOfBounds;
2851 }
2852 const GLuint* queries = GetSharedMemoryAs<const GLuint*>(
2853 c.queries_shm_id, c.queries_shm_offset, data_size);
2854 if (queries == NULL) {
2855 return error::kOutOfBounds;
2856 }
2857 DeleteQueriesEXTHelper(n, queries);
2858 return error::kNoError;
2859 }
2860
HandleDeleteQueriesEXTImmediate(uint32 immediate_data_size,const gles2::cmds::DeleteQueriesEXTImmediate & c)2861 error::Error GLES2DecoderImpl::HandleDeleteQueriesEXTImmediate(
2862 uint32 immediate_data_size,
2863 const gles2::cmds::DeleteQueriesEXTImmediate& c) {
2864 GLsizei n = static_cast<GLsizei>(c.n);
2865 uint32 data_size;
2866 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
2867 return error::kOutOfBounds;
2868 }
2869 const GLuint* queries = GetImmediateDataAs<const GLuint*>(
2870 c, data_size, immediate_data_size);
2871 if (queries == NULL) {
2872 return error::kOutOfBounds;
2873 }
2874 DeleteQueriesEXTHelper(n, queries);
2875 return error::kNoError;
2876 }
2877
HandleInsertEventMarkerEXT(uint32 immediate_data_size,const gles2::cmds::InsertEventMarkerEXT & c)2878 error::Error GLES2DecoderImpl::HandleInsertEventMarkerEXT(
2879 uint32 immediate_data_size, const gles2::cmds::InsertEventMarkerEXT& c) {
2880 GLuint bucket_id = static_cast<GLuint>(c.bucket_id);
2881 Bucket* bucket = GetBucket(bucket_id);
2882 if (!bucket || bucket->size() == 0) {
2883 return error::kInvalidArguments;
2884 }
2885 std::string str;
2886 if (!bucket->GetAsString(&str)) {
2887 return error::kInvalidArguments;
2888 }
2889 DoInsertEventMarkerEXT(0, str.c_str());
2890 return error::kNoError;
2891 }
2892
HandlePushGroupMarkerEXT(uint32 immediate_data_size,const gles2::cmds::PushGroupMarkerEXT & c)2893 error::Error GLES2DecoderImpl::HandlePushGroupMarkerEXT(
2894 uint32 immediate_data_size, const gles2::cmds::PushGroupMarkerEXT& c) {
2895 GLuint bucket_id = static_cast<GLuint>(c.bucket_id);
2896 Bucket* bucket = GetBucket(bucket_id);
2897 if (!bucket || bucket->size() == 0) {
2898 return error::kInvalidArguments;
2899 }
2900 std::string str;
2901 if (!bucket->GetAsString(&str)) {
2902 return error::kInvalidArguments;
2903 }
2904 DoPushGroupMarkerEXT(0, str.c_str());
2905 return error::kNoError;
2906 }
2907
HandlePopGroupMarkerEXT(uint32 immediate_data_size,const gles2::cmds::PopGroupMarkerEXT & c)2908 error::Error GLES2DecoderImpl::HandlePopGroupMarkerEXT(
2909 uint32 immediate_data_size, const gles2::cmds::PopGroupMarkerEXT& c) {
2910 DoPopGroupMarkerEXT();
2911 return error::kNoError;
2912 }
2913
HandleGenVertexArraysOES(uint32 immediate_data_size,const gles2::cmds::GenVertexArraysOES & c)2914 error::Error GLES2DecoderImpl::HandleGenVertexArraysOES(
2915 uint32 immediate_data_size, const gles2::cmds::GenVertexArraysOES& c) {
2916 GLsizei n = static_cast<GLsizei>(c.n);
2917 uint32 data_size;
2918 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
2919 return error::kOutOfBounds;
2920 }
2921 GLuint* arrays = GetSharedMemoryAs<GLuint*>(
2922 c.arrays_shm_id, c.arrays_shm_offset, data_size);
2923 if (arrays == NULL) {
2924 return error::kOutOfBounds;
2925 }
2926 if (!GenVertexArraysOESHelper(n, arrays)) {
2927 return error::kInvalidArguments;
2928 }
2929 return error::kNoError;
2930 }
2931
HandleGenVertexArraysOESImmediate(uint32 immediate_data_size,const gles2::cmds::GenVertexArraysOESImmediate & c)2932 error::Error GLES2DecoderImpl::HandleGenVertexArraysOESImmediate(
2933 uint32 immediate_data_size,
2934 const gles2::cmds::GenVertexArraysOESImmediate& c) {
2935 GLsizei n = static_cast<GLsizei>(c.n);
2936 uint32 data_size;
2937 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
2938 return error::kOutOfBounds;
2939 }
2940 GLuint* arrays = GetImmediateDataAs<GLuint*>(
2941 c, data_size, immediate_data_size);
2942 if (arrays == NULL) {
2943 return error::kOutOfBounds;
2944 }
2945 if (!GenVertexArraysOESHelper(n, arrays)) {
2946 return error::kInvalidArguments;
2947 }
2948 return error::kNoError;
2949 }
2950
HandleDeleteVertexArraysOES(uint32 immediate_data_size,const gles2::cmds::DeleteVertexArraysOES & c)2951 error::Error GLES2DecoderImpl::HandleDeleteVertexArraysOES(
2952 uint32 immediate_data_size, const gles2::cmds::DeleteVertexArraysOES& c) {
2953 GLsizei n = static_cast<GLsizei>(c.n);
2954 uint32 data_size;
2955 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
2956 return error::kOutOfBounds;
2957 }
2958 const GLuint* arrays = GetSharedMemoryAs<const GLuint*>(
2959 c.arrays_shm_id, c.arrays_shm_offset, data_size);
2960 if (arrays == NULL) {
2961 return error::kOutOfBounds;
2962 }
2963 DeleteVertexArraysOESHelper(n, arrays);
2964 return error::kNoError;
2965 }
2966
HandleDeleteVertexArraysOESImmediate(uint32 immediate_data_size,const gles2::cmds::DeleteVertexArraysOESImmediate & c)2967 error::Error GLES2DecoderImpl::HandleDeleteVertexArraysOESImmediate(
2968 uint32 immediate_data_size,
2969 const gles2::cmds::DeleteVertexArraysOESImmediate& c) {
2970 GLsizei n = static_cast<GLsizei>(c.n);
2971 uint32 data_size;
2972 if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
2973 return error::kOutOfBounds;
2974 }
2975 const GLuint* arrays = GetImmediateDataAs<const GLuint*>(
2976 c, data_size, immediate_data_size);
2977 if (arrays == NULL) {
2978 return error::kOutOfBounds;
2979 }
2980 DeleteVertexArraysOESHelper(n, arrays);
2981 return error::kNoError;
2982 }
2983
HandleIsVertexArrayOES(uint32 immediate_data_size,const gles2::cmds::IsVertexArrayOES & c)2984 error::Error GLES2DecoderImpl::HandleIsVertexArrayOES(
2985 uint32 immediate_data_size, const gles2::cmds::IsVertexArrayOES& c) {
2986 GLuint array = c.array;
2987 typedef cmds::IsVertexArrayOES::Result Result;
2988 Result* result_dst = GetSharedMemoryAs<Result*>(
2989 c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
2990 if (!result_dst) {
2991 return error::kOutOfBounds;
2992 }
2993 *result_dst = DoIsVertexArrayOES(array);
2994 return error::kNoError;
2995 }
2996
HandleBindVertexArrayOES(uint32 immediate_data_size,const gles2::cmds::BindVertexArrayOES & c)2997 error::Error GLES2DecoderImpl::HandleBindVertexArrayOES(
2998 uint32 immediate_data_size, const gles2::cmds::BindVertexArrayOES& c) {
2999 GLuint array = c.array;
3000 DoBindVertexArrayOES(array);
3001 return error::kNoError;
3002 }
3003
HandleSwapBuffers(uint32 immediate_data_size,const gles2::cmds::SwapBuffers & c)3004 error::Error GLES2DecoderImpl::HandleSwapBuffers(
3005 uint32 immediate_data_size, const gles2::cmds::SwapBuffers& c) {
3006 DoSwapBuffers();
3007 return error::kNoError;
3008 }
3009
HandleGetMaxValueInBufferCHROMIUM(uint32 immediate_data_size,const gles2::cmds::GetMaxValueInBufferCHROMIUM & c)3010 error::Error GLES2DecoderImpl::HandleGetMaxValueInBufferCHROMIUM(
3011 uint32 immediate_data_size,
3012 const gles2::cmds::GetMaxValueInBufferCHROMIUM& c) {
3013 GLuint buffer_id = c.buffer_id;
3014 GLsizei count = static_cast<GLsizei>(c.count);
3015 GLenum type = static_cast<GLenum>(c.type);
3016 GLuint offset = static_cast<GLuint>(c.offset);
3017 typedef cmds::GetMaxValueInBufferCHROMIUM::Result Result;
3018 Result* result_dst = GetSharedMemoryAs<Result*>(
3019 c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
3020 if (!result_dst) {
3021 return error::kOutOfBounds;
3022 }
3023 if (count < 0) {
3024 LOCAL_SET_GL_ERROR(
3025 GL_INVALID_VALUE, "glGetMaxValueInBufferCHROMIUM", "count < 0");
3026 return error::kNoError;
3027 }
3028 if (!validators_->get_max_index_type.IsValid(type)) {
3029 LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetMaxValueInBufferCHROMIUM", type,
3030 "type");
3031 return error::kNoError;
3032 }
3033 *result_dst = DoGetMaxValueInBufferCHROMIUM(buffer_id, count, type, offset);
3034 return error::kNoError;
3035 }
3036
HandleTexImageIOSurface2DCHROMIUM(uint32 immediate_data_size,const gles2::cmds::TexImageIOSurface2DCHROMIUM & c)3037 error::Error GLES2DecoderImpl::HandleTexImageIOSurface2DCHROMIUM(
3038 uint32 immediate_data_size,
3039 const gles2::cmds::TexImageIOSurface2DCHROMIUM& c) {
3040 GLenum target = static_cast<GLenum>(c.target);
3041 GLsizei width = static_cast<GLsizei>(c.width);
3042 GLsizei height = static_cast<GLsizei>(c.height);
3043 GLuint ioSurfaceId = static_cast<GLuint>(c.ioSurfaceId);
3044 GLuint plane = static_cast<GLuint>(c.plane);
3045 if (!validators_->texture_bind_target.IsValid(target)) {
3046 LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexImageIOSurface2DCHROMIUM", target,
3047 "target");
3048 return error::kNoError;
3049 }
3050 if (width < 0) {
3051 LOCAL_SET_GL_ERROR(
3052 GL_INVALID_VALUE, "glTexImageIOSurface2DCHROMIUM", "width < 0");
3053 return error::kNoError;
3054 }
3055 if (height < 0) {
3056 LOCAL_SET_GL_ERROR(
3057 GL_INVALID_VALUE, "glTexImageIOSurface2DCHROMIUM", "height < 0");
3058 return error::kNoError;
3059 }
3060 DoTexImageIOSurface2DCHROMIUM(target, width, height, ioSurfaceId, plane);
3061 return error::kNoError;
3062 }
3063
HandleCopyTextureCHROMIUM(uint32 immediate_data_size,const gles2::cmds::CopyTextureCHROMIUM & c)3064 error::Error GLES2DecoderImpl::HandleCopyTextureCHROMIUM(
3065 uint32 immediate_data_size, const gles2::cmds::CopyTextureCHROMIUM& c) {
3066 GLenum target = static_cast<GLenum>(c.target);
3067 GLenum source_id = static_cast<GLenum>(c.source_id);
3068 GLenum dest_id = static_cast<GLenum>(c.dest_id);
3069 GLint level = static_cast<GLint>(c.level);
3070 GLint internalformat = static_cast<GLint>(c.internalformat);
3071 GLenum dest_type = static_cast<GLenum>(c.dest_type);
3072 if (!validators_->texture_internal_format.IsValid(internalformat)) {
3073 LOCAL_SET_GL_ERROR(
3074 GL_INVALID_VALUE, "glCopyTextureCHROMIUM", "internalformat GL_INVALID_VALUE"); // NOLINT
3075 return error::kNoError;
3076 }
3077 if (!validators_->pixel_type.IsValid(dest_type)) {
3078 LOCAL_SET_GL_ERROR_INVALID_ENUM("glCopyTextureCHROMIUM", dest_type,
3079 "dest_type");
3080 return error::kNoError;
3081 }
3082 DoCopyTextureCHROMIUM(
3083 target, source_id, dest_id, level, internalformat, dest_type);
3084 return error::kNoError;
3085 }
3086
HandleProduceTextureCHROMIUM(uint32 immediate_data_size,const gles2::cmds::ProduceTextureCHROMIUM & c)3087 error::Error GLES2DecoderImpl::HandleProduceTextureCHROMIUM(
3088 uint32 immediate_data_size, const gles2::cmds::ProduceTextureCHROMIUM& c) {
3089 GLenum target = static_cast<GLenum>(c.target);
3090 uint32 data_size;
3091 if (!ComputeDataSize(1, sizeof(GLbyte), 64, &data_size)) {
3092 return error::kOutOfBounds;
3093 }
3094 const GLbyte* mailbox = GetSharedMemoryAs<const GLbyte*>(
3095 c.mailbox_shm_id, c.mailbox_shm_offset, data_size);
3096 if (!validators_->texture_bind_target.IsValid(target)) {
3097 LOCAL_SET_GL_ERROR_INVALID_ENUM("glProduceTextureCHROMIUM", target,
3098 "target");
3099 return error::kNoError;
3100 }
3101 if (mailbox == NULL) {
3102 return error::kOutOfBounds;
3103 }
3104 DoProduceTextureCHROMIUM(target, mailbox);
3105 return error::kNoError;
3106 }
3107
HandleProduceTextureCHROMIUMImmediate(uint32 immediate_data_size,const gles2::cmds::ProduceTextureCHROMIUMImmediate & c)3108 error::Error GLES2DecoderImpl::HandleProduceTextureCHROMIUMImmediate(
3109 uint32 immediate_data_size,
3110 const gles2::cmds::ProduceTextureCHROMIUMImmediate& c) {
3111 GLenum target = static_cast<GLenum>(c.target);
3112 uint32 data_size;
3113 if (!ComputeDataSize(1, sizeof(GLbyte), 64, &data_size)) {
3114 return error::kOutOfBounds;
3115 }
3116 if (data_size > immediate_data_size) {
3117 return error::kOutOfBounds;
3118 }
3119 const GLbyte* mailbox = GetImmediateDataAs<const GLbyte*>(
3120 c, data_size, immediate_data_size);
3121 if (!validators_->texture_bind_target.IsValid(target)) {
3122 LOCAL_SET_GL_ERROR_INVALID_ENUM("glProduceTextureCHROMIUM", target,
3123 "target");
3124 return error::kNoError;
3125 }
3126 if (mailbox == NULL) {
3127 return error::kOutOfBounds;
3128 }
3129 DoProduceTextureCHROMIUM(target, mailbox);
3130 return error::kNoError;
3131 }
3132
HandleConsumeTextureCHROMIUM(uint32 immediate_data_size,const gles2::cmds::ConsumeTextureCHROMIUM & c)3133 error::Error GLES2DecoderImpl::HandleConsumeTextureCHROMIUM(
3134 uint32 immediate_data_size, const gles2::cmds::ConsumeTextureCHROMIUM& c) {
3135 GLenum target = static_cast<GLenum>(c.target);
3136 uint32 data_size;
3137 if (!ComputeDataSize(1, sizeof(GLbyte), 64, &data_size)) {
3138 return error::kOutOfBounds;
3139 }
3140 const GLbyte* mailbox = GetSharedMemoryAs<const GLbyte*>(
3141 c.mailbox_shm_id, c.mailbox_shm_offset, data_size);
3142 if (!validators_->texture_bind_target.IsValid(target)) {
3143 LOCAL_SET_GL_ERROR_INVALID_ENUM("glConsumeTextureCHROMIUM", target,
3144 "target");
3145 return error::kNoError;
3146 }
3147 if (mailbox == NULL) {
3148 return error::kOutOfBounds;
3149 }
3150 DoConsumeTextureCHROMIUM(target, mailbox);
3151 return error::kNoError;
3152 }
3153
HandleConsumeTextureCHROMIUMImmediate(uint32 immediate_data_size,const gles2::cmds::ConsumeTextureCHROMIUMImmediate & c)3154 error::Error GLES2DecoderImpl::HandleConsumeTextureCHROMIUMImmediate(
3155 uint32 immediate_data_size,
3156 const gles2::cmds::ConsumeTextureCHROMIUMImmediate& c) {
3157 GLenum target = static_cast<GLenum>(c.target);
3158 uint32 data_size;
3159 if (!ComputeDataSize(1, sizeof(GLbyte), 64, &data_size)) {
3160 return error::kOutOfBounds;
3161 }
3162 if (data_size > immediate_data_size) {
3163 return error::kOutOfBounds;
3164 }
3165 const GLbyte* mailbox = GetImmediateDataAs<const GLbyte*>(
3166 c, data_size, immediate_data_size);
3167 if (!validators_->texture_bind_target.IsValid(target)) {
3168 LOCAL_SET_GL_ERROR_INVALID_ENUM("glConsumeTextureCHROMIUM", target,
3169 "target");
3170 return error::kNoError;
3171 }
3172 if (mailbox == NULL) {
3173 return error::kOutOfBounds;
3174 }
3175 DoConsumeTextureCHROMIUM(target, mailbox);
3176 return error::kNoError;
3177 }
3178
HandleBindTexImage2DCHROMIUM(uint32 immediate_data_size,const gles2::cmds::BindTexImage2DCHROMIUM & c)3179 error::Error GLES2DecoderImpl::HandleBindTexImage2DCHROMIUM(
3180 uint32 immediate_data_size, const gles2::cmds::BindTexImage2DCHROMIUM& c) {
3181 GLenum target = static_cast<GLenum>(c.target);
3182 GLint imageId = static_cast<GLint>(c.imageId);
3183 if (!validators_->texture_bind_target.IsValid(target)) {
3184 LOCAL_SET_GL_ERROR_INVALID_ENUM("glBindTexImage2DCHROMIUM", target,
3185 "target");
3186 return error::kNoError;
3187 }
3188 DoBindTexImage2DCHROMIUM(target, imageId);
3189 return error::kNoError;
3190 }
3191
HandleReleaseTexImage2DCHROMIUM(uint32 immediate_data_size,const gles2::cmds::ReleaseTexImage2DCHROMIUM & c)3192 error::Error GLES2DecoderImpl::HandleReleaseTexImage2DCHROMIUM(
3193 uint32 immediate_data_size,
3194 const gles2::cmds::ReleaseTexImage2DCHROMIUM& c) {
3195 GLenum target = static_cast<GLenum>(c.target);
3196 GLint imageId = static_cast<GLint>(c.imageId);
3197 if (!validators_->texture_bind_target.IsValid(target)) {
3198 LOCAL_SET_GL_ERROR_INVALID_ENUM("glReleaseTexImage2DCHROMIUM", target,
3199 "target");
3200 return error::kNoError;
3201 }
3202 DoReleaseTexImage2DCHROMIUM(target, imageId);
3203 return error::kNoError;
3204 }
3205
HandleTraceEndCHROMIUM(uint32 immediate_data_size,const gles2::cmds::TraceEndCHROMIUM & c)3206 error::Error GLES2DecoderImpl::HandleTraceEndCHROMIUM(
3207 uint32 immediate_data_size, const gles2::cmds::TraceEndCHROMIUM& c) {
3208 DoTraceEndCHROMIUM();
3209 return error::kNoError;
3210 }
3211
HandleDiscardFramebufferEXT(uint32 immediate_data_size,const gles2::cmds::DiscardFramebufferEXT & c)3212 error::Error GLES2DecoderImpl::HandleDiscardFramebufferEXT(
3213 uint32 immediate_data_size, const gles2::cmds::DiscardFramebufferEXT& c) {
3214 GLenum target = static_cast<GLenum>(c.target);
3215 GLsizei count = static_cast<GLsizei>(c.count);
3216 uint32 data_size;
3217 if (!ComputeDataSize(count, sizeof(GLenum), 1, &data_size)) {
3218 return error::kOutOfBounds;
3219 }
3220 const GLenum* attachments = GetSharedMemoryAs<const GLenum*>(
3221 c.attachments_shm_id, c.attachments_shm_offset, data_size);
3222 if (count < 0) {
3223 LOCAL_SET_GL_ERROR(
3224 GL_INVALID_VALUE, "glDiscardFramebufferEXT", "count < 0");
3225 return error::kNoError;
3226 }
3227 if (attachments == NULL) {
3228 return error::kOutOfBounds;
3229 }
3230 DoDiscardFramebufferEXT(target, count, attachments);
3231 return error::kNoError;
3232 }
3233
HandleDiscardFramebufferEXTImmediate(uint32 immediate_data_size,const gles2::cmds::DiscardFramebufferEXTImmediate & c)3234 error::Error GLES2DecoderImpl::HandleDiscardFramebufferEXTImmediate(
3235 uint32 immediate_data_size,
3236 const gles2::cmds::DiscardFramebufferEXTImmediate& c) {
3237 GLenum target = static_cast<GLenum>(c.target);
3238 GLsizei count = static_cast<GLsizei>(c.count);
3239 uint32 data_size;
3240 if (!ComputeDataSize(count, sizeof(GLenum), 1, &data_size)) {
3241 return error::kOutOfBounds;
3242 }
3243 if (data_size > immediate_data_size) {
3244 return error::kOutOfBounds;
3245 }
3246 const GLenum* attachments = GetImmediateDataAs<const GLenum*>(
3247 c, data_size, immediate_data_size);
3248 if (count < 0) {
3249 LOCAL_SET_GL_ERROR(
3250 GL_INVALID_VALUE, "glDiscardFramebufferEXT", "count < 0");
3251 return error::kNoError;
3252 }
3253 if (attachments == NULL) {
3254 return error::kOutOfBounds;
3255 }
3256 DoDiscardFramebufferEXT(target, count, attachments);
3257 return error::kNoError;
3258 }
3259
HandleDrawBuffersEXT(uint32 immediate_data_size,const gles2::cmds::DrawBuffersEXT & c)3260 error::Error GLES2DecoderImpl::HandleDrawBuffersEXT(
3261 uint32 immediate_data_size, const gles2::cmds::DrawBuffersEXT& c) {
3262 GLsizei count = static_cast<GLsizei>(c.count);
3263 uint32 data_size;
3264 if (!ComputeDataSize(count, sizeof(GLenum), 1, &data_size)) {
3265 return error::kOutOfBounds;
3266 }
3267 const GLenum* bufs = GetSharedMemoryAs<const GLenum*>(
3268 c.bufs_shm_id, c.bufs_shm_offset, data_size);
3269 if (count < 0) {
3270 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glDrawBuffersEXT", "count < 0");
3271 return error::kNoError;
3272 }
3273 if (bufs == NULL) {
3274 return error::kOutOfBounds;
3275 }
3276 DoDrawBuffersEXT(count, bufs);
3277 return error::kNoError;
3278 }
3279
HandleDrawBuffersEXTImmediate(uint32 immediate_data_size,const gles2::cmds::DrawBuffersEXTImmediate & c)3280 error::Error GLES2DecoderImpl::HandleDrawBuffersEXTImmediate(
3281 uint32 immediate_data_size,
3282 const gles2::cmds::DrawBuffersEXTImmediate& c) {
3283 GLsizei count = static_cast<GLsizei>(c.count);
3284 uint32 data_size;
3285 if (!ComputeDataSize(count, sizeof(GLenum), 1, &data_size)) {
3286 return error::kOutOfBounds;
3287 }
3288 if (data_size > immediate_data_size) {
3289 return error::kOutOfBounds;
3290 }
3291 const GLenum* bufs = GetImmediateDataAs<const GLenum*>(
3292 c, data_size, immediate_data_size);
3293 if (count < 0) {
3294 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glDrawBuffersEXT", "count < 0");
3295 return error::kNoError;
3296 }
3297 if (bufs == NULL) {
3298 return error::kOutOfBounds;
3299 }
3300 DoDrawBuffersEXT(count, bufs);
3301 return error::kNoError;
3302 }
3303
3304
SetCapabilityState(GLenum cap,bool enabled)3305 bool GLES2DecoderImpl::SetCapabilityState(GLenum cap, bool enabled) {
3306 switch (cap) {
3307 case GL_BLEND:
3308 state_.enable_flags.blend = enabled;
3309 return true;
3310 case GL_CULL_FACE:
3311 state_.enable_flags.cull_face = enabled;
3312 return true;
3313 case GL_DEPTH_TEST:
3314 if (state_.enable_flags.depth_test != enabled) {
3315 state_.enable_flags.depth_test = enabled;
3316 framebuffer_state_.clear_state_dirty = true;
3317 }
3318 return false;
3319 case GL_DITHER:
3320 state_.enable_flags.dither = enabled;
3321 return true;
3322 case GL_POLYGON_OFFSET_FILL:
3323 state_.enable_flags.polygon_offset_fill = enabled;
3324 return true;
3325 case GL_SAMPLE_ALPHA_TO_COVERAGE:
3326 state_.enable_flags.sample_alpha_to_coverage = enabled;
3327 return true;
3328 case GL_SAMPLE_COVERAGE:
3329 state_.enable_flags.sample_coverage = enabled;
3330 return true;
3331 case GL_SCISSOR_TEST:
3332 if (state_.enable_flags.scissor_test != enabled) {
3333 state_.enable_flags.scissor_test = enabled;
3334 framebuffer_state_.clear_state_dirty = true;
3335 }
3336 return false;
3337 case GL_STENCIL_TEST:
3338 if (state_.enable_flags.stencil_test != enabled) {
3339 state_.enable_flags.stencil_test = enabled;
3340 framebuffer_state_.clear_state_dirty = true;
3341 }
3342 return false;
3343 default:
3344 NOTREACHED();
3345 return false;
3346 }
3347 }
3348 #endif // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_AUTOGEN_H_
3349
3350