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