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