gpu/command_buffer/service/gles2_cmd_decoder_autogen.h

   1 // Copyright 2014 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 // It's formatted by clang-format using chromium coding style:
   8 //    clang-format -i -style=chromium filename
   9 // DO NOT EDIT!
  10
  11 // It is included by gles2_cmd_decoder.cc
  12 #ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_AUTOGEN_H_
  13 #define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_AUTOGEN_H_
  14
  15 error::Error GLES2DecoderImpl::HandleActiveTexture(uint32_t immediate_data_size,
  16                                                    const void* cmd_data) {
  17   const gles2::cmds::ActiveTexture& c =
  18       *static_cast<const gles2::cmds::ActiveTexture*>(cmd_data);
  19   (void)c;
  20   GLenum texture = static_cast<GLenum>(c.texture);
  21   DoActiveTexture(texture);
  22   return error::kNoError;
  23 }
  24
  25 error::Error GLES2DecoderImpl::HandleAttachShader(uint32_t immediate_data_size,
  26                                                   const void* cmd_data) {
  27   const gles2::cmds::AttachShader& c =
  28       *static_cast<const gles2::cmds::AttachShader*>(cmd_data);
  29   (void)c;
  30   GLuint program = c.program;
  31   GLuint shader = c.shader;
  32   DoAttachShader(program, shader);
  33   return error::kNoError;
  34 }
  35
  36 error::Error GLES2DecoderImpl::HandleBindBuffer(uint32_t immediate_data_size,
  37                                                 const void* cmd_data) {
  38   const gles2::cmds::BindBuffer& c =
  39       *static_cast<const gles2::cmds::BindBuffer*>(cmd_data);
  40   (void)c;
  41   GLenum target = static_cast<GLenum>(c.target);
  42   GLuint buffer = c.buffer;
  43   if (!validators_->buffer_target.IsValid(target)) {
  44     LOCAL_SET_GL_ERROR_INVALID_ENUM("glBindBuffer", target, "target");
  45     return error::kNoError;
  46   }
  47   DoBindBuffer(target, buffer);
  48   return error::kNoError;
  49 }
  50
  51 error::Error GLES2DecoderImpl::HandleBindBufferBase(
  52     uint32_t immediate_data_size,
  53     const void* cmd_data) {
  54   if (!unsafe_es3_apis_enabled())
  55     return error::kUnknownCommand;
  56   const gles2::cmds::BindBufferBase& c =
  57       *static_cast<const gles2::cmds::BindBufferBase*>(cmd_data);
  58   (void)c;
  59   GLenum target = static_cast<GLenum>(c.target);
  60   GLuint index = static_cast<GLuint>(c.index);
  61   GLuint buffer = c.buffer;
  62   if (!group_->GetBufferServiceId(buffer, &buffer)) {
  63     if (!group_->bind_generates_resource()) {
  64       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glBindBufferBase",
  65                          "invalid buffer id");
  66       return error::kNoError;
  67     }
  68     GLuint client_id = buffer;
  69     glGenBuffersARB(1, &buffer);
  70     CreateBuffer(client_id, buffer);
  71   }
  72   glBindBufferBase(target, index, buffer);
  73   return error::kNoError;
  74 }
  75
  76 error::Error GLES2DecoderImpl::HandleBindBufferRange(
  77     uint32_t immediate_data_size,
  78     const void* cmd_data) {
  79   if (!unsafe_es3_apis_enabled())
  80     return error::kUnknownCommand;
  81   const gles2::cmds::BindBufferRange& c =
  82       *static_cast<const gles2::cmds::BindBufferRange*>(cmd_data);
  83   (void)c;
  84   GLenum target = static_cast<GLenum>(c.target);
  85   GLuint index = static_cast<GLuint>(c.index);
  86   GLuint buffer = c.buffer;
  87   GLintptr offset = static_cast<GLintptr>(c.offset);
  88   GLsizeiptr size = static_cast<GLsizeiptr>(c.size);
  89   if (!group_->GetBufferServiceId(buffer, &buffer)) {
  90     if (!group_->bind_generates_resource()) {
  91       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glBindBufferRange",
  92                          "invalid buffer id");
  93       return error::kNoError;
  94     }
  95     GLuint client_id = buffer;
  96     glGenBuffersARB(1, &buffer);
  97     CreateBuffer(client_id, buffer);
  98   }
  99   glBindBufferRange(target, index, buffer, offset, size);
 100   return error::kNoError;
 101 }
 102
 103 error::Error GLES2DecoderImpl::HandleBindFramebuffer(
 104     uint32_t immediate_data_size,
 105     const void* cmd_data) {
 106   const gles2::cmds::BindFramebuffer& c =
 107       *static_cast<const gles2::cmds::BindFramebuffer*>(cmd_data);
 108   (void)c;
 109   GLenum target = static_cast<GLenum>(c.target);
 110   GLuint framebuffer = c.framebuffer;
 111   if (!validators_->frame_buffer_target.IsValid(target)) {
 112     LOCAL_SET_GL_ERROR_INVALID_ENUM("glBindFramebuffer", target, "target");
 113     return error::kNoError;
 114   }
 115   DoBindFramebuffer(target, framebuffer);
 116   return error::kNoError;
 117 }
 118
 119 error::Error GLES2DecoderImpl::HandleBindRenderbuffer(
 120     uint32_t immediate_data_size,
 121     const void* cmd_data) {
 122   const gles2::cmds::BindRenderbuffer& c =
 123       *static_cast<const gles2::cmds::BindRenderbuffer*>(cmd_data);
 124   (void)c;
 125   GLenum target = static_cast<GLenum>(c.target);
 126   GLuint renderbuffer = c.renderbuffer;
 127   if (!validators_->render_buffer_target.IsValid(target)) {
 128     LOCAL_SET_GL_ERROR_INVALID_ENUM("glBindRenderbuffer", target, "target");
 129     return error::kNoError;
 130   }
 131   DoBindRenderbuffer(target, renderbuffer);
 132   return error::kNoError;
 133 }
 134
 135 error::Error GLES2DecoderImpl::HandleBindSampler(uint32_t immediate_data_size,
 136                                                  const void* cmd_data) {
 137   if (!unsafe_es3_apis_enabled())
 138     return error::kUnknownCommand;
 139   const gles2::cmds::BindSampler& c =
 140       *static_cast<const gles2::cmds::BindSampler*>(cmd_data);
 141   (void)c;
 142   GLuint unit = static_cast<GLuint>(c.unit);
 143   GLuint sampler = c.sampler;
 144   if (!group_->GetSamplerServiceId(sampler, &sampler)) {
 145     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glBindSampler",
 146                        "invalid sampler id");
 147     return error::kNoError;
 148   }
 149   glBindSampler(unit, sampler);
 150   return error::kNoError;
 151 }
 152
 153 error::Error GLES2DecoderImpl::HandleBindTexture(uint32_t immediate_data_size,
 154                                                  const void* cmd_data) {
 155   const gles2::cmds::BindTexture& c =
 156       *static_cast<const gles2::cmds::BindTexture*>(cmd_data);
 157   (void)c;
 158   GLenum target = static_cast<GLenum>(c.target);
 159   GLuint texture = c.texture;
 160   if (!validators_->texture_bind_target.IsValid(target)) {
 161     LOCAL_SET_GL_ERROR_INVALID_ENUM("glBindTexture", target, "target");
 162     return error::kNoError;
 163   }
 164   DoBindTexture(target, texture);
 165   return error::kNoError;
 166 }
 167
 168 error::Error GLES2DecoderImpl::HandleBindTransformFeedback(
 169     uint32_t immediate_data_size,
 170     const void* cmd_data) {
 171   if (!unsafe_es3_apis_enabled())
 172     return error::kUnknownCommand;
 173   const gles2::cmds::BindTransformFeedback& c =
 174       *static_cast<const gles2::cmds::BindTransformFeedback*>(cmd_data);
 175   (void)c;
 176   GLenum target = static_cast<GLenum>(c.target);
 177   GLuint transformfeedback = c.transformfeedback;
 178   if (!group_->GetTransformFeedbackServiceId(transformfeedback,
 179                                              &transformfeedback)) {
 180     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glBindTransformFeedback",
 181                        "invalid transformfeedback id");
 182     return error::kNoError;
 183   }
 184   glBindTransformFeedback(target, transformfeedback);
 185   return error::kNoError;
 186 }
 187
 188 error::Error GLES2DecoderImpl::HandleBlendColor(uint32_t immediate_data_size,
 189                                                 const void* cmd_data) {
 190   const gles2::cmds::BlendColor& c =
 191       *static_cast<const gles2::cmds::BlendColor*>(cmd_data);
 192   (void)c;
 193   GLclampf red = static_cast<GLclampf>(c.red);
 194   GLclampf green = static_cast<GLclampf>(c.green);
 195   GLclampf blue = static_cast<GLclampf>(c.blue);
 196   GLclampf alpha = static_cast<GLclampf>(c.alpha);
 197   if (state_.blend_color_red != red || state_.blend_color_green != green ||
 198       state_.blend_color_blue != blue || state_.blend_color_alpha != alpha) {
 199     state_.blend_color_red = red;
 200     state_.blend_color_green = green;
 201     state_.blend_color_blue = blue;
 202     state_.blend_color_alpha = alpha;
 203     glBlendColor(red, green, blue, alpha);
 204   }
 205   return error::kNoError;
 206 }
 207
 208 error::Error GLES2DecoderImpl::HandleBlendEquation(uint32_t immediate_data_size,
 209                                                    const void* cmd_data) {
 210   const gles2::cmds::BlendEquation& c =
 211       *static_cast<const gles2::cmds::BlendEquation*>(cmd_data);
 212   (void)c;
 213   GLenum mode = static_cast<GLenum>(c.mode);
 214   if (!validators_->equation.IsValid(mode)) {
 215     LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendEquation", mode, "mode");
 216     return error::kNoError;
 217   }
 218   if (state_.blend_equation_rgb != mode ||
 219       state_.blend_equation_alpha != mode) {
 220     state_.blend_equation_rgb = mode;
 221     state_.blend_equation_alpha = mode;
 222     glBlendEquation(mode);
 223   }
 224   return error::kNoError;
 225 }
 226
 227 error::Error GLES2DecoderImpl::HandleBlendEquationSeparate(
 228     uint32_t immediate_data_size,
 229     const void* cmd_data) {
 230   const gles2::cmds::BlendEquationSeparate& c =
 231       *static_cast<const gles2::cmds::BlendEquationSeparate*>(cmd_data);
 232   (void)c;
 233   GLenum modeRGB = static_cast<GLenum>(c.modeRGB);
 234   GLenum modeAlpha = static_cast<GLenum>(c.modeAlpha);
 235   if (!validators_->equation.IsValid(modeRGB)) {
 236     LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendEquationSeparate", modeRGB,
 237                                     "modeRGB");
 238     return error::kNoError;
 239   }
 240   if (!validators_->equation.IsValid(modeAlpha)) {
 241     LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendEquationSeparate", modeAlpha,
 242                                     "modeAlpha");
 243     return error::kNoError;
 244   }
 245   if (state_.blend_equation_rgb != modeRGB ||
 246       state_.blend_equation_alpha != modeAlpha) {
 247     state_.blend_equation_rgb = modeRGB;
 248     state_.blend_equation_alpha = modeAlpha;
 249     glBlendEquationSeparate(modeRGB, modeAlpha);
 250   }
 251   return error::kNoError;
 252 }
 253
 254 error::Error GLES2DecoderImpl::HandleBlendFunc(uint32_t immediate_data_size,
 255                                                const void* cmd_data) {
 256   const gles2::cmds::BlendFunc& c =
 257       *static_cast<const gles2::cmds::BlendFunc*>(cmd_data);
 258   (void)c;
 259   GLenum sfactor = static_cast<GLenum>(c.sfactor);
 260   GLenum dfactor = static_cast<GLenum>(c.dfactor);
 261   if (!validators_->src_blend_factor.IsValid(sfactor)) {
 262     LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendFunc", sfactor, "sfactor");
 263     return error::kNoError;
 264   }
 265   if (!validators_->dst_blend_factor.IsValid(dfactor)) {
 266     LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendFunc", dfactor, "dfactor");
 267     return error::kNoError;
 268   }
 269   if (state_.blend_source_rgb != sfactor || state_.blend_dest_rgb != dfactor ||
 270       state_.blend_source_alpha != sfactor ||
 271       state_.blend_dest_alpha != dfactor) {
 272     state_.blend_source_rgb = sfactor;
 273     state_.blend_dest_rgb = dfactor;
 274     state_.blend_source_alpha = sfactor;
 275     state_.blend_dest_alpha = dfactor;
 276     glBlendFunc(sfactor, dfactor);
 277   }
 278   return error::kNoError;
 279 }
 280
 281 error::Error GLES2DecoderImpl::HandleBlendFuncSeparate(
 282     uint32_t immediate_data_size,
 283     const void* cmd_data) {
 284   const gles2::cmds::BlendFuncSeparate& c =
 285       *static_cast<const gles2::cmds::BlendFuncSeparate*>(cmd_data);
 286   (void)c;
 287   GLenum srcRGB = static_cast<GLenum>(c.srcRGB);
 288   GLenum dstRGB = static_cast<GLenum>(c.dstRGB);
 289   GLenum srcAlpha = static_cast<GLenum>(c.srcAlpha);
 290   GLenum dstAlpha = static_cast<GLenum>(c.dstAlpha);
 291   if (!validators_->src_blend_factor.IsValid(srcRGB)) {
 292     LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendFuncSeparate", srcRGB, "srcRGB");
 293     return error::kNoError;
 294   }
 295   if (!validators_->dst_blend_factor.IsValid(dstRGB)) {
 296     LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendFuncSeparate", dstRGB, "dstRGB");
 297     return error::kNoError;
 298   }
 299   if (!validators_->src_blend_factor.IsValid(srcAlpha)) {
 300     LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendFuncSeparate", srcAlpha,
 301                                     "srcAlpha");
 302     return error::kNoError;
 303   }
 304   if (!validators_->dst_blend_factor.IsValid(dstAlpha)) {
 305     LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlendFuncSeparate", dstAlpha,
 306                                     "dstAlpha");
 307     return error::kNoError;
 308   }
 309   if (state_.blend_source_rgb != srcRGB || state_.blend_dest_rgb != dstRGB ||
 310       state_.blend_source_alpha != srcAlpha ||
 311       state_.blend_dest_alpha != dstAlpha) {
 312     state_.blend_source_rgb = srcRGB;
 313     state_.blend_dest_rgb = dstRGB;
 314     state_.blend_source_alpha = srcAlpha;
 315     state_.blend_dest_alpha = dstAlpha;
 316     glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
 317   }
 318   return error::kNoError;
 319 }
 320
 321 error::Error GLES2DecoderImpl::HandleBufferSubData(uint32_t immediate_data_size,
 322                                                    const void* cmd_data) {
 323   const gles2::cmds::BufferSubData& c =
 324       *static_cast<const gles2::cmds::BufferSubData*>(cmd_data);
 325   (void)c;
 326   GLenum target = static_cast<GLenum>(c.target);
 327   GLintptr offset = static_cast<GLintptr>(c.offset);
 328   GLsizeiptr size = static_cast<GLsizeiptr>(c.size);
 329   uint32_t data_size = size;
 330   const void* data = GetSharedMemoryAs<const void*>(
 331       c.data_shm_id, c.data_shm_offset, data_size);
 332   if (!validators_->buffer_target.IsValid(target)) {
 333     LOCAL_SET_GL_ERROR_INVALID_ENUM("glBufferSubData", target, "target");
 334     return error::kNoError;
 335   }
 336   if (size < 0) {
 337     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glBufferSubData", "size < 0");
 338     return error::kNoError;
 339   }
 340   if (data == NULL) {
 341     return error::kOutOfBounds;
 342   }
 343   DoBufferSubData(target, offset, size, data);
 344   return error::kNoError;
 345 }
 346
 347 error::Error GLES2DecoderImpl::HandleCheckFramebufferStatus(
 348     uint32_t immediate_data_size,
 349     const void* cmd_data) {
 350   const gles2::cmds::CheckFramebufferStatus& c =
 351       *static_cast<const gles2::cmds::CheckFramebufferStatus*>(cmd_data);
 352   (void)c;
 353   GLenum target = static_cast<GLenum>(c.target);
 354   typedef cmds::CheckFramebufferStatus::Result Result;
 355   Result* result_dst = GetSharedMemoryAs<Result*>(
 356       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
 357   if (!result_dst) {
 358     return error::kOutOfBounds;
 359   }
 360   if (!validators_->frame_buffer_target.IsValid(target)) {
 361     LOCAL_SET_GL_ERROR_INVALID_ENUM("glCheckFramebufferStatus", target,
 362                                     "target");
 363     return error::kNoError;
 364   }
 365   *result_dst = DoCheckFramebufferStatus(target);
 366   return error::kNoError;
 367 }
 368
 369 error::Error GLES2DecoderImpl::HandleClear(uint32_t immediate_data_size,
 370                                            const void* cmd_data) {
 371   const gles2::cmds::Clear& c =
 372       *static_cast<const gles2::cmds::Clear*>(cmd_data);
 373   (void)c;
 374   error::Error error;
 375   error = WillAccessBoundFramebufferForDraw();
 376   if (error != error::kNoError)
 377     return error;
 378   GLbitfield mask = static_cast<GLbitfield>(c.mask);
 379   DoClear(mask);
 380   return error::kNoError;
 381 }
 382
 383 error::Error GLES2DecoderImpl::HandleClearBufferfi(uint32_t immediate_data_size,
 384                                                    const void* cmd_data) {
 385   if (!unsafe_es3_apis_enabled())
 386     return error::kUnknownCommand;
 387   const gles2::cmds::ClearBufferfi& c =
 388       *static_cast<const gles2::cmds::ClearBufferfi*>(cmd_data);
 389   (void)c;
 390   GLenum buffer = static_cast<GLenum>(c.buffer);
 391   GLint drawbuffers = static_cast<GLint>(c.drawbuffers);
 392   GLfloat depth = static_cast<GLfloat>(c.depth);
 393   GLint stencil = static_cast<GLint>(c.stencil);
 394   glClearBufferfi(buffer, drawbuffers, depth, stencil);
 395   return error::kNoError;
 396 }
 397
 398 error::Error GLES2DecoderImpl::HandleClearBufferfvImmediate(
 399     uint32_t immediate_data_size,
 400     const void* cmd_data) {
 401   if (!unsafe_es3_apis_enabled())
 402     return error::kUnknownCommand;
 403   const gles2::cmds::ClearBufferfvImmediate& c =
 404       *static_cast<const gles2::cmds::ClearBufferfvImmediate*>(cmd_data);
 405   (void)c;
 406   GLenum buffer = static_cast<GLenum>(c.buffer);
 407   GLint drawbuffers = static_cast<GLint>(c.drawbuffers);
 408   uint32_t data_size;
 409   if (!ComputeDataSize(1, sizeof(GLfloat), 4, &data_size)) {
 410     return error::kOutOfBounds;
 411   }
 412   if (data_size > immediate_data_size) {
 413     return error::kOutOfBounds;
 414   }
 415   const GLfloat* value =
 416       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
 417   if (value == NULL) {
 418     return error::kOutOfBounds;
 419   }
 420   glClearBufferfv(buffer, drawbuffers, value);
 421   return error::kNoError;
 422 }
 423
 424 error::Error GLES2DecoderImpl::HandleClearBufferivImmediate(
 425     uint32_t immediate_data_size,
 426     const void* cmd_data) {
 427   if (!unsafe_es3_apis_enabled())
 428     return error::kUnknownCommand;
 429   const gles2::cmds::ClearBufferivImmediate& c =
 430       *static_cast<const gles2::cmds::ClearBufferivImmediate*>(cmd_data);
 431   (void)c;
 432   GLenum buffer = static_cast<GLenum>(c.buffer);
 433   GLint drawbuffers = static_cast<GLint>(c.drawbuffers);
 434   uint32_t data_size;
 435   if (!ComputeDataSize(1, sizeof(GLint), 4, &data_size)) {
 436     return error::kOutOfBounds;
 437   }
 438   if (data_size > immediate_data_size) {
 439     return error::kOutOfBounds;
 440   }
 441   const GLint* value =
 442       GetImmediateDataAs<const GLint*>(c, data_size, immediate_data_size);
 443   if (value == NULL) {
 444     return error::kOutOfBounds;
 445   }
 446   glClearBufferiv(buffer, drawbuffers, value);
 447   return error::kNoError;
 448 }
 449
 450 error::Error GLES2DecoderImpl::HandleClearBufferuivImmediate(
 451     uint32_t immediate_data_size,
 452     const void* cmd_data) {
 453   if (!unsafe_es3_apis_enabled())
 454     return error::kUnknownCommand;
 455   const gles2::cmds::ClearBufferuivImmediate& c =
 456       *static_cast<const gles2::cmds::ClearBufferuivImmediate*>(cmd_data);
 457   (void)c;
 458   GLenum buffer = static_cast<GLenum>(c.buffer);
 459   GLint drawbuffers = static_cast<GLint>(c.drawbuffers);
 460   uint32_t data_size;
 461   if (!ComputeDataSize(1, sizeof(GLuint), 4, &data_size)) {
 462     return error::kOutOfBounds;
 463   }
 464   if (data_size > immediate_data_size) {
 465     return error::kOutOfBounds;
 466   }
 467   const GLuint* value =
 468       GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
 469   if (value == NULL) {
 470     return error::kOutOfBounds;
 471   }
 472   glClearBufferuiv(buffer, drawbuffers, value);
 473   return error::kNoError;
 474 }
 475
 476 error::Error GLES2DecoderImpl::HandleClearColor(uint32_t immediate_data_size,
 477                                                 const void* cmd_data) {
 478   const gles2::cmds::ClearColor& c =
 479       *static_cast<const gles2::cmds::ClearColor*>(cmd_data);
 480   (void)c;
 481   GLclampf red = static_cast<GLclampf>(c.red);
 482   GLclampf green = static_cast<GLclampf>(c.green);
 483   GLclampf blue = static_cast<GLclampf>(c.blue);
 484   GLclampf alpha = static_cast<GLclampf>(c.alpha);
 485   if (state_.color_clear_red != red || state_.color_clear_green != green ||
 486       state_.color_clear_blue != blue || state_.color_clear_alpha != alpha) {
 487     state_.color_clear_red = red;
 488     state_.color_clear_green = green;
 489     state_.color_clear_blue = blue;
 490     state_.color_clear_alpha = alpha;
 491     glClearColor(red, green, blue, alpha);
 492   }
 493   return error::kNoError;
 494 }
 495
 496 error::Error GLES2DecoderImpl::HandleClearDepthf(uint32_t immediate_data_size,
 497                                                  const void* cmd_data) {
 498   const gles2::cmds::ClearDepthf& c =
 499       *static_cast<const gles2::cmds::ClearDepthf*>(cmd_data);
 500   (void)c;
 501   GLclampf depth = static_cast<GLclampf>(c.depth);
 502   if (state_.depth_clear != depth) {
 503     state_.depth_clear = depth;
 504     glClearDepth(depth);
 505   }
 506   return error::kNoError;
 507 }
 508
 509 error::Error GLES2DecoderImpl::HandleClearStencil(uint32_t immediate_data_size,
 510                                                   const void* cmd_data) {
 511   const gles2::cmds::ClearStencil& c =
 512       *static_cast<const gles2::cmds::ClearStencil*>(cmd_data);
 513   (void)c;
 514   GLint s = static_cast<GLint>(c.s);
 515   if (state_.stencil_clear != s) {
 516     state_.stencil_clear = s;
 517     glClearStencil(s);
 518   }
 519   return error::kNoError;
 520 }
 521
 522 error::Error GLES2DecoderImpl::HandleColorMask(uint32_t immediate_data_size,
 523                                                const void* cmd_data) {
 524   const gles2::cmds::ColorMask& c =
 525       *static_cast<const gles2::cmds::ColorMask*>(cmd_data);
 526   (void)c;
 527   GLboolean red = static_cast<GLboolean>(c.red);
 528   GLboolean green = static_cast<GLboolean>(c.green);
 529   GLboolean blue = static_cast<GLboolean>(c.blue);
 530   GLboolean alpha = static_cast<GLboolean>(c.alpha);
 531   if (state_.color_mask_red != red || state_.color_mask_green != green ||
 532       state_.color_mask_blue != blue || state_.color_mask_alpha != alpha) {
 533     state_.color_mask_red = red;
 534     state_.color_mask_green = green;
 535     state_.color_mask_blue = blue;
 536     state_.color_mask_alpha = alpha;
 537     framebuffer_state_.clear_state_dirty = true;
 538   }
 539   return error::kNoError;
 540 }
 541
 542 error::Error GLES2DecoderImpl::HandleCompileShader(uint32_t immediate_data_size,
 543                                                    const void* cmd_data) {
 544   const gles2::cmds::CompileShader& c =
 545       *static_cast<const gles2::cmds::CompileShader*>(cmd_data);
 546   (void)c;
 547   GLuint shader = c.shader;
 548   DoCompileShader(shader);
 549   return error::kNoError;
 550 }
 551
 552 error::Error GLES2DecoderImpl::HandleCompressedTexSubImage2D(
 553     uint32_t immediate_data_size,
 554     const void* cmd_data) {
 555   const gles2::cmds::CompressedTexSubImage2D& c =
 556       *static_cast<const gles2::cmds::CompressedTexSubImage2D*>(cmd_data);
 557   (void)c;
 558   GLenum target = static_cast<GLenum>(c.target);
 559   GLint level = static_cast<GLint>(c.level);
 560   GLint xoffset = static_cast<GLint>(c.xoffset);
 561   GLint yoffset = static_cast<GLint>(c.yoffset);
 562   GLsizei width = static_cast<GLsizei>(c.width);
 563   GLsizei height = static_cast<GLsizei>(c.height);
 564   GLenum format = static_cast<GLenum>(c.format);
 565   GLsizei imageSize = static_cast<GLsizei>(c.imageSize);
 566   uint32_t data_size = imageSize;
 567   const void* data = GetSharedMemoryAs<const void*>(
 568       c.data_shm_id, c.data_shm_offset, data_size);
 569   if (!validators_->texture_target.IsValid(target)) {
 570     LOCAL_SET_GL_ERROR_INVALID_ENUM("glCompressedTexSubImage2D", target,
 571                                     "target");
 572     return error::kNoError;
 573   }
 574   if (width < 0) {
 575     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glCompressedTexSubImage2D",
 576                        "width < 0");
 577     return error::kNoError;
 578   }
 579   if (height < 0) {
 580     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glCompressedTexSubImage2D",
 581                        "height < 0");
 582     return error::kNoError;
 583   }
 584   if (!validators_->compressed_texture_format.IsValid(format)) {
 585     LOCAL_SET_GL_ERROR_INVALID_ENUM("glCompressedTexSubImage2D", format,
 586                                     "format");
 587     return error::kNoError;
 588   }
 589   if (imageSize < 0) {
 590     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glCompressedTexSubImage2D",
 591                        "imageSize < 0");
 592     return error::kNoError;
 593   }
 594   if (data == NULL) {
 595     return error::kOutOfBounds;
 596   }
 597   DoCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height,
 598                             format, imageSize, data);
 599   return error::kNoError;
 600 }
 601
 602 error::Error GLES2DecoderImpl::HandleCompressedTexSubImage3D(
 603     uint32_t immediate_data_size,
 604     const void* cmd_data) {
 605   if (!unsafe_es3_apis_enabled())
 606     return error::kUnknownCommand;
 607   const gles2::cmds::CompressedTexSubImage3D& c =
 608       *static_cast<const gles2::cmds::CompressedTexSubImage3D*>(cmd_data);
 609   (void)c;
 610   GLenum target = static_cast<GLenum>(c.target);
 611   GLint level = static_cast<GLint>(c.level);
 612   GLint xoffset = static_cast<GLint>(c.xoffset);
 613   GLint yoffset = static_cast<GLint>(c.yoffset);
 614   GLint zoffset = static_cast<GLint>(c.zoffset);
 615   GLsizei width = static_cast<GLsizei>(c.width);
 616   GLsizei height = static_cast<GLsizei>(c.height);
 617   GLsizei depth = static_cast<GLsizei>(c.depth);
 618   GLenum format = static_cast<GLenum>(c.format);
 619   GLsizei imageSize = static_cast<GLsizei>(c.imageSize);
 620   uint32_t data_size = imageSize;
 621   const void* data = GetSharedMemoryAs<const void*>(
 622       c.data_shm_id, c.data_shm_offset, data_size);
 623   if (data == NULL) {
 624     return error::kOutOfBounds;
 625   }
 626   DoCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width,
 627                             height, depth, format, imageSize, data);
 628   return error::kNoError;
 629 }
 630
 631 error::Error GLES2DecoderImpl::HandleCopyBufferSubData(
 632     uint32_t immediate_data_size,
 633     const void* cmd_data) {
 634   if (!unsafe_es3_apis_enabled())
 635     return error::kUnknownCommand;
 636   const gles2::cmds::CopyBufferSubData& c =
 637       *static_cast<const gles2::cmds::CopyBufferSubData*>(cmd_data);
 638   (void)c;
 639   GLenum readtarget = static_cast<GLenum>(c.readtarget);
 640   GLenum writetarget = static_cast<GLenum>(c.writetarget);
 641   GLintptr readoffset = static_cast<GLintptr>(c.readoffset);
 642   GLintptr writeoffset = static_cast<GLintptr>(c.writeoffset);
 643   GLsizeiptr size = static_cast<GLsizeiptr>(c.size);
 644   glCopyBufferSubData(readtarget, writetarget, readoffset, writeoffset, size);
 645   return error::kNoError;
 646 }
 647
 648 error::Error GLES2DecoderImpl::HandleCopyTexImage2D(
 649     uint32_t immediate_data_size,
 650     const void* cmd_data) {
 651   const gles2::cmds::CopyTexImage2D& c =
 652       *static_cast<const gles2::cmds::CopyTexImage2D*>(cmd_data);
 653   (void)c;
 654   error::Error error;
 655   error = WillAccessBoundFramebufferForRead();
 656   if (error != error::kNoError)
 657     return error;
 658   GLenum target = static_cast<GLenum>(c.target);
 659   GLint level = static_cast<GLint>(c.level);
 660   GLenum internalformat = static_cast<GLenum>(c.internalformat);
 661   GLint x = static_cast<GLint>(c.x);
 662   GLint y = static_cast<GLint>(c.y);
 663   GLsizei width = static_cast<GLsizei>(c.width);
 664   GLsizei height = static_cast<GLsizei>(c.height);
 665   GLint border = static_cast<GLint>(c.border);
 666   if (!validators_->texture_target.IsValid(target)) {
 667     LOCAL_SET_GL_ERROR_INVALID_ENUM("glCopyTexImage2D", target, "target");
 668     return error::kNoError;
 669   }
 670   if (!validators_->texture_internal_format.IsValid(internalformat)) {
 671     LOCAL_SET_GL_ERROR_INVALID_ENUM("glCopyTexImage2D", internalformat,
 672                                     "internalformat");
 673     return error::kNoError;
 674   }
 675   if (width < 0) {
 676     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glCopyTexImage2D", "width < 0");
 677     return error::kNoError;
 678   }
 679   if (height < 0) {
 680     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glCopyTexImage2D", "height < 0");
 681     return error::kNoError;
 682   }
 683   DoCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 684   return error::kNoError;
 685 }
 686
 687 error::Error GLES2DecoderImpl::HandleCopyTexSubImage2D(
 688     uint32_t immediate_data_size,
 689     const void* cmd_data) {
 690   const gles2::cmds::CopyTexSubImage2D& c =
 691       *static_cast<const gles2::cmds::CopyTexSubImage2D*>(cmd_data);
 692   (void)c;
 693   error::Error error;
 694   error = WillAccessBoundFramebufferForRead();
 695   if (error != error::kNoError)
 696     return error;
 697   GLenum target = static_cast<GLenum>(c.target);
 698   GLint level = static_cast<GLint>(c.level);
 699   GLint xoffset = static_cast<GLint>(c.xoffset);
 700   GLint yoffset = static_cast<GLint>(c.yoffset);
 701   GLint x = static_cast<GLint>(c.x);
 702   GLint y = static_cast<GLint>(c.y);
 703   GLsizei width = static_cast<GLsizei>(c.width);
 704   GLsizei height = static_cast<GLsizei>(c.height);
 705   if (!validators_->texture_target.IsValid(target)) {
 706     LOCAL_SET_GL_ERROR_INVALID_ENUM("glCopyTexSubImage2D", target, "target");
 707     return error::kNoError;
 708   }
 709   if (width < 0) {
 710     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glCopyTexSubImage2D", "width < 0");
 711     return error::kNoError;
 712   }
 713   if (height < 0) {
 714     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glCopyTexSubImage2D", "height < 0");
 715     return error::kNoError;
 716   }
 717   DoCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 718   return error::kNoError;
 719 }
 720
 721 error::Error GLES2DecoderImpl::HandleCopyTexSubImage3D(
 722     uint32_t immediate_data_size,
 723     const void* cmd_data) {
 724   if (!unsafe_es3_apis_enabled())
 725     return error::kUnknownCommand;
 726   const gles2::cmds::CopyTexSubImage3D& c =
 727       *static_cast<const gles2::cmds::CopyTexSubImage3D*>(cmd_data);
 728   (void)c;
 729   error::Error error;
 730   error = WillAccessBoundFramebufferForRead();
 731   if (error != error::kNoError)
 732     return error;
 733   GLenum target = static_cast<GLenum>(c.target);
 734   GLint level = static_cast<GLint>(c.level);
 735   GLint xoffset = static_cast<GLint>(c.xoffset);
 736   GLint yoffset = static_cast<GLint>(c.yoffset);
 737   GLint zoffset = static_cast<GLint>(c.zoffset);
 738   GLint x = static_cast<GLint>(c.x);
 739   GLint y = static_cast<GLint>(c.y);
 740   GLsizei width = static_cast<GLsizei>(c.width);
 741   GLsizei height = static_cast<GLsizei>(c.height);
 742   glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width,
 743                       height);
 744   return error::kNoError;
 745 }
 746
 747 error::Error GLES2DecoderImpl::HandleCreateProgram(uint32_t immediate_data_size,
 748                                                    const void* cmd_data) {
 749   const gles2::cmds::CreateProgram& c =
 750       *static_cast<const gles2::cmds::CreateProgram*>(cmd_data);
 751   (void)c;
 752   uint32_t client_id = c.client_id;
 753   if (GetProgram(client_id)) {
 754     return error::kInvalidArguments;
 755   }
 756   GLuint service_id = glCreateProgram();
 757   if (service_id) {
 758     CreateProgram(client_id, service_id);
 759   }
 760   return error::kNoError;
 761 }
 762
 763 error::Error GLES2DecoderImpl::HandleCreateShader(uint32_t immediate_data_size,
 764                                                   const void* cmd_data) {
 765   const gles2::cmds::CreateShader& c =
 766       *static_cast<const gles2::cmds::CreateShader*>(cmd_data);
 767   (void)c;
 768   GLenum type = static_cast<GLenum>(c.type);
 769   if (!validators_->shader_type.IsValid(type)) {
 770     LOCAL_SET_GL_ERROR_INVALID_ENUM("glCreateShader", type, "type");
 771     return error::kNoError;
 772   }
 773   uint32_t client_id = c.client_id;
 774   if (GetShader(client_id)) {
 775     return error::kInvalidArguments;
 776   }
 777   GLuint service_id = glCreateShader(type);
 778   if (service_id) {
 779     CreateShader(client_id, service_id, type);
 780   }
 781   return error::kNoError;
 782 }
 783
 784 error::Error GLES2DecoderImpl::HandleCullFace(uint32_t immediate_data_size,
 785                                               const void* cmd_data) {
 786   const gles2::cmds::CullFace& c =
 787       *static_cast<const gles2::cmds::CullFace*>(cmd_data);
 788   (void)c;
 789   GLenum mode = static_cast<GLenum>(c.mode);
 790   if (!validators_->face_type.IsValid(mode)) {
 791     LOCAL_SET_GL_ERROR_INVALID_ENUM("glCullFace", mode, "mode");
 792     return error::kNoError;
 793   }
 794   if (state_.cull_mode != mode) {
 795     state_.cull_mode = mode;
 796     glCullFace(mode);
 797   }
 798   return error::kNoError;
 799 }
 800
 801 error::Error GLES2DecoderImpl::HandleDeleteBuffersImmediate(
 802     uint32_t immediate_data_size,
 803     const void* cmd_data) {
 804   const gles2::cmds::DeleteBuffersImmediate& c =
 805       *static_cast<const gles2::cmds::DeleteBuffersImmediate*>(cmd_data);
 806   (void)c;
 807   GLsizei n = static_cast<GLsizei>(c.n);
 808   uint32_t data_size;
 809   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
 810     return error::kOutOfBounds;
 811   }
 812   const GLuint* buffers =
 813       GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
 814   if (buffers == NULL) {
 815     return error::kOutOfBounds;
 816   }
 817   DeleteBuffersHelper(n, buffers);
 818   return error::kNoError;
 819 }
 820
 821 error::Error GLES2DecoderImpl::HandleDeleteFramebuffersImmediate(
 822     uint32_t immediate_data_size,
 823     const void* cmd_data) {
 824   const gles2::cmds::DeleteFramebuffersImmediate& c =
 825       *static_cast<const gles2::cmds::DeleteFramebuffersImmediate*>(cmd_data);
 826   (void)c;
 827   GLsizei n = static_cast<GLsizei>(c.n);
 828   uint32_t data_size;
 829   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
 830     return error::kOutOfBounds;
 831   }
 832   const GLuint* framebuffers =
 833       GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
 834   if (framebuffers == NULL) {
 835     return error::kOutOfBounds;
 836   }
 837   DeleteFramebuffersHelper(n, framebuffers);
 838   return error::kNoError;
 839 }
 840
 841 error::Error GLES2DecoderImpl::HandleDeleteRenderbuffersImmediate(
 842     uint32_t immediate_data_size,
 843     const void* cmd_data) {
 844   const gles2::cmds::DeleteRenderbuffersImmediate& c =
 845       *static_cast<const gles2::cmds::DeleteRenderbuffersImmediate*>(cmd_data);
 846   (void)c;
 847   GLsizei n = static_cast<GLsizei>(c.n);
 848   uint32_t data_size;
 849   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
 850     return error::kOutOfBounds;
 851   }
 852   const GLuint* renderbuffers =
 853       GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
 854   if (renderbuffers == NULL) {
 855     return error::kOutOfBounds;
 856   }
 857   DeleteRenderbuffersHelper(n, renderbuffers);
 858   return error::kNoError;
 859 }
 860
 861 error::Error GLES2DecoderImpl::HandleDeleteSamplersImmediate(
 862     uint32_t immediate_data_size,
 863     const void* cmd_data) {
 864   if (!unsafe_es3_apis_enabled())
 865     return error::kUnknownCommand;
 866   const gles2::cmds::DeleteSamplersImmediate& c =
 867       *static_cast<const gles2::cmds::DeleteSamplersImmediate*>(cmd_data);
 868   (void)c;
 869   GLsizei n = static_cast<GLsizei>(c.n);
 870   uint32_t data_size;
 871   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
 872     return error::kOutOfBounds;
 873   }
 874   const GLuint* samplers =
 875       GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
 876   if (samplers == NULL) {
 877     return error::kOutOfBounds;
 878   }
 879   for (GLsizei ii = 0; ii < n; ++ii) {
 880     GLuint service_id = 0;
 881     if (group_->GetSamplerServiceId(samplers[ii], &service_id)) {
 882       glDeleteSamplers(1, &service_id);
 883       group_->RemoveSamplerId(samplers[ii]);
 884     }
 885   }
 886   return error::kNoError;
 887 }
 888
 889 error::Error GLES2DecoderImpl::HandleDeleteSync(uint32_t immediate_data_size,
 890                                                 const void* cmd_data) {
 891   if (!unsafe_es3_apis_enabled())
 892     return error::kUnknownCommand;
 893   const gles2::cmds::DeleteSync& c =
 894       *static_cast<const gles2::cmds::DeleteSync*>(cmd_data);
 895   (void)c;
 896   GLuint sync = c.sync;
 897   GLsync service_id = 0;
 898   if (group_->GetSyncServiceId(sync, &service_id)) {
 899     glDeleteSync(service_id);
 900     group_->RemoveSyncId(sync);
 901   } else {
 902     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glDeleteSync", "unknown sync");
 903   }
 904   return error::kNoError;
 905 }
 906
 907 error::Error GLES2DecoderImpl::HandleDeleteTexturesImmediate(
 908     uint32_t immediate_data_size,
 909     const void* cmd_data) {
 910   const gles2::cmds::DeleteTexturesImmediate& c =
 911       *static_cast<const gles2::cmds::DeleteTexturesImmediate*>(cmd_data);
 912   (void)c;
 913   GLsizei n = static_cast<GLsizei>(c.n);
 914   uint32_t data_size;
 915   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
 916     return error::kOutOfBounds;
 917   }
 918   const GLuint* textures =
 919       GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
 920   if (textures == NULL) {
 921     return error::kOutOfBounds;
 922   }
 923   DeleteTexturesHelper(n, textures);
 924   return error::kNoError;
 925 }
 926
 927 error::Error GLES2DecoderImpl::HandleDeleteTransformFeedbacksImmediate(
 928     uint32_t immediate_data_size,
 929     const void* cmd_data) {
 930   if (!unsafe_es3_apis_enabled())
 931     return error::kUnknownCommand;
 932   const gles2::cmds::DeleteTransformFeedbacksImmediate& c =
 933       *static_cast<const gles2::cmds::DeleteTransformFeedbacksImmediate*>(
 934           cmd_data);
 935   (void)c;
 936   GLsizei n = static_cast<GLsizei>(c.n);
 937   uint32_t data_size;
 938   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
 939     return error::kOutOfBounds;
 940   }
 941   const GLuint* ids =
 942       GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
 943   if (ids == NULL) {
 944     return error::kOutOfBounds;
 945   }
 946   for (GLsizei ii = 0; ii < n; ++ii) {
 947     GLuint service_id = 0;
 948     if (group_->GetTransformFeedbackServiceId(ids[ii], &service_id)) {
 949       glDeleteTransformFeedbacks(1, &service_id);
 950       group_->RemoveTransformFeedbackId(ids[ii]);
 951     }
 952   }
 953   return error::kNoError;
 954 }
 955
 956 error::Error GLES2DecoderImpl::HandleDepthFunc(uint32_t immediate_data_size,
 957                                                const void* cmd_data) {
 958   const gles2::cmds::DepthFunc& c =
 959       *static_cast<const gles2::cmds::DepthFunc*>(cmd_data);
 960   (void)c;
 961   GLenum func = static_cast<GLenum>(c.func);
 962   if (!validators_->cmp_function.IsValid(func)) {
 963     LOCAL_SET_GL_ERROR_INVALID_ENUM("glDepthFunc", func, "func");
 964     return error::kNoError;
 965   }
 966   if (state_.depth_func != func) {
 967     state_.depth_func = func;
 968     glDepthFunc(func);
 969   }
 970   return error::kNoError;
 971 }
 972
 973 error::Error GLES2DecoderImpl::HandleDepthMask(uint32_t immediate_data_size,
 974                                                const void* cmd_data) {
 975   const gles2::cmds::DepthMask& c =
 976       *static_cast<const gles2::cmds::DepthMask*>(cmd_data);
 977   (void)c;
 978   GLboolean flag = static_cast<GLboolean>(c.flag);
 979   if (state_.depth_mask != flag) {
 980     state_.depth_mask = flag;
 981     framebuffer_state_.clear_state_dirty = true;
 982   }
 983   return error::kNoError;
 984 }
 985
 986 error::Error GLES2DecoderImpl::HandleDepthRangef(uint32_t immediate_data_size,
 987                                                  const void* cmd_data) {
 988   const gles2::cmds::DepthRangef& c =
 989       *static_cast<const gles2::cmds::DepthRangef*>(cmd_data);
 990   (void)c;
 991   GLclampf zNear = static_cast<GLclampf>(c.zNear);
 992   GLclampf zFar = static_cast<GLclampf>(c.zFar);
 993   DoDepthRangef(zNear, zFar);
 994   return error::kNoError;
 995 }
 996
 997 error::Error GLES2DecoderImpl::HandleDetachShader(uint32_t immediate_data_size,
 998                                                   const void* cmd_data) {
 999   const gles2::cmds::DetachShader& c =
1000       *static_cast<const gles2::cmds::DetachShader*>(cmd_data);
1001   (void)c;
1002   GLuint program = c.program;
1003   GLuint shader = c.shader;
1004   DoDetachShader(program, shader);
1005   return error::kNoError;
1006 }
1007
1008 error::Error GLES2DecoderImpl::HandleDisable(uint32_t immediate_data_size,
1009                                              const void* cmd_data) {
1010   const gles2::cmds::Disable& c =
1011       *static_cast<const gles2::cmds::Disable*>(cmd_data);
1012   (void)c;
1013   GLenum cap = static_cast<GLenum>(c.cap);
1014   if (!validators_->capability.IsValid(cap)) {
1015     LOCAL_SET_GL_ERROR_INVALID_ENUM("glDisable", cap, "cap");
1016     return error::kNoError;
1017   }
1018   DoDisable(cap);
1019   return error::kNoError;
1020 }
1021
1022 error::Error GLES2DecoderImpl::HandleDisableVertexAttribArray(
1023     uint32_t immediate_data_size,
1024     const void* cmd_data) {
1025   const gles2::cmds::DisableVertexAttribArray& c =
1026       *static_cast<const gles2::cmds::DisableVertexAttribArray*>(cmd_data);
1027   (void)c;
1028   GLuint index = static_cast<GLuint>(c.index);
1029   DoDisableVertexAttribArray(index);
1030   return error::kNoError;
1031 }
1032
1033 error::Error GLES2DecoderImpl::HandleEnable(uint32_t immediate_data_size,
1034                                             const void* cmd_data) {
1035   const gles2::cmds::Enable& c =
1036       *static_cast<const gles2::cmds::Enable*>(cmd_data);
1037   (void)c;
1038   GLenum cap = static_cast<GLenum>(c.cap);
1039   if (!validators_->capability.IsValid(cap)) {
1040     LOCAL_SET_GL_ERROR_INVALID_ENUM("glEnable", cap, "cap");
1041     return error::kNoError;
1042   }
1043   DoEnable(cap);
1044   return error::kNoError;
1045 }
1046
1047 error::Error GLES2DecoderImpl::HandleEnableVertexAttribArray(
1048     uint32_t immediate_data_size,
1049     const void* cmd_data) {
1050   const gles2::cmds::EnableVertexAttribArray& c =
1051       *static_cast<const gles2::cmds::EnableVertexAttribArray*>(cmd_data);
1052   (void)c;
1053   GLuint index = static_cast<GLuint>(c.index);
1054   DoEnableVertexAttribArray(index);
1055   return error::kNoError;
1056 }
1057
1058 error::Error GLES2DecoderImpl::HandleFenceSync(uint32_t immediate_data_size,
1059                                                const void* cmd_data) {
1060   if (!unsafe_es3_apis_enabled())
1061     return error::kUnknownCommand;
1062   const gles2::cmds::FenceSync& c =
1063       *static_cast<const gles2::cmds::FenceSync*>(cmd_data);
1064   (void)c;
1065   GLenum condition = static_cast<GLenum>(c.condition);
1066   GLbitfield flags = static_cast<GLbitfield>(c.flags);
1067   uint32_t client_id = c.client_id;
1068   GLsync service_id = 0;
1069   if (group_->GetSyncServiceId(client_id, &service_id)) {
1070     return error::kInvalidArguments;
1071   }
1072   service_id = glFenceSync(condition, flags);
1073   if (service_id) {
1074     group_->AddSyncId(client_id, service_id);
1075   }
1076   return error::kNoError;
1077 }
1078
1079 error::Error GLES2DecoderImpl::HandleFinish(uint32_t immediate_data_size,
1080                                             const void* cmd_data) {
1081   const gles2::cmds::Finish& c =
1082       *static_cast<const gles2::cmds::Finish*>(cmd_data);
1083   (void)c;
1084   error::Error error;
1085   error = WillAccessBoundFramebufferForRead();
1086   if (error != error::kNoError)
1087     return error;
1088   DoFinish();
1089   return error::kNoError;
1090 }
1091
1092 error::Error GLES2DecoderImpl::HandleFlush(uint32_t immediate_data_size,
1093                                            const void* cmd_data) {
1094   const gles2::cmds::Flush& c =
1095       *static_cast<const gles2::cmds::Flush*>(cmd_data);
1096   (void)c;
1097   DoFlush();
1098   return error::kNoError;
1099 }
1100
1101 error::Error GLES2DecoderImpl::HandleFramebufferRenderbuffer(
1102     uint32_t immediate_data_size,
1103     const void* cmd_data) {
1104   const gles2::cmds::FramebufferRenderbuffer& c =
1105       *static_cast<const gles2::cmds::FramebufferRenderbuffer*>(cmd_data);
1106   (void)c;
1107   GLenum target = static_cast<GLenum>(c.target);
1108   GLenum attachment = static_cast<GLenum>(c.attachment);
1109   GLenum renderbuffertarget = static_cast<GLenum>(c.renderbuffertarget);
1110   GLuint renderbuffer = c.renderbuffer;
1111   if (!validators_->frame_buffer_target.IsValid(target)) {
1112     LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferRenderbuffer", target,
1113                                     "target");
1114     return error::kNoError;
1115   }
1116   if (!validators_->attachment.IsValid(attachment)) {
1117     LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferRenderbuffer", attachment,
1118                                     "attachment");
1119     return error::kNoError;
1120   }
1121   if (!validators_->render_buffer_target.IsValid(renderbuffertarget)) {
1122     LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferRenderbuffer",
1123                                     renderbuffertarget, "renderbuffertarget");
1124     return error::kNoError;
1125   }
1126   DoFramebufferRenderbuffer(target, attachment, renderbuffertarget,
1127                             renderbuffer);
1128   return error::kNoError;
1129 }
1130
1131 error::Error GLES2DecoderImpl::HandleFramebufferTexture2D(
1132     uint32_t immediate_data_size,
1133     const void* cmd_data) {
1134   const gles2::cmds::FramebufferTexture2D& c =
1135       *static_cast<const gles2::cmds::FramebufferTexture2D*>(cmd_data);
1136   (void)c;
1137   GLenum target = static_cast<GLenum>(c.target);
1138   GLenum attachment = static_cast<GLenum>(c.attachment);
1139   GLenum textarget = static_cast<GLenum>(c.textarget);
1140   GLuint texture = c.texture;
1141   GLint level = static_cast<GLint>(c.level);
1142   if (!validators_->frame_buffer_target.IsValid(target)) {
1143     LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferTexture2D", target, "target");
1144     return error::kNoError;
1145   }
1146   if (!validators_->attachment.IsValid(attachment)) {
1147     LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferTexture2D", attachment,
1148                                     "attachment");
1149     return error::kNoError;
1150   }
1151   if (!validators_->texture_target.IsValid(textarget)) {
1152     LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferTexture2D", textarget,
1153                                     "textarget");
1154     return error::kNoError;
1155   }
1156   DoFramebufferTexture2D(target, attachment, textarget, texture, level);
1157   return error::kNoError;
1158 }
1159
1160 error::Error GLES2DecoderImpl::HandleFramebufferTextureLayer(
1161     uint32_t immediate_data_size,
1162     const void* cmd_data) {
1163   if (!unsafe_es3_apis_enabled())
1164     return error::kUnknownCommand;
1165   const gles2::cmds::FramebufferTextureLayer& c =
1166       *static_cast<const gles2::cmds::FramebufferTextureLayer*>(cmd_data);
1167   (void)c;
1168   GLenum target = static_cast<GLenum>(c.target);
1169   GLenum attachment = static_cast<GLenum>(c.attachment);
1170   GLuint texture = c.texture;
1171   GLint level = static_cast<GLint>(c.level);
1172   GLint layer = static_cast<GLint>(c.layer);
1173   DoFramebufferTextureLayer(target, attachment, texture, level, layer);
1174   return error::kNoError;
1175 }
1176
1177 error::Error GLES2DecoderImpl::HandleFrontFace(uint32_t immediate_data_size,
1178                                                const void* cmd_data) {
1179   const gles2::cmds::FrontFace& c =
1180       *static_cast<const gles2::cmds::FrontFace*>(cmd_data);
1181   (void)c;
1182   GLenum mode = static_cast<GLenum>(c.mode);
1183   if (!validators_->face_mode.IsValid(mode)) {
1184     LOCAL_SET_GL_ERROR_INVALID_ENUM("glFrontFace", mode, "mode");
1185     return error::kNoError;
1186   }
1187   if (state_.front_face != mode) {
1188     state_.front_face = mode;
1189     glFrontFace(mode);
1190   }
1191   return error::kNoError;
1192 }
1193
1194 error::Error GLES2DecoderImpl::HandleGenBuffersImmediate(
1195     uint32_t immediate_data_size,
1196     const void* cmd_data) {
1197   const gles2::cmds::GenBuffersImmediate& c =
1198       *static_cast<const gles2::cmds::GenBuffersImmediate*>(cmd_data);
1199   (void)c;
1200   GLsizei n = static_cast<GLsizei>(c.n);
1201   uint32_t data_size;
1202   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
1203     return error::kOutOfBounds;
1204   }
1205   GLuint* buffers =
1206       GetImmediateDataAs<GLuint*>(c, data_size, immediate_data_size);
1207   if (buffers == NULL) {
1208     return error::kOutOfBounds;
1209   }
1210   if (!GenBuffersHelper(n, buffers)) {
1211     return error::kInvalidArguments;
1212   }
1213   return error::kNoError;
1214 }
1215
1216 error::Error GLES2DecoderImpl::HandleGenerateMipmap(
1217     uint32_t immediate_data_size,
1218     const void* cmd_data) {
1219   const gles2::cmds::GenerateMipmap& c =
1220       *static_cast<const gles2::cmds::GenerateMipmap*>(cmd_data);
1221   (void)c;
1222   GLenum target = static_cast<GLenum>(c.target);
1223   if (!validators_->texture_bind_target.IsValid(target)) {
1224     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGenerateMipmap", target, "target");
1225     return error::kNoError;
1226   }
1227   DoGenerateMipmap(target);
1228   return error::kNoError;
1229 }
1230
1231 error::Error GLES2DecoderImpl::HandleGenFramebuffersImmediate(
1232     uint32_t immediate_data_size,
1233     const void* cmd_data) {
1234   const gles2::cmds::GenFramebuffersImmediate& c =
1235       *static_cast<const gles2::cmds::GenFramebuffersImmediate*>(cmd_data);
1236   (void)c;
1237   GLsizei n = static_cast<GLsizei>(c.n);
1238   uint32_t data_size;
1239   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
1240     return error::kOutOfBounds;
1241   }
1242   GLuint* framebuffers =
1243       GetImmediateDataAs<GLuint*>(c, data_size, immediate_data_size);
1244   if (framebuffers == NULL) {
1245     return error::kOutOfBounds;
1246   }
1247   if (!GenFramebuffersHelper(n, framebuffers)) {
1248     return error::kInvalidArguments;
1249   }
1250   return error::kNoError;
1251 }
1252
1253 error::Error GLES2DecoderImpl::HandleGenRenderbuffersImmediate(
1254     uint32_t immediate_data_size,
1255     const void* cmd_data) {
1256   const gles2::cmds::GenRenderbuffersImmediate& c =
1257       *static_cast<const gles2::cmds::GenRenderbuffersImmediate*>(cmd_data);
1258   (void)c;
1259   GLsizei n = static_cast<GLsizei>(c.n);
1260   uint32_t data_size;
1261   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
1262     return error::kOutOfBounds;
1263   }
1264   GLuint* renderbuffers =
1265       GetImmediateDataAs<GLuint*>(c, data_size, immediate_data_size);
1266   if (renderbuffers == NULL) {
1267     return error::kOutOfBounds;
1268   }
1269   if (!GenRenderbuffersHelper(n, renderbuffers)) {
1270     return error::kInvalidArguments;
1271   }
1272   return error::kNoError;
1273 }
1274
1275 error::Error GLES2DecoderImpl::HandleGenSamplersImmediate(
1276     uint32_t immediate_data_size,
1277     const void* cmd_data) {
1278   if (!unsafe_es3_apis_enabled())
1279     return error::kUnknownCommand;
1280   const gles2::cmds::GenSamplersImmediate& c =
1281       *static_cast<const gles2::cmds::GenSamplersImmediate*>(cmd_data);
1282   (void)c;
1283   GLsizei n = static_cast<GLsizei>(c.n);
1284   uint32_t data_size;
1285   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
1286     return error::kOutOfBounds;
1287   }
1288   GLuint* samplers =
1289       GetImmediateDataAs<GLuint*>(c, data_size, immediate_data_size);
1290   if (samplers == NULL) {
1291     return error::kOutOfBounds;
1292   }
1293   for (GLsizei ii = 0; ii < n; ++ii) {
1294     if (group_->GetSamplerServiceId(samplers[ii], NULL)) {
1295       return error::kInvalidArguments;
1296     }
1297   }
1298   scoped_ptr<GLuint[]> service_ids(new GLuint[n]);
1299   glGenSamplers(n, service_ids.get());
1300   for (GLsizei ii = 0; ii < n; ++ii) {
1301     group_->AddSamplerId(samplers[ii], service_ids[ii]);
1302   }
1303   return error::kNoError;
1304 }
1305
1306 error::Error GLES2DecoderImpl::HandleGenTexturesImmediate(
1307     uint32_t immediate_data_size,
1308     const void* cmd_data) {
1309   const gles2::cmds::GenTexturesImmediate& c =
1310       *static_cast<const gles2::cmds::GenTexturesImmediate*>(cmd_data);
1311   (void)c;
1312   GLsizei n = static_cast<GLsizei>(c.n);
1313   uint32_t data_size;
1314   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
1315     return error::kOutOfBounds;
1316   }
1317   GLuint* textures =
1318       GetImmediateDataAs<GLuint*>(c, data_size, immediate_data_size);
1319   if (textures == NULL) {
1320     return error::kOutOfBounds;
1321   }
1322   if (!GenTexturesHelper(n, textures)) {
1323     return error::kInvalidArguments;
1324   }
1325   return error::kNoError;
1326 }
1327
1328 error::Error GLES2DecoderImpl::HandleGenTransformFeedbacksImmediate(
1329     uint32_t immediate_data_size,
1330     const void* cmd_data) {
1331   if (!unsafe_es3_apis_enabled())
1332     return error::kUnknownCommand;
1333   const gles2::cmds::GenTransformFeedbacksImmediate& c =
1334       *static_cast<const gles2::cmds::GenTransformFeedbacksImmediate*>(
1335           cmd_data);
1336   (void)c;
1337   GLsizei n = static_cast<GLsizei>(c.n);
1338   uint32_t data_size;
1339   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
1340     return error::kOutOfBounds;
1341   }
1342   GLuint* ids = GetImmediateDataAs<GLuint*>(c, data_size, immediate_data_size);
1343   if (ids == NULL) {
1344     return error::kOutOfBounds;
1345   }
1346   for (GLsizei ii = 0; ii < n; ++ii) {
1347     if (group_->GetTransformFeedbackServiceId(ids[ii], NULL)) {
1348       return error::kInvalidArguments;
1349     }
1350   }
1351   scoped_ptr<GLuint[]> service_ids(new GLuint[n]);
1352   glGenTransformFeedbacks(n, service_ids.get());
1353   for (GLsizei ii = 0; ii < n; ++ii) {
1354     group_->AddTransformFeedbackId(ids[ii], service_ids[ii]);
1355   }
1356   return error::kNoError;
1357 }
1358
1359 error::Error GLES2DecoderImpl::HandleGetBooleanv(uint32_t immediate_data_size,
1360                                                  const void* cmd_data) {
1361   const gles2::cmds::GetBooleanv& c =
1362       *static_cast<const gles2::cmds::GetBooleanv*>(cmd_data);
1363   (void)c;
1364   GLenum pname = static_cast<GLenum>(c.pname);
1365   typedef cmds::GetBooleanv::Result Result;
1366   GLsizei num_values = 0;
1367   GetNumValuesReturnedForGLGet(pname, &num_values);
1368   Result* result = GetSharedMemoryAs<Result*>(
1369       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1370   GLboolean* params = result ? result->GetData() : NULL;
1371   if (!validators_->g_l_state.IsValid(pname)) {
1372     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetBooleanv", pname, "pname");
1373     return error::kNoError;
1374   }
1375   if (params == NULL) {
1376     return error::kOutOfBounds;
1377   }
1378   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetBooleanv");
1379   // Check that the client initialized the result.
1380   if (result->size != 0) {
1381     return error::kInvalidArguments;
1382   }
1383   DoGetBooleanv(pname, params);
1384   GLenum error = glGetError();
1385   if (error == GL_NO_ERROR) {
1386     result->SetNumResults(num_values);
1387   } else {
1388     LOCAL_SET_GL_ERROR(error, "GetBooleanv", "");
1389   }
1390   return error::kNoError;
1391 }
1392
1393 error::Error GLES2DecoderImpl::HandleGetBufferParameteriv(
1394     uint32_t immediate_data_size,
1395     const void* cmd_data) {
1396   const gles2::cmds::GetBufferParameteriv& c =
1397       *static_cast<const gles2::cmds::GetBufferParameteriv*>(cmd_data);
1398   (void)c;
1399   GLenum target = static_cast<GLenum>(c.target);
1400   GLenum pname = static_cast<GLenum>(c.pname);
1401   typedef cmds::GetBufferParameteriv::Result Result;
1402   GLsizei num_values = 0;
1403   GetNumValuesReturnedForGLGet(pname, &num_values);
1404   Result* result = GetSharedMemoryAs<Result*>(
1405       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1406   GLint* params = result ? result->GetData() : NULL;
1407   if (!validators_->buffer_target.IsValid(target)) {
1408     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetBufferParameteriv", target, "target");
1409     return error::kNoError;
1410   }
1411   if (!validators_->buffer_parameter.IsValid(pname)) {
1412     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetBufferParameteriv", pname, "pname");
1413     return error::kNoError;
1414   }
1415   if (params == NULL) {
1416     return error::kOutOfBounds;
1417   }
1418   // Check that the client initialized the result.
1419   if (result->size != 0) {
1420     return error::kInvalidArguments;
1421   }
1422   DoGetBufferParameteriv(target, pname, params);
1423   result->SetNumResults(num_values);
1424   return error::kNoError;
1425 }
1426 error::Error GLES2DecoderImpl::HandleGetError(uint32_t immediate_data_size,
1427                                               const void* cmd_data) {
1428   const gles2::cmds::GetError& c =
1429       *static_cast<const gles2::cmds::GetError*>(cmd_data);
1430   (void)c;
1431   typedef cmds::GetError::Result Result;
1432   Result* result_dst = GetSharedMemoryAs<Result*>(
1433       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
1434   if (!result_dst) {
1435     return error::kOutOfBounds;
1436   }
1437   *result_dst = GetErrorState()->GetGLError();
1438   return error::kNoError;
1439 }
1440
1441 error::Error GLES2DecoderImpl::HandleGetFloatv(uint32_t immediate_data_size,
1442                                                const void* cmd_data) {
1443   const gles2::cmds::GetFloatv& c =
1444       *static_cast<const gles2::cmds::GetFloatv*>(cmd_data);
1445   (void)c;
1446   GLenum pname = static_cast<GLenum>(c.pname);
1447   typedef cmds::GetFloatv::Result Result;
1448   GLsizei num_values = 0;
1449   GetNumValuesReturnedForGLGet(pname, &num_values);
1450   Result* result = GetSharedMemoryAs<Result*>(
1451       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1452   GLfloat* params = result ? result->GetData() : NULL;
1453   if (!validators_->g_l_state.IsValid(pname)) {
1454     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetFloatv", pname, "pname");
1455     return error::kNoError;
1456   }
1457   if (params == NULL) {
1458     return error::kOutOfBounds;
1459   }
1460   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetFloatv");
1461   // Check that the client initialized the result.
1462   if (result->size != 0) {
1463     return error::kInvalidArguments;
1464   }
1465   DoGetFloatv(pname, params);
1466   GLenum error = glGetError();
1467   if (error == GL_NO_ERROR) {
1468     result->SetNumResults(num_values);
1469   } else {
1470     LOCAL_SET_GL_ERROR(error, "GetFloatv", "");
1471   }
1472   return error::kNoError;
1473 }
1474
1475 error::Error GLES2DecoderImpl::HandleGetFramebufferAttachmentParameteriv(
1476     uint32_t immediate_data_size,
1477     const void* cmd_data) {
1478   const gles2::cmds::GetFramebufferAttachmentParameteriv& c =
1479       *static_cast<const gles2::cmds::GetFramebufferAttachmentParameteriv*>(
1480           cmd_data);
1481   (void)c;
1482   GLenum target = static_cast<GLenum>(c.target);
1483   GLenum attachment = static_cast<GLenum>(c.attachment);
1484   GLenum pname = static_cast<GLenum>(c.pname);
1485   typedef cmds::GetFramebufferAttachmentParameteriv::Result Result;
1486   GLsizei num_values = 0;
1487   GetNumValuesReturnedForGLGet(pname, &num_values);
1488   Result* result = GetSharedMemoryAs<Result*>(
1489       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1490   GLint* params = result ? result->GetData() : NULL;
1491   if (!validators_->frame_buffer_target.IsValid(target)) {
1492     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetFramebufferAttachmentParameteriv",
1493                                     target, "target");
1494     return error::kNoError;
1495   }
1496   if (!validators_->attachment.IsValid(attachment)) {
1497     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetFramebufferAttachmentParameteriv",
1498                                     attachment, "attachment");
1499     return error::kNoError;
1500   }
1501   if (!validators_->frame_buffer_parameter.IsValid(pname)) {
1502     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetFramebufferAttachmentParameteriv",
1503                                     pname, "pname");
1504     return error::kNoError;
1505   }
1506   if (params == NULL) {
1507     return error::kOutOfBounds;
1508   }
1509   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetFramebufferAttachmentParameteriv");
1510   // Check that the client initialized the result.
1511   if (result->size != 0) {
1512     return error::kInvalidArguments;
1513   }
1514   DoGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
1515   GLenum error = glGetError();
1516   if (error == GL_NO_ERROR) {
1517     result->SetNumResults(num_values);
1518   } else {
1519     LOCAL_SET_GL_ERROR(error, "GetFramebufferAttachmentParameteriv", "");
1520   }
1521   return error::kNoError;
1522 }
1523
1524 error::Error GLES2DecoderImpl::HandleGetInteger64v(uint32_t immediate_data_size,
1525                                                    const void* cmd_data) {
1526   if (!unsafe_es3_apis_enabled())
1527     return error::kUnknownCommand;
1528   const gles2::cmds::GetInteger64v& c =
1529       *static_cast<const gles2::cmds::GetInteger64v*>(cmd_data);
1530   (void)c;
1531   GLenum pname = static_cast<GLenum>(c.pname);
1532   typedef cmds::GetInteger64v::Result Result;
1533   GLsizei num_values = 0;
1534   GetNumValuesReturnedForGLGet(pname, &num_values);
1535   Result* result = GetSharedMemoryAs<Result*>(
1536       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1537   GLint64* params = result ? result->GetData() : NULL;
1538   if (params == NULL) {
1539     return error::kOutOfBounds;
1540   }
1541   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetInteger64v");
1542   // Check that the client initialized the result.
1543   if (result->size != 0) {
1544     return error::kInvalidArguments;
1545   }
1546   DoGetInteger64v(pname, params);
1547   GLenum error = glGetError();
1548   if (error == GL_NO_ERROR) {
1549     result->SetNumResults(num_values);
1550   } else {
1551     LOCAL_SET_GL_ERROR(error, "GetInteger64v", "");
1552   }
1553   return error::kNoError;
1554 }
1555
1556 error::Error GLES2DecoderImpl::HandleGetIntegeri_v(uint32_t immediate_data_size,
1557                                                    const void* cmd_data) {
1558   if (!unsafe_es3_apis_enabled())
1559     return error::kUnknownCommand;
1560   const gles2::cmds::GetIntegeri_v& c =
1561       *static_cast<const gles2::cmds::GetIntegeri_v*>(cmd_data);
1562   (void)c;
1563   GLenum pname = static_cast<GLenum>(c.pname);
1564   GLuint index = static_cast<GLuint>(c.index);
1565   typedef cmds::GetIntegeri_v::Result Result;
1566   GLsizei num_values = 0;
1567   GetNumValuesReturnedForGLGet(pname, &num_values);
1568   Result* result = GetSharedMemoryAs<Result*>(c.data_shm_id, c.data_shm_offset,
1569                                               Result::ComputeSize(num_values));
1570   GLint* data = result ? result->GetData() : NULL;
1571   if (data == NULL) {
1572     return error::kOutOfBounds;
1573   }
1574   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetIntegeri_v");
1575   // Check that the client initialized the result.
1576   if (result->size != 0) {
1577     return error::kInvalidArguments;
1578   }
1579   glGetIntegeri_v(pname, index, data);
1580   GLenum error = glGetError();
1581   if (error == GL_NO_ERROR) {
1582     result->SetNumResults(num_values);
1583   } else {
1584     LOCAL_SET_GL_ERROR(error, "GetIntegeri_v", "");
1585   }
1586   return error::kNoError;
1587 }
1588
1589 error::Error GLES2DecoderImpl::HandleGetInteger64i_v(
1590     uint32_t immediate_data_size,
1591     const void* cmd_data) {
1592   if (!unsafe_es3_apis_enabled())
1593     return error::kUnknownCommand;
1594   const gles2::cmds::GetInteger64i_v& c =
1595       *static_cast<const gles2::cmds::GetInteger64i_v*>(cmd_data);
1596   (void)c;
1597   GLenum pname = static_cast<GLenum>(c.pname);
1598   GLuint index = static_cast<GLuint>(c.index);
1599   typedef cmds::GetInteger64i_v::Result Result;
1600   GLsizei num_values = 0;
1601   GetNumValuesReturnedForGLGet(pname, &num_values);
1602   Result* result = GetSharedMemoryAs<Result*>(c.data_shm_id, c.data_shm_offset,
1603                                               Result::ComputeSize(num_values));
1604   GLint64* data = result ? result->GetData() : NULL;
1605   if (data == NULL) {
1606     return error::kOutOfBounds;
1607   }
1608   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetInteger64i_v");
1609   // Check that the client initialized the result.
1610   if (result->size != 0) {
1611     return error::kInvalidArguments;
1612   }
1613   glGetInteger64i_v(pname, index, data);
1614   GLenum error = glGetError();
1615   if (error == GL_NO_ERROR) {
1616     result->SetNumResults(num_values);
1617   } else {
1618     LOCAL_SET_GL_ERROR(error, "GetInteger64i_v", "");
1619   }
1620   return error::kNoError;
1621 }
1622
1623 error::Error GLES2DecoderImpl::HandleGetIntegerv(uint32_t immediate_data_size,
1624                                                  const void* cmd_data) {
1625   const gles2::cmds::GetIntegerv& c =
1626       *static_cast<const gles2::cmds::GetIntegerv*>(cmd_data);
1627   (void)c;
1628   GLenum pname = static_cast<GLenum>(c.pname);
1629   typedef cmds::GetIntegerv::Result Result;
1630   GLsizei num_values = 0;
1631   GetNumValuesReturnedForGLGet(pname, &num_values);
1632   Result* result = GetSharedMemoryAs<Result*>(
1633       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1634   GLint* params = result ? result->GetData() : NULL;
1635   if (!validators_->g_l_state.IsValid(pname)) {
1636     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetIntegerv", pname, "pname");
1637     return error::kNoError;
1638   }
1639   if (params == NULL) {
1640     return error::kOutOfBounds;
1641   }
1642   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetIntegerv");
1643   // Check that the client initialized the result.
1644   if (result->size != 0) {
1645     return error::kInvalidArguments;
1646   }
1647   DoGetIntegerv(pname, params);
1648   GLenum error = glGetError();
1649   if (error == GL_NO_ERROR) {
1650     result->SetNumResults(num_values);
1651   } else {
1652     LOCAL_SET_GL_ERROR(error, "GetIntegerv", "");
1653   }
1654   return error::kNoError;
1655 }
1656
1657 error::Error GLES2DecoderImpl::HandleGetInternalformativ(
1658     uint32_t immediate_data_size,
1659     const void* cmd_data) {
1660   if (!unsafe_es3_apis_enabled())
1661     return error::kUnknownCommand;
1662   const gles2::cmds::GetInternalformativ& c =
1663       *static_cast<const gles2::cmds::GetInternalformativ*>(cmd_data);
1664   (void)c;
1665   GLenum target = static_cast<GLenum>(c.target);
1666   GLenum format = static_cast<GLenum>(c.format);
1667   GLenum pname = static_cast<GLenum>(c.pname);
1668   GLsizei bufSize = static_cast<GLsizei>(c.bufSize);
1669   typedef cmds::GetInternalformativ::Result Result;
1670   GLsizei num_values = 0;
1671   GetNumValuesReturnedForGLGet(pname, &num_values);
1672   Result* result = GetSharedMemoryAs<Result*>(
1673       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1674   GLint* params = result ? result->GetData() : NULL;
1675   if (params == NULL) {
1676     return error::kOutOfBounds;
1677   }
1678   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetInternalformativ");
1679   // Check that the client initialized the result.
1680   if (result->size != 0) {
1681     return error::kInvalidArguments;
1682   }
1683   glGetInternalformativ(target, format, pname, bufSize, params);
1684   GLenum error = glGetError();
1685   if (error == GL_NO_ERROR) {
1686     result->SetNumResults(num_values);
1687   } else {
1688     LOCAL_SET_GL_ERROR(error, "GetInternalformativ", "");
1689   }
1690   return error::kNoError;
1691 }
1692
1693 error::Error GLES2DecoderImpl::HandleGetProgramiv(uint32_t immediate_data_size,
1694                                                   const void* cmd_data) {
1695   const gles2::cmds::GetProgramiv& c =
1696       *static_cast<const gles2::cmds::GetProgramiv*>(cmd_data);
1697   (void)c;
1698   GLuint program = c.program;
1699   GLenum pname = static_cast<GLenum>(c.pname);
1700   typedef cmds::GetProgramiv::Result Result;
1701   GLsizei num_values = 0;
1702   GetNumValuesReturnedForGLGet(pname, &num_values);
1703   Result* result = GetSharedMemoryAs<Result*>(
1704       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1705   GLint* params = result ? result->GetData() : NULL;
1706   if (!validators_->program_parameter.IsValid(pname)) {
1707     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetProgramiv", pname, "pname");
1708     return error::kNoError;
1709   }
1710   if (params == NULL) {
1711     return error::kOutOfBounds;
1712   }
1713   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetProgramiv");
1714   // Check that the client initialized the result.
1715   if (result->size != 0) {
1716     return error::kInvalidArguments;
1717   }
1718   DoGetProgramiv(program, pname, params);
1719   GLenum error = glGetError();
1720   if (error == GL_NO_ERROR) {
1721     result->SetNumResults(num_values);
1722   } else {
1723     LOCAL_SET_GL_ERROR(error, "GetProgramiv", "");
1724   }
1725   return error::kNoError;
1726 }
1727
1728 error::Error GLES2DecoderImpl::HandleGetRenderbufferParameteriv(
1729     uint32_t immediate_data_size,
1730     const void* cmd_data) {
1731   const gles2::cmds::GetRenderbufferParameteriv& c =
1732       *static_cast<const gles2::cmds::GetRenderbufferParameteriv*>(cmd_data);
1733   (void)c;
1734   GLenum target = static_cast<GLenum>(c.target);
1735   GLenum pname = static_cast<GLenum>(c.pname);
1736   typedef cmds::GetRenderbufferParameteriv::Result Result;
1737   GLsizei num_values = 0;
1738   GetNumValuesReturnedForGLGet(pname, &num_values);
1739   Result* result = GetSharedMemoryAs<Result*>(
1740       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1741   GLint* params = result ? result->GetData() : NULL;
1742   if (!validators_->render_buffer_target.IsValid(target)) {
1743     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetRenderbufferParameteriv", target,
1744                                     "target");
1745     return error::kNoError;
1746   }
1747   if (!validators_->render_buffer_parameter.IsValid(pname)) {
1748     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetRenderbufferParameteriv", pname,
1749                                     "pname");
1750     return error::kNoError;
1751   }
1752   if (params == NULL) {
1753     return error::kOutOfBounds;
1754   }
1755   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetRenderbufferParameteriv");
1756   // Check that the client initialized the result.
1757   if (result->size != 0) {
1758     return error::kInvalidArguments;
1759   }
1760   DoGetRenderbufferParameteriv(target, pname, params);
1761   GLenum error = glGetError();
1762   if (error == GL_NO_ERROR) {
1763     result->SetNumResults(num_values);
1764   } else {
1765     LOCAL_SET_GL_ERROR(error, "GetRenderbufferParameteriv", "");
1766   }
1767   return error::kNoError;
1768 }
1769
1770 error::Error GLES2DecoderImpl::HandleGetSamplerParameterfv(
1771     uint32_t immediate_data_size,
1772     const void* cmd_data) {
1773   if (!unsafe_es3_apis_enabled())
1774     return error::kUnknownCommand;
1775   const gles2::cmds::GetSamplerParameterfv& c =
1776       *static_cast<const gles2::cmds::GetSamplerParameterfv*>(cmd_data);
1777   (void)c;
1778   GLuint sampler = c.sampler;
1779   GLenum pname = static_cast<GLenum>(c.pname);
1780   typedef cmds::GetSamplerParameterfv::Result Result;
1781   GLsizei num_values = 0;
1782   GetNumValuesReturnedForGLGet(pname, &num_values);
1783   Result* result = GetSharedMemoryAs<Result*>(
1784       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1785   GLfloat* params = result ? result->GetData() : NULL;
1786   if (params == NULL) {
1787     return error::kOutOfBounds;
1788   }
1789   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetSamplerParameterfv");
1790   // Check that the client initialized the result.
1791   if (result->size != 0) {
1792     return error::kInvalidArguments;
1793   }
1794   if (!group_->GetSamplerServiceId(sampler, &sampler)) {
1795     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glGetSamplerParameterfv",
1796                        "invalid sampler id");
1797     return error::kNoError;
1798   }
1799   glGetSamplerParameterfv(sampler, pname, params);
1800   GLenum error = glGetError();
1801   if (error == GL_NO_ERROR) {
1802     result->SetNumResults(num_values);
1803   } else {
1804     LOCAL_SET_GL_ERROR(error, "GetSamplerParameterfv", "");
1805   }
1806   return error::kNoError;
1807 }
1808
1809 error::Error GLES2DecoderImpl::HandleGetSamplerParameteriv(
1810     uint32_t immediate_data_size,
1811     const void* cmd_data) {
1812   if (!unsafe_es3_apis_enabled())
1813     return error::kUnknownCommand;
1814   const gles2::cmds::GetSamplerParameteriv& c =
1815       *static_cast<const gles2::cmds::GetSamplerParameteriv*>(cmd_data);
1816   (void)c;
1817   GLuint sampler = c.sampler;
1818   GLenum pname = static_cast<GLenum>(c.pname);
1819   typedef cmds::GetSamplerParameteriv::Result Result;
1820   GLsizei num_values = 0;
1821   GetNumValuesReturnedForGLGet(pname, &num_values);
1822   Result* result = GetSharedMemoryAs<Result*>(
1823       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1824   GLint* params = result ? result->GetData() : NULL;
1825   if (params == NULL) {
1826     return error::kOutOfBounds;
1827   }
1828   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetSamplerParameteriv");
1829   // Check that the client initialized the result.
1830   if (result->size != 0) {
1831     return error::kInvalidArguments;
1832   }
1833   if (!group_->GetSamplerServiceId(sampler, &sampler)) {
1834     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glGetSamplerParameteriv",
1835                        "invalid sampler id");
1836     return error::kNoError;
1837   }
1838   glGetSamplerParameteriv(sampler, pname, params);
1839   GLenum error = glGetError();
1840   if (error == GL_NO_ERROR) {
1841     result->SetNumResults(num_values);
1842   } else {
1843     LOCAL_SET_GL_ERROR(error, "GetSamplerParameteriv", "");
1844   }
1845   return error::kNoError;
1846 }
1847
1848 error::Error GLES2DecoderImpl::HandleGetShaderiv(uint32_t immediate_data_size,
1849                                                  const void* cmd_data) {
1850   const gles2::cmds::GetShaderiv& c =
1851       *static_cast<const gles2::cmds::GetShaderiv*>(cmd_data);
1852   (void)c;
1853   GLuint shader = c.shader;
1854   GLenum pname = static_cast<GLenum>(c.pname);
1855   typedef cmds::GetShaderiv::Result Result;
1856   GLsizei num_values = 0;
1857   GetNumValuesReturnedForGLGet(pname, &num_values);
1858   Result* result = GetSharedMemoryAs<Result*>(
1859       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1860   GLint* params = result ? result->GetData() : NULL;
1861   if (!validators_->shader_parameter.IsValid(pname)) {
1862     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetShaderiv", pname, "pname");
1863     return error::kNoError;
1864   }
1865   if (params == NULL) {
1866     return error::kOutOfBounds;
1867   }
1868   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetShaderiv");
1869   // Check that the client initialized the result.
1870   if (result->size != 0) {
1871     return error::kInvalidArguments;
1872   }
1873   DoGetShaderiv(shader, pname, params);
1874   GLenum error = glGetError();
1875   if (error == GL_NO_ERROR) {
1876     result->SetNumResults(num_values);
1877   } else {
1878     LOCAL_SET_GL_ERROR(error, "GetShaderiv", "");
1879   }
1880   return error::kNoError;
1881 }
1882
1883 error::Error GLES2DecoderImpl::HandleGetSynciv(uint32_t immediate_data_size,
1884                                                const void* cmd_data) {
1885   if (!unsafe_es3_apis_enabled())
1886     return error::kUnknownCommand;
1887   const gles2::cmds::GetSynciv& c =
1888       *static_cast<const gles2::cmds::GetSynciv*>(cmd_data);
1889   (void)c;
1890   GLuint sync = static_cast<GLuint>(c.sync);
1891   GLenum pname = static_cast<GLenum>(c.pname);
1892   typedef cmds::GetSynciv::Result Result;
1893   GLsizei num_values = 0;
1894   GetNumValuesReturnedForGLGet(pname, &num_values);
1895   Result* result = GetSharedMemoryAs<Result*>(
1896       c.values_shm_id, c.values_shm_offset, Result::ComputeSize(num_values));
1897   GLint* values = result ? result->GetData() : NULL;
1898   if (values == NULL) {
1899     return error::kOutOfBounds;
1900   }
1901   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetSynciv");
1902   // Check that the client initialized the result.
1903   if (result->size != 0) {
1904     return error::kInvalidArguments;
1905   }
1906   GLsync service_sync = 0;
1907   if (!group_->GetSyncServiceId(sync, &service_sync)) {
1908     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glGetSynciv", "invalid sync id");
1909     return error::kNoError;
1910   }
1911   glGetSynciv(service_sync, pname, num_values, nullptr, values);
1912   GLenum error = glGetError();
1913   if (error == GL_NO_ERROR) {
1914     result->SetNumResults(num_values);
1915   } else {
1916     LOCAL_SET_GL_ERROR(error, "GetSynciv", "");
1917   }
1918   return error::kNoError;
1919 }
1920
1921 error::Error GLES2DecoderImpl::HandleGetTexParameterfv(
1922     uint32_t immediate_data_size,
1923     const void* cmd_data) {
1924   const gles2::cmds::GetTexParameterfv& c =
1925       *static_cast<const gles2::cmds::GetTexParameterfv*>(cmd_data);
1926   (void)c;
1927   GLenum target = static_cast<GLenum>(c.target);
1928   GLenum pname = static_cast<GLenum>(c.pname);
1929   typedef cmds::GetTexParameterfv::Result Result;
1930   GLsizei num_values = 0;
1931   GetNumValuesReturnedForGLGet(pname, &num_values);
1932   Result* result = GetSharedMemoryAs<Result*>(
1933       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1934   GLfloat* params = result ? result->GetData() : NULL;
1935   if (!validators_->get_tex_param_target.IsValid(target)) {
1936     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetTexParameterfv", target, "target");
1937     return error::kNoError;
1938   }
1939   if (!validators_->texture_parameter.IsValid(pname)) {
1940     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetTexParameterfv", pname, "pname");
1941     return error::kNoError;
1942   }
1943   if (params == NULL) {
1944     return error::kOutOfBounds;
1945   }
1946   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetTexParameterfv");
1947   // Check that the client initialized the result.
1948   if (result->size != 0) {
1949     return error::kInvalidArguments;
1950   }
1951   DoGetTexParameterfv(target, pname, params);
1952   GLenum error = glGetError();
1953   if (error == GL_NO_ERROR) {
1954     result->SetNumResults(num_values);
1955   } else {
1956     LOCAL_SET_GL_ERROR(error, "GetTexParameterfv", "");
1957   }
1958   return error::kNoError;
1959 }
1960
1961 error::Error GLES2DecoderImpl::HandleGetTexParameteriv(
1962     uint32_t immediate_data_size,
1963     const void* cmd_data) {
1964   const gles2::cmds::GetTexParameteriv& c =
1965       *static_cast<const gles2::cmds::GetTexParameteriv*>(cmd_data);
1966   (void)c;
1967   GLenum target = static_cast<GLenum>(c.target);
1968   GLenum pname = static_cast<GLenum>(c.pname);
1969   typedef cmds::GetTexParameteriv::Result Result;
1970   GLsizei num_values = 0;
1971   GetNumValuesReturnedForGLGet(pname, &num_values);
1972   Result* result = GetSharedMemoryAs<Result*>(
1973       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
1974   GLint* params = result ? result->GetData() : NULL;
1975   if (!validators_->get_tex_param_target.IsValid(target)) {
1976     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetTexParameteriv", target, "target");
1977     return error::kNoError;
1978   }
1979   if (!validators_->texture_parameter.IsValid(pname)) {
1980     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetTexParameteriv", pname, "pname");
1981     return error::kNoError;
1982   }
1983   if (params == NULL) {
1984     return error::kOutOfBounds;
1985   }
1986   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetTexParameteriv");
1987   // Check that the client initialized the result.
1988   if (result->size != 0) {
1989     return error::kInvalidArguments;
1990   }
1991   DoGetTexParameteriv(target, pname, params);
1992   GLenum error = glGetError();
1993   if (error == GL_NO_ERROR) {
1994     result->SetNumResults(num_values);
1995   } else {
1996     LOCAL_SET_GL_ERROR(error, "GetTexParameteriv", "");
1997   }
1998   return error::kNoError;
1999 }
2000
2001 error::Error GLES2DecoderImpl::HandleGetVertexAttribfv(
2002     uint32_t immediate_data_size,
2003     const void* cmd_data) {
2004   const gles2::cmds::GetVertexAttribfv& c =
2005       *static_cast<const gles2::cmds::GetVertexAttribfv*>(cmd_data);
2006   (void)c;
2007   GLuint index = static_cast<GLuint>(c.index);
2008   GLenum pname = static_cast<GLenum>(c.pname);
2009   typedef cmds::GetVertexAttribfv::Result Result;
2010   GLsizei num_values = 0;
2011   GetNumValuesReturnedForGLGet(pname, &num_values);
2012   Result* result = GetSharedMemoryAs<Result*>(
2013       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
2014   GLfloat* params = result ? result->GetData() : NULL;
2015   if (!validators_->vertex_attribute.IsValid(pname)) {
2016     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetVertexAttribfv", pname, "pname");
2017     return error::kNoError;
2018   }
2019   if (params == NULL) {
2020     return error::kOutOfBounds;
2021   }
2022   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetVertexAttribfv");
2023   // Check that the client initialized the result.
2024   if (result->size != 0) {
2025     return error::kInvalidArguments;
2026   }
2027   DoGetVertexAttribfv(index, pname, params);
2028   GLenum error = glGetError();
2029   if (error == GL_NO_ERROR) {
2030     result->SetNumResults(num_values);
2031   } else {
2032     LOCAL_SET_GL_ERROR(error, "GetVertexAttribfv", "");
2033   }
2034   return error::kNoError;
2035 }
2036
2037 error::Error GLES2DecoderImpl::HandleGetVertexAttribiv(
2038     uint32_t immediate_data_size,
2039     const void* cmd_data) {
2040   const gles2::cmds::GetVertexAttribiv& c =
2041       *static_cast<const gles2::cmds::GetVertexAttribiv*>(cmd_data);
2042   (void)c;
2043   GLuint index = static_cast<GLuint>(c.index);
2044   GLenum pname = static_cast<GLenum>(c.pname);
2045   typedef cmds::GetVertexAttribiv::Result Result;
2046   GLsizei num_values = 0;
2047   GetNumValuesReturnedForGLGet(pname, &num_values);
2048   Result* result = GetSharedMemoryAs<Result*>(
2049       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
2050   GLint* params = result ? result->GetData() : NULL;
2051   if (!validators_->vertex_attribute.IsValid(pname)) {
2052     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetVertexAttribiv", pname, "pname");
2053     return error::kNoError;
2054   }
2055   if (params == NULL) {
2056     return error::kOutOfBounds;
2057   }
2058   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetVertexAttribiv");
2059   // Check that the client initialized the result.
2060   if (result->size != 0) {
2061     return error::kInvalidArguments;
2062   }
2063   DoGetVertexAttribiv(index, pname, params);
2064   GLenum error = glGetError();
2065   if (error == GL_NO_ERROR) {
2066     result->SetNumResults(num_values);
2067   } else {
2068     LOCAL_SET_GL_ERROR(error, "GetVertexAttribiv", "");
2069   }
2070   return error::kNoError;
2071 }
2072
2073 error::Error GLES2DecoderImpl::HandleHint(uint32_t immediate_data_size,
2074                                           const void* cmd_data) {
2075   const gles2::cmds::Hint& c = *static_cast<const gles2::cmds::Hint*>(cmd_data);
2076   (void)c;
2077   GLenum target = static_cast<GLenum>(c.target);
2078   GLenum mode = static_cast<GLenum>(c.mode);
2079   if (!validators_->hint_target.IsValid(target)) {
2080     LOCAL_SET_GL_ERROR_INVALID_ENUM("glHint", target, "target");
2081     return error::kNoError;
2082   }
2083   if (!validators_->hint_mode.IsValid(mode)) {
2084     LOCAL_SET_GL_ERROR_INVALID_ENUM("glHint", mode, "mode");
2085     return error::kNoError;
2086   }
2087   switch (target) {
2088     case GL_GENERATE_MIPMAP_HINT:
2089       if (state_.hint_generate_mipmap != mode) {
2090         state_.hint_generate_mipmap = mode;
2091         glHint(target, mode);
2092       }
2093       break;
2094     case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES:
2095       if (state_.hint_fragment_shader_derivative != mode) {
2096         state_.hint_fragment_shader_derivative = mode;
2097         glHint(target, mode);
2098       }
2099       break;
2100     default:
2101       NOTREACHED();
2102   }
2103   return error::kNoError;
2104 }
2105
2106 error::Error GLES2DecoderImpl::HandleInvalidateFramebufferImmediate(
2107     uint32_t immediate_data_size,
2108     const void* cmd_data) {
2109   if (!unsafe_es3_apis_enabled())
2110     return error::kUnknownCommand;
2111   const gles2::cmds::InvalidateFramebufferImmediate& c =
2112       *static_cast<const gles2::cmds::InvalidateFramebufferImmediate*>(
2113           cmd_data);
2114   (void)c;
2115   GLenum target = static_cast<GLenum>(c.target);
2116   GLsizei count = static_cast<GLsizei>(c.count);
2117   uint32_t data_size;
2118   if (!ComputeDataSize(count, sizeof(GLenum), 1, &data_size)) {
2119     return error::kOutOfBounds;
2120   }
2121   if (data_size > immediate_data_size) {
2122     return error::kOutOfBounds;
2123   }
2124   const GLenum* attachments =
2125       GetImmediateDataAs<const GLenum*>(c, data_size, immediate_data_size);
2126   if (attachments == NULL) {
2127     return error::kOutOfBounds;
2128   }
2129   glInvalidateFramebuffer(target, count, attachments);
2130   return error::kNoError;
2131 }
2132
2133 error::Error GLES2DecoderImpl::HandleInvalidateSubFramebufferImmediate(
2134     uint32_t immediate_data_size,
2135     const void* cmd_data) {
2136   if (!unsafe_es3_apis_enabled())
2137     return error::kUnknownCommand;
2138   const gles2::cmds::InvalidateSubFramebufferImmediate& c =
2139       *static_cast<const gles2::cmds::InvalidateSubFramebufferImmediate*>(
2140           cmd_data);
2141   (void)c;
2142   GLenum target = static_cast<GLenum>(c.target);
2143   GLsizei count = static_cast<GLsizei>(c.count);
2144   uint32_t data_size;
2145   if (!ComputeDataSize(count, sizeof(GLenum), 1, &data_size)) {
2146     return error::kOutOfBounds;
2147   }
2148   if (data_size > immediate_data_size) {
2149     return error::kOutOfBounds;
2150   }
2151   const GLenum* attachments =
2152       GetImmediateDataAs<const GLenum*>(c, data_size, immediate_data_size);
2153   GLint x = static_cast<GLint>(c.x);
2154   GLint y = static_cast<GLint>(c.y);
2155   GLsizei width = static_cast<GLsizei>(c.width);
2156   GLsizei height = static_cast<GLsizei>(c.height);
2157   if (attachments == NULL) {
2158     return error::kOutOfBounds;
2159   }
2160   glInvalidateSubFramebuffer(target, count, attachments, x, y, width, height);
2161   return error::kNoError;
2162 }
2163
2164 error::Error GLES2DecoderImpl::HandleIsBuffer(uint32_t immediate_data_size,
2165                                               const void* cmd_data) {
2166   const gles2::cmds::IsBuffer& c =
2167       *static_cast<const gles2::cmds::IsBuffer*>(cmd_data);
2168   (void)c;
2169   GLuint buffer = c.buffer;
2170   typedef cmds::IsBuffer::Result Result;
2171   Result* result_dst = GetSharedMemoryAs<Result*>(
2172       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
2173   if (!result_dst) {
2174     return error::kOutOfBounds;
2175   }
2176   *result_dst = DoIsBuffer(buffer);
2177   return error::kNoError;
2178 }
2179
2180 error::Error GLES2DecoderImpl::HandleIsEnabled(uint32_t immediate_data_size,
2181                                                const void* cmd_data) {
2182   const gles2::cmds::IsEnabled& c =
2183       *static_cast<const gles2::cmds::IsEnabled*>(cmd_data);
2184   (void)c;
2185   GLenum cap = static_cast<GLenum>(c.cap);
2186   typedef cmds::IsEnabled::Result Result;
2187   Result* result_dst = GetSharedMemoryAs<Result*>(
2188       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
2189   if (!result_dst) {
2190     return error::kOutOfBounds;
2191   }
2192   if (!validators_->capability.IsValid(cap)) {
2193     LOCAL_SET_GL_ERROR_INVALID_ENUM("glIsEnabled", cap, "cap");
2194     return error::kNoError;
2195   }
2196   *result_dst = DoIsEnabled(cap);
2197   return error::kNoError;
2198 }
2199
2200 error::Error GLES2DecoderImpl::HandleIsFramebuffer(uint32_t immediate_data_size,
2201                                                    const void* cmd_data) {
2202   const gles2::cmds::IsFramebuffer& c =
2203       *static_cast<const gles2::cmds::IsFramebuffer*>(cmd_data);
2204   (void)c;
2205   GLuint framebuffer = c.framebuffer;
2206   typedef cmds::IsFramebuffer::Result Result;
2207   Result* result_dst = GetSharedMemoryAs<Result*>(
2208       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
2209   if (!result_dst) {
2210     return error::kOutOfBounds;
2211   }
2212   *result_dst = DoIsFramebuffer(framebuffer);
2213   return error::kNoError;
2214 }
2215
2216 error::Error GLES2DecoderImpl::HandleIsProgram(uint32_t immediate_data_size,
2217                                                const void* cmd_data) {
2218   const gles2::cmds::IsProgram& c =
2219       *static_cast<const gles2::cmds::IsProgram*>(cmd_data);
2220   (void)c;
2221   GLuint program = c.program;
2222   typedef cmds::IsProgram::Result Result;
2223   Result* result_dst = GetSharedMemoryAs<Result*>(
2224       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
2225   if (!result_dst) {
2226     return error::kOutOfBounds;
2227   }
2228   *result_dst = DoIsProgram(program);
2229   return error::kNoError;
2230 }
2231
2232 error::Error GLES2DecoderImpl::HandleIsRenderbuffer(
2233     uint32_t immediate_data_size,
2234     const void* cmd_data) {
2235   const gles2::cmds::IsRenderbuffer& c =
2236       *static_cast<const gles2::cmds::IsRenderbuffer*>(cmd_data);
2237   (void)c;
2238   GLuint renderbuffer = c.renderbuffer;
2239   typedef cmds::IsRenderbuffer::Result Result;
2240   Result* result_dst = GetSharedMemoryAs<Result*>(
2241       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
2242   if (!result_dst) {
2243     return error::kOutOfBounds;
2244   }
2245   *result_dst = DoIsRenderbuffer(renderbuffer);
2246   return error::kNoError;
2247 }
2248
2249 error::Error GLES2DecoderImpl::HandleIsSampler(uint32_t immediate_data_size,
2250                                                const void* cmd_data) {
2251   if (!unsafe_es3_apis_enabled())
2252     return error::kUnknownCommand;
2253   const gles2::cmds::IsSampler& c =
2254       *static_cast<const gles2::cmds::IsSampler*>(cmd_data);
2255   (void)c;
2256   GLuint sampler = c.sampler;
2257   typedef cmds::IsSampler::Result Result;
2258   Result* result_dst = GetSharedMemoryAs<Result*>(
2259       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
2260   if (!result_dst) {
2261     return error::kOutOfBounds;
2262   }
2263   GLuint service_sampler = 0;
2264   *result_dst = group_->GetSamplerServiceId(sampler, &service_sampler);
2265   return error::kNoError;
2266 }
2267
2268 error::Error GLES2DecoderImpl::HandleIsShader(uint32_t immediate_data_size,
2269                                               const void* cmd_data) {
2270   const gles2::cmds::IsShader& c =
2271       *static_cast<const gles2::cmds::IsShader*>(cmd_data);
2272   (void)c;
2273   GLuint shader = c.shader;
2274   typedef cmds::IsShader::Result Result;
2275   Result* result_dst = GetSharedMemoryAs<Result*>(
2276       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
2277   if (!result_dst) {
2278     return error::kOutOfBounds;
2279   }
2280   *result_dst = DoIsShader(shader);
2281   return error::kNoError;
2282 }
2283
2284 error::Error GLES2DecoderImpl::HandleIsSync(uint32_t immediate_data_size,
2285                                             const void* cmd_data) {
2286   if (!unsafe_es3_apis_enabled())
2287     return error::kUnknownCommand;
2288   const gles2::cmds::IsSync& c =
2289       *static_cast<const gles2::cmds::IsSync*>(cmd_data);
2290   (void)c;
2291   GLuint sync = c.sync;
2292   typedef cmds::IsSync::Result Result;
2293   Result* result_dst = GetSharedMemoryAs<Result*>(
2294       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
2295   if (!result_dst) {
2296     return error::kOutOfBounds;
2297   }
2298   GLsync service_sync = 0;
2299   *result_dst = group_->GetSyncServiceId(sync, &service_sync);
2300   return error::kNoError;
2301 }
2302
2303 error::Error GLES2DecoderImpl::HandleIsTexture(uint32_t immediate_data_size,
2304                                                const void* cmd_data) {
2305   const gles2::cmds::IsTexture& c =
2306       *static_cast<const gles2::cmds::IsTexture*>(cmd_data);
2307   (void)c;
2308   GLuint texture = c.texture;
2309   typedef cmds::IsTexture::Result Result;
2310   Result* result_dst = GetSharedMemoryAs<Result*>(
2311       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
2312   if (!result_dst) {
2313     return error::kOutOfBounds;
2314   }
2315   *result_dst = DoIsTexture(texture);
2316   return error::kNoError;
2317 }
2318
2319 error::Error GLES2DecoderImpl::HandleIsTransformFeedback(
2320     uint32_t immediate_data_size,
2321     const void* cmd_data) {
2322   if (!unsafe_es3_apis_enabled())
2323     return error::kUnknownCommand;
2324   const gles2::cmds::IsTransformFeedback& c =
2325       *static_cast<const gles2::cmds::IsTransformFeedback*>(cmd_data);
2326   (void)c;
2327   GLuint transformfeedback = c.transformfeedback;
2328   typedef cmds::IsTransformFeedback::Result Result;
2329   Result* result_dst = GetSharedMemoryAs<Result*>(
2330       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
2331   if (!result_dst) {
2332     return error::kOutOfBounds;
2333   }
2334   GLuint service_transformfeedback = 0;
2335   *result_dst = group_->GetTransformFeedbackServiceId(
2336       transformfeedback, &service_transformfeedback);
2337   return error::kNoError;
2338 }
2339
2340 error::Error GLES2DecoderImpl::HandleLineWidth(uint32_t immediate_data_size,
2341                                                const void* cmd_data) {
2342   const gles2::cmds::LineWidth& c =
2343       *static_cast<const gles2::cmds::LineWidth*>(cmd_data);
2344   (void)c;
2345   GLfloat width = static_cast<GLfloat>(c.width);
2346   if (width <= 0.0f || std::isnan(width)) {
2347     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "LineWidth", "width out of range");
2348     return error::kNoError;
2349   }
2350   if (state_.line_width != width) {
2351     state_.line_width = width;
2352     glLineWidth(width);
2353   }
2354   return error::kNoError;
2355 }
2356
2357 error::Error GLES2DecoderImpl::HandleLinkProgram(uint32_t immediate_data_size,
2358                                                  const void* cmd_data) {
2359   const gles2::cmds::LinkProgram& c =
2360       *static_cast<const gles2::cmds::LinkProgram*>(cmd_data);
2361   (void)c;
2362   GLuint program = c.program;
2363   DoLinkProgram(program);
2364   return error::kNoError;
2365 }
2366
2367 error::Error GLES2DecoderImpl::HandlePauseTransformFeedback(
2368     uint32_t immediate_data_size,
2369     const void* cmd_data) {
2370   if (!unsafe_es3_apis_enabled())
2371     return error::kUnknownCommand;
2372   const gles2::cmds::PauseTransformFeedback& c =
2373       *static_cast<const gles2::cmds::PauseTransformFeedback*>(cmd_data);
2374   (void)c;
2375   glPauseTransformFeedback();
2376   return error::kNoError;
2377 }
2378
2379 error::Error GLES2DecoderImpl::HandlePolygonOffset(uint32_t immediate_data_size,
2380                                                    const void* cmd_data) {
2381   const gles2::cmds::PolygonOffset& c =
2382       *static_cast<const gles2::cmds::PolygonOffset*>(cmd_data);
2383   (void)c;
2384   GLfloat factor = static_cast<GLfloat>(c.factor);
2385   GLfloat units = static_cast<GLfloat>(c.units);
2386   if (state_.polygon_offset_factor != factor ||
2387       state_.polygon_offset_units != units) {
2388     state_.polygon_offset_factor = factor;
2389     state_.polygon_offset_units = units;
2390     glPolygonOffset(factor, units);
2391   }
2392   return error::kNoError;
2393 }
2394
2395 error::Error GLES2DecoderImpl::HandleReadBuffer(uint32_t immediate_data_size,
2396                                                 const void* cmd_data) {
2397   if (!unsafe_es3_apis_enabled())
2398     return error::kUnknownCommand;
2399   const gles2::cmds::ReadBuffer& c =
2400       *static_cast<const gles2::cmds::ReadBuffer*>(cmd_data);
2401   (void)c;
2402   GLenum src = static_cast<GLenum>(c.src);
2403   glReadBuffer(src);
2404   return error::kNoError;
2405 }
2406
2407 error::Error GLES2DecoderImpl::HandleReleaseShaderCompiler(
2408     uint32_t immediate_data_size,
2409     const void* cmd_data) {
2410   const gles2::cmds::ReleaseShaderCompiler& c =
2411       *static_cast<const gles2::cmds::ReleaseShaderCompiler*>(cmd_data);
2412   (void)c;
2413   DoReleaseShaderCompiler();
2414   return error::kNoError;
2415 }
2416
2417 error::Error GLES2DecoderImpl::HandleRenderbufferStorage(
2418     uint32_t immediate_data_size,
2419     const void* cmd_data) {
2420   const gles2::cmds::RenderbufferStorage& c =
2421       *static_cast<const gles2::cmds::RenderbufferStorage*>(cmd_data);
2422   (void)c;
2423   GLenum target = static_cast<GLenum>(c.target);
2424   GLenum internalformat = static_cast<GLenum>(c.internalformat);
2425   GLsizei width = static_cast<GLsizei>(c.width);
2426   GLsizei height = static_cast<GLsizei>(c.height);
2427   if (!validators_->render_buffer_target.IsValid(target)) {
2428     LOCAL_SET_GL_ERROR_INVALID_ENUM("glRenderbufferStorage", target, "target");
2429     return error::kNoError;
2430   }
2431   if (!validators_->render_buffer_format.IsValid(internalformat)) {
2432     LOCAL_SET_GL_ERROR_INVALID_ENUM("glRenderbufferStorage", internalformat,
2433                                     "internalformat");
2434     return error::kNoError;
2435   }
2436   if (width < 0) {
2437     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glRenderbufferStorage", "width < 0");
2438     return error::kNoError;
2439   }
2440   if (height < 0) {
2441     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glRenderbufferStorage", "height < 0");
2442     return error::kNoError;
2443   }
2444   DoRenderbufferStorage(target, internalformat, width, height);
2445   return error::kNoError;
2446 }
2447
2448 error::Error GLES2DecoderImpl::HandleResumeTransformFeedback(
2449     uint32_t immediate_data_size,
2450     const void* cmd_data) {
2451   if (!unsafe_es3_apis_enabled())
2452     return error::kUnknownCommand;
2453   const gles2::cmds::ResumeTransformFeedback& c =
2454       *static_cast<const gles2::cmds::ResumeTransformFeedback*>(cmd_data);
2455   (void)c;
2456   glResumeTransformFeedback();
2457   return error::kNoError;
2458 }
2459
2460 error::Error GLES2DecoderImpl::HandleSampleCoverage(
2461     uint32_t immediate_data_size,
2462     const void* cmd_data) {
2463   const gles2::cmds::SampleCoverage& c =
2464       *static_cast<const gles2::cmds::SampleCoverage*>(cmd_data);
2465   (void)c;
2466   GLclampf value = static_cast<GLclampf>(c.value);
2467   GLboolean invert = static_cast<GLboolean>(c.invert);
2468   DoSampleCoverage(value, invert);
2469   return error::kNoError;
2470 }
2471
2472 error::Error GLES2DecoderImpl::HandleSamplerParameterf(
2473     uint32_t immediate_data_size,
2474     const void* cmd_data) {
2475   if (!unsafe_es3_apis_enabled())
2476     return error::kUnknownCommand;
2477   const gles2::cmds::SamplerParameterf& c =
2478       *static_cast<const gles2::cmds::SamplerParameterf*>(cmd_data);
2479   (void)c;
2480   GLuint sampler = c.sampler;
2481   GLenum pname = static_cast<GLenum>(c.pname);
2482   GLfloat param = static_cast<GLfloat>(c.param);
2483   if (!group_->GetSamplerServiceId(sampler, &sampler)) {
2484     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glSamplerParameterf",
2485                        "invalid sampler id");
2486     return error::kNoError;
2487   }
2488   glSamplerParameterf(sampler, pname, param);
2489   return error::kNoError;
2490 }
2491
2492 error::Error GLES2DecoderImpl::HandleSamplerParameterfvImmediate(
2493     uint32_t immediate_data_size,
2494     const void* cmd_data) {
2495   if (!unsafe_es3_apis_enabled())
2496     return error::kUnknownCommand;
2497   const gles2::cmds::SamplerParameterfvImmediate& c =
2498       *static_cast<const gles2::cmds::SamplerParameterfvImmediate*>(cmd_data);
2499   (void)c;
2500   GLuint sampler = c.sampler;
2501   GLenum pname = static_cast<GLenum>(c.pname);
2502   uint32_t data_size;
2503   if (!ComputeDataSize(1, sizeof(GLfloat), 1, &data_size)) {
2504     return error::kOutOfBounds;
2505   }
2506   if (data_size > immediate_data_size) {
2507     return error::kOutOfBounds;
2508   }
2509   const GLfloat* params =
2510       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
2511   if (params == NULL) {
2512     return error::kOutOfBounds;
2513   }
2514   group_->GetSamplerServiceId(sampler, &sampler);
2515   DoSamplerParameterfv(sampler, pname, params);
2516   return error::kNoError;
2517 }
2518
2519 error::Error GLES2DecoderImpl::HandleSamplerParameteri(
2520     uint32_t immediate_data_size,
2521     const void* cmd_data) {
2522   if (!unsafe_es3_apis_enabled())
2523     return error::kUnknownCommand;
2524   const gles2::cmds::SamplerParameteri& c =
2525       *static_cast<const gles2::cmds::SamplerParameteri*>(cmd_data);
2526   (void)c;
2527   GLuint sampler = c.sampler;
2528   GLenum pname = static_cast<GLenum>(c.pname);
2529   GLint param = static_cast<GLint>(c.param);
2530   if (!group_->GetSamplerServiceId(sampler, &sampler)) {
2531     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glSamplerParameteri",
2532                        "invalid sampler id");
2533     return error::kNoError;
2534   }
2535   glSamplerParameteri(sampler, pname, param);
2536   return error::kNoError;
2537 }
2538
2539 error::Error GLES2DecoderImpl::HandleSamplerParameterivImmediate(
2540     uint32_t immediate_data_size,
2541     const void* cmd_data) {
2542   if (!unsafe_es3_apis_enabled())
2543     return error::kUnknownCommand;
2544   const gles2::cmds::SamplerParameterivImmediate& c =
2545       *static_cast<const gles2::cmds::SamplerParameterivImmediate*>(cmd_data);
2546   (void)c;
2547   GLuint sampler = c.sampler;
2548   GLenum pname = static_cast<GLenum>(c.pname);
2549   uint32_t data_size;
2550   if (!ComputeDataSize(1, sizeof(GLint), 1, &data_size)) {
2551     return error::kOutOfBounds;
2552   }
2553   if (data_size > immediate_data_size) {
2554     return error::kOutOfBounds;
2555   }
2556   const GLint* params =
2557       GetImmediateDataAs<const GLint*>(c, data_size, immediate_data_size);
2558   if (params == NULL) {
2559     return error::kOutOfBounds;
2560   }
2561   DoSamplerParameteriv(sampler, pname, params);
2562   return error::kNoError;
2563 }
2564
2565 error::Error GLES2DecoderImpl::HandleScissor(uint32_t immediate_data_size,
2566                                              const void* cmd_data) {
2567   const gles2::cmds::Scissor& c =
2568       *static_cast<const gles2::cmds::Scissor*>(cmd_data);
2569   (void)c;
2570   GLint x = static_cast<GLint>(c.x);
2571   GLint y = static_cast<GLint>(c.y);
2572   GLsizei width = static_cast<GLsizei>(c.width);
2573   GLsizei height = static_cast<GLsizei>(c.height);
2574   if (width < 0) {
2575     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glScissor", "width < 0");
2576     return error::kNoError;
2577   }
2578   if (height < 0) {
2579     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glScissor", "height < 0");
2580     return error::kNoError;
2581   }
2582   if (state_.scissor_x != x || state_.scissor_y != y ||
2583       state_.scissor_width != width || state_.scissor_height != height) {
2584     state_.scissor_x = x;
2585     state_.scissor_y = y;
2586     state_.scissor_width = width;
2587     state_.scissor_height = height;
2588     glScissor(x, y, width, height);
2589   }
2590   return error::kNoError;
2591 }
2592
2593 error::Error GLES2DecoderImpl::HandleShaderSourceBucket(
2594     uint32_t immediate_data_size,
2595     const void* cmd_data) {
2596   const gles2::cmds::ShaderSourceBucket& c =
2597       *static_cast<const gles2::cmds::ShaderSourceBucket*>(cmd_data);
2598   (void)c;
2599   GLuint shader = static_cast<GLuint>(c.shader);
2600
2601   Bucket* bucket = GetBucket(c.str_bucket_id);
2602   if (!bucket) {
2603     return error::kInvalidArguments;
2604   }
2605   GLsizei count = 0;
2606   std::vector<char*> strs;
2607   std::vector<GLint> len;
2608   if (!bucket->GetAsStrings(&count, &strs, &len)) {
2609     return error::kInvalidArguments;
2610   }
2611   const char** str =
2612       strs.size() > 0 ? const_cast<const char**>(&strs[0]) : NULL;
2613   const GLint* length =
2614       len.size() > 0 ? const_cast<const GLint*>(&len[0]) : NULL;
2615   (void)length;
2616   DoShaderSource(shader, count, str, length);
2617   return error::kNoError;
2618 }
2619
2620 error::Error GLES2DecoderImpl::HandleStencilFunc(uint32_t immediate_data_size,
2621                                                  const void* cmd_data) {
2622   const gles2::cmds::StencilFunc& c =
2623       *static_cast<const gles2::cmds::StencilFunc*>(cmd_data);
2624   (void)c;
2625   GLenum func = static_cast<GLenum>(c.func);
2626   GLint ref = static_cast<GLint>(c.ref);
2627   GLuint mask = static_cast<GLuint>(c.mask);
2628   if (!validators_->cmp_function.IsValid(func)) {
2629     LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilFunc", func, "func");
2630     return error::kNoError;
2631   }
2632   if (state_.stencil_front_func != func || state_.stencil_front_ref != ref ||
2633       state_.stencil_front_mask != mask || state_.stencil_back_func != func ||
2634       state_.stencil_back_ref != ref || state_.stencil_back_mask != mask) {
2635     state_.stencil_front_func = func;
2636     state_.stencil_front_ref = ref;
2637     state_.stencil_front_mask = mask;
2638     state_.stencil_back_func = func;
2639     state_.stencil_back_ref = ref;
2640     state_.stencil_back_mask = mask;
2641     glStencilFunc(func, ref, mask);
2642   }
2643   return error::kNoError;
2644 }
2645
2646 error::Error GLES2DecoderImpl::HandleStencilFuncSeparate(
2647     uint32_t immediate_data_size,
2648     const void* cmd_data) {
2649   const gles2::cmds::StencilFuncSeparate& c =
2650       *static_cast<const gles2::cmds::StencilFuncSeparate*>(cmd_data);
2651   (void)c;
2652   GLenum face = static_cast<GLenum>(c.face);
2653   GLenum func = static_cast<GLenum>(c.func);
2654   GLint ref = static_cast<GLint>(c.ref);
2655   GLuint mask = static_cast<GLuint>(c.mask);
2656   if (!validators_->face_type.IsValid(face)) {
2657     LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilFuncSeparate", face, "face");
2658     return error::kNoError;
2659   }
2660   if (!validators_->cmp_function.IsValid(func)) {
2661     LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilFuncSeparate", func, "func");
2662     return error::kNoError;
2663   }
2664   bool changed = false;
2665   if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
2666     changed |= state_.stencil_front_func != func ||
2667                state_.stencil_front_ref != ref ||
2668                state_.stencil_front_mask != mask;
2669   }
2670   if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
2671     changed |= state_.stencil_back_func != func ||
2672                state_.stencil_back_ref != ref ||
2673                state_.stencil_back_mask != mask;
2674   }
2675   if (changed) {
2676     if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
2677       state_.stencil_front_func = func;
2678       state_.stencil_front_ref = ref;
2679       state_.stencil_front_mask = mask;
2680     }
2681     if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
2682       state_.stencil_back_func = func;
2683       state_.stencil_back_ref = ref;
2684       state_.stencil_back_mask = mask;
2685     }
2686     glStencilFuncSeparate(face, func, ref, mask);
2687   }
2688   return error::kNoError;
2689 }
2690
2691 error::Error GLES2DecoderImpl::HandleStencilMask(uint32_t immediate_data_size,
2692                                                  const void* cmd_data) {
2693   const gles2::cmds::StencilMask& c =
2694       *static_cast<const gles2::cmds::StencilMask*>(cmd_data);
2695   (void)c;
2696   GLuint mask = static_cast<GLuint>(c.mask);
2697   if (state_.stencil_front_writemask != mask ||
2698       state_.stencil_back_writemask != mask) {
2699     state_.stencil_front_writemask = mask;
2700     state_.stencil_back_writemask = mask;
2701     framebuffer_state_.clear_state_dirty = true;
2702   }
2703   return error::kNoError;
2704 }
2705
2706 error::Error GLES2DecoderImpl::HandleStencilMaskSeparate(
2707     uint32_t immediate_data_size,
2708     const void* cmd_data) {
2709   const gles2::cmds::StencilMaskSeparate& c =
2710       *static_cast<const gles2::cmds::StencilMaskSeparate*>(cmd_data);
2711   (void)c;
2712   GLenum face = static_cast<GLenum>(c.face);
2713   GLuint mask = static_cast<GLuint>(c.mask);
2714   if (!validators_->face_type.IsValid(face)) {
2715     LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilMaskSeparate", face, "face");
2716     return error::kNoError;
2717   }
2718   bool changed = false;
2719   if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
2720     changed |= state_.stencil_front_writemask != mask;
2721   }
2722   if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
2723     changed |= state_.stencil_back_writemask != mask;
2724   }
2725   if (changed) {
2726     if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
2727       state_.stencil_front_writemask = mask;
2728     }
2729     if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
2730       state_.stencil_back_writemask = mask;
2731     }
2732     framebuffer_state_.clear_state_dirty = true;
2733   }
2734   return error::kNoError;
2735 }
2736
2737 error::Error GLES2DecoderImpl::HandleStencilOp(uint32_t immediate_data_size,
2738                                                const void* cmd_data) {
2739   const gles2::cmds::StencilOp& c =
2740       *static_cast<const gles2::cmds::StencilOp*>(cmd_data);
2741   (void)c;
2742   GLenum fail = static_cast<GLenum>(c.fail);
2743   GLenum zfail = static_cast<GLenum>(c.zfail);
2744   GLenum zpass = static_cast<GLenum>(c.zpass);
2745   if (!validators_->stencil_op.IsValid(fail)) {
2746     LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilOp", fail, "fail");
2747     return error::kNoError;
2748   }
2749   if (!validators_->stencil_op.IsValid(zfail)) {
2750     LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilOp", zfail, "zfail");
2751     return error::kNoError;
2752   }
2753   if (!validators_->stencil_op.IsValid(zpass)) {
2754     LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilOp", zpass, "zpass");
2755     return error::kNoError;
2756   }
2757   if (state_.stencil_front_fail_op != fail ||
2758       state_.stencil_front_z_fail_op != zfail ||
2759       state_.stencil_front_z_pass_op != zpass ||
2760       state_.stencil_back_fail_op != fail ||
2761       state_.stencil_back_z_fail_op != zfail ||
2762       state_.stencil_back_z_pass_op != zpass) {
2763     state_.stencil_front_fail_op = fail;
2764     state_.stencil_front_z_fail_op = zfail;
2765     state_.stencil_front_z_pass_op = zpass;
2766     state_.stencil_back_fail_op = fail;
2767     state_.stencil_back_z_fail_op = zfail;
2768     state_.stencil_back_z_pass_op = zpass;
2769     glStencilOp(fail, zfail, zpass);
2770   }
2771   return error::kNoError;
2772 }
2773
2774 error::Error GLES2DecoderImpl::HandleStencilOpSeparate(
2775     uint32_t immediate_data_size,
2776     const void* cmd_data) {
2777   const gles2::cmds::StencilOpSeparate& c =
2778       *static_cast<const gles2::cmds::StencilOpSeparate*>(cmd_data);
2779   (void)c;
2780   GLenum face = static_cast<GLenum>(c.face);
2781   GLenum fail = static_cast<GLenum>(c.fail);
2782   GLenum zfail = static_cast<GLenum>(c.zfail);
2783   GLenum zpass = static_cast<GLenum>(c.zpass);
2784   if (!validators_->face_type.IsValid(face)) {
2785     LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilOpSeparate", face, "face");
2786     return error::kNoError;
2787   }
2788   if (!validators_->stencil_op.IsValid(fail)) {
2789     LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilOpSeparate", fail, "fail");
2790     return error::kNoError;
2791   }
2792   if (!validators_->stencil_op.IsValid(zfail)) {
2793     LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilOpSeparate", zfail, "zfail");
2794     return error::kNoError;
2795   }
2796   if (!validators_->stencil_op.IsValid(zpass)) {
2797     LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilOpSeparate", zpass, "zpass");
2798     return error::kNoError;
2799   }
2800   bool changed = false;
2801   if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
2802     changed |= state_.stencil_front_fail_op != fail ||
2803                state_.stencil_front_z_fail_op != zfail ||
2804                state_.stencil_front_z_pass_op != zpass;
2805   }
2806   if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
2807     changed |= state_.stencil_back_fail_op != fail ||
2808                state_.stencil_back_z_fail_op != zfail ||
2809                state_.stencil_back_z_pass_op != zpass;
2810   }
2811   if (changed) {
2812     if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
2813       state_.stencil_front_fail_op = fail;
2814       state_.stencil_front_z_fail_op = zfail;
2815       state_.stencil_front_z_pass_op = zpass;
2816     }
2817     if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
2818       state_.stencil_back_fail_op = fail;
2819       state_.stencil_back_z_fail_op = zfail;
2820       state_.stencil_back_z_pass_op = zpass;
2821     }
2822     glStencilOpSeparate(face, fail, zfail, zpass);
2823   }
2824   return error::kNoError;
2825 }
2826
2827 error::Error GLES2DecoderImpl::HandleTexParameterf(uint32_t immediate_data_size,
2828                                                    const void* cmd_data) {
2829   const gles2::cmds::TexParameterf& c =
2830       *static_cast<const gles2::cmds::TexParameterf*>(cmd_data);
2831   (void)c;
2832   GLenum target = static_cast<GLenum>(c.target);
2833   GLenum pname = static_cast<GLenum>(c.pname);
2834   GLfloat param = static_cast<GLfloat>(c.param);
2835   if (!validators_->texture_bind_target.IsValid(target)) {
2836     LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameterf", target, "target");
2837     return error::kNoError;
2838   }
2839   if (!validators_->texture_parameter.IsValid(pname)) {
2840     LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameterf", pname, "pname");
2841     return error::kNoError;
2842   }
2843   DoTexParameterf(target, pname, param);
2844   return error::kNoError;
2845 }
2846
2847 error::Error GLES2DecoderImpl::HandleTexParameterfvImmediate(
2848     uint32_t immediate_data_size,
2849     const void* cmd_data) {
2850   const gles2::cmds::TexParameterfvImmediate& c =
2851       *static_cast<const gles2::cmds::TexParameterfvImmediate*>(cmd_data);
2852   (void)c;
2853   GLenum target = static_cast<GLenum>(c.target);
2854   GLenum pname = static_cast<GLenum>(c.pname);
2855   uint32_t data_size;
2856   if (!ComputeDataSize(1, sizeof(GLfloat), 1, &data_size)) {
2857     return error::kOutOfBounds;
2858   }
2859   if (data_size > immediate_data_size) {
2860     return error::kOutOfBounds;
2861   }
2862   const GLfloat* params =
2863       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
2864   if (!validators_->texture_bind_target.IsValid(target)) {
2865     LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameterfv", target, "target");
2866     return error::kNoError;
2867   }
2868   if (!validators_->texture_parameter.IsValid(pname)) {
2869     LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameterfv", pname, "pname");
2870     return error::kNoError;
2871   }
2872   if (params == NULL) {
2873     return error::kOutOfBounds;
2874   }
2875   DoTexParameterfv(target, pname, params);
2876   return error::kNoError;
2877 }
2878
2879 error::Error GLES2DecoderImpl::HandleTexParameteri(uint32_t immediate_data_size,
2880                                                    const void* cmd_data) {
2881   const gles2::cmds::TexParameteri& c =
2882       *static_cast<const gles2::cmds::TexParameteri*>(cmd_data);
2883   (void)c;
2884   GLenum target = static_cast<GLenum>(c.target);
2885   GLenum pname = static_cast<GLenum>(c.pname);
2886   GLint param = static_cast<GLint>(c.param);
2887   if (!validators_->texture_bind_target.IsValid(target)) {
2888     LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameteri", target, "target");
2889     return error::kNoError;
2890   }
2891   if (!validators_->texture_parameter.IsValid(pname)) {
2892     LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameteri", pname, "pname");
2893     return error::kNoError;
2894   }
2895   DoTexParameteri(target, pname, param);
2896   return error::kNoError;
2897 }
2898
2899 error::Error GLES2DecoderImpl::HandleTexParameterivImmediate(
2900     uint32_t immediate_data_size,
2901     const void* cmd_data) {
2902   const gles2::cmds::TexParameterivImmediate& c =
2903       *static_cast<const gles2::cmds::TexParameterivImmediate*>(cmd_data);
2904   (void)c;
2905   GLenum target = static_cast<GLenum>(c.target);
2906   GLenum pname = static_cast<GLenum>(c.pname);
2907   uint32_t data_size;
2908   if (!ComputeDataSize(1, sizeof(GLint), 1, &data_size)) {
2909     return error::kOutOfBounds;
2910   }
2911   if (data_size > immediate_data_size) {
2912     return error::kOutOfBounds;
2913   }
2914   const GLint* params =
2915       GetImmediateDataAs<const GLint*>(c, data_size, immediate_data_size);
2916   if (!validators_->texture_bind_target.IsValid(target)) {
2917     LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameteriv", target, "target");
2918     return error::kNoError;
2919   }
2920   if (!validators_->texture_parameter.IsValid(pname)) {
2921     LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameteriv", pname, "pname");
2922     return error::kNoError;
2923   }
2924   if (params == NULL) {
2925     return error::kOutOfBounds;
2926   }
2927   DoTexParameteriv(target, pname, params);
2928   return error::kNoError;
2929 }
2930
2931 error::Error GLES2DecoderImpl::HandleTexStorage3D(uint32_t immediate_data_size,
2932                                                   const void* cmd_data) {
2933   if (!unsafe_es3_apis_enabled())
2934     return error::kUnknownCommand;
2935   const gles2::cmds::TexStorage3D& c =
2936       *static_cast<const gles2::cmds::TexStorage3D*>(cmd_data);
2937   (void)c;
2938   GLenum target = static_cast<GLenum>(c.target);
2939   GLsizei levels = static_cast<GLsizei>(c.levels);
2940   GLenum internalFormat = static_cast<GLenum>(c.internalFormat);
2941   GLsizei width = static_cast<GLsizei>(c.width);
2942   GLsizei height = static_cast<GLsizei>(c.height);
2943   GLsizei depth = static_cast<GLsizei>(c.depth);
2944   glTexStorage3D(target, levels, internalFormat, width, height, depth);
2945   return error::kNoError;
2946 }
2947
2948 error::Error GLES2DecoderImpl::HandleTransformFeedbackVaryingsBucket(
2949     uint32_t immediate_data_size,
2950     const void* cmd_data) {
2951   if (!unsafe_es3_apis_enabled())
2952     return error::kUnknownCommand;
2953   const gles2::cmds::TransformFeedbackVaryingsBucket& c =
2954       *static_cast<const gles2::cmds::TransformFeedbackVaryingsBucket*>(
2955           cmd_data);
2956   (void)c;
2957   GLuint program = static_cast<GLuint>(c.program);
2958
2959   Bucket* bucket = GetBucket(c.varyings_bucket_id);
2960   if (!bucket) {
2961     return error::kInvalidArguments;
2962   }
2963   GLsizei count = 0;
2964   std::vector<char*> strs;
2965   std::vector<GLint> len;
2966   if (!bucket->GetAsStrings(&count, &strs, &len)) {
2967     return error::kInvalidArguments;
2968   }
2969   const char** varyings =
2970       strs.size() > 0 ? const_cast<const char**>(&strs[0]) : NULL;
2971   const GLint* length =
2972       len.size() > 0 ? const_cast<const GLint*>(&len[0]) : NULL;
2973   (void)length;
2974   GLenum buffermode = static_cast<GLenum>(c.buffermode);
2975   DoTransformFeedbackVaryings(program, count, varyings, buffermode);
2976   return error::kNoError;
2977 }
2978
2979 error::Error GLES2DecoderImpl::HandleUniform1f(uint32_t immediate_data_size,
2980                                                const void* cmd_data) {
2981   const gles2::cmds::Uniform1f& c =
2982       *static_cast<const gles2::cmds::Uniform1f*>(cmd_data);
2983   (void)c;
2984   GLint location = static_cast<GLint>(c.location);
2985   GLfloat x = static_cast<GLfloat>(c.x);
2986   GLfloat temp[1] = {
2987       x,
2988   };
2989   DoUniform1fv(location, 1, &temp[0]);
2990   return error::kNoError;
2991 }
2992
2993 error::Error GLES2DecoderImpl::HandleUniform1fvImmediate(
2994     uint32_t immediate_data_size,
2995     const void* cmd_data) {
2996   const gles2::cmds::Uniform1fvImmediate& c =
2997       *static_cast<const gles2::cmds::Uniform1fvImmediate*>(cmd_data);
2998   (void)c;
2999   GLint location = static_cast<GLint>(c.location);
3000   GLsizei count = static_cast<GLsizei>(c.count);
3001   uint32_t data_size;
3002   if (!ComputeDataSize(count, sizeof(GLfloat), 1, &data_size)) {
3003     return error::kOutOfBounds;
3004   }
3005   if (data_size > immediate_data_size) {
3006     return error::kOutOfBounds;
3007   }
3008   const GLfloat* v =
3009       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
3010   if (v == NULL) {
3011     return error::kOutOfBounds;
3012   }
3013   DoUniform1fv(location, count, v);
3014   return error::kNoError;
3015 }
3016
3017 error::Error GLES2DecoderImpl::HandleUniform1i(uint32_t immediate_data_size,
3018                                                const void* cmd_data) {
3019   const gles2::cmds::Uniform1i& c =
3020       *static_cast<const gles2::cmds::Uniform1i*>(cmd_data);
3021   (void)c;
3022   GLint location = static_cast<GLint>(c.location);
3023   GLint x = static_cast<GLint>(c.x);
3024   DoUniform1i(location, x);
3025   return error::kNoError;
3026 }
3027
3028 error::Error GLES2DecoderImpl::HandleUniform1ivImmediate(
3029     uint32_t immediate_data_size,
3030     const void* cmd_data) {
3031   const gles2::cmds::Uniform1ivImmediate& c =
3032       *static_cast<const gles2::cmds::Uniform1ivImmediate*>(cmd_data);
3033   (void)c;
3034   GLint location = static_cast<GLint>(c.location);
3035   GLsizei count = static_cast<GLsizei>(c.count);
3036   uint32_t data_size;
3037   if (!ComputeDataSize(count, sizeof(GLint), 1, &data_size)) {
3038     return error::kOutOfBounds;
3039   }
3040   if (data_size > immediate_data_size) {
3041     return error::kOutOfBounds;
3042   }
3043   const GLint* v =
3044       GetImmediateDataAs<const GLint*>(c, data_size, immediate_data_size);
3045   if (v == NULL) {
3046     return error::kOutOfBounds;
3047   }
3048   DoUniform1iv(location, count, v);
3049   return error::kNoError;
3050 }
3051
3052 error::Error GLES2DecoderImpl::HandleUniform1ui(uint32_t immediate_data_size,
3053                                                 const void* cmd_data) {
3054   if (!unsafe_es3_apis_enabled())
3055     return error::kUnknownCommand;
3056   const gles2::cmds::Uniform1ui& c =
3057       *static_cast<const gles2::cmds::Uniform1ui*>(cmd_data);
3058   (void)c;
3059   GLint location = static_cast<GLint>(c.location);
3060   GLuint x = static_cast<GLuint>(c.x);
3061   GLuint temp[1] = {
3062       x,
3063   };
3064   glUniform1uiv(location, 1, &temp[0]);
3065   return error::kNoError;
3066 }
3067
3068 error::Error GLES2DecoderImpl::HandleUniform1uivImmediate(
3069     uint32_t immediate_data_size,
3070     const void* cmd_data) {
3071   if (!unsafe_es3_apis_enabled())
3072     return error::kUnknownCommand;
3073   const gles2::cmds::Uniform1uivImmediate& c =
3074       *static_cast<const gles2::cmds::Uniform1uivImmediate*>(cmd_data);
3075   (void)c;
3076   GLint location = static_cast<GLint>(c.location);
3077   GLsizei count = static_cast<GLsizei>(c.count);
3078   uint32_t data_size;
3079   if (!ComputeDataSize(count, sizeof(GLuint), 1, &data_size)) {
3080     return error::kOutOfBounds;
3081   }
3082   if (data_size > immediate_data_size) {
3083     return error::kOutOfBounds;
3084   }
3085   const GLuint* v =
3086       GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
3087   if (v == NULL) {
3088     return error::kOutOfBounds;
3089   }
3090   glUniform1uiv(location, count, v);
3091   return error::kNoError;
3092 }
3093
3094 error::Error GLES2DecoderImpl::HandleUniform2f(uint32_t immediate_data_size,
3095                                                const void* cmd_data) {
3096   const gles2::cmds::Uniform2f& c =
3097       *static_cast<const gles2::cmds::Uniform2f*>(cmd_data);
3098   (void)c;
3099   GLint location = static_cast<GLint>(c.location);
3100   GLfloat x = static_cast<GLfloat>(c.x);
3101   GLfloat y = static_cast<GLfloat>(c.y);
3102   GLfloat temp[2] = {
3103       x, y,
3104   };
3105   DoUniform2fv(location, 1, &temp[0]);
3106   return error::kNoError;
3107 }
3108
3109 error::Error GLES2DecoderImpl::HandleUniform2fvImmediate(
3110     uint32_t immediate_data_size,
3111     const void* cmd_data) {
3112   const gles2::cmds::Uniform2fvImmediate& c =
3113       *static_cast<const gles2::cmds::Uniform2fvImmediate*>(cmd_data);
3114   (void)c;
3115   GLint location = static_cast<GLint>(c.location);
3116   GLsizei count = static_cast<GLsizei>(c.count);
3117   uint32_t data_size;
3118   if (!ComputeDataSize(count, sizeof(GLfloat), 2, &data_size)) {
3119     return error::kOutOfBounds;
3120   }
3121   if (data_size > immediate_data_size) {
3122     return error::kOutOfBounds;
3123   }
3124   const GLfloat* v =
3125       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
3126   if (v == NULL) {
3127     return error::kOutOfBounds;
3128   }
3129   DoUniform2fv(location, count, v);
3130   return error::kNoError;
3131 }
3132
3133 error::Error GLES2DecoderImpl::HandleUniform2i(uint32_t immediate_data_size,
3134                                                const void* cmd_data) {
3135   const gles2::cmds::Uniform2i& c =
3136       *static_cast<const gles2::cmds::Uniform2i*>(cmd_data);
3137   (void)c;
3138   GLint location = static_cast<GLint>(c.location);
3139   GLint x = static_cast<GLint>(c.x);
3140   GLint y = static_cast<GLint>(c.y);
3141   GLint temp[2] = {
3142       x, y,
3143   };
3144   DoUniform2iv(location, 1, &temp[0]);
3145   return error::kNoError;
3146 }
3147
3148 error::Error GLES2DecoderImpl::HandleUniform2ivImmediate(
3149     uint32_t immediate_data_size,
3150     const void* cmd_data) {
3151   const gles2::cmds::Uniform2ivImmediate& c =
3152       *static_cast<const gles2::cmds::Uniform2ivImmediate*>(cmd_data);
3153   (void)c;
3154   GLint location = static_cast<GLint>(c.location);
3155   GLsizei count = static_cast<GLsizei>(c.count);
3156   uint32_t data_size;
3157   if (!ComputeDataSize(count, sizeof(GLint), 2, &data_size)) {
3158     return error::kOutOfBounds;
3159   }
3160   if (data_size > immediate_data_size) {
3161     return error::kOutOfBounds;
3162   }
3163   const GLint* v =
3164       GetImmediateDataAs<const GLint*>(c, data_size, immediate_data_size);
3165   if (v == NULL) {
3166     return error::kOutOfBounds;
3167   }
3168   DoUniform2iv(location, count, v);
3169   return error::kNoError;
3170 }
3171
3172 error::Error GLES2DecoderImpl::HandleUniform2ui(uint32_t immediate_data_size,
3173                                                 const void* cmd_data) {
3174   if (!unsafe_es3_apis_enabled())
3175     return error::kUnknownCommand;
3176   const gles2::cmds::Uniform2ui& c =
3177       *static_cast<const gles2::cmds::Uniform2ui*>(cmd_data);
3178   (void)c;
3179   GLint location = static_cast<GLint>(c.location);
3180   GLuint x = static_cast<GLuint>(c.x);
3181   GLuint y = static_cast<GLuint>(c.y);
3182   GLuint temp[2] = {
3183       x, y,
3184   };
3185   glUniform2uiv(location, 1, &temp[0]);
3186   return error::kNoError;
3187 }
3188
3189 error::Error GLES2DecoderImpl::HandleUniform2uivImmediate(
3190     uint32_t immediate_data_size,
3191     const void* cmd_data) {
3192   if (!unsafe_es3_apis_enabled())
3193     return error::kUnknownCommand;
3194   const gles2::cmds::Uniform2uivImmediate& c =
3195       *static_cast<const gles2::cmds::Uniform2uivImmediate*>(cmd_data);
3196   (void)c;
3197   GLint location = static_cast<GLint>(c.location);
3198   GLsizei count = static_cast<GLsizei>(c.count);
3199   uint32_t data_size;
3200   if (!ComputeDataSize(count, sizeof(GLuint), 2, &data_size)) {
3201     return error::kOutOfBounds;
3202   }
3203   if (data_size > immediate_data_size) {
3204     return error::kOutOfBounds;
3205   }
3206   const GLuint* v =
3207       GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
3208   if (v == NULL) {
3209     return error::kOutOfBounds;
3210   }
3211   glUniform2uiv(location, count, v);
3212   return error::kNoError;
3213 }
3214
3215 error::Error GLES2DecoderImpl::HandleUniform3f(uint32_t immediate_data_size,
3216                                                const void* cmd_data) {
3217   const gles2::cmds::Uniform3f& c =
3218       *static_cast<const gles2::cmds::Uniform3f*>(cmd_data);
3219   (void)c;
3220   GLint location = static_cast<GLint>(c.location);
3221   GLfloat x = static_cast<GLfloat>(c.x);
3222   GLfloat y = static_cast<GLfloat>(c.y);
3223   GLfloat z = static_cast<GLfloat>(c.z);
3224   GLfloat temp[3] = {
3225       x, y, z,
3226   };
3227   DoUniform3fv(location, 1, &temp[0]);
3228   return error::kNoError;
3229 }
3230
3231 error::Error GLES2DecoderImpl::HandleUniform3fvImmediate(
3232     uint32_t immediate_data_size,
3233     const void* cmd_data) {
3234   const gles2::cmds::Uniform3fvImmediate& c =
3235       *static_cast<const gles2::cmds::Uniform3fvImmediate*>(cmd_data);
3236   (void)c;
3237   GLint location = static_cast<GLint>(c.location);
3238   GLsizei count = static_cast<GLsizei>(c.count);
3239   uint32_t data_size;
3240   if (!ComputeDataSize(count, sizeof(GLfloat), 3, &data_size)) {
3241     return error::kOutOfBounds;
3242   }
3243   if (data_size > immediate_data_size) {
3244     return error::kOutOfBounds;
3245   }
3246   const GLfloat* v =
3247       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
3248   if (v == NULL) {
3249     return error::kOutOfBounds;
3250   }
3251   DoUniform3fv(location, count, v);
3252   return error::kNoError;
3253 }
3254
3255 error::Error GLES2DecoderImpl::HandleUniform3i(uint32_t immediate_data_size,
3256                                                const void* cmd_data) {
3257   const gles2::cmds::Uniform3i& c =
3258       *static_cast<const gles2::cmds::Uniform3i*>(cmd_data);
3259   (void)c;
3260   GLint location = static_cast<GLint>(c.location);
3261   GLint x = static_cast<GLint>(c.x);
3262   GLint y = static_cast<GLint>(c.y);
3263   GLint z = static_cast<GLint>(c.z);
3264   GLint temp[3] = {
3265       x, y, z,
3266   };
3267   DoUniform3iv(location, 1, &temp[0]);
3268   return error::kNoError;
3269 }
3270
3271 error::Error GLES2DecoderImpl::HandleUniform3ivImmediate(
3272     uint32_t immediate_data_size,
3273     const void* cmd_data) {
3274   const gles2::cmds::Uniform3ivImmediate& c =
3275       *static_cast<const gles2::cmds::Uniform3ivImmediate*>(cmd_data);
3276   (void)c;
3277   GLint location = static_cast<GLint>(c.location);
3278   GLsizei count = static_cast<GLsizei>(c.count);
3279   uint32_t data_size;
3280   if (!ComputeDataSize(count, sizeof(GLint), 3, &data_size)) {
3281     return error::kOutOfBounds;
3282   }
3283   if (data_size > immediate_data_size) {
3284     return error::kOutOfBounds;
3285   }
3286   const GLint* v =
3287       GetImmediateDataAs<const GLint*>(c, data_size, immediate_data_size);
3288   if (v == NULL) {
3289     return error::kOutOfBounds;
3290   }
3291   DoUniform3iv(location, count, v);
3292   return error::kNoError;
3293 }
3294
3295 error::Error GLES2DecoderImpl::HandleUniform3ui(uint32_t immediate_data_size,
3296                                                 const void* cmd_data) {
3297   if (!unsafe_es3_apis_enabled())
3298     return error::kUnknownCommand;
3299   const gles2::cmds::Uniform3ui& c =
3300       *static_cast<const gles2::cmds::Uniform3ui*>(cmd_data);
3301   (void)c;
3302   GLint location = static_cast<GLint>(c.location);
3303   GLuint x = static_cast<GLuint>(c.x);
3304   GLuint y = static_cast<GLuint>(c.y);
3305   GLuint z = static_cast<GLuint>(c.z);
3306   GLuint temp[3] = {
3307       x, y, z,
3308   };
3309   glUniform3uiv(location, 1, &temp[0]);
3310   return error::kNoError;
3311 }
3312
3313 error::Error GLES2DecoderImpl::HandleUniform3uivImmediate(
3314     uint32_t immediate_data_size,
3315     const void* cmd_data) {
3316   if (!unsafe_es3_apis_enabled())
3317     return error::kUnknownCommand;
3318   const gles2::cmds::Uniform3uivImmediate& c =
3319       *static_cast<const gles2::cmds::Uniform3uivImmediate*>(cmd_data);
3320   (void)c;
3321   GLint location = static_cast<GLint>(c.location);
3322   GLsizei count = static_cast<GLsizei>(c.count);
3323   uint32_t data_size;
3324   if (!ComputeDataSize(count, sizeof(GLuint), 3, &data_size)) {
3325     return error::kOutOfBounds;
3326   }
3327   if (data_size > immediate_data_size) {
3328     return error::kOutOfBounds;
3329   }
3330   const GLuint* v =
3331       GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
3332   if (v == NULL) {
3333     return error::kOutOfBounds;
3334   }
3335   glUniform3uiv(location, count, v);
3336   return error::kNoError;
3337 }
3338
3339 error::Error GLES2DecoderImpl::HandleUniform4f(uint32_t immediate_data_size,
3340                                                const void* cmd_data) {
3341   const gles2::cmds::Uniform4f& c =
3342       *static_cast<const gles2::cmds::Uniform4f*>(cmd_data);
3343   (void)c;
3344   GLint location = static_cast<GLint>(c.location);
3345   GLfloat x = static_cast<GLfloat>(c.x);
3346   GLfloat y = static_cast<GLfloat>(c.y);
3347   GLfloat z = static_cast<GLfloat>(c.z);
3348   GLfloat w = static_cast<GLfloat>(c.w);
3349   GLfloat temp[4] = {
3350       x, y, z, w,
3351   };
3352   DoUniform4fv(location, 1, &temp[0]);
3353   return error::kNoError;
3354 }
3355
3356 error::Error GLES2DecoderImpl::HandleUniform4fvImmediate(
3357     uint32_t immediate_data_size,
3358     const void* cmd_data) {
3359   const gles2::cmds::Uniform4fvImmediate& c =
3360       *static_cast<const gles2::cmds::Uniform4fvImmediate*>(cmd_data);
3361   (void)c;
3362   GLint location = static_cast<GLint>(c.location);
3363   GLsizei count = static_cast<GLsizei>(c.count);
3364   uint32_t data_size;
3365   if (!ComputeDataSize(count, sizeof(GLfloat), 4, &data_size)) {
3366     return error::kOutOfBounds;
3367   }
3368   if (data_size > immediate_data_size) {
3369     return error::kOutOfBounds;
3370   }
3371   const GLfloat* v =
3372       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
3373   if (v == NULL) {
3374     return error::kOutOfBounds;
3375   }
3376   DoUniform4fv(location, count, v);
3377   return error::kNoError;
3378 }
3379
3380 error::Error GLES2DecoderImpl::HandleUniform4i(uint32_t immediate_data_size,
3381                                                const void* cmd_data) {
3382   const gles2::cmds::Uniform4i& c =
3383       *static_cast<const gles2::cmds::Uniform4i*>(cmd_data);
3384   (void)c;
3385   GLint location = static_cast<GLint>(c.location);
3386   GLint x = static_cast<GLint>(c.x);
3387   GLint y = static_cast<GLint>(c.y);
3388   GLint z = static_cast<GLint>(c.z);
3389   GLint w = static_cast<GLint>(c.w);
3390   GLint temp[4] = {
3391       x, y, z, w,
3392   };
3393   DoUniform4iv(location, 1, &temp[0]);
3394   return error::kNoError;
3395 }
3396
3397 error::Error GLES2DecoderImpl::HandleUniform4ivImmediate(
3398     uint32_t immediate_data_size,
3399     const void* cmd_data) {
3400   const gles2::cmds::Uniform4ivImmediate& c =
3401       *static_cast<const gles2::cmds::Uniform4ivImmediate*>(cmd_data);
3402   (void)c;
3403   GLint location = static_cast<GLint>(c.location);
3404   GLsizei count = static_cast<GLsizei>(c.count);
3405   uint32_t data_size;
3406   if (!ComputeDataSize(count, sizeof(GLint), 4, &data_size)) {
3407     return error::kOutOfBounds;
3408   }
3409   if (data_size > immediate_data_size) {
3410     return error::kOutOfBounds;
3411   }
3412   const GLint* v =
3413       GetImmediateDataAs<const GLint*>(c, data_size, immediate_data_size);
3414   if (v == NULL) {
3415     return error::kOutOfBounds;
3416   }
3417   DoUniform4iv(location, count, v);
3418   return error::kNoError;
3419 }
3420
3421 error::Error GLES2DecoderImpl::HandleUniform4ui(uint32_t immediate_data_size,
3422                                                 const void* cmd_data) {
3423   if (!unsafe_es3_apis_enabled())
3424     return error::kUnknownCommand;
3425   const gles2::cmds::Uniform4ui& c =
3426       *static_cast<const gles2::cmds::Uniform4ui*>(cmd_data);
3427   (void)c;
3428   GLint location = static_cast<GLint>(c.location);
3429   GLuint x = static_cast<GLuint>(c.x);
3430   GLuint y = static_cast<GLuint>(c.y);
3431   GLuint z = static_cast<GLuint>(c.z);
3432   GLuint w = static_cast<GLuint>(c.w);
3433   GLuint temp[4] = {
3434       x, y, z, w,
3435   };
3436   glUniform4uiv(location, 1, &temp[0]);
3437   return error::kNoError;
3438 }
3439
3440 error::Error GLES2DecoderImpl::HandleUniform4uivImmediate(
3441     uint32_t immediate_data_size,
3442     const void* cmd_data) {
3443   if (!unsafe_es3_apis_enabled())
3444     return error::kUnknownCommand;
3445   const gles2::cmds::Uniform4uivImmediate& c =
3446       *static_cast<const gles2::cmds::Uniform4uivImmediate*>(cmd_data);
3447   (void)c;
3448   GLint location = static_cast<GLint>(c.location);
3449   GLsizei count = static_cast<GLsizei>(c.count);
3450   uint32_t data_size;
3451   if (!ComputeDataSize(count, sizeof(GLuint), 4, &data_size)) {
3452     return error::kOutOfBounds;
3453   }
3454   if (data_size > immediate_data_size) {
3455     return error::kOutOfBounds;
3456   }
3457   const GLuint* v =
3458       GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
3459   if (v == NULL) {
3460     return error::kOutOfBounds;
3461   }
3462   glUniform4uiv(location, count, v);
3463   return error::kNoError;
3464 }
3465
3466 error::Error GLES2DecoderImpl::HandleUniformMatrix2fvImmediate(
3467     uint32_t immediate_data_size,
3468     const void* cmd_data) {
3469   const gles2::cmds::UniformMatrix2fvImmediate& c =
3470       *static_cast<const gles2::cmds::UniformMatrix2fvImmediate*>(cmd_data);
3471   (void)c;
3472   GLint location = static_cast<GLint>(c.location);
3473   GLsizei count = static_cast<GLsizei>(c.count);
3474   GLboolean transpose = static_cast<GLboolean>(c.transpose);
3475   uint32_t data_size;
3476   if (!ComputeDataSize(count, sizeof(GLfloat), 4, &data_size)) {
3477     return error::kOutOfBounds;
3478   }
3479   if (data_size > immediate_data_size) {
3480     return error::kOutOfBounds;
3481   }
3482   const GLfloat* value =
3483       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
3484   if (value == NULL) {
3485     return error::kOutOfBounds;
3486   }
3487   DoUniformMatrix2fv(location, count, transpose, value);
3488   return error::kNoError;
3489 }
3490
3491 error::Error GLES2DecoderImpl::HandleUniformMatrix2x3fvImmediate(
3492     uint32_t immediate_data_size,
3493     const void* cmd_data) {
3494   if (!unsafe_es3_apis_enabled())
3495     return error::kUnknownCommand;
3496   const gles2::cmds::UniformMatrix2x3fvImmediate& c =
3497       *static_cast<const gles2::cmds::UniformMatrix2x3fvImmediate*>(cmd_data);
3498   (void)c;
3499   GLint location = static_cast<GLint>(c.location);
3500   GLsizei count = static_cast<GLsizei>(c.count);
3501   GLboolean transpose = static_cast<GLboolean>(c.transpose);
3502   uint32_t data_size;
3503   if (!ComputeDataSize(count, sizeof(GLfloat), 6, &data_size)) {
3504     return error::kOutOfBounds;
3505   }
3506   if (data_size > immediate_data_size) {
3507     return error::kOutOfBounds;
3508   }
3509   const GLfloat* value =
3510       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
3511   if (value == NULL) {
3512     return error::kOutOfBounds;
3513   }
3514   glUniformMatrix2x3fv(location, count, transpose, value);
3515   return error::kNoError;
3516 }
3517
3518 error::Error GLES2DecoderImpl::HandleUniformMatrix2x4fvImmediate(
3519     uint32_t immediate_data_size,
3520     const void* cmd_data) {
3521   if (!unsafe_es3_apis_enabled())
3522     return error::kUnknownCommand;
3523   const gles2::cmds::UniformMatrix2x4fvImmediate& c =
3524       *static_cast<const gles2::cmds::UniformMatrix2x4fvImmediate*>(cmd_data);
3525   (void)c;
3526   GLint location = static_cast<GLint>(c.location);
3527   GLsizei count = static_cast<GLsizei>(c.count);
3528   GLboolean transpose = static_cast<GLboolean>(c.transpose);
3529   uint32_t data_size;
3530   if (!ComputeDataSize(count, sizeof(GLfloat), 8, &data_size)) {
3531     return error::kOutOfBounds;
3532   }
3533   if (data_size > immediate_data_size) {
3534     return error::kOutOfBounds;
3535   }
3536   const GLfloat* value =
3537       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
3538   if (value == NULL) {
3539     return error::kOutOfBounds;
3540   }
3541   glUniformMatrix2x4fv(location, count, transpose, value);
3542   return error::kNoError;
3543 }
3544
3545 error::Error GLES2DecoderImpl::HandleUniformMatrix3fvImmediate(
3546     uint32_t immediate_data_size,
3547     const void* cmd_data) {
3548   const gles2::cmds::UniformMatrix3fvImmediate& c =
3549       *static_cast<const gles2::cmds::UniformMatrix3fvImmediate*>(cmd_data);
3550   (void)c;
3551   GLint location = static_cast<GLint>(c.location);
3552   GLsizei count = static_cast<GLsizei>(c.count);
3553   GLboolean transpose = static_cast<GLboolean>(c.transpose);
3554   uint32_t data_size;
3555   if (!ComputeDataSize(count, sizeof(GLfloat), 9, &data_size)) {
3556     return error::kOutOfBounds;
3557   }
3558   if (data_size > immediate_data_size) {
3559     return error::kOutOfBounds;
3560   }
3561   const GLfloat* value =
3562       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
3563   if (value == NULL) {
3564     return error::kOutOfBounds;
3565   }
3566   DoUniformMatrix3fv(location, count, transpose, value);
3567   return error::kNoError;
3568 }
3569
3570 error::Error GLES2DecoderImpl::HandleUniformMatrix3x2fvImmediate(
3571     uint32_t immediate_data_size,
3572     const void* cmd_data) {
3573   if (!unsafe_es3_apis_enabled())
3574     return error::kUnknownCommand;
3575   const gles2::cmds::UniformMatrix3x2fvImmediate& c =
3576       *static_cast<const gles2::cmds::UniformMatrix3x2fvImmediate*>(cmd_data);
3577   (void)c;
3578   GLint location = static_cast<GLint>(c.location);
3579   GLsizei count = static_cast<GLsizei>(c.count);
3580   GLboolean transpose = static_cast<GLboolean>(c.transpose);
3581   uint32_t data_size;
3582   if (!ComputeDataSize(count, sizeof(GLfloat), 6, &data_size)) {
3583     return error::kOutOfBounds;
3584   }
3585   if (data_size > immediate_data_size) {
3586     return error::kOutOfBounds;
3587   }
3588   const GLfloat* value =
3589       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
3590   if (value == NULL) {
3591     return error::kOutOfBounds;
3592   }
3593   glUniformMatrix3x2fv(location, count, transpose, value);
3594   return error::kNoError;
3595 }
3596
3597 error::Error GLES2DecoderImpl::HandleUniformMatrix3x4fvImmediate(
3598     uint32_t immediate_data_size,
3599     const void* cmd_data) {
3600   if (!unsafe_es3_apis_enabled())
3601     return error::kUnknownCommand;
3602   const gles2::cmds::UniformMatrix3x4fvImmediate& c =
3603       *static_cast<const gles2::cmds::UniformMatrix3x4fvImmediate*>(cmd_data);
3604   (void)c;
3605   GLint location = static_cast<GLint>(c.location);
3606   GLsizei count = static_cast<GLsizei>(c.count);
3607   GLboolean transpose = static_cast<GLboolean>(c.transpose);
3608   uint32_t data_size;
3609   if (!ComputeDataSize(count, sizeof(GLfloat), 12, &data_size)) {
3610     return error::kOutOfBounds;
3611   }
3612   if (data_size > immediate_data_size) {
3613     return error::kOutOfBounds;
3614   }
3615   const GLfloat* value =
3616       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
3617   if (value == NULL) {
3618     return error::kOutOfBounds;
3619   }
3620   glUniformMatrix3x4fv(location, count, transpose, value);
3621   return error::kNoError;
3622 }
3623
3624 error::Error GLES2DecoderImpl::HandleUniformMatrix4fvImmediate(
3625     uint32_t immediate_data_size,
3626     const void* cmd_data) {
3627   const gles2::cmds::UniformMatrix4fvImmediate& c =
3628       *static_cast<const gles2::cmds::UniformMatrix4fvImmediate*>(cmd_data);
3629   (void)c;
3630   GLint location = static_cast<GLint>(c.location);
3631   GLsizei count = static_cast<GLsizei>(c.count);
3632   GLboolean transpose = static_cast<GLboolean>(c.transpose);
3633   uint32_t data_size;
3634   if (!ComputeDataSize(count, sizeof(GLfloat), 16, &data_size)) {
3635     return error::kOutOfBounds;
3636   }
3637   if (data_size > immediate_data_size) {
3638     return error::kOutOfBounds;
3639   }
3640   const GLfloat* value =
3641       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
3642   if (value == NULL) {
3643     return error::kOutOfBounds;
3644   }
3645   DoUniformMatrix4fv(location, count, transpose, value);
3646   return error::kNoError;
3647 }
3648
3649 error::Error GLES2DecoderImpl::HandleUniformMatrix4x2fvImmediate(
3650     uint32_t immediate_data_size,
3651     const void* cmd_data) {
3652   if (!unsafe_es3_apis_enabled())
3653     return error::kUnknownCommand;
3654   const gles2::cmds::UniformMatrix4x2fvImmediate& c =
3655       *static_cast<const gles2::cmds::UniformMatrix4x2fvImmediate*>(cmd_data);
3656   (void)c;
3657   GLint location = static_cast<GLint>(c.location);
3658   GLsizei count = static_cast<GLsizei>(c.count);
3659   GLboolean transpose = static_cast<GLboolean>(c.transpose);
3660   uint32_t data_size;
3661   if (!ComputeDataSize(count, sizeof(GLfloat), 8, &data_size)) {
3662     return error::kOutOfBounds;
3663   }
3664   if (data_size > immediate_data_size) {
3665     return error::kOutOfBounds;
3666   }
3667   const GLfloat* value =
3668       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
3669   if (value == NULL) {
3670     return error::kOutOfBounds;
3671   }
3672   glUniformMatrix4x2fv(location, count, transpose, value);
3673   return error::kNoError;
3674 }
3675
3676 error::Error GLES2DecoderImpl::HandleUniformMatrix4x3fvImmediate(
3677     uint32_t immediate_data_size,
3678     const void* cmd_data) {
3679   if (!unsafe_es3_apis_enabled())
3680     return error::kUnknownCommand;
3681   const gles2::cmds::UniformMatrix4x3fvImmediate& c =
3682       *static_cast<const gles2::cmds::UniformMatrix4x3fvImmediate*>(cmd_data);
3683   (void)c;
3684   GLint location = static_cast<GLint>(c.location);
3685   GLsizei count = static_cast<GLsizei>(c.count);
3686   GLboolean transpose = static_cast<GLboolean>(c.transpose);
3687   uint32_t data_size;
3688   if (!ComputeDataSize(count, sizeof(GLfloat), 12, &data_size)) {
3689     return error::kOutOfBounds;
3690   }
3691   if (data_size > immediate_data_size) {
3692     return error::kOutOfBounds;
3693   }
3694   const GLfloat* value =
3695       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
3696   if (value == NULL) {
3697     return error::kOutOfBounds;
3698   }
3699   glUniformMatrix4x3fv(location, count, transpose, value);
3700   return error::kNoError;
3701 }
3702
3703 error::Error GLES2DecoderImpl::HandleUseProgram(uint32_t immediate_data_size,
3704                                                 const void* cmd_data) {
3705   const gles2::cmds::UseProgram& c =
3706       *static_cast<const gles2::cmds::UseProgram*>(cmd_data);
3707   (void)c;
3708   GLuint program = c.program;
3709   DoUseProgram(program);
3710   return error::kNoError;
3711 }
3712
3713 error::Error GLES2DecoderImpl::HandleValidateProgram(
3714     uint32_t immediate_data_size,
3715     const void* cmd_data) {
3716   const gles2::cmds::ValidateProgram& c =
3717       *static_cast<const gles2::cmds::ValidateProgram*>(cmd_data);
3718   (void)c;
3719   GLuint program = c.program;
3720   DoValidateProgram(program);
3721   return error::kNoError;
3722 }
3723
3724 error::Error GLES2DecoderImpl::HandleVertexAttrib1f(
3725     uint32_t immediate_data_size,
3726     const void* cmd_data) {
3727   const gles2::cmds::VertexAttrib1f& c =
3728       *static_cast<const gles2::cmds::VertexAttrib1f*>(cmd_data);
3729   (void)c;
3730   GLuint indx = static_cast<GLuint>(c.indx);
3731   GLfloat x = static_cast<GLfloat>(c.x);
3732   DoVertexAttrib1f(indx, x);
3733   return error::kNoError;
3734 }
3735
3736 error::Error GLES2DecoderImpl::HandleVertexAttrib1fvImmediate(
3737     uint32_t immediate_data_size,
3738     const void* cmd_data) {
3739   const gles2::cmds::VertexAttrib1fvImmediate& c =
3740       *static_cast<const gles2::cmds::VertexAttrib1fvImmediate*>(cmd_data);
3741   (void)c;
3742   GLuint indx = static_cast<GLuint>(c.indx);
3743   uint32_t data_size;
3744   if (!ComputeDataSize(1, sizeof(GLfloat), 1, &data_size)) {
3745     return error::kOutOfBounds;
3746   }
3747   if (data_size > immediate_data_size) {
3748     return error::kOutOfBounds;
3749   }
3750   const GLfloat* values =
3751       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
3752   if (values == NULL) {
3753     return error::kOutOfBounds;
3754   }
3755   DoVertexAttrib1fv(indx, values);
3756   return error::kNoError;
3757 }
3758
3759 error::Error GLES2DecoderImpl::HandleVertexAttrib2f(
3760     uint32_t immediate_data_size,
3761     const void* cmd_data) {
3762   const gles2::cmds::VertexAttrib2f& c =
3763       *static_cast<const gles2::cmds::VertexAttrib2f*>(cmd_data);
3764   (void)c;
3765   GLuint indx = static_cast<GLuint>(c.indx);
3766   GLfloat x = static_cast<GLfloat>(c.x);
3767   GLfloat y = static_cast<GLfloat>(c.y);
3768   DoVertexAttrib2f(indx, x, y);
3769   return error::kNoError;
3770 }
3771
3772 error::Error GLES2DecoderImpl::HandleVertexAttrib2fvImmediate(
3773     uint32_t immediate_data_size,
3774     const void* cmd_data) {
3775   const gles2::cmds::VertexAttrib2fvImmediate& c =
3776       *static_cast<const gles2::cmds::VertexAttrib2fvImmediate*>(cmd_data);
3777   (void)c;
3778   GLuint indx = static_cast<GLuint>(c.indx);
3779   uint32_t data_size;
3780   if (!ComputeDataSize(1, sizeof(GLfloat), 2, &data_size)) {
3781     return error::kOutOfBounds;
3782   }
3783   if (data_size > immediate_data_size) {
3784     return error::kOutOfBounds;
3785   }
3786   const GLfloat* values =
3787       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
3788   if (values == NULL) {
3789     return error::kOutOfBounds;
3790   }
3791   DoVertexAttrib2fv(indx, values);
3792   return error::kNoError;
3793 }
3794
3795 error::Error GLES2DecoderImpl::HandleVertexAttrib3f(
3796     uint32_t immediate_data_size,
3797     const void* cmd_data) {
3798   const gles2::cmds::VertexAttrib3f& c =
3799       *static_cast<const gles2::cmds::VertexAttrib3f*>(cmd_data);
3800   (void)c;
3801   GLuint indx = static_cast<GLuint>(c.indx);
3802   GLfloat x = static_cast<GLfloat>(c.x);
3803   GLfloat y = static_cast<GLfloat>(c.y);
3804   GLfloat z = static_cast<GLfloat>(c.z);
3805   DoVertexAttrib3f(indx, x, y, z);
3806   return error::kNoError;
3807 }
3808
3809 error::Error GLES2DecoderImpl::HandleVertexAttrib3fvImmediate(
3810     uint32_t immediate_data_size,
3811     const void* cmd_data) {
3812   const gles2::cmds::VertexAttrib3fvImmediate& c =
3813       *static_cast<const gles2::cmds::VertexAttrib3fvImmediate*>(cmd_data);
3814   (void)c;
3815   GLuint indx = static_cast<GLuint>(c.indx);
3816   uint32_t data_size;
3817   if (!ComputeDataSize(1, sizeof(GLfloat), 3, &data_size)) {
3818     return error::kOutOfBounds;
3819   }
3820   if (data_size > immediate_data_size) {
3821     return error::kOutOfBounds;
3822   }
3823   const GLfloat* values =
3824       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
3825   if (values == NULL) {
3826     return error::kOutOfBounds;
3827   }
3828   DoVertexAttrib3fv(indx, values);
3829   return error::kNoError;
3830 }
3831
3832 error::Error GLES2DecoderImpl::HandleVertexAttrib4f(
3833     uint32_t immediate_data_size,
3834     const void* cmd_data) {
3835   const gles2::cmds::VertexAttrib4f& c =
3836       *static_cast<const gles2::cmds::VertexAttrib4f*>(cmd_data);
3837   (void)c;
3838   GLuint indx = static_cast<GLuint>(c.indx);
3839   GLfloat x = static_cast<GLfloat>(c.x);
3840   GLfloat y = static_cast<GLfloat>(c.y);
3841   GLfloat z = static_cast<GLfloat>(c.z);
3842   GLfloat w = static_cast<GLfloat>(c.w);
3843   DoVertexAttrib4f(indx, x, y, z, w);
3844   return error::kNoError;
3845 }
3846
3847 error::Error GLES2DecoderImpl::HandleVertexAttrib4fvImmediate(
3848     uint32_t immediate_data_size,
3849     const void* cmd_data) {
3850   const gles2::cmds::VertexAttrib4fvImmediate& c =
3851       *static_cast<const gles2::cmds::VertexAttrib4fvImmediate*>(cmd_data);
3852   (void)c;
3853   GLuint indx = static_cast<GLuint>(c.indx);
3854   uint32_t data_size;
3855   if (!ComputeDataSize(1, sizeof(GLfloat), 4, &data_size)) {
3856     return error::kOutOfBounds;
3857   }
3858   if (data_size > immediate_data_size) {
3859     return error::kOutOfBounds;
3860   }
3861   const GLfloat* values =
3862       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
3863   if (values == NULL) {
3864     return error::kOutOfBounds;
3865   }
3866   DoVertexAttrib4fv(indx, values);
3867   return error::kNoError;
3868 }
3869
3870 error::Error GLES2DecoderImpl::HandleVertexAttribI4i(
3871     uint32_t immediate_data_size,
3872     const void* cmd_data) {
3873   if (!unsafe_es3_apis_enabled())
3874     return error::kUnknownCommand;
3875   const gles2::cmds::VertexAttribI4i& c =
3876       *static_cast<const gles2::cmds::VertexAttribI4i*>(cmd_data);
3877   (void)c;
3878   GLuint indx = static_cast<GLuint>(c.indx);
3879   GLint x = static_cast<GLint>(c.x);
3880   GLint y = static_cast<GLint>(c.y);
3881   GLint z = static_cast<GLint>(c.z);
3882   GLint w = static_cast<GLint>(c.w);
3883   glVertexAttribI4i(indx, x, y, z, w);
3884   return error::kNoError;
3885 }
3886
3887 error::Error GLES2DecoderImpl::HandleVertexAttribI4ivImmediate(
3888     uint32_t immediate_data_size,
3889     const void* cmd_data) {
3890   if (!unsafe_es3_apis_enabled())
3891     return error::kUnknownCommand;
3892   const gles2::cmds::VertexAttribI4ivImmediate& c =
3893       *static_cast<const gles2::cmds::VertexAttribI4ivImmediate*>(cmd_data);
3894   (void)c;
3895   GLuint indx = static_cast<GLuint>(c.indx);
3896   uint32_t data_size;
3897   if (!ComputeDataSize(1, sizeof(GLint), 4, &data_size)) {
3898     return error::kOutOfBounds;
3899   }
3900   if (data_size > immediate_data_size) {
3901     return error::kOutOfBounds;
3902   }
3903   const GLint* values =
3904       GetImmediateDataAs<const GLint*>(c, data_size, immediate_data_size);
3905   if (values == NULL) {
3906     return error::kOutOfBounds;
3907   }
3908   glVertexAttribI4iv(indx, values);
3909   return error::kNoError;
3910 }
3911
3912 error::Error GLES2DecoderImpl::HandleVertexAttribI4ui(
3913     uint32_t immediate_data_size,
3914     const void* cmd_data) {
3915   if (!unsafe_es3_apis_enabled())
3916     return error::kUnknownCommand;
3917   const gles2::cmds::VertexAttribI4ui& c =
3918       *static_cast<const gles2::cmds::VertexAttribI4ui*>(cmd_data);
3919   (void)c;
3920   GLuint indx = static_cast<GLuint>(c.indx);
3921   GLuint x = static_cast<GLuint>(c.x);
3922   GLuint y = static_cast<GLuint>(c.y);
3923   GLuint z = static_cast<GLuint>(c.z);
3924   GLuint w = static_cast<GLuint>(c.w);
3925   glVertexAttribI4ui(indx, x, y, z, w);
3926   return error::kNoError;
3927 }
3928
3929 error::Error GLES2DecoderImpl::HandleVertexAttribI4uivImmediate(
3930     uint32_t immediate_data_size,
3931     const void* cmd_data) {
3932   if (!unsafe_es3_apis_enabled())
3933     return error::kUnknownCommand;
3934   const gles2::cmds::VertexAttribI4uivImmediate& c =
3935       *static_cast<const gles2::cmds::VertexAttribI4uivImmediate*>(cmd_data);
3936   (void)c;
3937   GLuint indx = static_cast<GLuint>(c.indx);
3938   uint32_t data_size;
3939   if (!ComputeDataSize(1, sizeof(GLuint), 4, &data_size)) {
3940     return error::kOutOfBounds;
3941   }
3942   if (data_size > immediate_data_size) {
3943     return error::kOutOfBounds;
3944   }
3945   const GLuint* values =
3946       GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
3947   if (values == NULL) {
3948     return error::kOutOfBounds;
3949   }
3950   glVertexAttribI4uiv(indx, values);
3951   return error::kNoError;
3952 }
3953
3954 error::Error GLES2DecoderImpl::HandleViewport(uint32_t immediate_data_size,
3955                                               const void* cmd_data) {
3956   const gles2::cmds::Viewport& c =
3957       *static_cast<const gles2::cmds::Viewport*>(cmd_data);
3958   (void)c;
3959   GLint x = static_cast<GLint>(c.x);
3960   GLint y = static_cast<GLint>(c.y);
3961   GLsizei width = static_cast<GLsizei>(c.width);
3962   GLsizei height = static_cast<GLsizei>(c.height);
3963   if (width < 0) {
3964     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glViewport", "width < 0");
3965     return error::kNoError;
3966   }
3967   if (height < 0) {
3968     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glViewport", "height < 0");
3969     return error::kNoError;
3970   }
3971   DoViewport(x, y, width, height);
3972   return error::kNoError;
3973 }
3974
3975 error::Error GLES2DecoderImpl::HandleBlitFramebufferCHROMIUM(
3976     uint32_t immediate_data_size,
3977     const void* cmd_data) {
3978   const gles2::cmds::BlitFramebufferCHROMIUM& c =
3979       *static_cast<const gles2::cmds::BlitFramebufferCHROMIUM*>(cmd_data);
3980   (void)c;
3981   if (!features().chromium_framebuffer_multisample) {
3982     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glBlitFramebufferCHROMIUM",
3983                        "function not available");
3984     return error::kNoError;
3985   }
3986
3987   error::Error error;
3988   error = WillAccessBoundFramebufferForDraw();
3989   if (error != error::kNoError)
3990     return error;
3991   error = WillAccessBoundFramebufferForRead();
3992   if (error != error::kNoError)
3993     return error;
3994   GLint srcX0 = static_cast<GLint>(c.srcX0);
3995   GLint srcY0 = static_cast<GLint>(c.srcY0);
3996   GLint srcX1 = static_cast<GLint>(c.srcX1);
3997   GLint srcY1 = static_cast<GLint>(c.srcY1);
3998   GLint dstX0 = static_cast<GLint>(c.dstX0);
3999   GLint dstY0 = static_cast<GLint>(c.dstY0);
4000   GLint dstX1 = static_cast<GLint>(c.dstX1);
4001   GLint dstY1 = static_cast<GLint>(c.dstY1);
4002   GLbitfield mask = static_cast<GLbitfield>(c.mask);
4003   GLenum filter = static_cast<GLenum>(c.filter);
4004   if (!validators_->blit_filter.IsValid(filter)) {
4005     LOCAL_SET_GL_ERROR_INVALID_ENUM("glBlitFramebufferCHROMIUM", filter,
4006                                     "filter");
4007     return error::kNoError;
4008   }
4009   DoBlitFramebufferCHROMIUM(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1,
4010                             dstY1, mask, filter);
4011   return error::kNoError;
4012 }
4013
4014 error::Error GLES2DecoderImpl::HandleRenderbufferStorageMultisampleCHROMIUM(
4015     uint32_t immediate_data_size,
4016     const void* cmd_data) {
4017   const gles2::cmds::RenderbufferStorageMultisampleCHROMIUM& c =
4018       *static_cast<const gles2::cmds::RenderbufferStorageMultisampleCHROMIUM*>(
4019           cmd_data);
4020   (void)c;
4021   if (!features().chromium_framebuffer_multisample) {
4022     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
4023                        "glRenderbufferStorageMultisampleCHROMIUM",
4024                        "function not available");
4025     return error::kNoError;
4026   }
4027
4028   GLenum target = static_cast<GLenum>(c.target);
4029   GLsizei samples = static_cast<GLsizei>(c.samples);
4030   GLenum internalformat = static_cast<GLenum>(c.internalformat);
4031   GLsizei width = static_cast<GLsizei>(c.width);
4032   GLsizei height = static_cast<GLsizei>(c.height);
4033   if (!validators_->render_buffer_target.IsValid(target)) {
4034     LOCAL_SET_GL_ERROR_INVALID_ENUM("glRenderbufferStorageMultisampleCHROMIUM",
4035                                     target, "target");
4036     return error::kNoError;
4037   }
4038   if (samples < 0) {
4039     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
4040                        "glRenderbufferStorageMultisampleCHROMIUM",
4041                        "samples < 0");
4042     return error::kNoError;
4043   }
4044   if (!validators_->render_buffer_format.IsValid(internalformat)) {
4045     LOCAL_SET_GL_ERROR_INVALID_ENUM("glRenderbufferStorageMultisampleCHROMIUM",
4046                                     internalformat, "internalformat");
4047     return error::kNoError;
4048   }
4049   if (width < 0) {
4050     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
4051                        "glRenderbufferStorageMultisampleCHROMIUM", "width < 0");
4052     return error::kNoError;
4053   }
4054   if (height < 0) {
4055     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
4056                        "glRenderbufferStorageMultisampleCHROMIUM",
4057                        "height < 0");
4058     return error::kNoError;
4059   }
4060   DoRenderbufferStorageMultisampleCHROMIUM(target, samples, internalformat,
4061                                            width, height);
4062   return error::kNoError;
4063 }
4064
4065 error::Error GLES2DecoderImpl::HandleRenderbufferStorageMultisampleEXT(
4066     uint32_t immediate_data_size,
4067     const void* cmd_data) {
4068   const gles2::cmds::RenderbufferStorageMultisampleEXT& c =
4069       *static_cast<const gles2::cmds::RenderbufferStorageMultisampleEXT*>(
4070           cmd_data);
4071   (void)c;
4072   if (!features().multisampled_render_to_texture) {
4073     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
4074                        "glRenderbufferStorageMultisampleEXT",
4075                        "function not available");
4076     return error::kNoError;
4077   }
4078
4079   GLenum target = static_cast<GLenum>(c.target);
4080   GLsizei samples = static_cast<GLsizei>(c.samples);
4081   GLenum internalformat = static_cast<GLenum>(c.internalformat);
4082   GLsizei width = static_cast<GLsizei>(c.width);
4083   GLsizei height = static_cast<GLsizei>(c.height);
4084   if (!validators_->render_buffer_target.IsValid(target)) {
4085     LOCAL_SET_GL_ERROR_INVALID_ENUM("glRenderbufferStorageMultisampleEXT",
4086                                     target, "target");
4087     return error::kNoError;
4088   }
4089   if (samples < 0) {
4090     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glRenderbufferStorageMultisampleEXT",
4091                        "samples < 0");
4092     return error::kNoError;
4093   }
4094   if (!validators_->render_buffer_format.IsValid(internalformat)) {
4095     LOCAL_SET_GL_ERROR_INVALID_ENUM("glRenderbufferStorageMultisampleEXT",
4096                                     internalformat, "internalformat");
4097     return error::kNoError;
4098   }
4099   if (width < 0) {
4100     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glRenderbufferStorageMultisampleEXT",
4101                        "width < 0");
4102     return error::kNoError;
4103   }
4104   if (height < 0) {
4105     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glRenderbufferStorageMultisampleEXT",
4106                        "height < 0");
4107     return error::kNoError;
4108   }
4109   DoRenderbufferStorageMultisampleEXT(target, samples, internalformat, width,
4110                                       height);
4111   return error::kNoError;
4112 }
4113
4114 error::Error GLES2DecoderImpl::HandleFramebufferTexture2DMultisampleEXT(
4115     uint32_t immediate_data_size,
4116     const void* cmd_data) {
4117   const gles2::cmds::FramebufferTexture2DMultisampleEXT& c =
4118       *static_cast<const gles2::cmds::FramebufferTexture2DMultisampleEXT*>(
4119           cmd_data);
4120   (void)c;
4121   if (!features().multisampled_render_to_texture) {
4122     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
4123                        "glFramebufferTexture2DMultisampleEXT",
4124                        "function not available");
4125     return error::kNoError;
4126   }
4127
4128   GLenum target = static_cast<GLenum>(c.target);
4129   GLenum attachment = static_cast<GLenum>(c.attachment);
4130   GLenum textarget = static_cast<GLenum>(c.textarget);
4131   GLuint texture = c.texture;
4132   GLint level = static_cast<GLint>(c.level);
4133   GLsizei samples = static_cast<GLsizei>(c.samples);
4134   if (!validators_->frame_buffer_target.IsValid(target)) {
4135     LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferTexture2DMultisampleEXT",
4136                                     target, "target");
4137     return error::kNoError;
4138   }
4139   if (!validators_->attachment.IsValid(attachment)) {
4140     LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferTexture2DMultisampleEXT",
4141                                     attachment, "attachment");
4142     return error::kNoError;
4143   }
4144   if (!validators_->texture_target.IsValid(textarget)) {
4145     LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferTexture2DMultisampleEXT",
4146                                     textarget, "textarget");
4147     return error::kNoError;
4148   }
4149   if (samples < 0) {
4150     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glFramebufferTexture2DMultisampleEXT",
4151                        "samples < 0");
4152     return error::kNoError;
4153   }
4154   DoFramebufferTexture2DMultisample(target, attachment, textarget, texture,
4155                                     level, samples);
4156   return error::kNoError;
4157 }
4158
4159 error::Error GLES2DecoderImpl::HandleTexStorage2DEXT(
4160     uint32_t immediate_data_size,
4161     const void* cmd_data) {
4162   const gles2::cmds::TexStorage2DEXT& c =
4163       *static_cast<const gles2::cmds::TexStorage2DEXT*>(cmd_data);
4164   (void)c;
4165   GLenum target = static_cast<GLenum>(c.target);
4166   GLsizei levels = static_cast<GLsizei>(c.levels);
4167   GLenum internalFormat = static_cast<GLenum>(c.internalFormat);
4168   GLsizei width = static_cast<GLsizei>(c.width);
4169   GLsizei height = static_cast<GLsizei>(c.height);
4170   if (!validators_->texture_target.IsValid(target)) {
4171     LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexStorage2DEXT", target, "target");
4172     return error::kNoError;
4173   }
4174   if (levels < 0) {
4175     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glTexStorage2DEXT", "levels < 0");
4176     return error::kNoError;
4177   }
4178   if (!validators_->texture_internal_format_storage.IsValid(internalFormat)) {
4179     LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexStorage2DEXT", internalFormat,
4180                                     "internalFormat");
4181     return error::kNoError;
4182   }
4183   if (width < 0) {
4184     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glTexStorage2DEXT", "width < 0");
4185     return error::kNoError;
4186   }
4187   if (height < 0) {
4188     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glTexStorage2DEXT", "height < 0");
4189     return error::kNoError;
4190   }
4191   DoTexStorage2DEXT(target, levels, internalFormat, width, height);
4192   return error::kNoError;
4193 }
4194
4195 error::Error GLES2DecoderImpl::HandleGenQueriesEXTImmediate(
4196     uint32_t immediate_data_size,
4197     const void* cmd_data) {
4198   const gles2::cmds::GenQueriesEXTImmediate& c =
4199       *static_cast<const gles2::cmds::GenQueriesEXTImmediate*>(cmd_data);
4200   (void)c;
4201   GLsizei n = static_cast<GLsizei>(c.n);
4202   uint32_t data_size;
4203   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
4204     return error::kOutOfBounds;
4205   }
4206   GLuint* queries =
4207       GetImmediateDataAs<GLuint*>(c, data_size, immediate_data_size);
4208   if (queries == NULL) {
4209     return error::kOutOfBounds;
4210   }
4211   if (!GenQueriesEXTHelper(n, queries)) {
4212     return error::kInvalidArguments;
4213   }
4214   return error::kNoError;
4215 }
4216
4217 error::Error GLES2DecoderImpl::HandleDeleteQueriesEXTImmediate(
4218     uint32_t immediate_data_size,
4219     const void* cmd_data) {
4220   const gles2::cmds::DeleteQueriesEXTImmediate& c =
4221       *static_cast<const gles2::cmds::DeleteQueriesEXTImmediate*>(cmd_data);
4222   (void)c;
4223   GLsizei n = static_cast<GLsizei>(c.n);
4224   uint32_t data_size;
4225   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
4226     return error::kOutOfBounds;
4227   }
4228   const GLuint* queries =
4229       GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
4230   if (queries == NULL) {
4231     return error::kOutOfBounds;
4232   }
4233   DeleteQueriesEXTHelper(n, queries);
4234   return error::kNoError;
4235 }
4236
4237 error::Error GLES2DecoderImpl::HandleBeginTransformFeedback(
4238     uint32_t immediate_data_size,
4239     const void* cmd_data) {
4240   if (!unsafe_es3_apis_enabled())
4241     return error::kUnknownCommand;
4242   const gles2::cmds::BeginTransformFeedback& c =
4243       *static_cast<const gles2::cmds::BeginTransformFeedback*>(cmd_data);
4244   (void)c;
4245   GLenum primitivemode = static_cast<GLenum>(c.primitivemode);
4246   glBeginTransformFeedback(primitivemode);
4247   return error::kNoError;
4248 }
4249
4250 error::Error GLES2DecoderImpl::HandleEndTransformFeedback(
4251     uint32_t immediate_data_size,
4252     const void* cmd_data) {
4253   if (!unsafe_es3_apis_enabled())
4254     return error::kUnknownCommand;
4255   const gles2::cmds::EndTransformFeedback& c =
4256       *static_cast<const gles2::cmds::EndTransformFeedback*>(cmd_data);
4257   (void)c;
4258   glEndTransformFeedback();
4259   return error::kNoError;
4260 }
4261
4262 error::Error GLES2DecoderImpl::HandleInsertEventMarkerEXT(
4263     uint32_t immediate_data_size,
4264     const void* cmd_data) {
4265   const gles2::cmds::InsertEventMarkerEXT& c =
4266       *static_cast<const gles2::cmds::InsertEventMarkerEXT*>(cmd_data);
4267   (void)c;
4268
4269   GLuint bucket_id = static_cast<GLuint>(c.bucket_id);
4270   Bucket* bucket = GetBucket(bucket_id);
4271   if (!bucket || bucket->size() == 0) {
4272     return error::kInvalidArguments;
4273   }
4274   std::string str;
4275   if (!bucket->GetAsString(&str)) {
4276     return error::kInvalidArguments;
4277   }
4278   DoInsertEventMarkerEXT(0, str.c_str());
4279   return error::kNoError;
4280 }
4281
4282 error::Error GLES2DecoderImpl::HandlePushGroupMarkerEXT(
4283     uint32_t immediate_data_size,
4284     const void* cmd_data) {
4285   const gles2::cmds::PushGroupMarkerEXT& c =
4286       *static_cast<const gles2::cmds::PushGroupMarkerEXT*>(cmd_data);
4287   (void)c;
4288
4289   GLuint bucket_id = static_cast<GLuint>(c.bucket_id);
4290   Bucket* bucket = GetBucket(bucket_id);
4291   if (!bucket || bucket->size() == 0) {
4292     return error::kInvalidArguments;
4293   }
4294   std::string str;
4295   if (!bucket->GetAsString(&str)) {
4296     return error::kInvalidArguments;
4297   }
4298   DoPushGroupMarkerEXT(0, str.c_str());
4299   return error::kNoError;
4300 }
4301
4302 error::Error GLES2DecoderImpl::HandlePopGroupMarkerEXT(
4303     uint32_t immediate_data_size,
4304     const void* cmd_data) {
4305   const gles2::cmds::PopGroupMarkerEXT& c =
4306       *static_cast<const gles2::cmds::PopGroupMarkerEXT*>(cmd_data);
4307   (void)c;
4308   DoPopGroupMarkerEXT();
4309   return error::kNoError;
4310 }
4311
4312 error::Error GLES2DecoderImpl::HandleGenVertexArraysOESImmediate(
4313     uint32_t immediate_data_size,
4314     const void* cmd_data) {
4315   const gles2::cmds::GenVertexArraysOESImmediate& c =
4316       *static_cast<const gles2::cmds::GenVertexArraysOESImmediate*>(cmd_data);
4317   (void)c;
4318   GLsizei n = static_cast<GLsizei>(c.n);
4319   uint32_t data_size;
4320   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
4321     return error::kOutOfBounds;
4322   }
4323   GLuint* arrays =
4324       GetImmediateDataAs<GLuint*>(c, data_size, immediate_data_size);
4325   if (arrays == NULL) {
4326     return error::kOutOfBounds;
4327   }
4328   if (!GenVertexArraysOESHelper(n, arrays)) {
4329     return error::kInvalidArguments;
4330   }
4331   return error::kNoError;
4332 }
4333
4334 error::Error GLES2DecoderImpl::HandleDeleteVertexArraysOESImmediate(
4335     uint32_t immediate_data_size,
4336     const void* cmd_data) {
4337   const gles2::cmds::DeleteVertexArraysOESImmediate& c =
4338       *static_cast<const gles2::cmds::DeleteVertexArraysOESImmediate*>(
4339           cmd_data);
4340   (void)c;
4341   GLsizei n = static_cast<GLsizei>(c.n);
4342   uint32_t data_size;
4343   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
4344     return error::kOutOfBounds;
4345   }
4346   const GLuint* arrays =
4347       GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
4348   if (arrays == NULL) {
4349     return error::kOutOfBounds;
4350   }
4351   DeleteVertexArraysOESHelper(n, arrays);
4352   return error::kNoError;
4353 }
4354
4355 error::Error GLES2DecoderImpl::HandleIsVertexArrayOES(
4356     uint32_t immediate_data_size,
4357     const void* cmd_data) {
4358   const gles2::cmds::IsVertexArrayOES& c =
4359       *static_cast<const gles2::cmds::IsVertexArrayOES*>(cmd_data);
4360   (void)c;
4361   GLuint array = c.array;
4362   typedef cmds::IsVertexArrayOES::Result Result;
4363   Result* result_dst = GetSharedMemoryAs<Result*>(
4364       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
4365   if (!result_dst) {
4366     return error::kOutOfBounds;
4367   }
4368   *result_dst = DoIsVertexArrayOES(array);
4369   return error::kNoError;
4370 }
4371
4372 error::Error GLES2DecoderImpl::HandleBindVertexArrayOES(
4373     uint32_t immediate_data_size,
4374     const void* cmd_data) {
4375   const gles2::cmds::BindVertexArrayOES& c =
4376       *static_cast<const gles2::cmds::BindVertexArrayOES*>(cmd_data);
4377   (void)c;
4378   GLuint array = c.array;
4379   DoBindVertexArrayOES(array);
4380   return error::kNoError;
4381 }
4382
4383 error::Error GLES2DecoderImpl::HandleSwapBuffers(uint32_t immediate_data_size,
4384                                                  const void* cmd_data) {
4385   const gles2::cmds::SwapBuffers& c =
4386       *static_cast<const gles2::cmds::SwapBuffers*>(cmd_data);
4387   (void)c;
4388   DoSwapBuffers();
4389   return error::kNoError;
4390 }
4391
4392 error::Error GLES2DecoderImpl::HandleGetMaxValueInBufferCHROMIUM(
4393     uint32_t immediate_data_size,
4394     const void* cmd_data) {
4395   const gles2::cmds::GetMaxValueInBufferCHROMIUM& c =
4396       *static_cast<const gles2::cmds::GetMaxValueInBufferCHROMIUM*>(cmd_data);
4397   (void)c;
4398   GLuint buffer_id = c.buffer_id;
4399   GLsizei count = static_cast<GLsizei>(c.count);
4400   GLenum type = static_cast<GLenum>(c.type);
4401   GLuint offset = static_cast<GLuint>(c.offset);
4402   typedef cmds::GetMaxValueInBufferCHROMIUM::Result Result;
4403   Result* result_dst = GetSharedMemoryAs<Result*>(
4404       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
4405   if (!result_dst) {
4406     return error::kOutOfBounds;
4407   }
4408   if (count < 0) {
4409     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glGetMaxValueInBufferCHROMIUM",
4410                        "count < 0");
4411     return error::kNoError;
4412   }
4413   if (!validators_->get_max_index_type.IsValid(type)) {
4414     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetMaxValueInBufferCHROMIUM", type,
4415                                     "type");
4416     return error::kNoError;
4417   }
4418   *result_dst = DoGetMaxValueInBufferCHROMIUM(buffer_id, count, type, offset);
4419   return error::kNoError;
4420 }
4421
4422 error::Error GLES2DecoderImpl::HandleTexImageIOSurface2DCHROMIUM(
4423     uint32_t immediate_data_size,
4424     const void* cmd_data) {
4425   const gles2::cmds::TexImageIOSurface2DCHROMIUM& c =
4426       *static_cast<const gles2::cmds::TexImageIOSurface2DCHROMIUM*>(cmd_data);
4427   (void)c;
4428   GLenum target = static_cast<GLenum>(c.target);
4429   GLsizei width = static_cast<GLsizei>(c.width);
4430   GLsizei height = static_cast<GLsizei>(c.height);
4431   GLuint ioSurfaceId = static_cast<GLuint>(c.ioSurfaceId);
4432   GLuint plane = static_cast<GLuint>(c.plane);
4433   if (!validators_->texture_bind_target.IsValid(target)) {
4434     LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexImageIOSurface2DCHROMIUM", target,
4435                                     "target");
4436     return error::kNoError;
4437   }
4438   if (width < 0) {
4439     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glTexImageIOSurface2DCHROMIUM",
4440                        "width < 0");
4441     return error::kNoError;
4442   }
4443   if (height < 0) {
4444     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glTexImageIOSurface2DCHROMIUM",
4445                        "height < 0");
4446     return error::kNoError;
4447   }
4448   DoTexImageIOSurface2DCHROMIUM(target, width, height, ioSurfaceId, plane);
4449   return error::kNoError;
4450 }
4451
4452 error::Error GLES2DecoderImpl::HandleCopyTextureCHROMIUM(
4453     uint32_t immediate_data_size,
4454     const void* cmd_data) {
4455   const gles2::cmds::CopyTextureCHROMIUM& c =
4456       *static_cast<const gles2::cmds::CopyTextureCHROMIUM*>(cmd_data);
4457   (void)c;
4458   GLenum target = static_cast<GLenum>(c.target);
4459   GLenum source_id = static_cast<GLenum>(c.source_id);
4460   GLenum dest_id = static_cast<GLenum>(c.dest_id);
4461   GLint internalformat = static_cast<GLint>(c.internalformat);
4462   GLenum dest_type = static_cast<GLenum>(c.dest_type);
4463   if (!validators_->texture_internal_format.IsValid(internalformat)) {
4464     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glCopyTextureCHROMIUM",
4465                        "internalformat GL_INVALID_VALUE");
4466     return error::kNoError;
4467   }
4468   if (!validators_->pixel_type.IsValid(dest_type)) {
4469     LOCAL_SET_GL_ERROR_INVALID_ENUM("glCopyTextureCHROMIUM", dest_type,
4470                                     "dest_type");
4471     return error::kNoError;
4472   }
4473   DoCopyTextureCHROMIUM(target, source_id, dest_id, internalformat, dest_type);
4474   return error::kNoError;
4475 }
4476
4477 error::Error GLES2DecoderImpl::HandleCopySubTextureCHROMIUM(
4478     uint32_t immediate_data_size,
4479     const void* cmd_data) {
4480   const gles2::cmds::CopySubTextureCHROMIUM& c =
4481       *static_cast<const gles2::cmds::CopySubTextureCHROMIUM*>(cmd_data);
4482   (void)c;
4483   GLenum target = static_cast<GLenum>(c.target);
4484   GLenum source_id = static_cast<GLenum>(c.source_id);
4485   GLenum dest_id = static_cast<GLenum>(c.dest_id);
4486   GLint xoffset = static_cast<GLint>(c.xoffset);
4487   GLint yoffset = static_cast<GLint>(c.yoffset);
4488   DoCopySubTextureCHROMIUM(target, source_id, dest_id, xoffset, yoffset);
4489   return error::kNoError;
4490 }
4491
4492 error::Error GLES2DecoderImpl::HandleProduceTextureCHROMIUMImmediate(
4493     uint32_t immediate_data_size,
4494     const void* cmd_data) {
4495   const gles2::cmds::ProduceTextureCHROMIUMImmediate& c =
4496       *static_cast<const gles2::cmds::ProduceTextureCHROMIUMImmediate*>(
4497           cmd_data);
4498   (void)c;
4499   GLenum target = static_cast<GLenum>(c.target);
4500   uint32_t data_size;
4501   if (!ComputeDataSize(1, sizeof(GLbyte), 64, &data_size)) {
4502     return error::kOutOfBounds;
4503   }
4504   if (data_size > immediate_data_size) {
4505     return error::kOutOfBounds;
4506   }
4507   const GLbyte* mailbox =
4508       GetImmediateDataAs<const GLbyte*>(c, data_size, immediate_data_size);
4509   if (!validators_->texture_bind_target.IsValid(target)) {
4510     LOCAL_SET_GL_ERROR_INVALID_ENUM("glProduceTextureCHROMIUM", target,
4511                                     "target");
4512     return error::kNoError;
4513   }
4514   if (mailbox == NULL) {
4515     return error::kOutOfBounds;
4516   }
4517   DoProduceTextureCHROMIUM(target, mailbox);
4518   return error::kNoError;
4519 }
4520
4521 error::Error GLES2DecoderImpl::HandleProduceTextureDirectCHROMIUMImmediate(
4522     uint32_t immediate_data_size,
4523     const void* cmd_data) {
4524   const gles2::cmds::ProduceTextureDirectCHROMIUMImmediate& c =
4525       *static_cast<const gles2::cmds::ProduceTextureDirectCHROMIUMImmediate*>(
4526           cmd_data);
4527   (void)c;
4528   GLuint texture = c.texture;
4529   GLenum target = static_cast<GLenum>(c.target);
4530   uint32_t data_size;
4531   if (!ComputeDataSize(1, sizeof(GLbyte), 64, &data_size)) {
4532     return error::kOutOfBounds;
4533   }
4534   if (data_size > immediate_data_size) {
4535     return error::kOutOfBounds;
4536   }
4537   const GLbyte* mailbox =
4538       GetImmediateDataAs<const GLbyte*>(c, data_size, immediate_data_size);
4539   if (!validators_->texture_bind_target.IsValid(target)) {
4540     LOCAL_SET_GL_ERROR_INVALID_ENUM("glProduceTextureDirectCHROMIUM", target,
4541                                     "target");
4542     return error::kNoError;
4543   }
4544   if (mailbox == NULL) {
4545     return error::kOutOfBounds;
4546   }
4547   DoProduceTextureDirectCHROMIUM(texture, target, mailbox);
4548   return error::kNoError;
4549 }
4550
4551 error::Error GLES2DecoderImpl::HandleConsumeTextureCHROMIUMImmediate(
4552     uint32_t immediate_data_size,
4553     const void* cmd_data) {
4554   const gles2::cmds::ConsumeTextureCHROMIUMImmediate& c =
4555       *static_cast<const gles2::cmds::ConsumeTextureCHROMIUMImmediate*>(
4556           cmd_data);
4557   (void)c;
4558   GLenum target = static_cast<GLenum>(c.target);
4559   uint32_t data_size;
4560   if (!ComputeDataSize(1, sizeof(GLbyte), 64, &data_size)) {
4561     return error::kOutOfBounds;
4562   }
4563   if (data_size > immediate_data_size) {
4564     return error::kOutOfBounds;
4565   }
4566   const GLbyte* mailbox =
4567       GetImmediateDataAs<const GLbyte*>(c, data_size, immediate_data_size);
4568   if (!validators_->texture_bind_target.IsValid(target)) {
4569     LOCAL_SET_GL_ERROR_INVALID_ENUM("glConsumeTextureCHROMIUM", target,
4570                                     "target");
4571     return error::kNoError;
4572   }
4573   if (mailbox == NULL) {
4574     return error::kOutOfBounds;
4575   }
4576   DoConsumeTextureCHROMIUM(target, mailbox);
4577   return error::kNoError;
4578 }
4579
4580 error::Error GLES2DecoderImpl::HandleGenValuebuffersCHROMIUMImmediate(
4581     uint32_t immediate_data_size,
4582     const void* cmd_data) {
4583   const gles2::cmds::GenValuebuffersCHROMIUMImmediate& c =
4584       *static_cast<const gles2::cmds::GenValuebuffersCHROMIUMImmediate*>(
4585           cmd_data);
4586   (void)c;
4587   GLsizei n = static_cast<GLsizei>(c.n);
4588   uint32_t data_size;
4589   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
4590     return error::kOutOfBounds;
4591   }
4592   GLuint* buffers =
4593       GetImmediateDataAs<GLuint*>(c, data_size, immediate_data_size);
4594   if (buffers == NULL) {
4595     return error::kOutOfBounds;
4596   }
4597   if (!GenValuebuffersCHROMIUMHelper(n, buffers)) {
4598     return error::kInvalidArguments;
4599   }
4600   return error::kNoError;
4601 }
4602
4603 error::Error GLES2DecoderImpl::HandleDeleteValuebuffersCHROMIUMImmediate(
4604     uint32_t immediate_data_size,
4605     const void* cmd_data) {
4606   const gles2::cmds::DeleteValuebuffersCHROMIUMImmediate& c =
4607       *static_cast<const gles2::cmds::DeleteValuebuffersCHROMIUMImmediate*>(
4608           cmd_data);
4609   (void)c;
4610   GLsizei n = static_cast<GLsizei>(c.n);
4611   uint32_t data_size;
4612   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
4613     return error::kOutOfBounds;
4614   }
4615   const GLuint* valuebuffers =
4616       GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
4617   if (valuebuffers == NULL) {
4618     return error::kOutOfBounds;
4619   }
4620   DeleteValuebuffersCHROMIUMHelper(n, valuebuffers);
4621   return error::kNoError;
4622 }
4623
4624 error::Error GLES2DecoderImpl::HandleIsValuebufferCHROMIUM(
4625     uint32_t immediate_data_size,
4626     const void* cmd_data) {
4627   const gles2::cmds::IsValuebufferCHROMIUM& c =
4628       *static_cast<const gles2::cmds::IsValuebufferCHROMIUM*>(cmd_data);
4629   (void)c;
4630   GLuint valuebuffer = c.valuebuffer;
4631   typedef cmds::IsValuebufferCHROMIUM::Result Result;
4632   Result* result_dst = GetSharedMemoryAs<Result*>(
4633       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
4634   if (!result_dst) {
4635     return error::kOutOfBounds;
4636   }
4637   *result_dst = DoIsValuebufferCHROMIUM(valuebuffer);
4638   return error::kNoError;
4639 }
4640
4641 error::Error GLES2DecoderImpl::HandleBindValuebufferCHROMIUM(
4642     uint32_t immediate_data_size,
4643     const void* cmd_data) {
4644   const gles2::cmds::BindValuebufferCHROMIUM& c =
4645       *static_cast<const gles2::cmds::BindValuebufferCHROMIUM*>(cmd_data);
4646   (void)c;
4647   GLenum target = static_cast<GLenum>(c.target);
4648   GLuint valuebuffer = c.valuebuffer;
4649   if (!validators_->value_buffer_target.IsValid(target)) {
4650     LOCAL_SET_GL_ERROR_INVALID_ENUM("glBindValuebufferCHROMIUM", target,
4651                                     "target");
4652     return error::kNoError;
4653   }
4654   DoBindValueBufferCHROMIUM(target, valuebuffer);
4655   return error::kNoError;
4656 }
4657
4658 error::Error GLES2DecoderImpl::HandleSubscribeValueCHROMIUM(
4659     uint32_t immediate_data_size,
4660     const void* cmd_data) {
4661   const gles2::cmds::SubscribeValueCHROMIUM& c =
4662       *static_cast<const gles2::cmds::SubscribeValueCHROMIUM*>(cmd_data);
4663   (void)c;
4664   GLenum target = static_cast<GLenum>(c.target);
4665   GLenum subscription = static_cast<GLenum>(c.subscription);
4666   if (!validators_->value_buffer_target.IsValid(target)) {
4667     LOCAL_SET_GL_ERROR_INVALID_ENUM("glSubscribeValueCHROMIUM", target,
4668                                     "target");
4669     return error::kNoError;
4670   }
4671   if (!validators_->subscription_target.IsValid(subscription)) {
4672     LOCAL_SET_GL_ERROR_INVALID_ENUM("glSubscribeValueCHROMIUM", subscription,
4673                                     "subscription");
4674     return error::kNoError;
4675   }
4676   DoSubscribeValueCHROMIUM(target, subscription);
4677   return error::kNoError;
4678 }
4679
4680 error::Error GLES2DecoderImpl::HandlePopulateSubscribedValuesCHROMIUM(
4681     uint32_t immediate_data_size,
4682     const void* cmd_data) {
4683   const gles2::cmds::PopulateSubscribedValuesCHROMIUM& c =
4684       *static_cast<const gles2::cmds::PopulateSubscribedValuesCHROMIUM*>(
4685           cmd_data);
4686   (void)c;
4687   GLenum target = static_cast<GLenum>(c.target);
4688   if (!validators_->value_buffer_target.IsValid(target)) {
4689     LOCAL_SET_GL_ERROR_INVALID_ENUM("glPopulateSubscribedValuesCHROMIUM",
4690                                     target, "target");
4691     return error::kNoError;
4692   }
4693   DoPopulateSubscribedValuesCHROMIUM(target);
4694   return error::kNoError;
4695 }
4696
4697 error::Error GLES2DecoderImpl::HandleUniformValuebufferCHROMIUM(
4698     uint32_t immediate_data_size,
4699     const void* cmd_data) {
4700   const gles2::cmds::UniformValuebufferCHROMIUM& c =
4701       *static_cast<const gles2::cmds::UniformValuebufferCHROMIUM*>(cmd_data);
4702   (void)c;
4703   GLint location = static_cast<GLint>(c.location);
4704   GLenum target = static_cast<GLenum>(c.target);
4705   GLenum subscription = static_cast<GLenum>(c.subscription);
4706   if (!validators_->value_buffer_target.IsValid(target)) {
4707     LOCAL_SET_GL_ERROR_INVALID_ENUM("glUniformValuebufferCHROMIUM", target,
4708                                     "target");
4709     return error::kNoError;
4710   }
4711   if (!validators_->subscription_target.IsValid(subscription)) {
4712     LOCAL_SET_GL_ERROR_INVALID_ENUM("glUniformValuebufferCHROMIUM",
4713                                     subscription, "subscription");
4714     return error::kNoError;
4715   }
4716   DoUniformValueBufferCHROMIUM(location, target, subscription);
4717   return error::kNoError;
4718 }
4719
4720 error::Error GLES2DecoderImpl::HandleBindTexImage2DCHROMIUM(
4721     uint32_t immediate_data_size,
4722     const void* cmd_data) {
4723   const gles2::cmds::BindTexImage2DCHROMIUM& c =
4724       *static_cast<const gles2::cmds::BindTexImage2DCHROMIUM*>(cmd_data);
4725   (void)c;
4726   GLenum target = static_cast<GLenum>(c.target);
4727   GLint imageId = static_cast<GLint>(c.imageId);
4728   if (!validators_->texture_bind_target.IsValid(target)) {
4729     LOCAL_SET_GL_ERROR_INVALID_ENUM("glBindTexImage2DCHROMIUM", target,
4730                                     "target");
4731     return error::kNoError;
4732   }
4733   DoBindTexImage2DCHROMIUM(target, imageId);
4734   return error::kNoError;
4735 }
4736
4737 error::Error GLES2DecoderImpl::HandleReleaseTexImage2DCHROMIUM(
4738     uint32_t immediate_data_size,
4739     const void* cmd_data) {
4740   const gles2::cmds::ReleaseTexImage2DCHROMIUM& c =
4741       *static_cast<const gles2::cmds::ReleaseTexImage2DCHROMIUM*>(cmd_data);
4742   (void)c;
4743   GLenum target = static_cast<GLenum>(c.target);
4744   GLint imageId = static_cast<GLint>(c.imageId);
4745   if (!validators_->texture_bind_target.IsValid(target)) {
4746     LOCAL_SET_GL_ERROR_INVALID_ENUM("glReleaseTexImage2DCHROMIUM", target,
4747                                     "target");
4748     return error::kNoError;
4749   }
4750   DoReleaseTexImage2DCHROMIUM(target, imageId);
4751   return error::kNoError;
4752 }
4753
4754 error::Error GLES2DecoderImpl::HandleTraceEndCHROMIUM(
4755     uint32_t immediate_data_size,
4756     const void* cmd_data) {
4757   const gles2::cmds::TraceEndCHROMIUM& c =
4758       *static_cast<const gles2::cmds::TraceEndCHROMIUM*>(cmd_data);
4759   (void)c;
4760   DoTraceEndCHROMIUM();
4761   return error::kNoError;
4762 }
4763
4764 error::Error GLES2DecoderImpl::HandleDiscardFramebufferEXTImmediate(
4765     uint32_t immediate_data_size,
4766     const void* cmd_data) {
4767   const gles2::cmds::DiscardFramebufferEXTImmediate& c =
4768       *static_cast<const gles2::cmds::DiscardFramebufferEXTImmediate*>(
4769           cmd_data);
4770   (void)c;
4771   if (!features().ext_discard_framebuffer) {
4772     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glDiscardFramebufferEXT",
4773                        "function not available");
4774     return error::kNoError;
4775   }
4776
4777   GLenum target = static_cast<GLenum>(c.target);
4778   GLsizei count = static_cast<GLsizei>(c.count);
4779   uint32_t data_size;
4780   if (!ComputeDataSize(count, sizeof(GLenum), 1, &data_size)) {
4781     return error::kOutOfBounds;
4782   }
4783   if (data_size > immediate_data_size) {
4784     return error::kOutOfBounds;
4785   }
4786   const GLenum* attachments =
4787       GetImmediateDataAs<const GLenum*>(c, data_size, immediate_data_size);
4788   if (count < 0) {
4789     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glDiscardFramebufferEXT",
4790                        "count < 0");
4791     return error::kNoError;
4792   }
4793   if (attachments == NULL) {
4794     return error::kOutOfBounds;
4795   }
4796   DoDiscardFramebufferEXT(target, count, attachments);
4797   return error::kNoError;
4798 }
4799
4800 error::Error GLES2DecoderImpl::HandleLoseContextCHROMIUM(
4801     uint32_t immediate_data_size,
4802     const void* cmd_data) {
4803   const gles2::cmds::LoseContextCHROMIUM& c =
4804       *static_cast<const gles2::cmds::LoseContextCHROMIUM*>(cmd_data);
4805   (void)c;
4806   GLenum current = static_cast<GLenum>(c.current);
4807   GLenum other = static_cast<GLenum>(c.other);
4808   if (!validators_->reset_status.IsValid(current)) {
4809     LOCAL_SET_GL_ERROR_INVALID_ENUM("glLoseContextCHROMIUM", current,
4810                                     "current");
4811     return error::kNoError;
4812   }
4813   if (!validators_->reset_status.IsValid(other)) {
4814     LOCAL_SET_GL_ERROR_INVALID_ENUM("glLoseContextCHROMIUM", other, "other");
4815     return error::kNoError;
4816   }
4817   DoLoseContextCHROMIUM(current, other);
4818   return error::kNoError;
4819 }
4820
4821 error::Error GLES2DecoderImpl::HandleDrawBuffersEXTImmediate(
4822     uint32_t immediate_data_size,
4823     const void* cmd_data) {
4824   const gles2::cmds::DrawBuffersEXTImmediate& c =
4825       *static_cast<const gles2::cmds::DrawBuffersEXTImmediate*>(cmd_data);
4826   (void)c;
4827   GLsizei count = static_cast<GLsizei>(c.count);
4828   uint32_t data_size;
4829   if (!ComputeDataSize(count, sizeof(GLenum), 1, &data_size)) {
4830     return error::kOutOfBounds;
4831   }
4832   if (data_size > immediate_data_size) {
4833     return error::kOutOfBounds;
4834   }
4835   const GLenum* bufs =
4836       GetImmediateDataAs<const GLenum*>(c, data_size, immediate_data_size);
4837   if (count < 0) {
4838     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glDrawBuffersEXT", "count < 0");
4839     return error::kNoError;
4840   }
4841   if (bufs == NULL) {
4842     return error::kOutOfBounds;
4843   }
4844   DoDrawBuffersEXT(count, bufs);
4845   return error::kNoError;
4846 }
4847
4848 error::Error GLES2DecoderImpl::HandleSwapInterval(uint32_t immediate_data_size,
4849                                                   const void* cmd_data) {
4850   const gles2::cmds::SwapInterval& c =
4851       *static_cast<const gles2::cmds::SwapInterval*>(cmd_data);
4852   (void)c;
4853   GLint interval = static_cast<GLint>(c.interval);
4854   DoSwapInterval(interval);
4855   return error::kNoError;
4856 }
4857
4858 error::Error GLES2DecoderImpl::HandleMatrixLoadfCHROMIUMImmediate(
4859     uint32_t immediate_data_size,
4860     const void* cmd_data) {
4861   const gles2::cmds::MatrixLoadfCHROMIUMImmediate& c =
4862       *static_cast<const gles2::cmds::MatrixLoadfCHROMIUMImmediate*>(cmd_data);
4863   (void)c;
4864   if (!features().chromium_path_rendering) {
4865     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glMatrixLoadfCHROMIUM",
4866                        "function not available");
4867     return error::kNoError;
4868   }
4869
4870   GLenum matrixMode = static_cast<GLenum>(c.matrixMode);
4871   uint32_t data_size;
4872   if (!ComputeDataSize(1, sizeof(GLfloat), 16, &data_size)) {
4873     return error::kOutOfBounds;
4874   }
4875   if (data_size > immediate_data_size) {
4876     return error::kOutOfBounds;
4877   }
4878   const GLfloat* m =
4879       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
4880   if (!validators_->matrix_mode.IsValid(matrixMode)) {
4881     LOCAL_SET_GL_ERROR_INVALID_ENUM("glMatrixLoadfCHROMIUM", matrixMode,
4882                                     "matrixMode");
4883     return error::kNoError;
4884   }
4885   if (m == NULL) {
4886     return error::kOutOfBounds;
4887   }
4888   DoMatrixLoadfCHROMIUM(matrixMode, m);
4889   return error::kNoError;
4890 }
4891
4892 error::Error GLES2DecoderImpl::HandleMatrixLoadIdentityCHROMIUM(
4893     uint32_t immediate_data_size,
4894     const void* cmd_data) {
4895   const gles2::cmds::MatrixLoadIdentityCHROMIUM& c =
4896       *static_cast<const gles2::cmds::MatrixLoadIdentityCHROMIUM*>(cmd_data);
4897   (void)c;
4898   if (!features().chromium_path_rendering) {
4899     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glMatrixLoadIdentityCHROMIUM",
4900                        "function not available");
4901     return error::kNoError;
4902   }
4903
4904   GLenum matrixMode = static_cast<GLenum>(c.matrixMode);
4905   if (!validators_->matrix_mode.IsValid(matrixMode)) {
4906     LOCAL_SET_GL_ERROR_INVALID_ENUM("glMatrixLoadIdentityCHROMIUM", matrixMode,
4907                                     "matrixMode");
4908     return error::kNoError;
4909   }
4910   DoMatrixLoadIdentityCHROMIUM(matrixMode);
4911   return error::kNoError;
4912 }
4913
4914 error::Error GLES2DecoderImpl::HandleBlendBarrierKHR(
4915     uint32_t immediate_data_size,
4916     const void* cmd_data) {
4917   const gles2::cmds::BlendBarrierKHR& c =
4918       *static_cast<const gles2::cmds::BlendBarrierKHR*>(cmd_data);
4919   (void)c;
4920   if (!features().blend_equation_advanced) {
4921     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glBlendBarrierKHR",
4922                        "function not available");
4923     return error::kNoError;
4924   }
4925
4926   glBlendBarrierKHR();
4927   return error::kNoError;
4928 }
4929
4930 bool GLES2DecoderImpl::SetCapabilityState(GLenum cap, bool enabled) {
4931   switch (cap) {
4932     case GL_BLEND:
4933       state_.enable_flags.blend = enabled;
4934       if (state_.enable_flags.cached_blend != enabled ||
4935           state_.ignore_cached_state) {
4936         state_.enable_flags.cached_blend = enabled;
4937         return true;
4938       }
4939       return false;
4940     case GL_CULL_FACE:
4941       state_.enable_flags.cull_face = enabled;
4942       if (state_.enable_flags.cached_cull_face != enabled ||
4943           state_.ignore_cached_state) {
4944         state_.enable_flags.cached_cull_face = enabled;
4945         return true;
4946       }
4947       return false;
4948     case GL_DEPTH_TEST:
4949       state_.enable_flags.depth_test = enabled;
4950       if (state_.enable_flags.cached_depth_test != enabled ||
4951           state_.ignore_cached_state) {
4952         framebuffer_state_.clear_state_dirty = true;
4953       }
4954       return false;
4955     case GL_DITHER:
4956       state_.enable_flags.dither = enabled;
4957       if (state_.enable_flags.cached_dither != enabled ||
4958           state_.ignore_cached_state) {
4959         state_.enable_flags.cached_dither = enabled;
4960         return true;
4961       }
4962       return false;
4963     case GL_POLYGON_OFFSET_FILL:
4964       state_.enable_flags.polygon_offset_fill = enabled;
4965       if (state_.enable_flags.cached_polygon_offset_fill != enabled ||
4966           state_.ignore_cached_state) {
4967         state_.enable_flags.cached_polygon_offset_fill = enabled;
4968         return true;
4969       }
4970       return false;
4971     case GL_SAMPLE_ALPHA_TO_COVERAGE:
4972       state_.enable_flags.sample_alpha_to_coverage = enabled;
4973       if (state_.enable_flags.cached_sample_alpha_to_coverage != enabled ||
4974           state_.ignore_cached_state) {
4975         state_.enable_flags.cached_sample_alpha_to_coverage = enabled;
4976         return true;
4977       }
4978       return false;
4979     case GL_SAMPLE_COVERAGE:
4980       state_.enable_flags.sample_coverage = enabled;
4981       if (state_.enable_flags.cached_sample_coverage != enabled ||
4982           state_.ignore_cached_state) {
4983         state_.enable_flags.cached_sample_coverage = enabled;
4984         return true;
4985       }
4986       return false;
4987     case GL_SCISSOR_TEST:
4988       state_.enable_flags.scissor_test = enabled;
4989       if (state_.enable_flags.cached_scissor_test != enabled ||
4990           state_.ignore_cached_state) {
4991         state_.enable_flags.cached_scissor_test = enabled;
4992         return true;
4993       }
4994       return false;
4995     case GL_STENCIL_TEST:
4996       state_.enable_flags.stencil_test = enabled;
4997       if (state_.enable_flags.cached_stencil_test != enabled ||
4998           state_.ignore_cached_state) {
4999         framebuffer_state_.clear_state_dirty = true;
5000       }
5001       return false;
5002     case GL_RASTERIZER_DISCARD:
5003       state_.enable_flags.rasterizer_discard = enabled;
5004       if (state_.enable_flags.cached_rasterizer_discard != enabled ||
5005           state_.ignore_cached_state) {
5006         state_.enable_flags.cached_rasterizer_discard = enabled;
5007         return true;
5008       }
5009       return false;
5010     case GL_PRIMITIVE_RESTART_FIXED_INDEX:
5011       state_.enable_flags.primitive_restart_fixed_index = enabled;
5012       if (state_.enable_flags.cached_primitive_restart_fixed_index != enabled ||
5013           state_.ignore_cached_state) {
5014         state_.enable_flags.cached_primitive_restart_fixed_index = enabled;
5015         return true;
5016       }
5017       return false;
5018     default:
5019       NOTREACHED();
5020       return false;
5021   }
5022 }
5023 #endif  // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_AUTOGEN_H_