Cache more GL state both service and client side.

gpu/command_buffer/service/gles2_cmd_decoder_autogen.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file is auto-generated from
 // gpu/command_buffer/build_gles2_cmd_buffer.py
 // DO NOT EDIT!
 
 // It is included by gles2_cmd_decoder.cc
 #ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_AUTOGEN_H_
@@ skipping 61 matching lines @@
   DoBindTexture(target, texture);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBlendColor(
     uint32 immediate_data_size, const gles2::BlendColor& c) {
   GLclampf red = static_cast<GLclampf>(c.red);
   GLclampf green = static_cast<GLclampf>(c.green);
   GLclampf blue = static_cast<GLclampf>(c.blue);
   GLclampf alpha = static_cast<GLclampf>(c.alpha);
-  state_.blend_color_red = red;
-  state_.blend_color_green = green;
-  state_.blend_color_blue = blue;
-  state_.blend_color_alpha = alpha;
-  glBlendColor(red, green, blue, alpha);
+  if (state_.blend_color_red != red ||
+      state_.blend_color_green != green ||
+      state_.blend_color_blue != blue ||
+      state_.blend_color_alpha != alpha) {
+    state_.blend_color_red = red;
+    state_.blend_color_green = green;
+    state_.blend_color_blue = blue;
+    state_.blend_color_alpha = alpha;
+    glBlendColor(red, green, blue, alpha);
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBlendEquation(
     uint32 immediate_data_size, const gles2::BlendEquation& c) {
   GLenum mode = static_cast<GLenum>(c.mode);
   if (!validators_->equation.IsValid(mode)) {
     SetGLErrorInvalidEnum("glBlendEquation", mode, "mode");
     return error::kNoError;
   }
-  state_.blend_equation_rgb = mode;
-  state_.blend_equation_alpha = mode;
-  glBlendEquation(mode);
+  if (state_.blend_equation_rgb != mode ||
+      state_.blend_equation_alpha != mode) {
+    state_.blend_equation_rgb = mode;
+    state_.blend_equation_alpha = mode;
+    glBlendEquation(mode);
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBlendEquationSeparate(
     uint32 immediate_data_size, const gles2::BlendEquationSeparate& c) {
   GLenum modeRGB = static_cast<GLenum>(c.modeRGB);
   GLenum modeAlpha = static_cast<GLenum>(c.modeAlpha);
   if (!validators_->equation.IsValid(modeRGB)) {
     SetGLErrorInvalidEnum("glBlendEquationSeparate", modeRGB, "modeRGB");
     return error::kNoError;
   }
   if (!validators_->equation.IsValid(modeAlpha)) {
     SetGLErrorInvalidEnum("glBlendEquationSeparate", modeAlpha, "modeAlpha");
     return error::kNoError;
   }
-  state_.blend_equation_rgb = modeRGB;
-  state_.blend_equation_alpha = modeAlpha;
-  glBlendEquationSeparate(modeRGB, modeAlpha);
+  if (state_.blend_equation_rgb != modeRGB ||
+      state_.blend_equation_alpha != modeAlpha) {
+    state_.blend_equation_rgb = modeRGB;
+    state_.blend_equation_alpha = modeAlpha;
+    glBlendEquationSeparate(modeRGB, modeAlpha);
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBlendFunc(
     uint32 immediate_data_size, const gles2::BlendFunc& c) {
   GLenum sfactor = static_cast<GLenum>(c.sfactor);
   GLenum dfactor = static_cast<GLenum>(c.dfactor);
   if (!validators_->src_blend_factor.IsValid(sfactor)) {
     SetGLErrorInvalidEnum("glBlendFunc", sfactor, "sfactor");
     return error::kNoError;
   }
   if (!validators_->dst_blend_factor.IsValid(dfactor)) {
     SetGLErrorInvalidEnum("glBlendFunc", dfactor, "dfactor");
     return error::kNoError;
   }
-  state_.blend_source_rgb = sfactor;
-  state_.blend_dest_rgb = dfactor;
-  state_.blend_source_alpha = sfactor;
-  state_.blend_dest_alpha = dfactor;
-  glBlendFunc(sfactor, dfactor);
+  if (state_.blend_source_rgb != sfactor ||
+      state_.blend_dest_rgb != dfactor ||
+      state_.blend_source_alpha != sfactor ||
+      state_.blend_dest_alpha != dfactor) {
+    state_.blend_source_rgb = sfactor;
+    state_.blend_dest_rgb = dfactor;
+    state_.blend_source_alpha = sfactor;
+    state_.blend_dest_alpha = dfactor;
+    glBlendFunc(sfactor, dfactor);
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBlendFuncSeparate(
     uint32 immediate_data_size, const gles2::BlendFuncSeparate& c) {
   GLenum srcRGB = static_cast<GLenum>(c.srcRGB);
   GLenum dstRGB = static_cast<GLenum>(c.dstRGB);
   GLenum srcAlpha = static_cast<GLenum>(c.srcAlpha);
   GLenum dstAlpha = static_cast<GLenum>(c.dstAlpha);
   if (!validators_->src_blend_factor.IsValid(srcRGB)) {
     SetGLErrorInvalidEnum("glBlendFuncSeparate", srcRGB, "srcRGB");
     return error::kNoError;
   }
   if (!validators_->dst_blend_factor.IsValid(dstRGB)) {
     SetGLErrorInvalidEnum("glBlendFuncSeparate", dstRGB, "dstRGB");
     return error::kNoError;
   }
   if (!validators_->src_blend_factor.IsValid(srcAlpha)) {
     SetGLErrorInvalidEnum("glBlendFuncSeparate", srcAlpha, "srcAlpha");
     return error::kNoError;
   }
   if (!validators_->dst_blend_factor.IsValid(dstAlpha)) {
     SetGLErrorInvalidEnum("glBlendFuncSeparate", dstAlpha, "dstAlpha");
     return error::kNoError;
   }
-  state_.blend_source_rgb = srcRGB;
-  state_.blend_dest_rgb = dstRGB;
-  state_.blend_source_alpha = srcAlpha;
-  state_.blend_dest_alpha = dstAlpha;
-  glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
+  if (state_.blend_source_rgb != srcRGB ||
+      state_.blend_dest_rgb != dstRGB ||
+      state_.blend_source_alpha != srcAlpha ||
+      state_.blend_dest_alpha != dstAlpha) {
+    state_.blend_source_rgb = srcRGB;
+    state_.blend_dest_rgb = dstRGB;
+    state_.blend_source_alpha = srcAlpha;
+    state_.blend_dest_alpha = dstAlpha;
+    glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBufferSubData(
     uint32 immediate_data_size, const gles2::BufferSubData& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLintptr offset = static_cast<GLintptr>(c.offset);
   GLsizeiptr size = static_cast<GLsizeiptr>(c.size);
   uint32 data_size = size;
   const void* data = GetSharedMemoryAs<const void*>(
@@ skipping 52 matching lines @@
   *result_dst = DoCheckFramebufferStatus(target);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleClearColor(
     uint32 immediate_data_size, const gles2::ClearColor& c) {
   GLclampf red = static_cast<GLclampf>(c.red);
   GLclampf green = static_cast<GLclampf>(c.green);
   GLclampf blue = static_cast<GLclampf>(c.blue);
   GLclampf alpha = static_cast<GLclampf>(c.alpha);
-  state_.color_clear_red = red;
-  state_.color_clear_green = green;
-  state_.color_clear_blue = blue;
-  state_.color_clear_alpha = alpha;
-  glClearColor(red, green, blue, alpha);
+  if (state_.color_clear_red != red ||
+      state_.color_clear_green != green ||
+      state_.color_clear_blue != blue ||
+      state_.color_clear_alpha != alpha) {
+    state_.color_clear_red = red;
+    state_.color_clear_green = green;
+    state_.color_clear_blue = blue;
+    state_.color_clear_alpha = alpha;
+    glClearColor(red, green, blue, alpha);
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleClearDepthf(
     uint32 immediate_data_size, const gles2::ClearDepthf& c) {
   GLclampf depth = static_cast<GLclampf>(c.depth);
-  state_.depth_clear = depth;
-  glClearDepth(depth);
+  if (state_.depth_clear != depth) {
+    state_.depth_clear = depth;
+    glClearDepth(depth);
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleClearStencil(
     uint32 immediate_data_size, const gles2::ClearStencil& c) {
   GLint s = static_cast<GLint>(c.s);
-  state_.stencil_clear = s;
-  glClearStencil(s);
+  if (state_.stencil_clear != s) {
+    state_.stencil_clear = s;
+    glClearStencil(s);
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleColorMask(
     uint32 immediate_data_size, const gles2::ColorMask& c) {
   GLboolean red = static_cast<GLboolean>(c.red);
   GLboolean green = static_cast<GLboolean>(c.green);
   GLboolean blue = static_cast<GLboolean>(c.blue);
   GLboolean alpha = static_cast<GLboolean>(c.alpha);
-  state_.color_mask_red = red;
-  state_.color_mask_green = green;
-  state_.color_mask_blue = blue;
-  state_.color_mask_alpha = alpha;
-  clear_state_dirty_ = true;
+  if (state_.color_mask_red != red ||
+      state_.color_mask_green != green ||
+      state_.color_mask_blue != blue ||
+      state_.color_mask_alpha != alpha) {
+    state_.color_mask_red = red;
+    state_.color_mask_green = green;
+    state_.color_mask_blue = blue;
+    state_.color_mask_alpha = alpha;
+    clear_state_dirty_ = true;
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCompileShader(
     uint32 immediate_data_size, const gles2::CompileShader& c) {
   GLuint shader = c.shader;
   DoCompileShader(shader);
   return error::kNoError;
 }
 
@@ skipping 165 matching lines @@
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCullFace(
     uint32 immediate_data_size, const gles2::CullFace& c) {
   GLenum mode = static_cast<GLenum>(c.mode);
   if (!validators_->face_type.IsValid(mode)) {
     SetGLErrorInvalidEnum("glCullFace", mode, "mode");
     return error::kNoError;
   }
-  state_.cull_mode = mode;
-  glCullFace(mode);
+  if (state_.cull_mode != mode) {
+    state_.cull_mode = mode;
+    glCullFace(mode);
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDeleteBuffers(
     uint32 immediate_data_size, const gles2::DeleteBuffers& c) {
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
@@ skipping 118 matching lines @@
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDepthFunc(
     uint32 immediate_data_size, const gles2::DepthFunc& c) {
   GLenum func = static_cast<GLenum>(c.func);
   if (!validators_->cmp_function.IsValid(func)) {
     SetGLErrorInvalidEnum("glDepthFunc", func, "func");
     return error::kNoError;
   }
-  state_.depth_func = func;
-  glDepthFunc(func);
+  if (state_.depth_func != func) {
+    state_.depth_func = func;
+    glDepthFunc(func);
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDepthMask(
     uint32 immediate_data_size, const gles2::DepthMask& c) {
   GLboolean flag = static_cast<GLboolean>(c.flag);
-  state_.depth_mask = flag;
-  clear_state_dirty_ = true;
+  if (state_.depth_mask != flag) {
+    state_.depth_mask = flag;
+    clear_state_dirty_ = true;
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDepthRangef(
     uint32 immediate_data_size, const gles2::DepthRangef& c) {
   GLclampf zNear = static_cast<GLclampf>(c.zNear);
   GLclampf zFar = static_cast<GLclampf>(c.zFar);
   DoDepthRangef(zNear, zFar);
   return error::kNoError;
 }
@@ skipping 107 matching lines @@
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleFrontFace(
     uint32 immediate_data_size, const gles2::FrontFace& c) {
   GLenum mode = static_cast<GLenum>(c.mode);
   if (!validators_->face_mode.IsValid(mode)) {
     SetGLErrorInvalidEnum("glFrontFace", mode, "mode");
     return error::kNoError;
   }
-  state_.front_face = mode;
-  glFrontFace(mode);
+  if (state_.front_face != mode) {
+    state_.front_face = mode;
+    glFrontFace(mode);
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGenBuffers(
     uint32 immediate_data_size, const gles2::GenBuffers& c) {
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
@@ skipping 674 matching lines @@
   if (!result_dst) {
     return error::kOutOfBounds;
   }
   *result_dst = DoIsTexture(texture);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleLineWidth(
     uint32 immediate_data_size, const gles2::LineWidth& c) {
   GLfloat width = static_cast<GLfloat>(c.width);
-  state_.line_width = width;
-  glLineWidth(width);
+  if (state_.line_width != width) {
+    state_.line_width = width;
+    glLineWidth(width);
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleLinkProgram(
     uint32 immediate_data_size, const gles2::LinkProgram& c) {
   GLuint program = c.program;
   DoLinkProgram(program);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandlePolygonOffset(
     uint32 immediate_data_size, const gles2::PolygonOffset& c) {
   GLfloat factor = static_cast<GLfloat>(c.factor);
   GLfloat units = static_cast<GLfloat>(c.units);
-  state_.polygon_offset_factor = factor;
-  state_.polygon_offset_units = units;
-  glPolygonOffset(factor, units);
+  if (state_.polygon_offset_factor != factor ||
+      state_.polygon_offset_units != units) {
+    state_.polygon_offset_factor = factor;
+    state_.polygon_offset_units = units;
+    glPolygonOffset(factor, units);
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleReleaseShaderCompiler(
     uint32 immediate_data_size, const gles2::ReleaseShaderCompiler& c) {
   DoReleaseShaderCompiler();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleRenderbufferStorage(
@@ skipping 38 matching lines @@
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   if (width < 0) {
     SetGLError(GL_INVALID_VALUE, "glScissor", "width < 0");
     return error::kNoError;
   }
   if (height < 0) {
     SetGLError(GL_INVALID_VALUE, "glScissor", "height < 0");
     return error::kNoError;
   }
-  state_.scissor_x = x;
-  state_.scissor_y = y;
-  state_.scissor_width = width;
-  state_.scissor_height = height;
-  glScissor(x, y, width, height);
+  if (state_.scissor_x != x ||
+      state_.scissor_y != y ||
+      state_.scissor_width != width ||
+      state_.scissor_height != height) {
+    state_.scissor_x = x;
+    state_.scissor_y = y;
+    state_.scissor_width = width;
+    state_.scissor_height = height;
+    glScissor(x, y, width, height);
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilFunc(
     uint32 immediate_data_size, const gles2::StencilFunc& c) {
   GLenum func = static_cast<GLenum>(c.func);
   GLint ref = static_cast<GLint>(c.ref);
   GLuint mask = static_cast<GLuint>(c.mask);
   if (!validators_->cmp_function.IsValid(func)) {
     SetGLErrorInvalidEnum("glStencilFunc", func, "func");
     return error::kNoError;
   }
-  glStencilFunc(func, ref, mask);
+  if (state_.stencil_front_func != func ||
+      state_.stencil_front_ref != ref ||
+      state_.stencil_front_mask != mask ||
+      state_.stencil_back_func != func ||
+      state_.stencil_back_ref != ref ||
+      state_.stencil_back_mask != mask) {
+    state_.stencil_front_func = func;
+    state_.stencil_front_ref = ref;
+    state_.stencil_front_mask = mask;
+    state_.stencil_back_func = func;
+    state_.stencil_back_ref = ref;
+    state_.stencil_back_mask = mask;
+    glStencilFunc(func, ref, mask);
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilFuncSeparate(
     uint32 immediate_data_size, const gles2::StencilFuncSeparate& c) {
   GLenum face = static_cast<GLenum>(c.face);
   GLenum func = static_cast<GLenum>(c.func);
   GLint ref = static_cast<GLint>(c.ref);
   GLuint mask = static_cast<GLuint>(c.mask);
   if (!validators_->face_type.IsValid(face)) {
     SetGLErrorInvalidEnum("glStencilFuncSeparate", face, "face");
     return error::kNoError;
   }
   if (!validators_->cmp_function.IsValid(func)) {
     SetGLErrorInvalidEnum("glStencilFuncSeparate", func, "func");
     return error::kNoError;
   }
-  glStencilFuncSeparate(face, func, ref, mask);
+  bool changed = false;
+  if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
+    changed |= state_.stencil_front_func != func ||
+        state_.stencil_front_ref != ref ||
+        state_.stencil_front_mask != mask;
+  }
+  if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
+    changed |= state_.stencil_back_func != func ||
+        state_.stencil_back_ref != ref ||
+        state_.stencil_back_mask != mask;
+  }
+  if (changed) {
+    if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
+      state_.stencil_front_func = func;
+      state_.stencil_front_ref = ref;
+      state_.stencil_front_mask = mask;
+    }
+    if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
+      state_.stencil_back_func = func;
+      state_.stencil_back_ref = ref;
+      state_.stencil_back_mask = mask;
+    }
+    glStencilFuncSeparate(face, func, ref, mask);
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilMask(
     uint32 immediate_data_size, const gles2::StencilMask& c) {
   GLuint mask = static_cast<GLuint>(c.mask);
-  state_.stencil_front_writemask = mask;
-  state_.stencil_back_writemask = mask;
-  clear_state_dirty_ = true;
+  if (state_.stencil_front_writemask != mask ||
+      state_.stencil_back_writemask != mask) {
+    state_.stencil_front_writemask = mask;
+    state_.stencil_back_writemask = mask;
+    clear_state_dirty_ = true;
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilMaskSeparate(
     uint32 immediate_data_size, const gles2::StencilMaskSeparate& c) {
   GLenum face = static_cast<GLenum>(c.face);
   GLuint mask = static_cast<GLuint>(c.mask);
   if (!validators_->face_type.IsValid(face)) {
     SetGLErrorInvalidEnum("glStencilMaskSeparate", face, "face");
     return error::kNoError;
   }
+  bool changed = false;
   if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
-    state_.stencil_front_writemask = mask;
+    changed |= state_.stencil_front_writemask != mask;
   }
   if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
-    state_.stencil_back_writemask = mask;
+    changed |= state_.stencil_back_writemask != mask;
   }
-  clear_state_dirty_ = true;
+  if (changed) {
+    if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
+      state_.stencil_front_writemask = mask;
+    }
+    if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
+      state_.stencil_back_writemask = mask;
+    }
+    clear_state_dirty_ = true;
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilOp(
     uint32 immediate_data_size, const gles2::StencilOp& c) {
   GLenum fail = static_cast<GLenum>(c.fail);
   GLenum zfail = static_cast<GLenum>(c.zfail);
   GLenum zpass = static_cast<GLenum>(c.zpass);
   if (!validators_->stencil_op.IsValid(fail)) {
     SetGLErrorInvalidEnum("glStencilOp", fail, "fail");
     return error::kNoError;
   }
   if (!validators_->stencil_op.IsValid(zfail)) {
     SetGLErrorInvalidEnum("glStencilOp", zfail, "zfail");
     return error::kNoError;
   }
   if (!validators_->stencil_op.IsValid(zpass)) {
     SetGLErrorInvalidEnum("glStencilOp", zpass, "zpass");
     return error::kNoError;
   }
-  state_.stencil_front_fail_op = fail;
-  state_.stencil_front_z_fail_op = zfail;
-  state_.stencil_front_z_pass_op = zpass;
-  state_.stencil_back_fail_op = fail;
-  state_.stencil_back_z_fail_op = zfail;
-  state_.stencil_back_z_pass_op = zpass;
-  glStencilOp(fail, zfail, zpass);
+  if (state_.stencil_front_fail_op != fail ||
+      state_.stencil_front_z_fail_op != zfail ||
+      state_.stencil_front_z_pass_op != zpass ||
+      state_.stencil_back_fail_op != fail ||
+      state_.stencil_back_z_fail_op != zfail ||
+      state_.stencil_back_z_pass_op != zpass) {
+    state_.stencil_front_fail_op = fail;
+    state_.stencil_front_z_fail_op = zfail;
+    state_.stencil_front_z_pass_op = zpass;
+    state_.stencil_back_fail_op = fail;
+    state_.stencil_back_z_fail_op = zfail;
+    state_.stencil_back_z_pass_op = zpass;
+    glStencilOp(fail, zfail, zpass);
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilOpSeparate(
     uint32 immediate_data_size, const gles2::StencilOpSeparate& c) {
   GLenum face = static_cast<GLenum>(c.face);
   GLenum fail = static_cast<GLenum>(c.fail);
   GLenum zfail = static_cast<GLenum>(c.zfail);
   GLenum zpass = static_cast<GLenum>(c.zpass);
   if (!validators_->face_type.IsValid(face)) {
     SetGLErrorInvalidEnum("glStencilOpSeparate", face, "face");
     return error::kNoError;
   }
   if (!validators_->stencil_op.IsValid(fail)) {
     SetGLErrorInvalidEnum("glStencilOpSeparate", fail, "fail");
     return error::kNoError;
   }
   if (!validators_->stencil_op.IsValid(zfail)) {
     SetGLErrorInvalidEnum("glStencilOpSeparate", zfail, "zfail");
     return error::kNoError;
   }
   if (!validators_->stencil_op.IsValid(zpass)) {
     SetGLErrorInvalidEnum("glStencilOpSeparate", zpass, "zpass");
     return error::kNoError;
   }
+  bool changed = false;
   if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
-    state_.stencil_front_fail_op = fail;
-    state_.stencil_front_z_fail_op = zfail;
-    state_.stencil_front_z_pass_op = zpass;
+    changed |= state_.stencil_front_fail_op != fail ||
+        state_.stencil_front_z_fail_op != zfail ||
+        state_.stencil_front_z_pass_op != zpass;
   }
   if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
-    state_.stencil_back_fail_op = fail;
-    state_.stencil_back_z_fail_op = zfail;
-    state_.stencil_back_z_pass_op = zpass;
+    changed |= state_.stencil_back_fail_op != fail ||
+        state_.stencil_back_z_fail_op != zfail ||
+        state_.stencil_back_z_pass_op != zpass;
   }
-  glStencilOpSeparate(face, fail, zfail, zpass);
+  if (changed) {
+    if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
+      state_.stencil_front_fail_op = fail;
+      state_.stencil_front_z_fail_op = zfail;
+      state_.stencil_front_z_pass_op = zpass;
+    }
+    if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
+      state_.stencil_back_fail_op = fail;
+      state_.stencil_back_z_fail_op = zfail;
+      state_.stencil_back_z_pass_op = zpass;
+    }
+    glStencilOpSeparate(face, fail, zfail, zpass);
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleTexParameterf(
     uint32 immediate_data_size, const gles2::TexParameterf& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum pname = static_cast<GLenum>(c.pname);
   GLfloat param = static_cast<GLfloat>(c.param);
   if (!validators_->texture_bind_target.IsValid(target)) {
     SetGLErrorInvalidEnum("glTexParameterf", target, "target");
@@ skipping 1347 matching lines @@
     case GL_POLYGON_OFFSET_FILL:
       state_.enable_flags.polygon_offset_fill = enabled;
       return true;
     case GL_SAMPLE_ALPHA_TO_COVERAGE:
       state_.enable_flags.sample_alpha_to_coverage = enabled;
       return true;
     case GL_SAMPLE_COVERAGE:
       state_.enable_flags.sample_coverage = enabled;
       return true;
     case GL_SCISSOR_TEST:
-      state_.enable_flags.scissor_test = enabled;
-      return true;
+      if (state_.enable_flags.scissor_test != enabled) {
+        state_.enable_flags.scissor_test = enabled;
+        clear_state_dirty_ = true;
+      }
+      return false;
     case GL_STENCIL_TEST:
       if (state_.enable_flags.stencil_test != enabled) {
         state_.enable_flags.stencil_test = enabled;
         clear_state_dirty_ = true;
       }
       return false;
     default:
       NOTREACHED();
       return false;
   }
 }
-
-bool GLES2DecoderImpl::DoIsEnabled(GLenum cap) {
-  switch (cap) {
-    case GL_BLEND:
-      return state_.enable_flags.blend;
-    case GL_CULL_FACE:
-      return state_.enable_flags.cull_face;
-    case GL_DEPTH_TEST:
-      return state_.enable_flags.depth_test;
-    case GL_DITHER:
-      return state_.enable_flags.dither;
-    case GL_POLYGON_OFFSET_FILL:
-      return state_.enable_flags.polygon_offset_fill;
-    case GL_SAMPLE_ALPHA_TO_COVERAGE:
-      return state_.enable_flags.sample_alpha_to_coverage;
-    case GL_SAMPLE_COVERAGE:
-      return state_.enable_flags.sample_coverage;
-    case GL_SCISSOR_TEST:
-      return state_.enable_flags.scissor_test;
-    case GL_STENCIL_TEST:
-      return state_.enable_flags.stencil_test;
-    default:
-      NOTREACHED();
-      return false;
-  }
-}
-
-bool GLES2DecoderImpl::GetStateAsGLint(
-    GLenum pname, GLint* params, GLsizei* num_written) {
-  switch (pname) {
-    case GL_VIEWPORT:
-      *num_written = 4;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.viewport_x);
-        params[1] = static_cast<GLint>(state_.viewport_y);
-        params[2] = static_cast<GLint>(state_.viewport_width);
-        params[3] = static_cast<GLint>(state_.viewport_height);
-      }
-      return true;
-    case GL_BLEND_SRC_RGB:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.blend_source_rgb);
-      }
-      return true;
-    case GL_BLEND_DST_RGB:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.blend_dest_rgb);
-      }
-      return true;
-    case GL_BLEND_SRC_ALPHA:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.blend_source_alpha);
-      }
-      return true;
-    case GL_BLEND_DST_ALPHA:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.blend_dest_alpha);
-      }
-      return true;
-    case GL_LINE_WIDTH:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.line_width);
-      }
-      return true;
-    case GL_BLEND_COLOR:
-      *num_written = 4;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.blend_color_red);
-        params[1] = static_cast<GLint>(state_.blend_color_green);
-        params[2] = static_cast<GLint>(state_.blend_color_blue);
-        params[3] = static_cast<GLint>(state_.blend_color_alpha);
-      }
-      return true;
-    case GL_STENCIL_CLEAR_VALUE:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.stencil_clear);
-      }
-      return true;
-    case GL_COLOR_WRITEMASK:
-      *num_written = 4;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.color_mask_red);
-        params[1] = static_cast<GLint>(state_.color_mask_green);
-        params[2] = static_cast<GLint>(state_.color_mask_blue);
-        params[3] = static_cast<GLint>(state_.color_mask_alpha);
-      }
-      return true;
-    case GL_COLOR_CLEAR_VALUE:
-      *num_written = 4;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.color_clear_red);
-        params[1] = static_cast<GLint>(state_.color_clear_green);
-        params[2] = static_cast<GLint>(state_.color_clear_blue);
-        params[3] = static_cast<GLint>(state_.color_clear_alpha);
-      }
-      return true;
-    case GL_DEPTH_RANGE:
-      *num_written = 2;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.z_near);
-        params[1] = static_cast<GLint>(state_.z_far);
-      }
-      return true;
-    case GL_DEPTH_CLEAR_VALUE:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.depth_clear);
-      }
-      return true;
-    case GL_STENCIL_FAIL:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.stencil_front_fail_op);
-      }
-      return true;
-    case GL_STENCIL_PASS_DEPTH_FAIL:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.stencil_front_z_fail_op);
-      }
-      return true;
-    case GL_STENCIL_PASS_DEPTH_PASS:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.stencil_front_z_pass_op);
-      }
-      return true;
-    case GL_STENCIL_BACK_FAIL:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.stencil_back_fail_op);
-      }
-      return true;
-    case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.stencil_back_z_fail_op);
-      }
-      return true;
-    case GL_STENCIL_BACK_PASS_DEPTH_PASS:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.stencil_back_z_pass_op);
-      }
-      return true;
-    case GL_SCISSOR_BOX:
-      *num_written = 4;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.scissor_x);
-        params[1] = static_cast<GLint>(state_.scissor_y);
-        params[2] = static_cast<GLint>(state_.scissor_width);
-        params[3] = static_cast<GLint>(state_.scissor_height);
-      }
-      return true;
-    case GL_FRONT_FACE:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.front_face);
-      }
-      return true;
-    case GL_SAMPLE_COVERAGE_VALUE:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.sample_coverage_value);
-      }
-      return true;
-    case GL_SAMPLE_COVERAGE_INVERT:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.sample_coverage_invert);
-      }
-      return true;
-    case GL_POLYGON_OFFSET_FACTOR:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.polygon_offset_factor);
-      }
-      return true;
-    case GL_POLYGON_OFFSET_UNITS:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.polygon_offset_units);
-      }
-      return true;
-    case GL_CULL_FACE_MODE:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.cull_mode);
-      }
-      return true;
-    case GL_DEPTH_FUNC:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.depth_func);
-      }
-      return true;
-    case GL_STENCIL_FUNC:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.stencil_front_func);
-      }
-      return true;
-    case GL_STENCIL_REF:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.stencil_front_ref);
-      }
-      return true;
-    case GL_STENCIL_VALUE_MASK:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.stencil_front_mask);
-      }
-      return true;
-    case GL_STENCIL_BACK_FUNC:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.stencil_back_func);
-      }
-      return true;
-    case GL_STENCIL_BACK_REF:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.stencil_back_ref);
-      }
-      return true;
-    case GL_STENCIL_BACK_VALUE_MASK:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.stencil_back_mask);
-      }
-      return true;
-    case GL_DEPTH_WRITEMASK:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.depth_mask);
-      }
-      return true;
-    case GL_BLEND_EQUATION_RGB:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.blend_equation_rgb);
-      }
-      return true;
-    case GL_BLEND_EQUATION_ALPHA:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.blend_equation_alpha);
-      }
-      return true;
-    case GL_STENCIL_WRITEMASK:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.stencil_front_writemask);
-      }
-      return true;
-    case GL_STENCIL_BACK_WRITEMASK:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.stencil_back_writemask);
-      }
-      return true;
-    case GL_BLEND:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.enable_flags.blend);
-      }
-      return true;
-    case GL_CULL_FACE:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.enable_flags.cull_face);
-      }
-      return true;
-    case GL_DEPTH_TEST:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.enable_flags.depth_test);
-      }
-      return true;
-    case GL_DITHER:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.enable_flags.dither);
-      }
-      return true;
-    case GL_POLYGON_OFFSET_FILL:
-      *num_written = 1;
-      if (params) {
-        params[0] =
-            static_cast<GLint>(state_.enable_flags.polygon_offset_fill);
-      }
-      return true;
-    case GL_SAMPLE_ALPHA_TO_COVERAGE:
-      *num_written = 1;
-      if (params) {
-        params[0] =
-            static_cast<GLint>(state_.enable_flags.sample_alpha_to_coverage);
-      }
-      return true;
-    case GL_SAMPLE_COVERAGE:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.enable_flags.sample_coverage);
-      }
-      return true;
-    case GL_SCISSOR_TEST:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.enable_flags.scissor_test);
-      }
-      return true;
-    case GL_STENCIL_TEST:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLint>(state_.enable_flags.stencil_test);
-      }
-      return true;
-    default:
-      return false;
-  }
-}
-
-bool GLES2DecoderImpl::GetStateAsGLfloat(
-    GLenum pname, GLfloat* params, GLsizei* num_written) {
-  switch (pname) {
-    case GL_VIEWPORT:
-      *num_written = 4;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.viewport_x);
-        params[1] = static_cast<GLfloat>(state_.viewport_y);
-        params[2] = static_cast<GLfloat>(state_.viewport_width);
-        params[3] = static_cast<GLfloat>(state_.viewport_height);
-      }
-      return true;
-    case GL_BLEND_SRC_RGB:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.blend_source_rgb);
-      }
-      return true;
-    case GL_BLEND_DST_RGB:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.blend_dest_rgb);
-      }
-      return true;
-    case GL_BLEND_SRC_ALPHA:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.blend_source_alpha);
-      }
-      return true;
-    case GL_BLEND_DST_ALPHA:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.blend_dest_alpha);
-      }
-      return true;
-    case GL_LINE_WIDTH:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.line_width);
-      }
-      return true;
-    case GL_BLEND_COLOR:
-      *num_written = 4;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.blend_color_red);
-        params[1] = static_cast<GLfloat>(state_.blend_color_green);
-        params[2] = static_cast<GLfloat>(state_.blend_color_blue);
-        params[3] = static_cast<GLfloat>(state_.blend_color_alpha);
-      }
-      return true;
-    case GL_STENCIL_CLEAR_VALUE:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.stencil_clear);
-      }
-      return true;
-    case GL_COLOR_WRITEMASK:
-      *num_written = 4;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.color_mask_red);
-        params[1] = static_cast<GLfloat>(state_.color_mask_green);
-        params[2] = static_cast<GLfloat>(state_.color_mask_blue);
-        params[3] = static_cast<GLfloat>(state_.color_mask_alpha);
-      }
-      return true;
-    case GL_COLOR_CLEAR_VALUE:
-      *num_written = 4;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.color_clear_red);
-        params[1] = static_cast<GLfloat>(state_.color_clear_green);
-        params[2] = static_cast<GLfloat>(state_.color_clear_blue);
-        params[3] = static_cast<GLfloat>(state_.color_clear_alpha);
-      }
-      return true;
-    case GL_DEPTH_RANGE:
-      *num_written = 2;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.z_near);
-        params[1] = static_cast<GLfloat>(state_.z_far);
-      }
-      return true;
-    case GL_DEPTH_CLEAR_VALUE:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.depth_clear);
-      }
-      return true;
-    case GL_STENCIL_FAIL:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.stencil_front_fail_op);
-      }
-      return true;
-    case GL_STENCIL_PASS_DEPTH_FAIL:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.stencil_front_z_fail_op);
-      }
-      return true;
-    case GL_STENCIL_PASS_DEPTH_PASS:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.stencil_front_z_pass_op);
-      }
-      return true;
-    case GL_STENCIL_BACK_FAIL:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.stencil_back_fail_op);
-      }
-      return true;
-    case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.stencil_back_z_fail_op);
-      }
-      return true;
-    case GL_STENCIL_BACK_PASS_DEPTH_PASS:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.stencil_back_z_pass_op);
-      }
-      return true;
-    case GL_SCISSOR_BOX:
-      *num_written = 4;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.scissor_x);
-        params[1] = static_cast<GLfloat>(state_.scissor_y);
-        params[2] = static_cast<GLfloat>(state_.scissor_width);
-        params[3] = static_cast<GLfloat>(state_.scissor_height);
-      }
-      return true;
-    case GL_FRONT_FACE:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.front_face);
-      }
-      return true;
-    case GL_SAMPLE_COVERAGE_VALUE:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.sample_coverage_value);
-      }
-      return true;
-    case GL_SAMPLE_COVERAGE_INVERT:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.sample_coverage_invert);
-      }
-      return true;
-    case GL_POLYGON_OFFSET_FACTOR:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.polygon_offset_factor);
-      }
-      return true;
-    case GL_POLYGON_OFFSET_UNITS:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.polygon_offset_units);
-      }
-      return true;
-    case GL_CULL_FACE_MODE:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.cull_mode);
-      }
-      return true;
-    case GL_DEPTH_FUNC:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.depth_func);
-      }
-      return true;
-    case GL_STENCIL_FUNC:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.stencil_front_func);
-      }
-      return true;
-    case GL_STENCIL_REF:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.stencil_front_ref);
-      }
-      return true;
-    case GL_STENCIL_VALUE_MASK:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.stencil_front_mask);
-      }
-      return true;
-    case GL_STENCIL_BACK_FUNC:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.stencil_back_func);
-      }
-      return true;
-    case GL_STENCIL_BACK_REF:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.stencil_back_ref);
-      }
-      return true;
-    case GL_STENCIL_BACK_VALUE_MASK:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.stencil_back_mask);
-      }
-      return true;
-    case GL_DEPTH_WRITEMASK:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.depth_mask);
-      }
-      return true;
-    case GL_BLEND_EQUATION_RGB:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.blend_equation_rgb);
-      }
-      return true;
-    case GL_BLEND_EQUATION_ALPHA:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.blend_equation_alpha);
-      }
-      return true;
-    case GL_STENCIL_WRITEMASK:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.stencil_front_writemask);
-      }
-      return true;
-    case GL_STENCIL_BACK_WRITEMASK:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.stencil_back_writemask);
-      }
-      return true;
-    case GL_BLEND:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.enable_flags.blend);
-      }
-      return true;
-    case GL_CULL_FACE:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.enable_flags.cull_face);
-      }
-      return true;
-    case GL_DEPTH_TEST:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.enable_flags.depth_test);
-      }
-      return true;
-    case GL_DITHER:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.enable_flags.dither);
-      }
-      return true;
-    case GL_POLYGON_OFFSET_FILL:
-      *num_written = 1;
-      if (params) {
-        params[0] =
-            static_cast<GLfloat>(state_.enable_flags.polygon_offset_fill);
-      }
-      return true;
-    case GL_SAMPLE_ALPHA_TO_COVERAGE:
-      *num_written = 1;
-      if (params) {
-        params[0] =
-            static_cast<GLfloat>(state_.enable_flags.sample_alpha_to_coverage);
-      }
-      return true;
-    case GL_SAMPLE_COVERAGE:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.enable_flags.sample_coverage);
-      }
-      return true;
-    case GL_SCISSOR_TEST:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.enable_flags.scissor_test);
-      }
-      return true;
-    case GL_STENCIL_TEST:
-      *num_written = 1;
-      if (params) {
-        params[0] = static_cast<GLfloat>(state_.enable_flags.stencil_test);
-      }
-      return true;
-    default:
-      return false;
-  }
-}
 #endif  // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_AUTOGEN_H_